import  java.util.*;
import java.lang.*;
import java.io.*;

 public class Code {

    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());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

//        static int[][] dp = new int[100002][6];
//        static ArrayList<Integer> a=new ArrayList<>();
//            static final int MAX_CHAR = 26;
//        static int c=1;

    public static void main (String[] args) throws java.lang.Exception{
            FastReader sc = new FastReader();
          StringBuffer sb=new StringBuffer();




            int l=sc.nextInt();
            while(l-->0) {
                int n=sc.nextInt();
                int[] a=new int[n];
                for (int i = 0; i < a.length; i++) {
                    a[i]=sc.nextInt();
                }
                int k=isPossibleTriangle(a,n);
                if(k==-1)
                    System.out.println(-1);
                else
                    System.out.println((k)+" "+(k+1)+" "+(k+2));

                

            }

//                int[] a={5,1,3,3,3};
//                int t=1;
//                int k=1;
//                int c=countFreq(a,a.length);
//                int x=Math.min(t*k+c,(t+1)*k);
//        System.out.println(x);




        }
//        static  int m=1;
//  static   Set<Integer> s=new HashSet<>();
     static int isPossibleTriangle(int []arr,
                                       int N)
     {

         // If number of elements are
         // less than 3, then no
         // triangle is possible


         // first sort the array


         // loop for all 3
         // consecutive triplets
         for (int i = 0; i < N - 2; i++) { // If triplet satisfies
             // triangle condition, break
             if (arr[i] + arr[i + 1] < arr[i + 2]) {
                 return i+1;
             }
         }

         return -1;
     }

//   static int wed(int[] a,int k)
//   {
//       int t=1;
//       int min=1;
//       int val=a[0];
//       s.add(a[0]);
//       int c=1;
//       for(int i=1;i<a.length;i++)
//       {
//           if(s.contains(a[i])) {
//               c++;
//               t = Math.min((t * k) + c, (t + 1) * k + 0);
//           }
//           else
//           {
//               t = Math.min((t * k) , (t + 1) * k + 0);
//
//           }
//           min=Math.max(min,t);
//       }
//       return c;

//   }
     static  int t1=0,t2=0;
        static int wed(int[] a,int k,int n,int t,int c)
        {




            if(n==0 || t>n+1) {


                if(t==t1) {
                    t1--;
                    return (t1 * k) + c;
                }
                else {
                    t1--;
                    return t2 * k + 0;
                }
            }




             return Math.min(wed(a,k,n-1,t1,c),wed(a,k,n-1,t2++,c));

        }

//        private static int walk(int[] a, int k, int z, int i) {
//
//            if (k == 0 || i >= a.length || i < 0) return 0;
//            if (dp[i][z] != 0)
//                return dp[i][z];
//
//
//            int val = a[i] + walk(a, k - 1, z, i + 1);
//            if (i > 0 && z > 0)
//                val = Math.max(val, a[i] + walk(a, k - 1, z - 1, i - 1));
//            dp[i][z] = val;
//            return val;
//
//        }

//    static String sortString(String str) {
//        String k="";
//        // Hash array to keep count of characters.
//        int letters[] = new int[MAX_CHAR];
//
//        // Traverse string and increment
//        // count of characters
//        for (char x : str.toCharArray()) {
//
//            // 'a'-'a' will be 0, 'b'-'a' will be 1,
//            // so for location of character in count
//            // array we will do str[i]-'a'.
//            letters[x - 'a']++;
//        }
//
//        // Traverse the hash array and print
//        // characters
//        for (int i = 0; i < MAX_CHAR; i++) {
//            for (int j = 0; j < letters[i]; j++) {
//
//              k+= (char) (i + 'a');
//            }
//        }
//        return k;
//    }


     static int  countFreq(int arr[], int n)
     {
         Map<Integer, Integer> mp = new HashMap<>();

         // Traverse through array elements and
         // count frequencies
         for (int i = 0; i < n; i++)
         {
             mp.put(arr[i], mp.get(arr[i]) == null ? 1 : mp.get(arr[i]) + 1);
         }

         // To print elements according to first
         // occurrence, traverse array one more time
         // print frequencies of elements and mark
         // frequencies as -1 so that same element
         // is not printed multiple times.
         int sum=0;
         for (int i = 0; i < n; i++)
         {
             if (mp.get(arr[i]) > 1)
             {
                  sum +=mp.get(arr[i]);
                 mp.put(arr[i], -1);
             }
         }
         return sum;
     }
//
//
//
//    ///////////////////////////////////
//    public static String toString(char[] a)
//    {
//        String string = String.valueOf(a);
//
//        return string;
//    }

}
