description: Ezzat has an array of n integers (maybe negative). He wants to split it into two non-empty subsequences a and b, such that every element from the array belongs to exactly one subsequence, and the value of f(a) + f(b) is the maximum possible value, where f(x) is the average of the subsequence x. 
  
  A sequence x is a subsequence of a sequence y if x can be obtained from y by deletion of several (possibly, zero or all) elements.
  
  The average of a subsequence is the sum of the numbers of this subsequence divided by the size of the subsequence.
  
  For example, the average of [1,5,6] is (1+5+6)/3 = 12/3 = 4, so f([1,5,6]) = 4.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^3)— the number of test cases. Each test case consists of two lines.
  
  The first line contains a single integer n (2 ≤ n ≤ 10^5).
  
  The second line contains n integers a_1, a_2, …, a_n (-10^9 ≤ a_i ≤ 10^9).
  
  It is guaranteed that the sum of n over all test cases does not exceed 3⋅10^5.
  
  Output
  
  For each test case, print a single value — the maximum value that Ezzat can achieve.
  
  Your answer is considered correct if its absolute or relative error does not exceed 10^{-6}.
  
  Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
  
  Example
  
  Input
  
  
  4
  3
  3 1 2
  3
  -7 -6 -6
  3
  2 2 2
  4
  17 3 5 -3
  
  
  Output
  
  
  4.500000000
  -12.500000000
  4.000000000
  18.666666667
  
  Note
  
  In the first test case, the array is [3, 1, 2]. These are all the possible ways to split this array: 
  
    * a = [3], b = [1,2], so the value of f(a) + f(b) = 3 + 1.5 = 4.5. 
    * a = [3,1], b = [2], so the value of f(a) + f(b) = 2 + 2 = 4. 
    * a = [3,2], b = [1], so the value of f(a) + f(b) = 2.5 + 1 = 3.5. 
  
  Therefore, the maximum possible value 4.5.
  
  In the second test case, the array is [-7, -6, -6]. These are all the possible ways to split this array: 
  
    * a = [-7], b = [-6,-6], so the value of f(a) + f(b) = (-7) + (-6) = -13. 
    * a = [-7,-6], b = [-6], so the value of f(a) + f(b) = (-6.5) + (-6) = -12.5. 
  
  Therefore, the maximum possible value -12.5.
solution: import java.sql.SQLSyntaxErrorException;
  import java.util.*;
  import java.io.*;
  import java.util.stream.StreamSupport;
  public class Solution {
      static int mod = 998244353;
      //static int mod =  (int)Math.pow(10,9)+7;
      public static void main(String str[]) throws IOException{
          Reader sc = new Reader();
          BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
  //        Scanner sc = new Scanner(System.in);
          int t =sc.nextInt();
          while(t-->0) {
              int n = sc.nextInt();
              long[] arr = new long[n];
              long total  = 0;
              long max = Integer.MIN_VALUE;
              for (int i = 0; i < n; i++) {
                  arr[i] = sc.nextInt();
                  max = Math.max(arr[i], max);
                  total+=arr[i];
              }
              System.out.println((double) max+(double)(total-max)/((double) (n-1)));
          }
  
          output.flush();
  
      }
  
  
      static class Graph{
          int ind;
          ArrayList<Integer> pq = new ArrayList<>();
          int max = -1;
          boolean b = false;
          public Graph(int a){
              ind = a;
          }
          public void maxupdate(){
              max = -1;
              for(int i: pq){
                  max = Math.max(max, i);
              }
              if(max<ind) b = true;
              else    b = false;
          }
  
      }
  
  
  
      static class Pair{
          int a=0;
          int b=0;
          int in = 0;
          int ac = 0;
          int ex = 0;
      }
      long fun2(ArrayList<Integer> arr, int x){
          ArrayList<ArrayList> al = new ArrayList<>();
          ArrayList<Integer> curr = new ArrayList<>();
          fun(arr, x, al, curr, 0);
          if(al.size()==0)    return 0;
          int max = 0;
          for(ArrayList<Integer> i: al){
              if(i.size()>max)    max = i.size();
          }
          for(int i=0;i<al.size();i++){
              if(al.get(i).size()!=max){
                  al.remove(i);
                  i--;
              }
          }
          for(ArrayList<Integer> i: al){
              Collections.sort(al, Collections.reverseOrder());
          }
          long ans = 0;
  
          for(ArrayList<Integer> i: al){
              long temp = 0;
              for(int j: i){
                  temp*=10;
                  temp+=j;
              }
              if(ans<temp)    ans = temp;
          }
          return ans;
  
      }
      void fun(ArrayList<Integer> arr, int x, ArrayList<ArrayList> al, ArrayList<Integer> curr, int i){
          if(x<0) return ;
          if(x==0) {
              al.add(curr);
              return;
          }
          for(int j=i;j<arr.size();j++){
              ArrayList<Integer> temp = new ArrayList<>(curr);
              fun(arr, x-arr.get(j), al, temp, j);
          }
      }
  
  
  
      // Returns n^(-1) mod p
      static int modInverse(long n, long p)
      {
          return (int)power(n, p - 2, p);
      }
  
      // Returns nCr % p using Fermat's
      // little theorem.
      static long nCrModPFermat(int n, int r,
                                int p, long[] fac)
      {
  
          if (n<r)
              return 0;
          // Base case
          if (r == 0)
              return 1;
  
          // Fill factorial array so that we
          // can find all factorial of r, n
          // and n-r
          long x = modInverse(fac[r], p);
          long y = modInverse(fac[n - r], p);
  
          return (fac[n] * x
                  % p * y
                  % p)
                  % p;
      }
  
      static long[] sum(String[] str){
          int n = str[0].length();
          long ans[] = new long[n];
          for(String s: str){
              for(int i=0;i<n;i++)   ans[i]+=s.charAt(i);
          }
          return ans;
      }
  
      static class tSort implements Comparator<Pair>{
  
          public int compare(Pair s1, Pair s2) {
              if (s1.b < s2.b)
                  return -1;
              else if (s1.b > s2.b)
                  return 1;
              return 0;
          }
      }
  
  
  //    static boolean checkCycle(Tree[] arr,  boolean[] visited, int curr, int node){
  //        if(curr==node && visited[curr]) return true;
  //        if(visited[curr])   return false;
  //        visited[curr]  = true;
  //        for(int i: arr[curr].al){
  //            if(checkCycle(arr, visited, i, node))    return true;
  //        }
  //        return false;
  //    }
  
  
  //    static boolean allCombinations(int n){      //Global round 15
  //        int three2n = 1;
  //        for (int i = 1; i <= n; i++)
  //            three2n *= 3;
  //
  //        for (int k = 1; k < three2n; k++) {
  //            int k_cp = k;
  //            int sum = 0;
  //            for (int i = 1; i <= n; i++) {
  //                int s = k_cp % 3;
  //                k_cp /= 3;
  //                if (s == 2) s = -1;
  //                sum += s * a[i];
  //            }
  //            if (sum == 0) {
  //                return true;
  //            }
  //        }
  //        return false;
  //    }
  
      static ArrayList<String> fun( int curr, int n, char c){
          int len = n-curr;
          if(len==0)  return null;
          ArrayList<String> al = new ArrayList<>();
          if(len==1){
              al.add(c+"");
              return al;
          }
          String ss = "";
          for(int i=0;i<len/2;i++){
              ss+=c;
          }
          ArrayList<String> one = fun(len/2+curr, n, (char)(c+1));
          for(String str: one){
              al.add(str+ss);
              al.add(ss+str);
          }
          return al;
      }
      static ArrayList convert(int x, int k){
          ArrayList<Integer> al = new ArrayList<>();
          if(x>0) {
              while (x > 0) {
                  al.add(x % k);
                  x /= k;
              }
          }
          else    al.add(0);
          return al;
      }
  
  
  
  
      static int max(int x, int y, int z){
          int ans = Math.max(x,y);
          ans = Math.max(ans, z);
          return ans;
      }
      static int min(int x, int y, int z){
          int ans = Math.min(x,y);
          ans = Math.min(ans, z);
          return ans;
      }
  
  //    static long treeTraversal(Tree arr[], int parent, int x){
  //        long tot = 0;
  //        for(int i: arr[x].al){
  //            if(i!=parent){
  //                tot+=treeTraversal(arr, x, i);
  //            }
  //        }
  //        arr[x].child = tot;
  //        if(arr[x].child==0) arr[x].child = 1;
  //        return tot+1;
  //    }
  
      public static int primeFactors(int n, int k)
      {
          int ans = 0;
  
          while (n%2==0)
          {
              ans++;
              if(ans>=k)  return k;
              n /= 2;
          }
          for (int i = 3; i <= Math.sqrt(n); i+= 2)
          {
              while (n%i == 0)
              {
                  ans++;
                  n /= i;
                  if(ans>=k)  return k;
              }
          }
  
          if (n > 2)  ans++;
          return ans;
      }
      static int binaryLow(ArrayList<Integer> arr, int x, int s, int e){
          if(s>=e){
              if(arr.get(s)>=x)  return s;
              else    return s+1;
          }
          int m = (s+e)/2;
          if(arr.get(m)==x)  return m;
          if(arr.get(m)>x)   return binaryLow(arr,x,s,m);
          if(arr.get(m)<x)   return binaryLow(arr,x,m+1,e);
          return 0;
      }
      static int binaryLow(int[] arr, int x, int s, int e){
          if(s>=e){
              if(arr[s]>=x)  return s;
              else    return s+1;
          }
          int m = (s+e)/2;
          if(arr[m]==x)  return m;
          if(arr[m]>x)   return binaryLow(arr,x,s,m);
          if(arr[m]<x)   return binaryLow(arr,x,m+1,e);
          return 0;
      }
      static int binaryHigh(int[] arr, int x, int s, int e){
          if(s>=e){
              if(arr[s]<=x)  return s;
              else    return s-1;
          }
          int m = (s+e)/2;
          if(arr[m]==x)  return m;
          if(arr[m]>x)   return binaryHigh(arr,x,s,m-1);
          if(arr[m]<x)   return binaryHigh(arr,x,m+1,e);
          return 0;
      }
  
  
      static void arri(int arr[], int n, Reader sc) throws IOException{
          for(int i=0;i<n;i++){
              arr[i] = sc.nextInt();
          }
      }
      static void arrl(long arr[], int n, Reader sc) throws IOException{
          for(int i=0;i<n;i++){
              arr[i] = sc.nextLong();
          }
      }
  
      static long gcd(long a, long b)
      {
          if (b == 0)
              return a;
          return gcd(b, a % b);
      }
      static long power(long x, long y, long p)
      {
          long res = 1; // Initialize result
  
          x = x % p; // Update x if it is more than or
          // equal to p
  
          if (x == 0)
              return 0; // In case x is divisible by p;
  
          while (y > 0)
          {
  
              // If y is odd, multiply x with result
              if ((y & 1) != 0)
                  res = (res * x) % p;
  
              // y must be even now
              y = y >> 1; // y = y/2
              x = (x * x) % p;
          }
          return res%p;
      }
  
  //    static boolean dfs(Tree node, boolean[] visited, int parent, ArrayList<Tree> tt){
  //        visited[node.a] = true;
  //        boolean b = false;
  //        for(int i: node.al){
  //            if(tt.get(i).a!=parent){
  //                if(visited[tt.get(i).a])    return true;
  //                b|= dfs(tt.get(i), visited, node.a, tt);
  //            }
  //        }
  //        return b;
  //    }
  
  
  
      //    static class sortT implements Comparator<Integer> {
  //        // Used for sorting in ascending order of
  //        // roll number
  //        public int compare(Integer a, Integer b)
  //        {
  //            if(a.ans[a.a]==-1)  return 1;
  //            if(b.ans[b.a]==-1) return -1;
  //            if(a.ans[a.a]>=a.ans[b.a]) return 1;
  //            else return -1;
  //        }
  //    }
      static class SortbyI implements Comparator<Pair> {
          // Used for sorting in ascending order of
          // roll number
          public int compare(Pair a, Pair b)
          {
              if(a.a>=b.a) return 1;
              else return -1;
          }
      }
      static class SortbyD implements Comparator<Pair> {
          // Used for sorting in ascending order of
          // roll number
          public int compare(Pair a, Pair b)
          {
              if(a.a<b.a) return 1;
              else if(a.a==b.b && a.b>b.b)    return 1;
              else return -1;
          }
      }
      static int binarySearch(ArrayList<Pair> a, int x, int s, int e){
          if(s>=e){
              if(x<=a.get(s).b)  return s;
              else    return s+1;
          }
          int mid = (e+s)/2;
          if(a.get(mid).b<x){
              return binarySearch(a, x, mid+1, e);
          }
          else    return binarySearch(a,x,s, mid);
      }
  
      //    static class Edge{
  //        int a;
  //        int b;
  //        int c;
  //        int sec;
  //        Edge(int a, int b, int c, int sec){
  //            this.a = a;
  //            this.b = b;
  //            this.c = c;
  //            this.sec = sec;
  //        }
  //
  //    }
      static class Tree{
          int a;
  
          ArrayList<Tree> al = new ArrayList<>();
          Tree(int a){
              this.a = a;
          }
  
  
      }
  
      static class Reader {
          final private int BUFFER_SIZE = 1 << 16;
          private DataInputStream din;
          private byte[] buffer;
          private int bufferPointer, bytesRead;
  
          public Reader()
          {
              din = new DataInputStream(System.in);
              buffer = new byte[BUFFER_SIZE];
              bufferPointer = bytesRead = 0;
          }
  
          public Reader(String file_name) throws IOException
          {
              din = new DataInputStream(
                      new FileInputStream(file_name));
              buffer = new byte[BUFFER_SIZE];
              bufferPointer = bytesRead = 0;
          }
  
          public String readLine() throws IOException
          {
              byte[] buf = new byte[64]; // line length
              int cnt = 0, c;
              while ((c = read()) != -1) {
                  if (c == '\n') {
                      if (cnt != 0) {
                          break;
                      }
                      else {
                          continue;
                      }
                  }
                  buf[cnt++] = (byte)c;
              }
              return new String(buf, 0, cnt);
          }
  
          public int nextInt() throws IOException
          {
              int ret = 0;
              byte c = read();
              while (c <= ' ') {
                  c = read();
              }
              boolean neg = (c == '-');
              if (neg)
                  c = read();
              do {
                  ret = ret * 10 + c - '0';
              } while ((c = read()) >= '0' && c <= '9');
  
              if (neg)
                  return -ret;
              return ret;
          }
  
          public long nextLong() throws IOException
          {
              long ret = 0;
              byte c = read();
              while (c <= ' ')
                  c = read();
              boolean neg = (c == '-');
              if (neg)
                  c = read();
              do {
                  ret = ret * 10 + c - '0';
              } while ((c = read()) >= '0' && c <= '9');
              if (neg)
                  return -ret;
              return ret;
          }
  
          public double nextDouble() throws IOException
          {
              double ret = 0, div = 1;
              byte c = read();
              while (c <= ' ')
                  c = read();
              boolean neg = (c == '-');
              if (neg)
                  c = read();
  
              do {
                  ret = ret * 10 + c - '0';
              } while ((c = read()) >= '0' && c <= '9');
  
              if (c == '.') {
                  while ((c = read()) >= '0' && c <= '9') {
                      ret += (c - '0') / (div *= 10);
                  }
              }
  
              if (neg)
                  return -ret;
              return ret;
          }
  
          private void fillBuffer() throws IOException
          {
              bytesRead = din.read(buffer, bufferPointer = 0,
                      BUFFER_SIZE);
              if (bytesRead == -1)
                  buffer[0] = -1;
          }
  
          private byte read() throws IOException
          {
              if (bufferPointer == bytesRead)
                  fillBuffer();
              return buffer[bufferPointer++];
          }
  
          public void close() throws IOException
          {
              if (din == null)
                  return;
              din.close();
          }
      }
  
  
      static boolean isPrime(int n)
      {
          if (n <= 1)
              return false;
          if (n <= 3)
              return true;
          if (n % 2 == 0 ||
                  n % 3 == 0)
              return false;
  
          for (int i = 5;
               i * i <= n; i = i + 6)
              if (n % i == 0 ||
                      n % (i + 2) == 0)
                  return false;
  
          return true;
      }
      static ArrayList<Integer> sieveOfEratosthenes(int n)
      {
          ArrayList<Integer> al = new ArrayList<>();
          // Create a boolean array
          // "prime[0..n]" and
          // initialize all entries
          // it as true. A value in
          // prime[i] will finally be
          // false if i is Not a
          // prime, else true.
          boolean prime[] = new boolean[n + 1];
          for (int i = 0; i <= n; i++)
              prime[i] = true;
  
          for (int p = 2; p * p <= n; p++)
          {
              // If prime[p] is not changed, then it is a
              // prime
              if (prime[p] == true)
              {
                  // Update all multiples of p
                  for (int i = p * p; i <= n; i += p)
                      prime[i] = false;
              }
          }
  
          // Print all prime numbers
          for (int i = 2; i <= n; i++)
          {
              if (prime[i] == true)
                  al.add(i);
          }
          return al;
      }
  
  }
  
  
  
  
  
  
  
  