/* 
 
_       -> 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))

static String happyLadybugs(String b) {
    int[] lb = new int['Z' - 'A' + 1];
    boolean esp = false;
    //The number of ladybirds for each color is saved in lb
    //and evaluated if there is at least one space
    for (char c : b.toCharArray()) {
        if(c!='_'){
            lb[c-'A']++;
        }else{
            esp = true;
        }
    }
    //If there are no spaces, all the ladybugs should have an equal partner
    if (!esp) {
        for (int i = 1; i < b.length()-1; i++) {
            if(b.charAt(i)!=b.charAt(i-1) && b.charAt(i)!=b.charAt(i+1)){
                return "NO";
            }
        }
    }
    //If there are spaces, there can not be a ladybug of a single color
    for (int i : lb) {
        if(i==1) return "NO";
    }
    //If there is no unhappy ladybug
    return "YES";
}

int main(){
    int Q;
    cin >> Q;
    for(int a0 = 0; a0 < Q; a0++){
        int n;
        cin >> n;
        string b;
        cin >> b;
   
        bool res=1;
        for(char i='A'; i<='Z'; i++){
            int cnt=0;
            for(int j=0; j<n; j++){
                if(b[j]==i) cnt++;
            }
            if(cnt==1){res=0; break;}     
        }
        if(res){
            int cnt_=0;
            for(int i=0; i<n; i++){
                if(b[i]=='_') cnt_++;
            }
            if(cnt_==0){
                for(int i=1; i<(n-1); i++){
                    if(b[i]!=b[i+1] && b[i]!=b[i-1]) {res=0; break;}
                }
            } 
        }
        if(res) cout << "YES" << endl;
        else cout << "NO" << endl;
    }
    return 0;
}

static boolean f1(String str)
    {
        int underscore=0;
        int[] abc = new int[26];
        for(int i=0;i<str.length();i++)
        {
            if(str.charAt(i)!='_')
                abc[str.charAt(i)-'A']++;
            else
                underscore++;
        } 
        
        for(int i=0;i<abc.length;i++)
            if(abc[i]==1)
                return false;
        
        return underscore==0?false:true;
    }
    static String happyLadybugs(String b) {

        String pattern="((\\w)\\2+)+\\_?";
        
        if(b.matches(pattern) || f1(b))
            return "YES";
        
        
        return "NO";
    }