 // package Jobeel;
import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
import java.util.Map.*;

public class codeforces {
	static 	PrintWriter pw=new PrintWriter(System.out);
	static int [] size,arr;
	static String [] words;
	static long k,n,a,b,y;
	public static int find(int i) {
		if(arr[i]==i) return i;
		else {
			int result=find(arr[i]);
			arr[i]=result;
			return result;
		}
	}
	
public static void union(int u,int v) {
		int root_u=find(u);
		int root_v=find(v);
		if (root_u==root_v) return;
		else if(size[root_u]>size[root_v]) {
			size[root_u]+=size[root_v];
			arr[root_v]=root_u;
		}else  {
			size[root_v]+=size[root_u];
			arr[root_u]=root_v;
		}
	}
    public static long binarysearch() {
    	long low=0,high=n,ans=-1;
    	while(low<=high) {
    		long mid=(low+high)>>1;
    	    long current=mid*a+(n-mid)*b;
    	    if(current<k) { ans=Math.max(ans, mid); low=mid+1;}
    	    else high=mid-1;
    	}
    	return ans;
    }
    
    static int getMinSteps(int n,int memo[]) 
    { 
        // base case 
        if (n == y) 
        return 0; 
        if (memo[n] != -1) 
        return memo[n]; 
      
        // store temp value for 
        // n as min( f(n-1), 
        // f(n/2), f(n/3)) +1 
        int res = getMinSteps(n - 1, memo); 
      
        if (n % 2 == 0) 
            res = Math.min(res,  
                  getMinSteps((n*3)>>1, memo)); 
        
        memo[n] = 1 + res; 
        return memo[n]; 
    } 
      
    // This function mainly 
    // initializes memo[] and 
    // calls getMinSteps(n, memo) 
    static int getMinSteps(int n) 
    { 
        int memo[] = new int[n + 1]; 
      
        // initialize memoized array 
        for (int i = 0; i <= n; i++) 
            memo[i] = -1; 
      
        return getMinSteps(n, memo); 
    } 
public static void main(String [] args) throws IOException, InterruptedException {
		Scanner sc=new Scanner(System.in);
		 int t =sc.nextInt();
		 while(t-->0) {
			int x=sc.nextInt(); 
			TreeMap<Integer, TreeSet<Integer>> map=new TreeMap<>();
			while(x-->0) {
				int y=sc.nextInt(); 
				if(map.containsKey(y)) map.get(y).add(x);
				else {map.put(y, new TreeSet<>());  map.get(y).add(x);}
				
			}
			int min=(int)1e10;
			while(!map.isEmpty()) {
				Entry<Integer,TreeSet<Integer>> entry=map.pollFirstEntry();
				while(entry.getValue().size()>1) {
					int b=entry.getValue().pollFirst(); 
					int a=entry.getValue().pollFirst(); 
					min=Math.min((a-b)+1,min);
					entry.getValue().add(a);
				}
			}
			pw.println(min==(int)1e10 ? -1:min);
		 }
		pw.flush();
		pw.close();
	}
	static class pair implements Comparable<pair>{
		String  name; int x,y ;
		
		
		public pair (int x,int y) {
			this.x=x; this.y=y;
		}
		public int compareTo(pair o) {
			if(!name.equals(o.name))
				return name.compareTo(o.name);
			return x-o.x;
		}
		public String toString() {
			return x+" "+y;
		}
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;
 
		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}
 
		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}
 
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public String nextLine() throws IOException {
			return br.readLine();
		}
 
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
 
		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}
 
		public char nextChar() throws IOException {
			return next().charAt(0);
		}
 
		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}
 
		public boolean ready() throws IOException {
			return br.ready();
		}
		public int[] nextIntArray(int n) throws IOException {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }
        public long[] nextLongArray(int n) throws IOException {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }
        public HashMap<Integer, Integer> nextHashMap(int n) throws IOException{
        	HashMap<Integer, Integer> map =new HashMap<>();
        	for(int i=0;i<n;i++) {
        		int x=nextInt();
        		int b=map.getOrDefault(x, 0);
        		map.put(x, b+1);
        	}
        	return map;
        }
        public TreeMap<Integer, Integer> nextTreeMap(int n) throws IOException{
        	TreeMap<Integer, Integer> map =new TreeMap<>();
        	for(int i=0;i<n;i++) {
        		int x=nextInt();
        		int b=map.getOrDefault(x, 0);
        		map.put(x, b+1);
        		
        	}
        	return map;
        }
        public HashSet<Integer> nextHashSet (int n) throws IOException{
        	HashSet<Integer> set=new HashSet<>();
        	for(int i=0;i<n;i++) set.add(nextInt());
        	return set;
        }
        public TreeSet<Integer> nextTreeSet(int n) throws IOException{
        	TreeSet<Integer> set=new TreeSet<>();
        	for(int i=0;i<n;i++) set.add(nextInt());
        	return set;
        }
        public long[] nextLongArraySorted(int n) throws IOException {
        	long [] arr=nextLongArray(n);
        	Arrays.parallelSort(arr);
            return arr;
        }
        public int [] nextIntArraySorted(int n) throws IOException{
        	int [] arr=nextIntArray(n);
        	Arrays.parallelSort(arr);
        	return arr;
        }
	    public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
	}