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: # DEFINING SOME GOOD STUFF
  import heapq
  import sys
  from math import *
  import threading
  from heapq import *
  from itertools import count
  from pprint import pprint
  from collections import defaultdict
  from heapq import heapify, heappop, heappush
  
  
  # threading.stack_size(10**8)
  # sys.setrecursionlimit(300000)
  '''
  -> if you are increasing recursionlimit then remember submitting using python3 rather pypy3
  -> sometimes increasing stack size don't work locally but it will work on CF
  '''
  
  mod = 10 ** 9+7
  inf = 10 ** 15
  decision = ['NO', 'YES']
  yes = 'YES'
  no = 'NO'
  
  # ------------------------------FASTIO----------------------------
  import os
  
  from io import BytesIO, IOBase
  
  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")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  
  # ________________________FAST FACTORIAL______________________________#
  class Factorial:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorials = [1, 1]
          self.invModulos = [0, 1]
          self.invFactorial_ = [1, 1]
  
      def calc(self, n):
          if n <= -1:
              print("Invalid argument to calculate n!")
              print("n must be non-negative value. But the argument was "+str(n))
              exit()
          if n < len(self.factorials):
              return self.factorials[n]
          nextArr = [0] * (n+1-len(self.factorials))
          initialI = len(self.factorials)
          prev = self.factorials[-1]
          m = self.MOD
          for i in range(initialI, n+1):
              prev = nextArr[i-initialI] = prev * i % m
          self.factorials += nextArr
          return self.factorials[n]
  
      def inv(self, n):
          if n <= -1:
              print("Invalid argument to calculate n^(-1)")
              print("n must be non-negative value. But the argument was "+str(n))
              exit()
          p = self.MOD
          pi = n % p
          if pi < len(self.invModulos):
              return self.invModulos[pi]
          nextArr = [0] * (n+1-len(self.invModulos))
          initialI = len(self.invModulos)
          for i in range(initialI, min(p, n+1)):
              next = -self.invModulos[p % i] * (p // i) % p
              self.invModulos.append(next)
          return self.invModulos[pi]
  
      def invFactorial(self, n):
          if n <= -1:
              print("Invalid argument to calculate (n^(-1))!")
              print("n must be non-negative value. But the argument was "+str(n))
              exit()
          if n < len(self.invFactorial_):
              return self.invFactorial_[n]
          self.inv(n)  # To make sure already calculated n^-1
          nextArr = [0] * (n+1-len(self.invFactorial_))
          initialI = len(self.invFactorial_)
          prev = self.invFactorial_[-1]
          p = self.MOD
          for i in range(initialI, n+1):
              prev = nextArr[i-initialI] = (prev * self.invModulos[i % p]) % p
          self.invFactorial_ += nextArr
          return self.invFactorial_[n]
  
  class Combination:
      def __init__(self, MOD):
          self.MOD = MOD
          self.factorial = Factorial(MOD)
  
      def ncr(self, n, k):
          if k < 0 or n < k:
              return 0
          k = min(k, n-k)
          f = self.factorial
          return f.calc(n) * f.invFactorial(max(n-k, k)) * f.invFactorial(min(k, n-k)) % self.MOD
  
      def npr(self, n, k):
          if k < 0 or n < k:
              return 0
          f = self.factorial
          return (f.calc(n) * f.invFactorial(n-k)) % self.MOD
  
  
  #_______________SEGMENT TREE ( logn range modifications )_____________#
  
  class SegmentTree:
      def __init__(self, data, default = 0, func = lambda a, b: max(a, b)):
          """initialize the segment tree with data"""
          self._default = default
          self._func = func
          self._len = len(data)
          self._size = _size = 1 << (self._len-1).bit_length()
  
          self.data = [default] * (2 * _size)
          self.data[_size:_size+self._len] = data
          for i in reversed(range(_size)):
              self.data[i] = func(self.data[i+i], self.data[i+i+1])
  
      def __delitem__(self, idx):
          self[idx] = self._default
  
      def __getitem__(self, idx):
          return self.data[idx+self._size]
  
      def __setitem__(self, idx, value):
          idx += self._size
          self.data[idx] = value
          idx >>= 1
          while idx:
              self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx+1])
              idx >>= 1
  
      def __len__(self):
          return self._len
  
      def query(self, start, stop):
          if start == stop:
              return self.__getitem__(start)
          stop += 1
          start += self._size
          stop += self._size
  
          res = self._default
          while start < stop:
              if start & 1:
                  res = self._func(res, self.data[start])
                  start += 1
              if stop & 1:
                  stop -= 1
                  res = self._func(res, self.data[stop])
              start >>= 1
              stop >>= 1
          return res
  
      def __repr__(self):
          return "SegmentTree({0})".format(self.data)
  
  
  # ____________________MY FAVOURITE FUNCTIONS_______________________#
  
  
  
  def lower_bound(li, num):
      answer = len(li)
      start = 0
      end = len(li)-1
  
      while (start <= end):
          middle = (end+start) // 2
          if li[middle] >= num:
              answer = middle
              end = middle-1
          else:
              start = middle+1
      return answer  # min index where x is not less than num
  
  
  def upper_bound(li, num):
      answer = len(li)
      start = 0
      end = len(li)-1
  
      while (start <= end):
          middle = (end+start) // 2
          if li[middle] <= num:
              start = middle+1
  
          else:
              answer = middle
              end = middle-1
      return answer  # max index where x is greater than num
  
  
  def abs(x):
      return x if x >= 0 else -x
  
  
  def binary_search(li, val):
      # print(lb, ub, li)
      ans = -1
      lb = 0
      ub = len(li)-1
      while (lb <= ub):
          mid = (lb+ub) // 2
          # print('mid is',mid, li[mid])
          if li[mid] > val:
              ub = mid-1
          elif val > li[mid]:
              lb = mid+1
          else:
              ans = mid  # return index
              break
      return ans
  
  
  def kadane(x):  # maximum sum contiguous subarray
      sum_so_far = 0
      current_sum = 0
      for i in x:
          current_sum += i
          if current_sum < 0:
              current_sum = 0
          else:
              sum_so_far = max(sum_so_far, current_sum)
      return sum_so_far
  
  
  def pref(li):
      pref_sum = [li[0]]
      for i in range(1, len(li)):
          pref_sum.append(pref_sum[-1]+i)
      return pref_sum
  
  
  def SieveOfEratosthenes(n):
      prime = [{1, i} for i in range(n+1)]
      p = 2
      while (p <= n):
          for i in range(p * 2, n+1, p):
              prime[i].add(p)
          p += 1
      return prime
  
  
  def primefactors(n):
      factors = []
      while (n % 2 == 0):
          factors.append(2)
          n //= 2
      for i in range(3, int(sqrt(n))+1, 2):  # only odd factors left
          while n % i == 0:
              factors.append(i)
              n //= i
      if n > 2:  # incase of prime
          factors.append(n)
      return factors
  
  
  def prod(li):
      ans = 1
      for i in li:
          ans *= i
      return ans
  
  
  
  
  # _______________________________________________________________#
  def given():
      a = list(map(int, input().split()))
      return a
  def givenString():
      s = list(input())
      return s
  def givenStringInt():
      s = [int(x) for x in givenString()]
      return s
  #_________________________________________________________________#
  
  def main():
      karmanya = given()[0]
      # karmanya = 1
      while karmanya != 0:
          karmanya -= 1
          n = given()[0]
          a = given()
          s = sum(a)
          mm = max(a)
          ans = mm + (s-mm)/(n-1)
          print('%.9f'%ans)
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  main()
  # t = threading.Thread(target=main)
  # t.start()
  # t.join()