/* 
 
_       -> YES
X       -> NO
XX      -> YES
X_      -> NO
XY      -> NO
X_X     -> YES
XYX     -> NO
XYZ     -> NO
_XX     -> YES
YXX     -> NO
X__     -> NO
X_Y     -> NO
XXYY    -> YES
XXYZ    -> NO
XYXY    -> NO
XXXY    -> NO
XYXX    -> NO
X_XX    -> YES
X__X    -> YES
XY_X    -> NO
X___    -> NO
XYZZZ   -> NO
X_XYY   -> YES
_XY_Y   -> NO
_XX__   -> YES
_XXYY   -> YES
X_XYY   -> YES
X___X   -> YES
X__YX   -> NO
X_X_Y_  -> NO
XXXYYY  -> YES 
____ZZ  -> YES 
XYZYZY  -> NO
XXYYZZ  -> YES 
X_XYXY  -> YES (can do moves XX_YXY, XXXY_Y, XXXYY_)
XZY_YZX -> YES (can do moves XZ_YYZX, XZZYY_X, _ZZYYXX)
_XYYYXX -> YES (can do moves XXYYY_X, XX_YYYX, XXXYYY_)
    */

// O(n) solution that is meant to be readable but not super-efficient 
    // due to use of LINQ and multiple passes through inputted string.
    static bool CanMakeAllHappy(string str)
    {
        // If there are any non-underscore characters that appear only one
        // time in the string, they can never be happy.
        bool existSingles = str.Where(c => c != '_')
            .GroupBy(c => c).Select(g => g.Count())
            .Any(count => count == 1);
        if(existSingles)
            return false;

        // If there are no unhappy characters, return true already.
        bool existUnhappies = str.Where((c, i) =>
            {
                if (c == '_')
                    return false;
                List<char> neighbors = new List<char>();
                if (i > 0)
                    neighbors.Add(str[i - 1]);
                if ((i + 1) < str.Length)
                    neighbors.Add(str[i + 1]);
                bool isHappy = neighbors.Any(n => n == c);
                return !isHappy;
            })
            .Any();
        if(!existUnhappies)
            return true;

        // If we made it here, there are unhappy characters and none of them
        // appear only one time in the string. So long as there exists an 
        // empty space, we can perform a sequence of swaps that make every
        // character happy (similar to insertion-sort algorithm).
        bool existsUnderscores = str.Any(c => c == '_');

        return existsUnderscores;
    }

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int Q = in.nextInt();
        for(int a0 = 0; a0 < Q; a0++){
            int n = in.nextInt();
            String b = in.next();
            System.out.println(isHappy(b) ? "YES" : "NO");
        }
    }
    
    public static boolean isHappy(String s) {
        if (hasUnique(s)) {
            return false;
        }
        
        if (alreadyHappy(s)) {
            return true;
        }
        
        if (hasSpace(s)) {
            return true;
        }
        
        return false;
    }
    
    public static boolean hasUnique(String s) {
        int[] ascii = new int[26];
        
        for (int i=0;i<s.length();i++) {
            if (s.charAt(i) != '_') {
                ascii[(int)s.charAt(i)-65]++;
            }
        }
        
        for (int i=0;i<26;i++) {
            if (ascii[i] == 1) {
                return true;
            }
        }
        
        return false;
    }
    
    public static boolean alreadyHappy(String s) {
        for (int i=0;i<s.length()-1;i++) {
            if (i == 0 && s.charAt(i) != s.charAt(i+1)) {
                return false;
            }
            else if (s.charAt(i) != s.charAt(i+1) && s.charAt(i) != s.charAt(i-1)){
                return false;
            }
        }
        
        return true;
    }
    
    public static boolean hasSpace(String s) {
        for (int i=0;i<s.length();i++) {
            if (s.charAt(i) == '_') {
                return true;
            }
        }
        
        return false;
    }
}

def calculate(n, b):
#   if b.count("_") == 0 and compare(b):
				# find if exists any single letter
    if b.count("_") == 0 and len(re.sub(r'((.)\2+)', "", b)) != 0:
        return "NO"
    for a in set(b):
        if a != "_" and b.count(a) == 1:
            return "NO"
    return "YES"
'''
Thanks to reddeadya, this part didn't work for "XXBBXX"
def compare(b):
    if len(b) == 1:
        return True
    for x in set(b):
        if x * b.count(x) != b[b.index(x):b.index(x) + b.count(x)]:
            return True
    return False
'''
for _ in range(int(input())):
    n = int(input())
    b = input()
    print(calculate(n, b))