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

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

#!/bin/python3

import sys
from collections import Counter

def has_unhappy_bees(b):
    counter = 1
    for i in range(0, len(b) - 1):
        if b[i + 1] == b[i]:
            counter += 1
        else:
            if counter <= 1:
                return True
    return False

Q = int(input().strip())
for a0 in range(Q):
    n = int(input().strip())
    b = input().strip()
    c = Counter(b)
    if any(1 for k, v in c.items() if v == 1 and k != '_'):
        print('NO')
    elif c.get('_', 0) == 0 and has_unhappy_bees(b):
        print('NO')
    else:
        print('YES')

gets.to_i.times do
    n = gets.strip.to_i
    s = gets.strip.chars
    c = s.group_by{|x| x}
    happy = true
    c.each{|k,v| happy = false if v.size < 2 and k != '_'}
    happy = false if !c['_'] and s.each_with_index.count{|x,i| i>0 and x != s[i-1]} > c.size
    puts happy ? 'YES' : 'NO'
end