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.io.BufferedReader;
      import java.io.FileInputStream;
      import java.io.FileNotFoundException;
      import java.io.IOException;
      import java.io.InputStreamReader;
      import java.util.*;
  import java.util.concurrent.LinkedBlockingDeque;
  import java.io.PrintStream;
      import java.io.PrintWriter;
      import java.io.DataInputStream;
  
          public class Solution {
  
              //TEMPLATE -------------------------------------------------------------------------------------
  
              public static boolean Local(){
                  try{ 
                      return System.getenv("LOCAL_SYS")!=null;
                  }catch(Exception e){
                      return false;
                  }
              }   
  
              public static boolean LOCAL;
  
              static class FastScanner {
  
                      BufferedReader br;
                      StringTokenizer st ;
  
                      FastScanner(){
                          br =  new BufferedReader(new InputStreamReader(System.in));
                          st = new StringTokenizer("");
                      }
  
                      FastScanner(String file) {
  
                          try{
                              br =  new BufferedReader(new InputStreamReader(new FileInputStream(file)));
                              st = new StringTokenizer("");
                          }catch(FileNotFoundException e) {
                              // TODO Auto-generated catch block
                              System.out.println("file not found");
                              e.printStackTrace();
                          }
                          
                      }
                      String next() {
                          while (!st.hasMoreTokens())
                              try {
                                  st = new StringTokenizer(br.readLine());
                              } catch (IOException e) {
                              }
                          return st.nextToken();
                      }
                      int nextInt() {
                          return Integer.parseInt(next());
                      }
                      long nextLong() {
                          return Long.parseLong(next());
                      }
                      String readLine() throws IOException{
                          return br.readLine();
                      }
                  }
                                      
              static class Pair<T,X> {
  
                  T first;
                  X second;
                  
                  Pair(T first,X second){
                      this.first = first;
                      this.second = second;
                  }
  
                  @Override
                  public int hashCode(){
                      return Objects.hash(first,second);
                  }
  
                  @Override
                  public boolean equals(Object obj){
                      return obj.hashCode() == this.hashCode();
                  }
  
              }
  
          
          static PrintStream debug = null;
          
          
          static long mod = (long)(Math.pow(10,9) + 7); 
         //TEMPLATE -------------------------------------------------------------------------------------END//
          public static void main(String[] args) throws Exception {
              
              FastScanner s = new FastScanner();
              LOCAL = Local();
              //PrintWriter pw = new PrintWriter(System.out);
              if(LOCAL){
                  s = new FastScanner("src/input.txt");
                  PrintStream o = new PrintStream("src/sampleout.txt");
                  debug = new PrintStream("src/debug.txt");
                  System.setOut(o);
              //  pw = new PrintWriter(o);
              } long mod = 1000000007;
  
          
              int tcr = s.nextInt();                  
              
              StringBuilder sb = new StringBuilder();
  
              for(int tc=0;tc<tcr;tc++){
                  int n = s.nextInt();
                  long arr[] = new long[n];
                  for(int i=0;i<n;i++){
                      arr[i] = s.nextLong();
                  }
                  if(n == 1){sb.append(arr[0]+"\n");continue;}
                  sort(arr);
                  long ans = arr[0];
                  for(int i=1;i<n;i++){
                      ans = Math.max(arr[i] - arr[i-1],ans);
                  }
                  sb.append(ans+"\n");
                  // long increase_by = 0;
                  // long ans = arr[0];
                  // int index = 0;
                  // for(;index < n - 1;index++){
                  //     if((arr[index] - increase_by) < 0){increase_by += (arr[index]);}
                  //     else{break;}
                  // }
                  // increase_by = -(increase_by);
                  // //println(index+"--");
                  // if(index == (n - 1)){
                  //     ans = arr[n-1] + increase_by;
                  //     sb.append(ans+"\n");
                  //     continue;
                  // }else{
                  //     long prev_sum = 0;
                  //     for(int i=index;i<n;i++){
                  //         arr[i] += increase_by;
                  //     }
                  //     for(int i = index;i<n;i++){
                  //         ans = Math.max(ans,arr[i] - prev_sum);
                  //         prev_sum += arr[i];
                  //     }
                    
                  //     sb.append(ans+"\n");
                  // }
  
              }    
  
  
              print(sb.toString());
          }
  
          public static void dec(TreeMap<Integer,Integer> map,int n){
              int cnt = map.get(n);
              if(cnt == 1){map.remove(n);return;}
              map.put(n,cnt - 1);
          }
   
          
  
          public static List<int[]> print_prime_factors(int n){
          
              List<int[]> list = new ArrayList<>();
              
              for(int i=2;i<=(int)(Math.sqrt(n));i++){
      
                  if(n % i == 0){
                      
                      int cnt = 0;
                      
                      while( (n % i) == 0){
                          n = n/i;
                          cnt++;
                      }
      
                      list.add(new int[]{i,cnt});
                  }
              }
      
              if(n!=1){
                  list.add(new int[]{n,1});
              }
  
              return list;
          }
  
          public static List<int[]> prime_factors(int n,List<Integer> sieve){
              List<int[]> list = new ArrayList<>();
              int index = 0;
              while(n > 1 && sieve.get(index) <= Math.sqrt(n)){
                  int curr = sieve.get(index);
                  int cnt = 0;
                  while((n % curr) == 0){
                      n = n/curr;
                      cnt++;
                  }
                  if(cnt >= 1){
                      list.add(new int[]{curr,cnt});
                  }
                  index++;
              }
              if(n > 1){
                  list.add(new int[]{n,1});
              }
              return list;
          }
  
          public static boolean inRange(int r1,int r2,int val){
              return ((val >= r1) && (val <= r2));
          }
  
          static int len(long num){
              return Long.toString(num).length();
          }
  
          static long mulmod(long a, long b,long mod)
          {
              long ans = 0l;
              
              while(b > 0){
                  long curr = (b & 1l);
                  if(curr == 1l){
                      ans = ((ans % mod) + a) % mod;
                  }
                  
                  a = (a + a) % mod;
  
                  b = b >> 1;
              }
  
              return ans;
          }
  
  
          public static void dbg(PrintStream ps,Object... o) throws Exception{
              if(ps == null){
                  return;
              }
              Debug.dbg(ps,o);
          }
  
          public static long modpow(long num,long pow,long mod){
  
              long val = num;
              long ans = 1l;
  
              while(pow > 0l){
                  
                  long bit = pow & 1l;
  
                  if(bit == 1){
                      ans = (ans * (val%mod))%mod;
                  }
  
                  val = (val * val) % mod;
                  pow = pow >> 1;
              }
  
              return ans;
  
          }
  
          public static char get(int n){
              return (char)('a' + n);
          }
  
          public static long[] sort(long arr[]){
              List<Long> list = new ArrayList<>();
              for(long n : arr){list.add(n);}
              Collections.sort(list);
              for(int i=0;i<arr.length;i++){
                  arr[i] = list.get(i);
              }
              return arr;
          }
  
          public static int[] sort(int arr[]){
              List<Integer> list = new ArrayList<>();
              for(int n : arr){list.add(n);}
              Collections.sort(list);
              for(int i=0;i<arr.length;i++){
                  arr[i] = list.get(i);
              }
              return arr;
          }
  
          // return the (index + 1)
          // where index is the pos of just smaller element
          // i.e count of elemets strictly less than num
          public static int justSmaller(long arr[],long num){
              //  System.out.println(num+"@");
              int st = 0;
              int e = arr.length - 1;
  
              int ans = -1;
  
              while(st <= e){
  
                  int mid = (st + e)/2;
  
                  if(arr[mid] >= num){
                      e = mid - 1;
                  }else{
                      ans = mid;
                      st = mid + 1;
                  }
  
              }
  
  
              return ans + 1;
  
          }
          public static int justSmaller(int arr[],int num){
              //  System.out.println(num+"@");
              int st = 0;
              int e = arr.length - 1;
  
              int ans = -1;
  
              while(st <= e){
  
                  int mid = (st + e)/2;
  
                  if(arr[mid] >= num){
                      e = mid - 1;
                  }else{
                      ans = mid;
                      st = mid + 1;
                  }
  
              }
  
  
              return ans + 1;
  
          }
          
          //return (index of just greater element)
          //count of elements smaller than or equal to num
  
          public static int justGreater(long arr[],long num){
              int st = 0;
              int e = arr.length - 1;
  
              int ans = arr.length;
  
              while(st <= e){
                  
                  int mid = (st + e)/2;
  
                  if(arr[mid] <= num){
                      st = mid + 1;
                  }else{
                      ans = mid;
                      e = mid - 1;
                  }
              }
  
              return ans;
  
          }
  
          public static int justGreater(int arr[],int num){
              int st = 0;
              int e = arr.length - 1;
  
              int ans = arr.length;
  
              while(st <= e){
                  
                  int mid = (st + e)/2;
  
                  if(arr[mid] <= num){
                      st = mid + 1;
                  }else{
                      ans = mid;
                      e = mid - 1;
                  }
              }
  
              return ans;
  
          }
  
          
  
          public static void println(Object obj){
              System.out.println(obj.toString());
          }
  
          public static void print(Object obj){
              System.out.print(obj.toString());
          }
  
          public static int gcd(int a,int b){
              if(b == 0){return a;}
              return gcd(b,a%b);
          }
  
          public static long gcd(long a,long b){
              if(b == 0l){
                  return a;
              }
  
              return gcd(b,a%b);
          }
  
          public static int find(int parent[],int v){
              if(parent[v] == v){
                  return v;
              }
              
              return parent[v] = find(parent, parent[v]);
          }
  
  
  
          public static List<Integer> sieve(){
          
                  List<Integer> prime = new ArrayList<>();
  
                  int arr[] = new int[100001];
  
              Arrays.fill(arr,1);
  
              arr[1] = 0;
              arr[2] = 1;
  
              for(int i=2;i<=100000;i++){
                  
                  if(arr[i] == 1){
                      
                      prime.add(i);
  
                      for(long j = (i*1l*i);j<100001;j+=i){
                          arr[(int)j] = 0;
                      }
                  }
              }
  
              return prime;
          }
  
          static boolean isPower(long n,long a){
              
              long log = (long)(Math.log(n)/Math.log(a));
  
              long power = (long)Math.pow(a,log);
  
              if(power == n){return true;}
  
              return false;
          }
  
  
          private static int mergeAndCount(int[] arr, int l,int m, int r)
          {
              // Left subarray
              int[] left =  Arrays.copyOfRange(arr, l, m + 1);
  
              // Right subarray
              int[] right = Arrays.copyOfRange(arr, m + 1, r + 1);
  
              int i = 0, j = 0, k = l, swaps = 0;
  
              while (i < left.length && j < right.length) {
                  if (left[i] <= right[j])
                      arr[k++] = left[i++];
                  else {
                      arr[k++] = right[j++];
                      swaps += (m + 1) - (l + i);
                  }
              }
              while (i < left.length)
                  arr[k++] = left[i++];
              while (j < right.length)
                  arr[k++] = right[j++];
              return swaps;
          }
  
          // Merge sort function
          private static int mergeSortAndCount(int[] arr, int l,int r)
          {
  
              // Keeps track of the inversion count at a
              // particular node of the recursion tree
              int count = 0;
  
              if (l < r) {
                  int m = (l + r) / 2;
  
                  // Total inversion count = left subarray count
                  // + right subarray count + merge count
  
                  // Left subarray count
                  count += mergeSortAndCount(arr, l, m);
  
                  // Right subarray count
                  count += mergeSortAndCount(arr, m + 1, r);
  
                  // Merge count
                  count += mergeAndCount(arr, l, m, r);
              }
  
              return count;
          }
  
          static class Debug{
              //change to System.getProperty("ONLINE_JUDGE")==null; for CodeForces
              public static final boolean LOCAL = System.getProperty("ONLINE_JUDGE")==null;
  
              
  
              private static <T> String ts(T t) {
                  if(t==null) {
                      return "null";
                  }
                  try {
                      return ts((Iterable) t);
                  }catch(ClassCastException e) {
                      if(t instanceof int[]) {
                          String s = Arrays.toString((int[]) t);
                          return "{"+s.substring(1, s.length()-1)+"}\n";
                      }else if(t instanceof long[]) {
                          String s = Arrays.toString((long[]) t);
                          return "{"+s.substring(1, s.length()-1)+"}\n";
                      }else if(t instanceof char[]) {
                          String s = Arrays.toString((char[]) t);
                          return "{"+s.substring(1, s.length()-1)+"}\n";
                      }else if(t instanceof double[]) {
                          String s = Arrays.toString((double[]) t);
                          return "{"+s.substring(1, s.length()-1)+"}\n";
                      }else if(t instanceof boolean[]) {
                          String s = Arrays.toString((boolean[]) t);
                          return "{"+s.substring(1, s.length()-1)+"}\n";
                      }
                      try {
                          return ts((Object[]) t);
                      }catch(ClassCastException e1) {
                          return t.toString();
                      }
                  }
              }
              private static <T> String ts(T[] arr) {
                  StringBuilder ret = new StringBuilder();
                  ret.append("{");
                  boolean first = true;
                  for(T t: arr) {
                      if(!first) {
                          ret.append(", ");
                      }
                      first = false;
                      ret.append(ts(t));
                  }
                  ret.append("}");
                  return ret.toString();
              }
              private static <T> String ts(Iterable<T> iter) {
                  StringBuilder ret = new StringBuilder();
                  ret.append("{");
                  boolean first = true;
                  for(T t: iter) {
                      if(!first) {
                          ret.append(", ");
                      }
                      first = false;
                      ret.append(ts(t));
                  }
                  ret.append("}\n");
                  return ret.toString();
              }
              public static void dbg(PrintStream ps,Object... o) throws Exception {
                  if(LOCAL) {
                      System.setErr(ps);
                      System.err.print("Line #"+Thread.currentThread().getStackTrace()[2].getLineNumber()+": [\n");
                      for(int i = 0; i<o.length; i++) {
                          if(i!=0) {
                              System.err.print(", ");
                          }
                          System.err.print(ts(o[i]));
                      }
                      System.err.println("]");
                  }
              }
          }
  
      }