description: Yelisey has an array a of n integers.
  
  If a has length strictly greater than 1, then Yelisei can apply an operation called minimum extraction to it: 
  
    1. First, Yelisei finds the minimal number m in the array. If there are several identical minima, Yelisey can choose any of them. 
    2. Then the selected minimal element is removed from the array. After that, m is subtracted from each remaining element. 
  
  
  
  Thus, after each operation, the length of the array is reduced by 1.
  
  For example, if a = [1, 6, -4, -2, -4], then the minimum element in it is a_3 = -4, which means that after this operation the array will be equal to a=[1 {- (-4)}, 6 {- (-4)}, -2 {- (-4)}, -4 {- (-4)}] = [5, 10, 2, 0].
  
  Since Yelisey likes big numbers, he wants the numbers in the array a to be as big as possible.
  
  Formally speaking, he wants to make the minimum of the numbers in array a to be maximal possible (i.e. he want to maximize a minimum). To do this, Yelisey can apply the minimum extraction operation to the array as many times as he wants (possibly, zero). Note that the operation cannot be applied to an array of length 1.
  
  Help him find what maximal value can the minimal element of the array have after applying several (possibly, zero) minimum extraction operations to the array.
  
  Input
  
  The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases.
  
  The next 2t lines contain descriptions of the test cases.
  
  In the description of each test case, the first line contains an integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the original length of the array a. The second line of the description lists n space-separated integers a_i (-10^9 ≤ a_i ≤ 10^9) — elements of the array a.
  
  It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
  
  Output
  
  Print t lines, each of them containing the answer to the corresponding test case. The answer to the test case is a single integer — the maximal possible minimum in a, which can be obtained by several applications of the described operation to it.
  
  Example
  
  Input
  
  
  8
  1
  10
  2
  0 0
  3
  -1 2 0
  4
  2 10 1 7
  2
  2 3
  5
  3 2 -4 -2 0
  2
  -1 1
  1
  -2
  
  
  Output
  
  
  10
  0
  2
  5
  2
  2
  2
  -2
  
  Note
  
  In the first example test case, the original length of the array n = 1. Therefore minimum extraction cannot be applied to it. Thus, the array remains unchanged and the answer is a_1 = 10.
  
  In the second set of input data, the array will always consist only of zeros.
  
  In the third set, the array will be changing as follows: [\color{blue}{-1}, 2, 0] → [3, \color{blue}{1}] → [\color{blue}{2}]. The minimum elements are highlighted with \color{blue}{blue}. The maximal one is 2.
  
  In the fourth set, the array will be modified as [2, 10, \color{blue}{1}, 7] → [\color{blue}{1}, 9, 6] → [8, \color{blue}{5}] → [\color{blue}{3}]. Similarly, the maximum of the minimum elements is 5.
solution: import sys
  import time
  import os
  from io import BytesIO, IOBase
  import math
  from random import randint
  
  M=10**9+7
  BUFSIZE = 8192
  class FastIO(IOBase):
      newlines = 0
   
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
   
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
   
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
   
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
   
   
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
   
   
  def print(*args, **kwargs):
      """Prints the values to a stream, or to sys.stdout by default."""
      sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
      at_start = True
      for x in args:
          if not at_start:
              file.write(sep)
          file.write(str(x))
          at_start = False
      file.write(kwargs.pop("end", "\n"))
      if kwargs.pop("flush", False):
          file.flush()
   
   
  if sys.version_info[0] < 3:
      sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
  else:
      sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
   
  def inputf(): 
      return sys.stdin.readline().rstrip("\r\n")   
   
  def get_ints(): 
      return list(map(int, inputf().split()))
   
   
  def get_string(): 
      return list(map(str, inputf().split()))
  
  
  
  
  
  global maximum
   
   
  def _lis(arr, n):
   
      global maximum
   
      if n == 1:
          return 1
   
      maxEndingHere = 1
      for i in range(1, n):
          res = _lis(arr, i)
          if arr[i-1] < arr[n-1] and res+1 > maxEndingHere:
              maxEndingHere = res + 1
   
      maximum = max(maximum, maxEndingHere)
   
      return maxEndingHere
   
   
  def LIS(arr):
   
      global maximum
   
      n = len(arr)
   
      maximum = 1
   
      _lis(arr, n)
   
      return maximum
   
  
  def binary_search(data, elem):
      
      low = 0
      high = len(data) - 1
      while low <= high:
        
          middle = (low + high)//2
          if data[middle] == elem:
              return middle
              
          elif data[middle] > elem:
  
              high = middle - 1
          else:
              low = middle + 1
  
      return middle   
  
  def upper_bound(my_list, key):
      large = len(my_list) -1
      small = 0
  
      while (small <= large):
          mid = (small + large) // 2
          if my_list[mid] < key:
              small = mid + 1
          elif my_list[mid] > key:
              large = mid - 1
          else:
              return mid
      if my_list[mid]>key:
          return mid
      else:
          return mid+1
  
  
  def lower_bound(my_list, key):
      large = len(my_list) -1
      small = 0
  
      while (small <= large):
          mid = (small + large) // 2
          if my_list[mid] < key:
              small = mid + 1
          elif my_list[mid] > key:
              large = mid - 1
          else:
              return mid
      if my_list[mid]<key:
          return mid
      else:
          return mid-1
  
  
  a=[]
  def SieveOfEratosthenes(n):
      
  	prime = [True for i in range(n+1)]
  	p = 2
  	while (p * p <= n):
  
  		if (prime[p] == True):
  
  			for i in range(p * p, n+1, p):
  				prime[i] = False
  		p += 1
  
  	for p in range(2, n+1):
  		if prime[p]:
  			a.append(p)
  
  def roman_number(x):
      if x > 15999:
          return
      value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
      symbol = ["F", "MF", "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
      roman = ""
      i = 0
      while x > 0:
          div = x // value[i]
          x = x % value[i]
          while div:
              roman += symbol[i]
              div -= 1
          i += 1
      return roman
  
  def maxSubArraySum(a,size):
       
      max_so_far = a[0]   
      max_ending_here = 0
       
      for i in range(0, size):
          max_ending_here = max_ending_here + a[i]
          if max_ending_here < 0:
              max_ending_here = 0
           
          elif (max_so_far < max_ending_here):   
              max_so_far = max_ending_here
               
      return max_so_far
  
      
  def prefixSum(test_list):
      res = [sum(test_list[ : i + 1]) for i in range(len(test_list))]
      return res
  
  # Python Program to find the L.C.M. of two input number
  
  def lcm(x, y):
  
     # choose the greater number
     if x > y:
         greater = x
     else:
         greater = y
  
     while(True):
         if((greater % x == 0) and (greater % y == 0)):
             lcm = greater
             break
         greater += 1
  
     return lcm
  """
  def find_shortest_path(graph, start, end, path):
      path = path + [start]
      if start == end:
          return path
      if start not in graph:
          return None
      shortest = None
      for node in graph[start]:
          if node not in path:
              newpath = find_shortest_path(graph, node, end, path)
              if newpath:
                  if not shortest or len(newpath) < len(shortest):
                      shortest = newpath
      return shortest
  """ 
  
  """
  def dfs(root,nodeVal,nodeConnection,visited):
      leftVal = nodeVal[root][0]
      rightVal = nodeVal[root][1]
      solution = []
      if nodeConnection[root]:
          visited.add(root)
          for i in nodeConnection[root]:
              if i not in visited:
                  solution.append(dfs(i,nodeVal,nodeConnection,visited))
          leftMax = 0
          rightMax = 0
          for i in solution:
              l, r = i
              leftMax += max(abs(leftVal - l[0]) + l[1], abs(leftVal - r[0]) + r[1])
              rightMax += max(abs(rightVal - l[0]) + l[1], abs(rightVal - r[0]) + r[1])
          return ((leftVal, leftMax), (rightVal, rightMax))
      else:
          return ((leftVal, 0), (rightVal, 0))
   
  """
   
  """
  def BFS(adj,src,dist,paths,n):
      visited=[False]*n
      dist[src]=0
      paths[0]=1
      q=[src]
      visited[src]=True
      while(q):
          p=q.pop(0)
          for j in adj[p]:
              if not visited[j]:
                  q.append(j)
                  visited[j]=True
              if dist[j]>dist[p]+1:
                  dist[j] = dist[p]+1
                  paths[j] = paths[p]
              elif dist[j]==dist[p]+1:
                  paths[j] +=paths[p]
      return paths
   
  """
  
  
  testcase=int(inputf())
  
  for test in range(testcase):
      n=int(inputf())
      a=get_ints()
      a.sort()
      res=a[0]
      for i in range(1,n):
          res=max(res,a[i]-a[i-1])
      print(res)
  
  