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 java.util.*;
  import java.lang.*;
  import java.io.*;
  
  public class Main
  {
      static long mod = (int)1e9 + 7;
      // static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
  	public static void main (String[] args) throws java.lang.Exception
  	{
  		FastReader sc =new FastReader();
  		
  	    int t=sc.nextInt();
  	    
  	   // int t=1;
  	    
  	    while(t-->0)
  	    {
  	        int n = sc.nextInt();
  	        int arr[] = sc.readArray(n);
  	        
  	        radixSort2(arr);
  	        
  	        if(n == 1)
  	        {
  	            System.out.println(arr[0]);
  	            continue;
  	        }
  	        
  	        long ans = arr[0];
  	        int stored = arr[0];
  	        int sub = 0;
  	        
  	        for(int i=1;i<n;i++)
  	        {
  	            sub = arr[i] - stored;
  	            stored += sub;
  	            ans = Math.max(ans , sub);
  	        }
  	        System.out.println(ans);
  	    }
  	    
  	}
  	
  	
  	
  	
  	static class FastReader {
          BufferedReader br;
          StringTokenizer st;
   
          public FastReader()
          {
              br = new BufferedReader(
                  new InputStreamReader(System.in));
          }
   
          String next()
          {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  }
                  catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
   
          int nextInt() { return Integer.parseInt(next()); }
   
          long nextLong() { return Long.parseLong(next()); }
   
          double nextDouble()
          {
              return Double.parseDouble(next());
          }
          
          float nextFloat()
          {
              return Float.parseFloat(next());
          }
   
          String nextLine()
          {
              String str = "";
              try {
                  str = br.readLine();
              }
              catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
          
          int[] readArray(int n) {
  			int[] a=new int[n];
  			for (int i=0; i<n; i++) a[i]=nextInt();
  			return a;
  		}
  		
  		long[] readArrayLong(int n) {
  			long[] a=new long[n];
  			for (int i=0; i<n; i++) a[i]=nextLong();
  			return a;
  		}
  		
      }
      
      
      
      public static int[] radixSort2(int[] a)
  	{
  		int n = a.length;
  		int[] c0 = new int[0x101];
  		int[] c1 = new int[0x101];
  		int[] c2 = new int[0x101];
  		int[] c3 = new int[0x101];
  		for(int v : a) {
  			c0[(v&0xff)+1]++;
  			c1[(v>>>8&0xff)+1]++;
  			c2[(v>>>16&0xff)+1]++;
  			c3[(v>>>24^0x80)+1]++;
  		}
  		for(int i = 0;i < 0xff;i++) {
  			c0[i+1] += c0[i];
  			c1[i+1] += c1[i];
  			c2[i+1] += c2[i];
  			c3[i+1] += c3[i];
  		}
  		int[] t = new int[n];
  		for(int v : a)t[c0[v&0xff]++] = v;
  		for(int v : t)a[c1[v>>>8&0xff]++] = v;
  		for(int v : a)t[c2[v>>>16&0xff]++] = v;
  		for(int v : t)a[c3[v>>>24^0x80]++] = v;
  		return a;
  	}
  	
  	static void reverse_sorted(int[] arr)
  	{
  	    ArrayList<Integer> list = new ArrayList<>();
  	    for(int i=0;i<arr.length;i++)
  	    {
  	        list.add(arr[i]);
  	    }
  	    Collections.sort(list , Collections.reverseOrder());
  	    for(int i=0;i<arr.length;i++)
  	    {
  	        arr[i] = list.get(i);
  	    }
  	}
  	
  	static int LowerBound(int a[], int x) { // x is the target value or key
          int l=-1,r=a.length;
          while(l+1<r) {
              int m=(l+r)>>>1;
              if(a[m]>=x) r=m;
              else l=m;
          }
          return r;
      }
      
      static int UpperBound(ArrayList<Integer> list, int x) {// x is the key or target value
          int l=-1,r=list.size();
          while(l+1<r) {
              int m=(l+r)>>>1;
              if(list.get(m)<=x) l=m;
              else r=m;
          }
          return l+1;
      }
      
      public static HashMap<String, Integer> sortByValue(HashMap<String, Integer> hm)
      {
          // Create a list from elements of HashMap
          List<Map.Entry<String, Integer> > list =
                 new LinkedList<Map.Entry<String, Integer> >(hm.entrySet());
   
          // Sort the list
          Collections.sort(list, new Comparator<Map.Entry<String, Integer> >() {
              public int compare(Map.Entry<String, Integer> o1,
                                 Map.Entry<String, Integer> o2)
              {
                  return (o1.getValue()).compareTo(o2.getValue());
              }
          });
           
          // put data from sorted list to hashmap
          HashMap<String, Integer> temp = new LinkedHashMap<String, Integer>();
          for (Map.Entry<String, Integer> aa : list) {
              temp.put(aa.getKey(), aa.getValue());
          }
          return temp;
      }
      
      static class Queue_Pair implements Comparable<Queue_Pair> {
  		int first , second;
  		public Queue_Pair(int first, int second) {
  			this.first=first;
  			this.second=second;
  		}
  		public int compareTo(Queue_Pair o) {
  			return Integer.compare(o.first, first);
  		}
  	}
      
      static void leftRotate(char arr[], int d, int n)
      {
          for (int i = 0; i < d; i++)
              leftRotatebyOne(arr, n);
      }
   
      static void leftRotatebyOne(char arr[], int n)
      {
          int i;
          char temp = arr[0];
          for (i = 0; i < n - 1; i++)
              arr[i] = arr[i + 1];
          arr[n-1] = temp;
          
      }
      
      static void rightRotate(char arr[], int d, int n)
      {
          for (int i = 0; i < d; i++)
              rightRotatebyOne(arr, n);
      }
   
      static void rightRotatebyOne(char arr[], int n)
      {
          int i;
          char temp = arr[n - 1];
          for (i = n - 1; i > 0; i--)
              arr[i] = arr[i - 1];
          arr[0] = temp;
          
      }
      
      static boolean isPalindrome(String str)
      {
   
          // Pointers pointing to the beginning
          // and the end of the string
          int i = 0, j = str.length() - 1;
   
          // While there are characters to compare
          while (i < j) {
   
              // If there is a mismatch
              if (str.charAt(i) != str.charAt(j))
                  return false;
   
              // Increment first pointer and
              // decrement the other
              i++;
              j--;
          }
   
          // Given string is a palindrome
          return true;
      }
      
      static boolean palindrome_array(char arr[], int n)
      {
          // Initialise flag to zero.
          int flag = 0;
   
          // Loop till array size n/2.
          for (int i = 0; i <= n / 2 && n != 0; i++) {
   
              // Check if first and last element are different
              // Then set flag to 1.
              if (arr[i] != arr[n - i - 1]) {
                  flag = 1;
                  break;
              }
          }
   
          // If flag is set then print Not Palindrome
          // else print Palindrome.
          if (flag == 1)
              return false;
          else
              return true;
      }
      
  	static boolean allElementsEqual(long[] arr,int n)
  	{
  	    int z=0;
  	        for(int i=0;i<n-1;i++)
  		    {
  		        if(arr[i]==arr[i+1])
  		        {
  		            z++;
  		        }
  		    }
  		    if(z==n-1)
  		    {
  		        return true;
  		    }
  		    else
  		    {
  		        return false;
  		    }
  		    
  	}
  	
  	static boolean allElementsDistinct(int[] arr,int n)
  	{
  	    int z=0;
  	        for(int i=0;i<n-1;i++)
  		    {
  		        if(arr[i]!=arr[i+1])
  		        {
  		            z++;
  		        }
  		    }
  		    if(z==n-1)
  		    {
  		        return true;
  		    }
  		    else
  		    {
  		        return false;
  		    }
  		    
  		    
  	}
  	
  	public static void reverse(int[] array)
      {
    
          // Length of the array
          int n = array.length;
    
          // Swaping the first half elements with last half
          // elements
          for (int i = 0; i < n / 2; i++) {
    
              // Storing the first half elements temporarily
              int temp = array[i];
    
              // Assigning the first half to the last half
              array[i] = array[n - i - 1];
    
              // Assigning the last half to the first half
              array[n - i - 1] = temp;
          }
      }
      
      public static void reverse_Long(long[] array)
      {
    
          // Length of the array
          int n = array.length;
    
          // Swaping the first half elements with last half
          // elements
          for (int i = 0; i < n / 2; i++) {
    
              // Storing the first half elements temporarily
              long temp = array[i];
    
              // Assigning the first half to the last half
              array[i] = array[n - i - 1];
    
              // Assigning the last half to the first half
              array[n - i - 1] = temp;
          }
      }
  	
  	static boolean isSorted(int[] a)
      {
          for (int i = 0; i < a.length - 1; i++)
          {
              if (a[i] > a[i + 1]) {
                  return false;
              }
          }
   
          return true;
      }
      
      
      
      static boolean isReverseSorted(int[] a)
      {
          for (int i = 0; i < a.length - 1; i++)
          {
              if (a[i] < a[i + 1]) {
                  return false;
              }
          }
   
          return true;
      }
      
      static int[] rearrangeEvenAndOdd(int arr[], int n)
      {
          ArrayList<Integer> list = new ArrayList<>();
  		    
  		    for(int i=0;i<n;i++)
  		    {
  		        if(arr[i]%2==0)
  		        {
  		            list.add(arr[i]);
  		        }
  		    }
  		    
  		    for(int i=0;i<n;i++)
  		    {
  		        if(arr[i]%2!=0)
  		        {
  		            list.add(arr[i]);
  		        }
  		    }
  		    int len = list.size();
  		    int[] array = list.stream().mapToInt(i->i).toArray();
  		    return array;
      }
      
      static long[] rearrangeEvenAndOddLong(long arr[], int n)
      {
          ArrayList<Long> list = new ArrayList<>();
  		    
  		    for(int i=0;i<n;i++)
  		    {
  		        if(arr[i]%2==0)
  		        {
  		            list.add(arr[i]);
  		        }
  		    }
  		    
  		    for(int i=0;i<n;i++)
  		    {
  		        if(arr[i]%2!=0)
  		        {
  		            list.add(arr[i]);
  		        }
  		    }
  		    int len = list.size();
  		    long[] array = list.stream().mapToLong(i->i).toArray();
  		    return array;
      }
  	
  	
      
      static boolean isPrime(long n)
      {
   
          // Check if number is less than
          // equal to 1
          if (n <= 1)
              return false;
   
          // Check if number is 2
          else if (n == 2)
              return true;
   
          // Check if n is a multiple of 2
          else if (n % 2 == 0)
              return false;
   
          // If not, then just check the odds
          for (long i = 3; i <= Math.sqrt(n); i += 2)
          {
              if (n % i == 0)
                  return false;
          }
          return true;
      }
      
      static long getSum(long n)
      {    
          long sum = 0;
            
          while (n != 0)
          {
              sum = sum + n % 10;
              n = n/10;
          }
        
      return sum;
      }
      
      static int gcd(int a, int b)
      {
        if (b == 0)
          return a;
        return gcd(b, a % b);
      }
       
      static long gcdLong(long a, long b)
      {
          if (b == 0)
          return a;
        return gcdLong(b, a % b);
      }
      
      static void swap(int i, int j)
      {
          int temp = i;
          i = j;
          j = temp;
      }
  	
  	static int countDigit(int n)
      {
          return (int)Math.floor(Math.log10(n) + 1);
      }
  	
  }
  
  class Pair
  {
      int first , second;
      Pair(int first , int second)
      {
          this.first = first;
          this.second = second;
      }
  }