description: Paprika loves permutations. She has an array a_1, a_2, ..., a_n. She wants to make the array a permutation of integers 1 to n.
  
  In order to achieve this goal, she can perform operations on the array. In each operation she can choose two integers i (1 ≤ i ≤ n) and x (x > 0), then perform a_i := a_i mod x (that is, replace a_i by the remainder of a_i divided by x). In different operations, the chosen i and x can be different.
  
  Determine the minimum number of operations needed to make the array a permutation of integers 1 to n. If it is impossible, output -1.
  
  A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
  
  Input
  
  Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. Description of the test cases follows.
  
  The first line of each test case contains an integer n (1 ≤ n ≤ 10^5).
  
  The second line of each test case contains n integers a_1, a_2, ..., a_n. (1 ≤ a_i ≤ 10^9).
  
  It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
  
  Output
  
  For each test case, output the minimum number of operations needed to make the array a permutation of integers 1 to n, or -1 if it is impossible.
  
  Example
  
  Input
  
  
  4
  2
  1 7
  3
  1 5 4
  4
  12345678 87654321 20211218 23571113
  9
  1 2 3 4 18 19 5 6 7
  
  
  Output
  
  
  1
  -1
  4
  2
  
  Note
  
  For the first test, the only possible sequence of operations which minimizes the number of operations is: 
  
    * Choose i=2, x=5. Perform a_2 := a_2 mod 5 = 2. 
  
  
  
  For the second test, it is impossible to obtain a permutation of integers from 1 to n.
solution: import java.util.*;
  import java.io.*;
  
  ////***************************************************************************
   /* public class E_Gardener_and_Tree implements Runnable{
  
         public static void main(String[] args) throws Exception {
          new Thread(null, new E_Gardener_and_Tree(), "E_Gardener_and_Tree", 1<<28).start();
         }
      public void run(){
           WRITE YOUR CODE HERE!!!!
           JUST WRITE EVERYTHING HERE WHICH YOU WRITE IN MAIN!!!
         }
  
    }
  */
  /////**************************************************************************
  
  
  public class C_Paprika_and_Permutation{
      public static void main(String[] args) {
          FastScanner s= new FastScanner();
          //PrintWriter out=new PrintWriter(System.out);
          //end of program
          //out.println(answer);
          //out.close();
          StringBuilder res = new StringBuilder();
          int t=s.nextInt();
          int p=0;
          while(p<t){
          int n=s.nextInt();
          ArrayList<Long> nice = new ArrayList<Long>();
          for(int i=0;i<n;i++){
              long a=s.nextLong();
              nice.add(a);
          }
          Collections.sort(nice);
          HashMap<Long,Long> map= new  HashMap<Long,Long>();
          ArrayList<Long> well = new ArrayList<Long>();
          long array[]= new long[n+1];
          long yoyo=0;
          for(int i=0;i<n;i++){
              long num=nice.get(i);
              if(num>=1 && num<=n){
                  if(!map.containsKey(num)){
                      map.put(num,(long)1);
                      array[(int)num]=1;
                      yoyo++;
                  }
                  else{
                      well.add(num);
                  }
              }
              else{
                  well.add(num);
              }
          }
          ArrayList<Long> see = new ArrayList<Long>();
          for(int i=1;i<=n;i++){
              if(array[i]==0){
                  see.add((long)i);
              }
          }
  
          Collections.sort(well);
          if(well.size()>0){
              long tt=0;
              long req=see.get((int)tt);
              for(int i=0;i<well.size();i++){
                  long num=well.get(i);
                  long b=2;
                  long hh=(num+1)/b;
                  if(req<hh){
                      tt++;
                      if(tt<see.size()){
                          req=see.get((int)(tt));
                      }
                      else{
                          break;
                      }
                  }
              }
              if(tt==see.size()){
                  res.append(see.size()+" \n");
              }
              else{
                  res.append("-1 \n");
              }
          }
          else{
              res.append("0 \n");
          }
  
          // long val=1;
          // long count=0;
          // for(int i=0;i<n;i++){
          //     long num=nice.get(i);
          //     if(num==val){
          //         val++;
          //     }
          //     else{
          //         long b=2;
          //         long hh=(num+1)/b;
          //         if(val<hh){
          //             count++;
          //             val++;
          //         }
          //     }
          // }
          // if(val==n+1){
            
          //     long ans=(n-yoyo);
          //     res.append(ans+" \n");
          // }
          // else{
          //     res.append("-1 \n");
          // }
          p++;
      }
      System.out.println(res);
      }
      static class FastScanner {
  		BufferedReader br;
  		StringTokenizer st;
   
  		public FastScanner(String s) {
  			try {
  				br = new BufferedReader(new FileReader(s));
  			} catch (FileNotFoundException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			}
  		}
   
  		public FastScanner() {
  			br = new BufferedReader(new InputStreamReader(System.in));
  		}
   
  		String nextToken() {
  			while (st == null || !st.hasMoreElements()) {
  				try {
  					st = new StringTokenizer(br.readLine());
  				} catch (IOException e) {
  					// TODO Auto-generated catch block
  					e.printStackTrace();
  				}
  			}
  			return st.nextToken();
  		}
   
  		int nextInt() {
  			return Integer.parseInt(nextToken());
  		}
   
  		long nextLong() {
  			return Long.parseLong(nextToken());
  		}
   
  		double nextDouble() {
  			return Double.parseDouble(nextToken());
  		}
  	}
  
  
      static long modpower(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;
      }
  
    
     // SIMPLE POWER FUNCTION=>
  
  
        static long power(long x, long y)
          {
              long res = 1;     // Initialize result
          
              while (y > 0)
              {
              
                  // If y is odd, multiply x with result
                  if ((y & 1) != 0)
                      res = res * x;
          
                  // y must be even now
                  y = y >> 1; // y = y/2
                  x = x * x;  // Change x to x^2
              }
              return res;
          }
  
  
  
  
  
  }