diff --git a/core/patch/cassandra/interception.patch b/core/patch/cassandra/interception.patch
new file mode 100644
index 00000000..bf4df75d
--- /dev/null
+++ b/core/patch/cassandra/interception.patch
@@ -0,0 +1,489 @@
+diff --git a/src/java/org/apache/cassandra/config/YamlConfigurationLoader.java b/src/java/org/apache/cassandra/config/YamlConfigurationLoader.java
+index a8d4695cb0..54720cec46 100644
+--- a/src/java/org/apache/cassandra/config/YamlConfigurationLoader.java
++++ b/src/java/org/apache/cassandra/config/YamlConfigurationLoader.java
+@@ -56,41 +56,40 @@ import org.yaml.snakeyaml.introspector.Property;
+ import org.yaml.snakeyaml.introspector.PropertyUtils;
+ import org.yaml.snakeyaml.nodes.Node;
+ 
+-public class YamlConfigurationLoader implements ConfigurationLoader
+-{
++public class YamlConfigurationLoader implements ConfigurationLoader {
+     private static final Logger logger = LoggerFactory.getLogger(YamlConfigurationLoader.class);
+ 
+     private final static String DEFAULT_CONFIGURATION = "cassandra.yaml";
++    private final static String CTEST_CONFIGURATION = "ctest-injection.yaml";
+ 
+     /**
+      * Inspect the classpath to find storage configuration file
+      */
+-    private static URL getStorageConfigURL() throws ConfigurationException
+-    {
++    private static URL getStorageConfigURL() throws ConfigurationException {
+         String configUrl = System.getProperty("cassandra.config");
+         if (configUrl == null)
+             configUrl = DEFAULT_CONFIGURATION;
+ 
+         URL url;
+-        try
+-        {
++        try {
+             url = new URL(configUrl);
+             url.openStream().close(); // catches well-formed but bogus URLs
+-        }
+-        catch (Exception e)
+-        {
++        } catch (Exception e) {
+             ClassLoader loader = DatabaseDescriptor.class.getClassLoader();
+             url = loader.getResource(configUrl);
+-            if (url == null)
+-            {
++            if (url == null) {
+                 String required = "file:" + File.separator + File.separator;
+                 if (!configUrl.startsWith(required))
+                     throw new ConfigurationException(String.format(
+-                        "Expecting URI in variable: [cassandra.config]. Found[%s]. Please prefix the file with [%s%s] for local " +
+-                        "files and [%s<server>%s] for remote files. If you are executing this from an external tool, it needs " +
+-                        "to set Config.setClientMode(true) to avoid loading configuration.",
+-                        configUrl, required, File.separator, required, File.separator));
+-                throw new ConfigurationException("Cannot locate " + configUrl + ".  If this is a local file, please confirm you've provided " + required + File.separator + " as a URI prefix.");
++                            "Expecting URI in variable: [cassandra.config]. Found[%s]. Please prefix the file with [%s%s] for local "
++                                    +
++                                    "files and [%s<server>%s] for remote files. If you are executing this from an external tool, it needs "
++                                    +
++                                    "to set Config.setClientMode(true) to avoid loading configuration.",
++                            configUrl, required, File.separator, required, File.separator));
++                throw new ConfigurationException(
++                        "Cannot locate " + configUrl + ".  If this is a local file, please confirm you've provided "
++                                + required + File.separator + " as a URI prefix.");
+             }
+         }
+ 
+@@ -102,30 +101,60 @@ public class YamlConfigurationLoader implements ConfigurationLoader
+     private static URL storageConfigURL;
+ 
+     @Override
+-    public Config loadConfig() throws ConfigurationException
+-    {
++    public Config loadConfig() throws ConfigurationException {
+         if (storageConfigURL == null)
+             storageConfigURL = getStorageConfigURL();
+-        return loadConfig(storageConfigURL);
++
++        logger.debug("Loading settings from {}", storageConfigURL);
++        byte[] configBytes;
++        Map<String, Object> confMap = new HashMap<>();
++        URL url;
++        Yaml yaml = new Yaml();
++        try (InputStream is = storageConfigURL.openStream()) {
++            configBytes = ByteStreams.toByteArray(is);
++            Map<String, Object> obj = yaml.load(new ByteArrayInputStream(configBytes));
++            confMap.putAll(obj);
++        } catch (IOException e) {
++            // getStorageConfigURL should have ruled this out
++            throw new AssertionError(e);
++        }
++
++        try {
++            url = new URL(CTEST_CONFIGURATION);
++            url.openStream().close(); // catches well-formed but bogus URLs
++        } catch (Exception e) {
++            ClassLoader loader = DatabaseDescriptor.class.getClassLoader();
++            url = loader.getResource(CTEST_CONFIGURATION);
++            if (url == null) {
++                throw new ConfigurationException("fail to load Ctest config");
++            }
++        }
++        logger.debug("Loading settings from {}", url);
++        try (InputStream is = url.openStream()) {
++            configBytes = ByteStreams.toByteArray(is);
++            Map<String, Object> obj = yaml.load(new ByteArrayInputStream(configBytes));
++            if (obj != null) {
++                confMap.putAll(obj);
++            }
++        } catch (IOException e) {
++            // getStorageConfigURL should have ruled this out
++            throw new AssertionError(e);
++        }
++
++        return fromMap(confMap, Config.class);
+     }
+ 
+-    public Config loadConfig(URL url) throws ConfigurationException
+-    {
+-        try
+-        {
++    public Config loadConfig(URL url) throws ConfigurationException {
++        try {
+             logger.debug("Loading settings from {}", url);
+             byte[] configBytes;
+-            try (InputStream is = url.openStream())
+-            {
++            try (InputStream is = url.openStream()) {
+                 configBytes = ByteStreams.toByteArray(is);
+-            }
+-            catch (IOException e)
+-            {
++            } catch (IOException e) {
+                 // getStorageConfigURL should have ruled this out
+                 throw new AssertionError(e);
+             }
+ 
+-
+             Constructor constructor = new CustomConstructor(Config.class, Yaml.class.getClassLoader());
+             Map<Class<?>, Map<String, Replacement>> replacements = getNameReplacements(Config.class);
+             PropertiesChecker propertiesChecker = new PropertiesChecker(replacements);
+@@ -134,34 +163,29 @@ public class YamlConfigurationLoader implements ConfigurationLoader
+             Config result = loadConfig(yaml, configBytes);
+             propertiesChecker.check();
+             return result;
+-        }
+-        catch (YAMLException e)
+-        {
++        } catch (YAMLException e) {
+             throw new ConfigurationException("Invalid yaml: " + url + SystemUtils.LINE_SEPARATOR
+-                                             +  " Error: " + e.getMessage(), false);
++                    + " Error: " + e.getMessage(), false);
+         }
+     }
+ 
+     @VisibleForTesting
+-    public static <T> T fromMap(Map<String,Object> map, Class<T> klass)
+-    {
++    public static <T> T fromMap(Map<String, Object> map, Class<T> klass) {
+         return fromMap(map, true, klass);
+     }
+ 
+-    @SuppressWarnings("unchecked") //getSingleData returns Object, not T
+-    public static <T> T fromMap(Map<String,Object> map, boolean shouldCheck, Class<T> klass)
+-    {
++    @SuppressWarnings("unchecked") // getSingleData returns Object, not T
++    public static <T> T fromMap(Map<String, Object> map, boolean shouldCheck, Class<T> klass) {
+         Constructor constructor = new YamlConfigurationLoader.CustomConstructor(klass, klass.getClassLoader());
+         Map<Class<?>, Map<String, Replacement>> replacements = getNameReplacements(Config.class);
+-        YamlConfigurationLoader.PropertiesChecker propertiesChecker = new YamlConfigurationLoader.PropertiesChecker(replacements);
++        YamlConfigurationLoader.PropertiesChecker propertiesChecker = new YamlConfigurationLoader.PropertiesChecker(
++                replacements);
+         constructor.setPropertyUtils(propertiesChecker);
+         Yaml yaml = new Yaml(constructor);
+         Node node = yaml.represent(map);
+-        constructor.setComposer(new Composer(null, null)
+-        {
++        constructor.setComposer(new Composer(null, null) {
+             @Override
+-            public Node getSingleNode()
+-            {
++            public Node getSingleNode() {
+                 return node;
+             }
+         });
+@@ -171,10 +195,8 @@ public class YamlConfigurationLoader implements ConfigurationLoader
+         return value;
+     }
+ 
+-    static class CustomConstructor extends CustomClassLoaderConstructor
+-    {
+-        CustomConstructor(Class<?> theRoot, ClassLoader classLoader)
+-        {
++    static class CustomConstructor extends CustomClassLoaderConstructor {
++        CustomConstructor(Class<?> theRoot, ClassLoader classLoader) {
+             super(theRoot, classLoader);
+ 
+             TypeDescription seedDesc = new TypeDescription(ParameterizedClass.class);
+@@ -183,38 +205,35 @@ public class YamlConfigurationLoader implements ConfigurationLoader
+         }
+ 
+         @Override
+-        protected List<Object> createDefaultList(int initSize)
+-        {
++        protected List<Object> createDefaultList(int initSize) {
+             return Lists.newCopyOnWriteArrayList();
+         }
+ 
+         @Override
+-        protected Map<Object, Object> createDefaultMap(int initSize)
+-        {
++        protected Map<Object, Object> createDefaultMap(int initSize) {
+             return Maps.newConcurrentMap();
+         }
+ 
+         @Override
+-        protected Set<Object> createDefaultSet(int initSize)
+-        {
++        protected Set<Object> createDefaultSet(int initSize) {
+             return Sets.newConcurrentHashSet();
+         }
+     }
+ 
+-    private static Config loadConfig(Yaml yaml, byte[] configBytes)
+-    {
++    private static Config loadConfig(Yaml yaml, byte[] configBytes) {
+         Config config = yaml.loadAs(new ByteArrayInputStream(configBytes), Config.class);
+-        // If the configuration file is empty yaml will return null. In this case we should use the default
++        // If the configuration file is empty yaml will return null. In this case we
++        // should use the default
+         // configuration to avoid hitting a NPE at a later stage.
+         return config == null ? new Config() : config;
+     }
+ 
+     /**
+-     * Utility class to check that there are no extra properties and that properties that are not null by default
++     * Utility class to check that there are no extra properties and that properties
++     * that are not null by default
+      * are not set to null.
+      */
+-    private static class PropertiesChecker extends PropertyUtils
+-    {
++    private static class PropertiesChecker extends PropertyUtils {
+         private final Set<String> missingProperties = new HashSet<>();
+ 
+         private final Set<String> nullProperties = new HashSet<>();
+@@ -223,115 +242,100 @@ public class YamlConfigurationLoader implements ConfigurationLoader
+ 
+         private final Map<Class<?>, Map<String, Replacement>> replacements;
+ 
+-        public PropertiesChecker(Map<Class<?>, Map<String, Replacement>> replacements)
+-        {
++        public PropertiesChecker(Map<Class<?>, Map<String, Replacement>> replacements) {
+             this.replacements = Objects.requireNonNull(replacements, "Replacements should not be null");
+             setSkipMissingProperties(true);
+         }
+ 
+         @Override
+-        public Property getProperty(Class<? extends Object> type, String name)
+-        {
++        public Property getProperty(Class<? extends Object> type, String name) {
+             final Property result;
+             Map<String, Replacement> typeReplacements = replacements.getOrDefault(type, Collections.emptyMap());
+-            if (typeReplacements.containsKey(name))
+-            {
++            if (typeReplacements.containsKey(name)) {
+                 Replacement replacement = typeReplacements.get(name);
+                 final Property newProperty = super.getProperty(type, replacement.newName);
+-                result = new Property(replacement.oldName, newProperty.getType())
+-                {
++                result = new Property(replacement.oldName, newProperty.getType()) {
+                     @Override
+-                    public Class<?>[] getActualTypeArguments()
+-                    {
++                    public Class<?>[] getActualTypeArguments() {
+                         return newProperty.getActualTypeArguments();
+                     }
+ 
+                     @Override
+-                    public void set(Object o, Object o1) throws Exception
+-                    {
++                    public void set(Object o, Object o1) throws Exception {
+                         newProperty.set(o, o1);
+                     }
+ 
+                     @Override
+-                    public Object get(Object o)
+-                    {
++                    public Object get(Object o) {
+                         return newProperty.get(o);
+                     }
+ 
+                     @Override
+-                    public List<Annotation> getAnnotations()
+-                    {
++                    public List<Annotation> getAnnotations() {
+                         return null;
+                     }
+ 
+                     @Override
+-                    public <A extends Annotation> A getAnnotation(Class<A> aClass)
+-                    {
++                    public <A extends Annotation> A getAnnotation(Class<A> aClass) {
+                         return null;
+                     }
+                 };
+ 
+                 if (replacement.deprecated)
+                     deprecationWarnings.add(replacement.oldName);
+-            }
+-            else
+-            {
++            } else {
+                 result = super.getProperty(type, name);
+             }
+ 
+-            if (result instanceof MissingProperty)
+-            {
++            if (result instanceof MissingProperty) {
+                 missingProperties.add(result.getName());
+             }
+ 
+-            return new Property(result.getName(), result.getType())
+-            {
++            return new Property(result.getName(), result.getType()) {
+                 @Override
+-                public void set(Object object, Object value) throws Exception
+-                {
+-                    if (value == null && get(object) != null)
+-                    {
++                public void set(Object object, Object value) throws Exception {
++                    if (value == null && get(object) != null) {
+                         nullProperties.add(getName());
+                     }
+                     result.set(object, value);
+                 }
+ 
+                 @Override
+-                public Class<?>[] getActualTypeArguments()
+-                {
++                public Class<?>[] getActualTypeArguments() {
+                     return result.getActualTypeArguments();
+                 }
+ 
+                 @Override
+-                public Object get(Object object)
+-                {
++                public Object get(Object object) {
+                     return result.get(object);
+                 }
+ 
+                 @Override
+-                public List<Annotation> getAnnotations()
+-                {
++                public List<Annotation> getAnnotations() {
+                     return Collections.EMPTY_LIST;
+                 }
+ 
+                 @Override
+-                public <A extends Annotation> A getAnnotation(Class<A> aClass)
+-                {
++                public <A extends Annotation> A getAnnotation(Class<A> aClass) {
+                     return null;
+                 }
+             };
+         }
+ 
+-        public void check() throws ConfigurationException
+-        {
++        public void check() throws ConfigurationException {
+             if (!nullProperties.isEmpty())
+-                throw new ConfigurationException("Invalid yaml. Those properties " + nullProperties + " are not valid", false);
++                throw new ConfigurationException("Invalid yaml. Those properties " + nullProperties + " are not valid",
++                        false);
+ 
+             if (!missingProperties.isEmpty())
+-                throw new ConfigurationException("Invalid yaml. Please remove properties " + missingProperties + " from your cassandra.yaml", false);
++                throw new ConfigurationException(
++                        "Invalid yaml. Please remove properties " + missingProperties + " from your cassandra.yaml",
++                        false);
+ 
+             if (!deprecationWarnings.isEmpty())
+-                logger.warn("{} parameters have been deprecated. They have new names; For more information, please refer to NEWS.txt", deprecationWarnings);
++                logger.warn(
++                        "{} parameters have been deprecated. They have new names; For more information, please refer to NEWS.txt",
++                        deprecationWarnings);
+         }
+     }
+ 
+@@ -339,39 +343,32 @@ public class YamlConfigurationLoader implements ConfigurationLoader
+      * @param klass to get replacements for
+      * @return map of old names and replacements needed.
+      */
+-    private static Map<Class<?>, Map<String, Replacement>> getNameReplacements(Class<?> klass)
+-    {
++    private static Map<Class<?>, Map<String, Replacement>> getNameReplacements(Class<?> klass) {
+         List<Replacement> replacements = getReplacements(klass);
+         Map<Class<?>, Map<String, Replacement>> objectOldNames = new HashMap<>();
+-        for (Replacement r : replacements)
+-        {
++        for (Replacement r : replacements) {
+             Map<String, Replacement> oldNames = objectOldNames.computeIfAbsent(r.parent, ignore -> new HashMap<>());
+             if (!oldNames.containsKey(r.oldName))
+                 oldNames.put(r.oldName, r);
+-            else
+-            {
+-                throw new ConfigurationException("Invalid annotations, you have more than one @Replaces annotation in " +
+-                                                 "Config class with same old name(" + r.oldName + ") defined.");
++            else {
++                throw new ConfigurationException(
++                        "Invalid annotations, you have more than one @Replaces annotation in " +
++                                "Config class with same old name(" + r.oldName + ") defined.");
+             }
+         }
+         return objectOldNames;
+     }
+ 
+-    private static List<Replacement> getReplacements(Class<?> klass)
+-    {
++    private static List<Replacement> getReplacements(Class<?> klass) {
+         List<Replacement> replacements = new ArrayList<>();
+-        for (Field field : klass.getDeclaredFields())
+-        {
++        for (Field field : klass.getDeclaredFields()) {
+             String newName = field.getName();
+             final ReplacesList[] byType = field.getAnnotationsByType(ReplacesList.class);
+-            if (byType == null || byType.length == 0)
+-            {
++            if (byType == null || byType.length == 0) {
+                 Replaces r = field.getAnnotation(Replaces.class);
+                 if (r != null)
+                     addReplacement(klass, replacements, newName, r);
+-            }
+-            else
+-            {
++            } else {
+                 for (ReplacesList replacesList : byType)
+                     for (Replaces r : replacesList.value())
+                         addReplacement(klass, replacements, newName, r);
+@@ -381,10 +378,9 @@ public class YamlConfigurationLoader implements ConfigurationLoader
+     }
+ 
+     private static void addReplacement(Class<?> klass,
+-                                       List<Replacement> replacements,
+-                                       String newName,
+-                                       Replaces r)
+-    {
++            List<Replacement> replacements,
++            String newName,
++            Replaces r) {
+         String oldName = r.oldName();
+         boolean deprecated = r.deprecated();
+ 
+@@ -392,12 +388,13 @@ public class YamlConfigurationLoader implements ConfigurationLoader
+     }
+ 
+     /**
+-     * Holder for replacements to support backward compatibility between old and new names for configuration parameters
+-     * backported partially from trunk(CASSANDRA-15234) to support a bug fix/improvement in Cassadra 4.0
++     * Holder for replacements to support backward compatibility between old and new
++     * names for configuration parameters
++     * backported partially from trunk(CASSANDRA-15234) to support a bug
++     * fix/improvement in Cassadra 4.0
+      * (CASSANDRA-17141)
+      */
+-    static final class Replacement
+-    {
++    static final class Replacement {
+         /**
+          * Currently we use for Config class
+          */
+@@ -411,15 +408,15 @@ public class YamlConfigurationLoader implements ConfigurationLoader
+          */
+         final String newName;
+         /**
+-         * A flag to mark whether the old name is deprecated and fire a warning to the user. By default we set it to false.
++         * A flag to mark whether the old name is deprecated and fire a warning to the
++         * user. By default we set it to false.
+          */
+         final boolean deprecated;
+ 
+         Replacement(Class<?> parent,
+-                    String oldName,
+-                    String newName,
+-                    boolean deprecated)
+-        {
++                String oldName,
++                String newName,
++                boolean deprecated) {
+             this.parent = Objects.requireNonNull(parent);
+             this.oldName = Objects.requireNonNull(oldName);
+             this.newName = Objects.requireNonNull(newName);
+diff --git a/test/conf/ctest-injection.yaml b/test/conf/ctest-injection.yaml
+new file mode 100644
+index 0000000000..e69de29bb2
diff --git a/core/patch/cassandra/logging.patch b/core/patch/cassandra/logging.patch
new file mode 100644
index 00000000..5396dd6b
--- /dev/null
+++ b/core/patch/cassandra/logging.patch
@@ -0,0 +1,2400 @@
+diff --git a/src/java/org/apache/cassandra/config/DatabaseDescriptor.java b/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
+index f78a5b668a..cb765a99d1 100644
+--- a/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
++++ b/src/java/org/apache/cassandra/config/DatabaseDescriptor.java
+@@ -858,8 +858,11 @@ public class DatabaseDescriptor
+     @VisibleForTesting
+     static void applyConcurrentValidations(Config config)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "concurrent_validations" ); //CTEST
++        logger.warn("[CTEST][GET-PARAM] " + "concurrent_compactors" ); //CTEST
+         if (config.concurrent_validations < 1)
+         {
++            logger.warn("[CTEST][SET-PARAM] " + "concurrent_compactors" + getStackTrace()); //CTEST
+             config.concurrent_validations = config.concurrent_compactors;
+         }
+         else if (config.concurrent_validations > config.concurrent_compactors && !allowUnlimitedConcurrentValidations)
+@@ -872,8 +875,10 @@ public class DatabaseDescriptor
+     @VisibleForTesting
+     static void applyRepairCommandPoolSize(Config config)
+     {
+-        if (config.repair_command_pool_size < 1)
++        if (config.repair_command_pool_size < 1) {
++            logger.warn("[CTEST][SET-PARAM] " + "concurrent_validations" + getStackTrace()); //CTEST
+             config.repair_command_pool_size = config.concurrent_validations;
++        }
+     }
+ 
+     private static String storagedirFor(String type)
+@@ -919,6 +924,8 @@ public class DatabaseDescriptor
+         broadcastRpcAddress = null;
+ 
+         /* Local IP, hostname or interface to bind services to */
++        logger.warn("[CTEST][GET-PARAM] " + "listen_address" ); //CTEST
++        logger.warn("[CTEST][GET-PARAM] " + "listen_interface" ); //CTEST
+         if (config.listen_address != null && config.listen_interface != null)
+         {
+             throw new ConfigurationException("Set listen_address OR listen_interface, not both", false);
+@@ -943,6 +950,7 @@ public class DatabaseDescriptor
+         }
+ 
+         /* Gossip Address to broadcast */
++        logger.warn("[CTEST][GET-PARAM] " + "broadcast_address" ); //CTEST
+         if (config.broadcast_address != null)
+         {
+             try
+@@ -959,6 +967,8 @@ public class DatabaseDescriptor
+         }
+ 
+         /* Local IP, hostname or interface to bind RPC server to */
++        logger.warn("[CTEST][GET-PARAM] " + "rpc_address" ); //CTEST
++        logger.warn("[CTEST][GET-PARAM] " + "rpc_interface" ); //CTEST
+         if (config.rpc_address != null && config.rpc_interface != null)
+         {
+             throw new ConfigurationException("Set rpc_address OR rpc_interface, not both", false);
+@@ -984,6 +994,7 @@ public class DatabaseDescriptor
+         }
+ 
+         /* RPC address to broadcast */
++        logger.warn("[CTEST][GET-PARAM] " + "broadcast_rpc_address" ); //CTEST
+         if (config.broadcast_rpc_address != null)
+         {
+             try
+@@ -1010,6 +1021,7 @@ public class DatabaseDescriptor
+     {
+         // always attempt to load the cipher factory, as we could be in the situation where the user has disabled encryption,
+         // but has existing commitlogs and sstables on disk that are still encrypted (and still need to be read)
++        logger.warn("[CTEST][GET-PARAM] " + "transparent_data_encryption_options" ); //CTEST
+         encryptionContext = new EncryptionContext(conf.transparent_data_encryption_options);
+     }
+ 
+@@ -1017,7 +1029,10 @@ public class DatabaseDescriptor
+     {
+         try
+         {
++            logger.warn("[CTEST][GET-PARAM] " + "server_encryption_options" ); //CTEST
+             SSLFactory.validateSslContext("Internode messaging", conf.server_encryption_options, true, true);
++            logger.warn("[CTEST][GET-PARAM] " + "client_encryption_options" ); //CTEST
++            logger.warn("[CTEST][GET-PARAM] " + "client_encryption_options.require_client_auth" ); //CTEST
+             SSLFactory.validateSslContext("Native transport", conf.client_encryption_options, conf.client_encryption_options.require_client_auth, true);
+             SSLFactory.initHotReloading(conf.server_encryption_options, conf.client_encryption_options, false);
+         }
+@@ -1036,6 +1051,7 @@ public class DatabaseDescriptor
+         }
+         try
+         {
++            logger.warn("[CTEST][GET-PARAM] " + "seed_provider.parameters" ); //CTEST
+             Class<?> seedProviderClass = Class.forName(conf.seed_provider.class_name);
+             seedProvider = (SeedProvider)seedProviderClass.getConstructor(Map.class).newInstance(conf.seed_provider.parameters);
+         }
+@@ -1055,42 +1071,49 @@ public class DatabaseDescriptor
+         {
+            logInfo("read_request_timeout_in_ms", conf.read_request_timeout_in_ms, LOWEST_ACCEPTED_TIMEOUT);
+            conf.read_request_timeout_in_ms = LOWEST_ACCEPTED_TIMEOUT;
++            logger.warn("[CTEST][SET-PARAM] " + "read_request_timeout_in_ms" + getStackTrace()); //CTEST
+         }
+ 
+         if(conf.range_request_timeout_in_ms < LOWEST_ACCEPTED_TIMEOUT)
+         {
+            logInfo("range_request_timeout_in_ms", conf.range_request_timeout_in_ms, LOWEST_ACCEPTED_TIMEOUT);
+            conf.range_request_timeout_in_ms = LOWEST_ACCEPTED_TIMEOUT;
++            logger.warn("[CTEST][SET-PARAM] " + "range_request_timeout_in_ms" + getStackTrace()); //CTEST
+         }
+ 
+         if(conf.request_timeout_in_ms < LOWEST_ACCEPTED_TIMEOUT)
+         {
+            logInfo("request_timeout_in_ms", conf.request_timeout_in_ms, LOWEST_ACCEPTED_TIMEOUT);
+            conf.request_timeout_in_ms = LOWEST_ACCEPTED_TIMEOUT;
++            logger.warn("[CTEST][SET-PARAM] " + "request_timeout_in_ms" + getStackTrace()); //CTEST
+         }
+ 
+         if(conf.write_request_timeout_in_ms < LOWEST_ACCEPTED_TIMEOUT)
+         {
+            logInfo("write_request_timeout_in_ms", conf.write_request_timeout_in_ms, LOWEST_ACCEPTED_TIMEOUT);
+            conf.write_request_timeout_in_ms = LOWEST_ACCEPTED_TIMEOUT;
++            logger.warn("[CTEST][SET-PARAM] " + "write_request_timeout_in_ms" + getStackTrace()); //CTEST
+         }
+ 
+         if(conf.cas_contention_timeout_in_ms < LOWEST_ACCEPTED_TIMEOUT)
+         {
+            logInfo("cas_contention_timeout_in_ms", conf.cas_contention_timeout_in_ms, LOWEST_ACCEPTED_TIMEOUT);
+            conf.cas_contention_timeout_in_ms = LOWEST_ACCEPTED_TIMEOUT;
++            logger.warn("[CTEST][SET-PARAM] " + "cas_contention_timeout_in_ms" + getStackTrace()); //CTEST
+         }
+ 
+         if(conf.counter_write_request_timeout_in_ms < LOWEST_ACCEPTED_TIMEOUT)
+         {
+            logInfo("counter_write_request_timeout_in_ms", conf.counter_write_request_timeout_in_ms, LOWEST_ACCEPTED_TIMEOUT);
+            conf.counter_write_request_timeout_in_ms = LOWEST_ACCEPTED_TIMEOUT;
++            logger.warn("[CTEST][SET-PARAM] " + "counter_write_request_timeout_in_ms" + getStackTrace()); //CTEST
+         }
+ 
+         if(conf.truncate_request_timeout_in_ms < LOWEST_ACCEPTED_TIMEOUT)
+         {
+            logInfo("truncate_request_timeout_in_ms", conf.truncate_request_timeout_in_ms, LOWEST_ACCEPTED_TIMEOUT);
+            conf.truncate_request_timeout_in_ms = LOWEST_ACCEPTED_TIMEOUT;
++            logger.warn("[CTEST][SET-PARAM] " + "truncate_request_timeout_in_ms" + getStackTrace()); //CTEST
+         }
+     }
+ 
+@@ -1106,13 +1129,16 @@ public class DatabaseDescriptor
+ 
+     static void applyTokensConfig(Config conf)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "initial_token" ); //CTEST
+         if (conf.initial_token != null)
+         {
+             Collection<String> tokens = tokensFromString(conf.initial_token);
+             if (conf.num_tokens == null)
+             {
+-                if (tokens.size() == 1)
++                if (tokens.size() == 1) {
+                     conf.num_tokens = 1;
++                    logger.warn("[CTEST][SET-PARAM] " + "num_tokens" + getStackTrace()); //CTEST
++                }
+                 else
+                     throw new ConfigurationException("initial_token was set but num_tokens is not!", false);
+             }
+@@ -1131,6 +1157,7 @@ public class DatabaseDescriptor
+         else if (conf.num_tokens == null)
+         {
+             conf.num_tokens = 1;
++            logger.warn("[CTEST][SET-PARAM] " + "num_tokens" + getStackTrace()); //CTEST
+         }
+     }
+ 
+@@ -1165,6 +1192,7 @@ public class DatabaseDescriptor
+ 
+     public static void applyPartitioner(Config conf)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "partitioner" ); //CTEST
+         /* Hashing strategy */
+         if (conf.partitioner == null)
+         {
+@@ -1249,56 +1277,68 @@ public class DatabaseDescriptor
+ 
+     public static IAuthenticator getAuthenticator()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "authenticator" ); //CTEST
+         return authenticator;
+     }
+ 
+     public static void setAuthenticator(IAuthenticator authenticator)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "authenticator" + getStackTrace()); //CTEST
+         DatabaseDescriptor.authenticator = authenticator;
+     }
+ 
+     public static IAuthorizer getAuthorizer()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "authorizer" ); //CTEST
+         return authorizer;
+     }
+ 
+     public static void setAuthorizer(IAuthorizer authorizer)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "authorizer" + getStackTrace()); //CTEST
+         DatabaseDescriptor.authorizer = authorizer;
+     }
+ 
+     public static INetworkAuthorizer getNetworkAuthorizer()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "networkAuthorizer" ); //CTEST
+         return networkAuthorizer;
+     }
+ 
+     public static void setNetworkAuthorizer(INetworkAuthorizer networkAuthorizer)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "networkAuthorizer" + getStackTrace()); //CTEST
+         DatabaseDescriptor.networkAuthorizer = networkAuthorizer;
+     }
+ 
+     public static IRoleManager getRoleManager()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "roleManager" ); //CTEST
+         return roleManager;
+     }
+ 
+     public static void setRoleManager(IRoleManager roleManager)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "roleManager" + getStackTrace()); //CTEST
+         DatabaseDescriptor.roleManager = roleManager;
+     }
+ 
+     public static int getPermissionsValidity()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "permissions_validity_in_ms" ); //CTEST
+         return conf.permissions_validity_in_ms;
+     }
+ 
+     public static void setPermissionsValidity(int timeout)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "rolemanager" + getStackTrace()); //CTEST
+         conf.permissions_validity_in_ms = timeout;
+     }
+ 
+     public static int getPermissionsUpdateInterval()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "permissions_update_interval_in_ms" ); //CTEST
++        logger.warn("[CTEST][GET-PARAM] " + "permissions_validity_in_ms" ); //CTEST
+         return conf.permissions_update_interval_in_ms == -1
+              ? conf.permissions_validity_in_ms
+              : conf.permissions_update_interval_in_ms;
+@@ -1306,31 +1346,38 @@ public class DatabaseDescriptor
+ 
+     public static void setPermissionsUpdateInterval(int updateInterval)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "permissions_update_interval_in_ms" + getStackTrace()); //CTEST
+         conf.permissions_update_interval_in_ms = updateInterval;
+     }
+ 
+     public static int getPermissionsCacheMaxEntries()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "permissions_cache_max_entries" ); //CTEST
+         return conf.permissions_cache_max_entries;
+     }
+ 
+     public static int setPermissionsCacheMaxEntries(int maxEntries)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "permissions_cache_max_entries" ); //CTEST
+         return conf.permissions_cache_max_entries = maxEntries;
+     }
+ 
+     public static int getRolesValidity()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "roles_validity_in_ms" ); //CTEST
+         return conf.roles_validity_in_ms;
+     }
+ 
+     public static void setRolesValidity(int validity)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "roles_validity_in_ms" + getStackTrace()); //CTEST
+         conf.roles_validity_in_ms = validity;
+     }
+ 
+     public static int getRolesUpdateInterval()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "roles_update_interval_in_ms" ); //CTEST
++        logger.warn("[CTEST][GET-PARAM] " + "roles_validity_in_ms" ); //CTEST
+         return conf.roles_update_interval_in_ms == -1
+              ? conf.roles_validity_in_ms
+              : conf.roles_update_interval_in_ms;
+@@ -1338,31 +1385,38 @@ public class DatabaseDescriptor
+ 
+     public static void setRolesUpdateInterval(int interval)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "roles_update_interval_in_ms" + getStackTrace()); //CTEST
+         conf.roles_update_interval_in_ms = interval;
+     }
+ 
+     public static int getRolesCacheMaxEntries()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "roles_cache_max_entries" ); //CTEST
+         return conf.roles_cache_max_entries;
+     }
+ 
+     public static int setRolesCacheMaxEntries(int maxEntries)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "roles_cache_max_entries" ); //CTEST
+         return conf.roles_cache_max_entries = maxEntries;
+     }
+ 
+     public static int getCredentialsValidity()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "credentials_validity_in_ms" ); //CTEST
+         return conf.credentials_validity_in_ms;
+     }
+ 
+     public static void setCredentialsValidity(int timeout)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "credentials_validity_in_ms" + getStackTrace()); //CTEST
+         conf.credentials_validity_in_ms = timeout;
+     }
+ 
+     public static int getCredentialsUpdateInterval()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "credentials_update_interval_in_ms" ); //CTEST
++        logger.warn("[CTEST][GET-PARAM] " + "credentials_validity_in_ms" ); //CTEST
+         return conf.credentials_update_interval_in_ms == -1
+                ? conf.credentials_validity_in_ms
+                : conf.credentials_update_interval_in_ms;
+@@ -1370,26 +1424,31 @@ public class DatabaseDescriptor
+ 
+     public static void setCredentialsUpdateInterval(int updateInterval)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "credentials_update_interval_in_ms" + getStackTrace()); //CTEST
+         conf.credentials_update_interval_in_ms = updateInterval;
+     }
+ 
+     public static int getCredentialsCacheMaxEntries()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "credentials_cache_max_entries" ); //CTEST
+         return conf.credentials_cache_max_entries;
+     }
+ 
+     public static int setCredentialsCacheMaxEntries(int maxEntries)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "credentials_cache_max_entries" ); //CTEST
+         return conf.credentials_cache_max_entries = maxEntries;
+     }
+ 
+     public static int getMaxValueSize()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "max_value_size_in_mb" ); //CTEST
+         return conf.max_value_size_in_mb * 1024 * 1024;
+     }
+ 
+     public static void setMaxValueSize(int maxValueSizeInBytes)
+     {
++        logger.warn("[CTEST][SET-PARAM] " + "max_value_size_in_mb" + getStackTrace()); //CTEST
+         conf.max_value_size_in_mb = maxValueSizeInBytes / 1024 / 1024;
+     }
+ 
+@@ -1400,29 +1459,36 @@ public class DatabaseDescriptor
+     {
+         try
+         {
++            logger.warn("[CTEST][GET-PARAM] " + "data_file_directories" ); //CTEST
+             if (conf.data_file_directories.length == 0)
+                 throw new ConfigurationException("At least one DataFileDirectory must be specified", false);
+ 
+             for (String dataFileDirectory : conf.data_file_directories)
+                 FileUtils.createDirectory(dataFileDirectory);
+ 
++            logger.warn("[CTEST][GET-PARAM] " + "local_system_data_file_directory" ); //CTEST
+             if (conf.local_system_data_file_directory != null)
+                 FileUtils.createDirectory(conf.local_system_data_file_directory);
+ 
++            logger.warn("[CTEST][GET-PARAM] " + "commitlog_directory" ); //CTEST
+             if (conf.commitlog_directory == null)
+                 throw new ConfigurationException("commitlog_directory must be specified", false);
+             FileUtils.createDirectory(conf.commitlog_directory);
+ 
++            logger.warn("[CTEST][GET-PARAM] " + "hints_directory" ); //CTEST
+             if (conf.hints_directory == null)
+                 throw new ConfigurationException("hints_directory must be specified", false);
+             FileUtils.createDirectory(conf.hints_directory);
+ 
++            logger.warn("[CTEST][GET-PARAM] " + "saved_caches_directory" ); //CTEST
+             if (conf.saved_caches_directory == null)
+                 throw new ConfigurationException("saved_caches_directory must be specified", false);
+             FileUtils.createDirectory(conf.saved_caches_directory);
+ 
++            logger.warn("[CTEST][GET-PARAM] " + "cdc_enabled" ); //CTEST
+             if (conf.cdc_enabled)
+             {
++                logger.warn("[CTEST][GET-PARAM] " + "cdc_raw_directory" ); //CTEST
+                 if (conf.cdc_raw_directory == null)
+                     throw new ConfigurationException("cdc_raw_directory must be specified", false);
+                 FileUtils.createDirectory(conf.cdc_raw_directory);
+@@ -1467,11 +1533,13 @@ public class DatabaseDescriptor
+ 
+     public static int getColumnIndexSize()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "column_index_size_in_kb" ); //CTEST
+         return (int) ByteUnit.KIBI_BYTES.toBytes(conf.column_index_size_in_kb);
+     }
+ 
+     public static int getColumnIndexSizeInKB()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "column_index_size_in_kb" ); //CTEST
+         return conf.column_index_size_in_kb;
+     }
+ 
+@@ -1480,15 +1548,18 @@ public class DatabaseDescriptor
+     {
+         checkValidForByteConversion(val, "column_index_size_in_kb", ByteUnit.KIBI_BYTES);
+         conf.column_index_size_in_kb = val;
++        logger.warn("[CTEST][SET-PARAM] " + "column_index_size_in_kb" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getColumnIndexCacheSize()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "column_index_cache_size_in_kb" ); //CTEST
+         return (int) ByteUnit.KIBI_BYTES.toBytes(conf.column_index_cache_size_in_kb);
+     }
+ 
+     public static int getColumnIndexCacheSizeInKB()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "column_index_cache_size_in_kb" ); //CTEST
+         return conf.column_index_cache_size_in_kb;
+     }
+ 
+@@ -1496,30 +1567,36 @@ public class DatabaseDescriptor
+     {
+         checkValidForByteConversion(val, "column_index_cache_size_in_kb", ByteUnit.KIBI_BYTES);
+         conf.column_index_cache_size_in_kb = val;
++        logger.warn("[CTEST][SET-PARAM] " + "column_index_cache_size_in_kb" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getBatchSizeWarnThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "batch_size_warn_threshold_in_kb" ); //CTEST
+         return (int) ByteUnit.KIBI_BYTES.toBytes(conf.batch_size_warn_threshold_in_kb);
+     }
+ 
+     public static int getBatchSizeWarnThresholdInKB()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "batch_size_warn_threshold_in_kb" ); //CTEST
+         return conf.batch_size_warn_threshold_in_kb;
+     }
+ 
+     public static long getBatchSizeFailThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "batch_size_fail_threshold_in_kb" ); //CTEST
+         return ByteUnit.KIBI_BYTES.toBytes(conf.batch_size_fail_threshold_in_kb);
+     }
+ 
+     public static int getBatchSizeFailThresholdInKB()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "batch_size_fail_threshold_in_kb" ); //CTEST
+         return conf.batch_size_fail_threshold_in_kb;
+     }
+ 
+     public static int getUnloggedBatchAcrossPartitionsWarnThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "unlogged_batch_across_partitions_warn_threshold" ); //CTEST
+         return conf.unlogged_batch_across_partitions_warn_threshold;
+     }
+ 
+@@ -1527,25 +1604,30 @@ public class DatabaseDescriptor
+     {
+         checkValidForByteConversion(threshold, "batch_size_warn_threshold_in_kb", ByteUnit.KIBI_BYTES);
+         conf.batch_size_warn_threshold_in_kb = threshold;
++        logger.warn("[CTEST][SET-PARAM] " + "batch_size_warn_threshold_in_kb" + getStackTrace()); //CTEST
+     }
+ 
+     public static void setBatchSizeFailThresholdInKB(int threshold)
+     {
+         conf.batch_size_fail_threshold_in_kb = threshold;
++        logger.warn("[CTEST][SET-PARAM] " + "batch_size_fail_threshold_in_kb" + getStackTrace()); //CTEST
+     }
+ 
+     public static Collection<String> getInitialTokens()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "initial_token" ); //CTEST
+         return tokensFromString(System.getProperty(Config.PROPERTY_PREFIX + "initial_token", conf.initial_token));
+     }
+ 
+     public static String getAllocateTokensForKeyspace()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "allocate_tokens_for_keyspace" ); //CTEST
+         return System.getProperty(Config.PROPERTY_PREFIX + "allocate_tokens_for_keyspace", conf.allocate_tokens_for_keyspace);
+     }
+ 
+     public static Integer getAllocateTokensForLocalRf()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "allocate_tokens_for_local_replication_factor" ); //CTEST
+         return conf.allocate_tokens_for_local_replication_factor;
+     }
+ 
+@@ -1560,6 +1642,7 @@ public class DatabaseDescriptor
+ 
+     public static int getNumTokens()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "num_tokens" ); //CTEST
+         return conf.num_tokens;
+     }
+ 
+@@ -1597,11 +1680,13 @@ public class DatabaseDescriptor
+ 
+     public static String getClusterName()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "cluster_name" ); //CTEST
+         return conf.cluster_name;
+     }
+ 
+     public static int getStoragePort()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "storage_port" ); //CTEST
+         return Integer.parseInt(System.getProperty(Config.PROPERTY_PREFIX + "storage_port", Integer.toString(conf.storage_port)));
+     }
+ 
+@@ -1612,96 +1697,115 @@ public class DatabaseDescriptor
+ 
+     public static long nativeTransportIdleTimeout()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_idle_timeout_in_ms" ); //CTEST
+         return conf.native_transport_idle_timeout_in_ms;
+     }
+ 
+     public static void setNativeTransportIdleTimeout(long nativeTransportTimeout)
+     {
+         conf.native_transport_idle_timeout_in_ms = nativeTransportTimeout;
++        logger.warn("[CTEST][SET-PARAM] " + "native_transport_idle_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getRpcTimeout(TimeUnit unit)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "request_timeout_in_ms" ); //CTEST
+         return unit.convert(conf.request_timeout_in_ms, MILLISECONDS);
+     }
+ 
+     public static void setRpcTimeout(long timeOutInMillis)
+     {
+         conf.request_timeout_in_ms = timeOutInMillis;
++        logger.warn("[CTEST][SET-PARAM] " + "request_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getReadRpcTimeout(TimeUnit unit)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "read_request_timeout_in_ms" ); //CTEST
+         return unit.convert(conf.read_request_timeout_in_ms, MILLISECONDS);
+     }
+ 
+     public static void setReadRpcTimeout(long timeOutInMillis)
+     {
+         conf.read_request_timeout_in_ms = timeOutInMillis;
++        logger.warn("[CTEST][SET-PARAM] " + "read_request_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getRangeRpcTimeout(TimeUnit unit)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "range_request_timeout_in_ms" ); //CTEST
+         return unit.convert(conf.range_request_timeout_in_ms, MILLISECONDS);
+     }
+ 
+     public static void setRangeRpcTimeout(long timeOutInMillis)
+     {
+         conf.range_request_timeout_in_ms = timeOutInMillis;
++        logger.warn("[CTEST][SET-PARAM] " + "range_request_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getWriteRpcTimeout(TimeUnit unit)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "write_request_timeout_in_ms" ); //CTEST
+         return unit.convert(conf.write_request_timeout_in_ms, MILLISECONDS);
+     }
+ 
+     public static void setWriteRpcTimeout(long timeOutInMillis)
+     {
+         conf.write_request_timeout_in_ms = timeOutInMillis;
++        logger.warn("[CTEST][SET-PARAM] " + "write_request_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getCounterWriteRpcTimeout(TimeUnit unit)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "counter_write_request_timeout_in_ms" ); //CTEST
+         return unit.convert(conf.counter_write_request_timeout_in_ms, MILLISECONDS);
+     }
+ 
+     public static void setCounterWriteRpcTimeout(long timeOutInMillis)
+     {
+         conf.counter_write_request_timeout_in_ms = timeOutInMillis;
++        logger.warn("[CTEST][SET-PARAM] " + "counter_write_request_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getCasContentionTimeout(TimeUnit unit)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "cas_contention_timeout_in_ms" ); //CTEST
+         return unit.convert(conf.cas_contention_timeout_in_ms, MILLISECONDS);
+     }
+ 
+     public static void setCasContentionTimeout(long timeOutInMillis)
+     {
+         conf.cas_contention_timeout_in_ms = timeOutInMillis;
++        logger.warn("[CTEST][SET-PARAM] " + "cas_contention_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getTruncateRpcTimeout(TimeUnit unit)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "truncate_request_timeout_in_ms" ); //CTEST
+         return unit.convert(conf.truncate_request_timeout_in_ms, MILLISECONDS);
+     }
+ 
+     public static void setTruncateRpcTimeout(long timeOutInMillis)
+     {
+         conf.truncate_request_timeout_in_ms = timeOutInMillis;
++        logger.warn("[CTEST][SET-PARAM] " + "truncate_request_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean hasCrossNodeTimeout()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "cross_node_timeout" ); //CTEST
+         return conf.cross_node_timeout;
+     }
+ 
+     public static void setCrossNodeTimeout(boolean crossNodeTimeout)
+     {
+         conf.cross_node_timeout = crossNodeTimeout;
++        logger.warn("[CTEST][SET-PARAM] " + "cross_node_timeout" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getSlowQueryTimeout(TimeUnit units)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "slow_query_log_timeout_in_ms" ); //CTEST
+         return units.convert(conf.slow_query_log_timeout_in_ms, MILLISECONDS);
+     }
+ 
+@@ -1725,26 +1829,31 @@ public class DatabaseDescriptor
+ 
+     public static long getRepairRpcTimeout(TimeUnit unit)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "repair_request_timeout_in_ms" ); //CTEST
+         return unit.convert(conf.repair_request_timeout_in_ms, MILLISECONDS);
+     }
+ 
+     public static void setRepairRpcTimeout(long time, TimeUnit unit)
+     {
+         conf.repair_request_timeout_in_ms = MILLISECONDS.convert(time, unit);
++        logger.warn("[CTEST][SET-PARAM] " + "repair_request_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static double getPhiConvictThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "phi_convict_threshold" ); //CTEST
+         return conf.phi_convict_threshold;
+     }
+ 
+     public static void setPhiConvictThreshold(double phiConvictThreshold)
+     {
+         conf.phi_convict_threshold = phiConvictThreshold;
++        logger.warn("[CTEST][SET-PARAM] " + "phi_convict_threshold" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getConcurrentReaders()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "concurrent_reads" ); //CTEST
+         return conf.concurrent_reads;
+     }
+ 
+@@ -1755,10 +1864,12 @@ public class DatabaseDescriptor
+             throw new IllegalArgumentException("Concurrent reads must be non-negative");
+         }
+         conf.concurrent_reads = concurrent_reads;
++        logger.warn("[CTEST][SET-PARAM] " + "concurrent_reads" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getConcurrentWriters()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "concurrent_writes" ); //CTEST
+         return conf.concurrent_writes;
+     }
+ 
+@@ -1769,10 +1880,12 @@ public class DatabaseDescriptor
+             throw new IllegalArgumentException("Concurrent reads must be non-negative");
+         }
+         conf.concurrent_writes = concurrent_writers;
++        logger.warn("[CTEST][SET-PARAM] " + "concurrent_writes" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getConcurrentCounterWriters()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "concurrent_counter_writes" ); //CTEST
+         return conf.concurrent_counter_writes;
+     }
+ 
+@@ -1783,10 +1896,12 @@ public class DatabaseDescriptor
+             throw new IllegalArgumentException("Concurrent reads must be non-negative");
+         }
+         conf.concurrent_counter_writes = concurrent_counter_writes;
++        logger.warn("[CTEST][SET-PARAM] " + "concurrent_counter_writes" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getConcurrentViewWriters()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "concurrent_materialized_view_writes" ); //CTEST
+         return conf.concurrent_materialized_view_writes;
+     }
+ 
+@@ -1797,37 +1912,47 @@ public class DatabaseDescriptor
+             throw new IllegalArgumentException("Concurrent reads must be non-negative");
+         }
+         conf.concurrent_materialized_view_writes = concurrent_materialized_view_writes;
++        logger.warn("[CTEST][SET-PARAM] " + "concurrent_materialized_view_writes" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getFlushWriters()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "memtable_flush_writers" ); //CTEST
+         return conf.memtable_flush_writers;
+     }
+ 
+     public static int getConcurrentCompactors()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "concurrent_compactors" ); //CTEST
+         return conf.concurrent_compactors;
+     }
+ 
+     public static void setConcurrentCompactors(int value)
+     {
+         conf.concurrent_compactors = value;
++        logger.warn("[CTEST][SET-PARAM] " + "concurrent_compactors" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getCompactionThroughputMbPerSec()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "compaction_throughput_mb_per_sec" ); //CTEST
+         return conf.compaction_throughput_mb_per_sec;
+     }
+ 
+     public static void setCompactionThroughputMbPerSec(int value)
+     {
+         conf.compaction_throughput_mb_per_sec = value;
++        logger.warn("[CTEST][SET-PARAM] " + "compaction_throughput_mb_per_sec" + getStackTrace()); //CTEST
+     }
+ 
+-    public static long getCompactionLargePartitionWarningThreshold() { return ByteUnit.MEBI_BYTES.toBytes(conf.compaction_large_partition_warning_threshold_mb); }
++    public static long getCompactionLargePartitionWarningThreshold() {
++        logger.warn("[CTEST][GET-PARAM] " + "compaction_large_partition_warning_threshold_mb" ); //CTEST
++        return ByteUnit.MEBI_BYTES.toBytes(conf.compaction_large_partition_warning_threshold_mb);
++    }
+ 
+     public static int getConcurrentValidations()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "concurrent_validations" ); //CTEST
+         return conf.concurrent_validations;
+     }
+ 
+@@ -1835,20 +1960,24 @@ public class DatabaseDescriptor
+     {
+         value = value > 0 ? value : Integer.MAX_VALUE;
+         conf.concurrent_validations = value;
++        logger.warn("[CTEST][SET-PARAM] " + "concurrent_validations" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getConcurrentViewBuilders()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "concurrent_materialized_view_builders" ); //CTEST
+         return conf.concurrent_materialized_view_builders;
+     }
+ 
+     public static void setConcurrentViewBuilders(int value)
+     {
+         conf.concurrent_materialized_view_builders = value;
++        logger.warn("[CTEST][SET-PARAM] " + "concurrent_materialized_view_builders" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getMinFreeSpacePerDriveInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "min_free_space_per_drive_in_mb" ); //CTEST
+         return ByteUnit.MEBI_BYTES.toBytes(conf.min_free_space_per_drive_in_mb);
+     }
+ 
+@@ -1864,22 +1993,26 @@ public class DatabaseDescriptor
+ 
+     public static int getStreamThroughputOutboundMegabitsPerSec()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "stream_throughput_outbound_megabits_per_sec" ); //CTEST
+         return conf.stream_throughput_outbound_megabits_per_sec;
+     }
+ 
+     public static void setStreamThroughputOutboundMegabitsPerSec(int value)
+     {
+         conf.stream_throughput_outbound_megabits_per_sec = value;
++        logger.warn("[CTEST][SET-PARAM] " + "stream_throughput_outbound_megabits_per_sec" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getInterDCStreamThroughputOutboundMegabitsPerSec()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "inter_dc_stream_throughput_outbound_megabits_per_sec" ); //CTEST
+         return conf.inter_dc_stream_throughput_outbound_megabits_per_sec;
+     }
+ 
+     public static void setInterDCStreamThroughputOutboundMegabitsPerSec(int value)
+     {
+         conf.inter_dc_stream_throughput_outbound_megabits_per_sec = value;
++        logger.warn("[CTEST][SET-PARAM] " + "inter_dc_stream_throughput_outbound_megabits_per_sec" + getStackTrace()); //CTEST
+     }
+ 
+     /**
+@@ -1890,6 +2023,7 @@ public class DatabaseDescriptor
+      */
+     public static boolean useSpecificLocationForLocalSystemData()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "local_system_data_file_directory" ); //CTEST
+         return conf.local_system_data_file_directory != null;
+     }
+ 
+@@ -1903,9 +2037,11 @@ public class DatabaseDescriptor
+      */
+     public static String[] getLocalSystemKeyspacesDataFileLocations()
+     {
+-        if (useSpecificLocationForLocalSystemData())
++        if (useSpecificLocationForLocalSystemData()) {
++            logger.warn("[CTEST][GET-PARAM] " + "local_system_data_file_directory" ); //CTEST
+             return new String[] {conf.local_system_data_file_directory};
+-
++        }
++        logger.warn("[CTEST][GET-PARAM] " + "local_system_data_file_directory" ); //CTEST
+         return conf.data_file_directories.length == 0  ? conf.data_file_directories
+                                                        : new String[] {conf.data_file_directories[0]};
+     }
+@@ -1917,6 +2053,7 @@ public class DatabaseDescriptor
+      */
+     public static String[] getNonLocalSystemKeyspacesDataFileLocations()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "data_file_directories" ); //CTEST
+         return conf.data_file_directories;
+     }
+ 
+@@ -1927,14 +2064,18 @@ public class DatabaseDescriptor
+      */
+     public static String[] getAllDataFileLocations()
+     {
+-        if (conf.local_system_data_file_directory == null)
++        logger.warn("[CTEST][GET-PARAM] " + "local_system_data_file_directory" ); //CTEST
++        if (conf.local_system_data_file_directory == null) {
++            logger.warn("[CTEST][GET-PARAM] " + "data_file_directories" ); //CTEST
+             return conf.data_file_directories;
+-
++        }
++        logger.warn("[CTEST][GET-PARAM] " + "data_file_directories" ); //CTEST
+         return ArrayUtils.addFirst(conf.data_file_directories, conf.local_system_data_file_directory);
+     }
+ 
+     public static String getCommitLogLocation()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "commitlog_directory" ); //CTEST
+         return conf.commitlog_directory;
+     }
+ 
+@@ -1942,26 +2083,31 @@ public class DatabaseDescriptor
+     public static void setCommitLogLocation(String value)
+     {
+         conf.commitlog_directory = value;
++        logger.warn("[CTEST][SET-PARAM] " + "commitlog_directory" + getStackTrace()); //CTEST
+     }
+ 
+     public static ParameterizedClass getCommitLogCompression()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "commitlog_compression" ); //CTEST
+         return conf.commitlog_compression;
+     }
+ 
+     public static void setCommitLogCompression(ParameterizedClass compressor)
+     {
+         conf.commitlog_compression = compressor;
++        logger.warn("[CTEST][SET-PARAM] " + "commitlog_compression" + getStackTrace()); //CTEST
+     }
+ 
+     public static Config.FlushCompression getFlushCompression()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "flush_compression" ); //CTEST
+         return conf.flush_compression;
+     }
+ 
+     public static void setFlushCompression(Config.FlushCompression compression)
+     {
+         conf.flush_compression = compression;
++        logger.warn("[CTEST][SET-PARAM] " + "flush_compression" + getStackTrace()); //CTEST
+     }
+ 
+    /**
+@@ -1971,57 +2117,68 @@ public class DatabaseDescriptor
+     */
+     public static int getCommitLogMaxCompressionBuffersInPool()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "commitlog_max_compression_buffers_in_pool" ); //CTEST
+         return conf.commitlog_max_compression_buffers_in_pool;
+     }
+ 
+     public static void setCommitLogMaxCompressionBuffersPerPool(int buffers)
+     {
+         conf.commitlog_max_compression_buffers_in_pool = buffers;
++        logger.warn("[CTEST][SET-PARAM] " + "commitlog_max_compression_buffers_in_pool" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getMaxMutationSize()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "max_mutation_size_in_kb" ); //CTEST
+         return (int) ByteUnit.KIBI_BYTES.toBytes(conf.max_mutation_size_in_kb);
+     }
+ 
+     public static int getTombstoneWarnThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "tombstone_warn_threshold" ); //CTEST
+         return conf.tombstone_warn_threshold;
+     }
+ 
+     public static void setTombstoneWarnThreshold(int threshold)
+     {
+         conf.tombstone_warn_threshold = threshold;
++        logger.warn("[CTEST][SET-PARAM] " + "tombstone_warn_threshold" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getTombstoneFailureThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "tombstone_failure_threshold" ); //CTEST
+         return conf.tombstone_failure_threshold;
+     }
+ 
+     public static void setTombstoneFailureThreshold(int threshold)
+     {
+         conf.tombstone_failure_threshold = threshold;
++        logger.warn("[CTEST][SET-PARAM] " + "tombstone_failure_threshold" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getCachedReplicaRowsWarnThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "replica_filtering_protection.cached_rows_warn_threshold" ); //CTEST
+         return conf.replica_filtering_protection.cached_rows_warn_threshold;
+     }
+ 
+     public static void setCachedReplicaRowsWarnThreshold(int threshold)
+     {
+         conf.replica_filtering_protection.cached_rows_warn_threshold = threshold;
++        logger.warn("[CTEST][SET-PARAM] " + "replica_filtering_protection.cached_rows_warn_threshold" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getCachedReplicaRowsFailThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "replica_filtering_protection.cached_rows_fail_threshold" ); //CTEST
+         return conf.replica_filtering_protection.cached_rows_fail_threshold;
+     }
+ 
+     public static void setCachedReplicaRowsFailThreshold(int threshold)
+     {
+         conf.replica_filtering_protection.cached_rows_fail_threshold = threshold;
++        logger.warn("[CTEST][SET-PARAM] " + "replica_filtering_protection.cached_rows_fail_threshold" + getStackTrace()); //CTEST
+     }
+ 
+     /**
+@@ -2029,16 +2186,19 @@ public class DatabaseDescriptor
+      */
+     public static int getCommitLogSegmentSize()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "commitlog_segment_size_in_mb" ); //CTEST
+         return (int) ByteUnit.MEBI_BYTES.toBytes(conf.commitlog_segment_size_in_mb);
+     }
+ 
+     public static void setCommitLogSegmentSize(int sizeMegabytes)
+     {
+         conf.commitlog_segment_size_in_mb = sizeMegabytes;
++        logger.warn("[CTEST][SET-PARAM] " + "commitlog_segment_size_in_mb" + getStackTrace()); //CTEST
+     }
+ 
+     public static String getSavedCachesLocation()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "saved_caches_directory" ); //CTEST
+         return conf.saved_caches_directory;
+     }
+ 
+@@ -2074,17 +2234,20 @@ public class DatabaseDescriptor
+ 
+     public static boolean shouldListenOnBroadcastAddress()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "listen_on_broadcast_address" ); //CTEST
+         return conf.listen_on_broadcast_address;
+     }
+ 
+     public static void setShouldListenOnBroadcastAddress(boolean shouldListenOnBroadcastAddress)
+     {
+         conf.listen_on_broadcast_address = shouldListenOnBroadcastAddress;
++        logger.warn("[CTEST][SET-PARAM] " + "listen_on_broadcast_address" + getStackTrace()); //CTEST
+     }
+ 
+     public static void setListenOnBroadcastAddress(boolean listen_on_broadcast_address)
+     {
+         conf.listen_on_broadcast_address = listen_on_broadcast_address;
++        logger.warn("[CTEST][SET-PARAM] " + "listen_on_broadcast_address" + getStackTrace()); //CTEST
+     }
+ 
+     public static IInternodeAuthenticator getInternodeAuthenticator()
+@@ -2134,81 +2297,97 @@ public class DatabaseDescriptor
+ 
+     public static boolean getRpcKeepAlive()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "rpc_keepalive" ); //CTEST
+         return conf.rpc_keepalive;
+     }
+ 
+     public static int getInternodeSocketSendBufferSizeInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_socket_send_buffer_size_in_bytes" ); //CTEST
+         return conf.internode_socket_send_buffer_size_in_bytes;
+     }
+ 
+     public static int getInternodeSocketReceiveBufferSizeInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_socket_receive_buffer_size_in_bytes" ); //CTEST
+         return conf.internode_socket_receive_buffer_size_in_bytes;
+     }
+ 
+     public static int getInternodeApplicationSendQueueCapacityInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_application_send_queue_capacity_in_bytes" ); //CTEST
+         return conf.internode_application_send_queue_capacity_in_bytes;
+     }
+ 
+     public static int getInternodeApplicationSendQueueReserveEndpointCapacityInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_application_send_queue_reserve_endpoint_capacity_in_bytes" ); //CTEST
+         return conf.internode_application_send_queue_reserve_endpoint_capacity_in_bytes;
+     }
+ 
+     public static int getInternodeApplicationSendQueueReserveGlobalCapacityInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_application_send_queue_reserve_global_capacity_in_bytes" ); //CTEST
+         return conf.internode_application_send_queue_reserve_global_capacity_in_bytes;
+     }
+ 
+     public static int getInternodeApplicationReceiveQueueCapacityInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_application_receive_queue_capacity_in_bytes" ); //CTEST
+         return conf.internode_application_receive_queue_capacity_in_bytes;
+     }
+ 
+     public static int getInternodeApplicationReceiveQueueReserveEndpointCapacityInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_application_receive_queue_reserve_endpoint_capacity_in_bytes" ); //CTEST
+         return conf.internode_application_receive_queue_reserve_endpoint_capacity_in_bytes;
+     }
+ 
+     public static int getInternodeApplicationReceiveQueueReserveGlobalCapacityInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_application_receive_queue_reserve_global_capacity_in_bytes" ); //CTEST
+         return conf.internode_application_receive_queue_reserve_global_capacity_in_bytes;
+     }
+ 
+     public static int getInternodeTcpConnectTimeoutInMS()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_tcp_connect_timeout_in_ms" ); //CTEST
+         return conf.internode_tcp_connect_timeout_in_ms;
+     }
+ 
+     public static void setInternodeTcpConnectTimeoutInMS(int value)
+     {
+         conf.internode_tcp_connect_timeout_in_ms = value;
++        logger.warn("[CTEST][SET-PARAM] " + "internode_tcp_connect_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getInternodeTcpUserTimeoutInMS()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_tcp_user_timeout_in_ms" ); //CTEST
+         return conf.internode_tcp_user_timeout_in_ms;
+     }
+ 
+     public static void setInternodeTcpUserTimeoutInMS(int value)
+     {
+         conf.internode_tcp_user_timeout_in_ms = value;
++        logger.warn("[CTEST][SET-PARAM] " + "internode_tcp_user_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getInternodeStreamingTcpUserTimeoutInMS()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_streaming_tcp_user_timeout_in_ms" ); //CTEST
+         return conf.internode_streaming_tcp_user_timeout_in_ms;
+     }
+ 
+     public static void setInternodeStreamingTcpUserTimeoutInMS(int value)
+     {
+         conf.internode_streaming_tcp_user_timeout_in_ms = value;
++        logger.warn("[CTEST][SET-PARAM] " + "internode_streaming_tcp_user_timeout_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getInternodeMaxMessageSizeInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_max_message_size_in_bytes" ); //CTEST
+         return conf.internode_max_message_size_in_bytes;
+     }
+ 
+@@ -2216,10 +2395,12 @@ public class DatabaseDescriptor
+     public static void setInternodeMaxMessageSizeInBytes(int value)
+     {
+         conf.internode_max_message_size_in_bytes = value;
++        logger.warn("[CTEST][SET-PARAM] " + "internode_max_message_size_in_bytes" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean startNativeTransport()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "start_native_transport" ); //CTEST
+         return conf.start_native_transport;
+     }
+ 
+@@ -2229,6 +2410,7 @@ public class DatabaseDescriptor
+      */
+     public static int getNativeTransportPort()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_port" ); //CTEST
+         return Integer.parseInt(System.getProperty(Config.PROPERTY_PREFIX + "native_transport_port", Integer.toString(conf.native_transport_port)));
+     }
+ 
+@@ -2236,10 +2418,12 @@ public class DatabaseDescriptor
+     public static void setNativeTransportPort(int port)
+     {
+         conf.native_transport_port = port;
++        logger.warn("[CTEST][SET-PARAM] " + "native_transport_port" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getNativeTransportPortSSL()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_port_ssl" ); //CTEST
+         return conf.native_transport_port_ssl == null ? getNativeTransportPort() : conf.native_transport_port_ssl;
+     }
+ 
+@@ -2247,105 +2431,126 @@ public class DatabaseDescriptor
+     public static void setNativeTransportPortSSL(Integer port)
+     {
+         conf.native_transport_port_ssl = port;
++        logger.warn("[CTEST][SET-PARAM] " + "native_transport_port_ssl" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getNativeTransportMaxThreads()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_max_threads" ); //CTEST
+         return conf.native_transport_max_threads;
+     }
+ 
+     public static void setNativeTransportMaxThreads(int max_threads)
+     {
+         conf.native_transport_max_threads = max_threads;
++        logger.warn("[CTEST][SET-PARAM] " + "native_transport_max_threads" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getNativeTransportMaxFrameSize()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_max_frame_size_in_mb" ); //CTEST
+         return (int) ByteUnit.MEBI_BYTES.toBytes(conf.native_transport_max_frame_size_in_mb);
+     }
+ 
+     public static long getNativeTransportMaxConcurrentConnections()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_max_concurrent_connections" ); //CTEST
+         return conf.native_transport_max_concurrent_connections;
+     }
+ 
+     public static void setNativeTransportMaxConcurrentConnections(long nativeTransportMaxConcurrentConnections)
+     {
+         conf.native_transport_max_concurrent_connections = nativeTransportMaxConcurrentConnections;
++        logger.warn("[CTEST][SET-PARAM] " + "native_transport_max_concurrent_connections" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getNativeTransportMaxConcurrentConnectionsPerIp()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_max_concurrent_connections_per_ip" ); //CTEST
+         return conf.native_transport_max_concurrent_connections_per_ip;
+     }
+ 
+     public static void setNativeTransportMaxConcurrentConnectionsPerIp(long native_transport_max_concurrent_connections_per_ip)
+     {
+         conf.native_transport_max_concurrent_connections_per_ip = native_transport_max_concurrent_connections_per_ip;
++        logger.warn("[CTEST][SET-PARAM] " + "native_transport_max_concurrent_connections_per_ip" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean useNativeTransportLegacyFlusher()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_flush_in_batches_legacy" ); //CTEST
+         return conf.native_transport_flush_in_batches_legacy;
+     }
+ 
+     public static boolean getNativeTransportAllowOlderProtocols()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_allow_older_protocols" ); //CTEST
+         return conf.native_transport_allow_older_protocols;
+     }
+ 
+     public static void setNativeTransportAllowOlderProtocols(boolean isEnabled)
+     {
+         conf.native_transport_allow_older_protocols = isEnabled;
++        logger.warn("[CTEST][SET-PARAM] " + "native_transport_allow_older_protocols" + getStackTrace()); //CTEST
+     }
+ 
+     public static double getCommitLogSyncGroupWindow()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "commitlog_sync_group_window_in_ms" ); //CTEST
+         return conf.commitlog_sync_group_window_in_ms;
+     }
+ 
+     public static void setCommitLogSyncGroupWindow(double windowMillis)
+     {
+         conf.commitlog_sync_group_window_in_ms = windowMillis;
++        logger.warn("[CTEST][SET-PARAM] " + "commitlog_sync_group_window_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getNativeTransportReceiveQueueCapacityInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_receive_queue_capacity_in_bytes" ); //CTEST
+         return conf.native_transport_receive_queue_capacity_in_bytes;
+     }
+ 
+     public static void setNativeTransportReceiveQueueCapacityInBytes(int queueSize)
+     {
+         conf.native_transport_receive_queue_capacity_in_bytes = queueSize;
++        logger.warn("[CTEST][SET-PARAM] " + "native_transport_receive_queue_capacity_in_bytes" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getNativeTransportMaxConcurrentRequestsInBytesPerIp()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_max_concurrent_requests_in_bytes_per_ip" ); //CTEST
+         return conf.native_transport_max_concurrent_requests_in_bytes_per_ip;
+     }
+ 
+     public static void setNativeTransportMaxConcurrentRequestsInBytesPerIp(long maxConcurrentRequestsInBytes)
+     {
+         conf.native_transport_max_concurrent_requests_in_bytes_per_ip = maxConcurrentRequestsInBytes;
++        logger.warn("[CTEST][SET-PARAM] " + "native_transport_max_concurrent_requests_in_bytes_per_ip" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getNativeTransportMaxConcurrentRequestsInBytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "native_transport_max_concurrent_requests_in_bytes" ); //CTEST
+         return conf.native_transport_max_concurrent_requests_in_bytes;
+     }
+ 
+     public static void setNativeTransportMaxConcurrentRequestsInBytes(long maxConcurrentRequestsInBytes)
+     {
+         conf.native_transport_max_concurrent_requests_in_bytes = maxConcurrentRequestsInBytes;
++        logger.warn("[CTEST][SET-PARAM] " + "native_transport_max_concurrent_requests_in_bytes" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getCommitLogSyncPeriod()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "commitlog_sync_period_in_ms" ); //CTEST
+         return conf.commitlog_sync_period_in_ms;
+     }
+ 
+     public static long getPeriodicCommitLogSyncBlock()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "periodic_commitlog_sync_lag_block_in_ms" ); //CTEST
+         Integer blockMillis = conf.periodic_commitlog_sync_lag_block_in_ms;
+         return blockMillis == null
+                ? (long)(getCommitLogSyncPeriod() * 1.5)
+@@ -2355,20 +2560,24 @@ public class DatabaseDescriptor
+     public static void setCommitLogSyncPeriod(int periodMillis)
+     {
+         conf.commitlog_sync_period_in_ms = periodMillis;
++        logger.warn("[CTEST][SET-PARAM] " + "commitlog_sync_period_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static Config.CommitLogSync getCommitLogSync()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "commitlog_sync" ); //CTEST
+         return conf.commitlog_sync;
+     }
+ 
+     public static void setCommitLogSync(CommitLogSync sync)
+     {
+         conf.commitlog_sync = sync;
++        logger.warn("[CTEST][SET-PARAM] " + "commitlog_sync" + getStackTrace()); //CTEST
+     }
+ 
+     public static Config.DiskAccessMode getDiskAccessMode()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "disk_access_mode" ); //CTEST
+         return conf.disk_access_mode;
+     }
+ 
+@@ -2377,6 +2586,7 @@ public class DatabaseDescriptor
+     public static void setDiskAccessMode(Config.DiskAccessMode mode)
+     {
+         conf.disk_access_mode = mode;
++        logger.warn("[CTEST][SET-PARAM] " + "disk_access_mode" + getStackTrace()); //CTEST
+     }
+ 
+     public static Config.DiskAccessMode getIndexAccessMode()
+@@ -2394,30 +2604,36 @@ public class DatabaseDescriptor
+     public static void setDiskFailurePolicy(Config.DiskFailurePolicy policy)
+     {
+         conf.disk_failure_policy = policy;
++        logger.warn("[CTEST][SET-PARAM] " + "disk_failure_policy" + getStackTrace()); //CTEST
+     }
+ 
+     public static Config.DiskFailurePolicy getDiskFailurePolicy()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "disk_failure_policy" ); //CTEST
+         return conf.disk_failure_policy;
+     }
+ 
+     public static void setCommitFailurePolicy(Config.CommitFailurePolicy policy)
+     {
+         conf.commit_failure_policy = policy;
++        logger.warn("[CTEST][SET-PARAM] " + "commit_failure_policy" + getStackTrace()); //CTEST
+     }
+ 
+     public static Config.CommitFailurePolicy getCommitFailurePolicy()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "commit_failure_policy" ); //CTEST
+         return conf.commit_failure_policy;
+     }
+ 
+     public static boolean isSnapshotBeforeCompaction()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "snapshot_before_compaction" ); //CTEST
+         return conf.snapshot_before_compaction;
+     }
+ 
+     public static boolean isAutoSnapshot()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "auto_snapshot" ); //CTEST
+         return conf.auto_snapshot;
+     }
+ 
+@@ -2425,15 +2641,18 @@ public class DatabaseDescriptor
+     public static void setAutoSnapshot(boolean autoSnapshot)
+     {
+         conf.auto_snapshot = autoSnapshot;
++        logger.warn("[CTEST][SET-PARAM] " + "auto_snapshot" + getStackTrace()); //CTEST
+     }
+     @VisibleForTesting
+     public static boolean getAutoSnapshot()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "auto_snapshot" ); //CTEST
+         return conf.auto_snapshot;
+     }
+ 
+     public static long getSnapshotLinksPerSecond()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "snapshot_links_per_second" ); //CTEST
+         return conf.snapshot_links_per_second == 0 ? Long.MAX_VALUE : conf.snapshot_links_per_second;
+     }
+ 
+@@ -2443,6 +2662,7 @@ public class DatabaseDescriptor
+             throw new IllegalArgumentException("Invalid throttle for snapshot_links_per_second: must be positive");
+ 
+         conf.snapshot_links_per_second = throttle;
++        logger.warn("[CTEST][SET-PARAM] " + "snapshot_links_per_second" + getStackTrace()); //CTEST
+     }
+ 
+     public static RateLimiter getSnapshotRateLimiter()
+@@ -2452,51 +2672,61 @@ public class DatabaseDescriptor
+ 
+     public static boolean isAutoBootstrap()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "auto_bootstrap" ); //CTEST
+         return Boolean.parseBoolean(System.getProperty(Config.PROPERTY_PREFIX + "auto_bootstrap", Boolean.toString(conf.auto_bootstrap)));
+     }
+ 
+     public static void setHintedHandoffEnabled(boolean hintedHandoffEnabled)
+     {
+         conf.hinted_handoff_enabled = hintedHandoffEnabled;
++        logger.warn("[CTEST][SET-PARAM] " + "hinted_handoff_enabled" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean hintedHandoffEnabled()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "hinted_handoff_enabled" ); //CTEST
+         return conf.hinted_handoff_enabled;
+     }
+ 
+     public static Set<String> hintedHandoffDisabledDCs()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "hinted_handoff_disabled_datacenters" ); //CTEST
+         return conf.hinted_handoff_disabled_datacenters;
+     }
+ 
+     public static void enableHintsForDC(String dc)
+     {
+         conf.hinted_handoff_disabled_datacenters.remove(dc);
++        logger.warn("[CTEST][SET-PARAM] " + "hinted_handoff_disabled_datacenters" + getStackTrace()); //CTEST
+     }
+ 
+     public static void disableHintsForDC(String dc)
+     {
+         conf.hinted_handoff_disabled_datacenters.add(dc);
++        logger.warn("[CTEST][SET-PARAM] " + "hinted_handoff_disabled_datacenters" + getStackTrace()); //CTEST
+     }
+ 
+     public static void setMaxHintWindow(int ms)
+     {
+         conf.max_hint_window_in_ms = ms;
++        logger.warn("[CTEST][SET-PARAM] " + "max_hint_window_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getMaxHintWindow()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "max_hint_window_in_ms" ); //CTEST
+         return conf.max_hint_window_in_ms;
+     }
+ 
+     public static File getHintsDirectory()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "hints_directory" ); //CTEST
+         return new File(conf.hints_directory);
+     }
+ 
+     public static File getSerializedCachePath(CacheType cacheType, String version, String extension)
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "saved_caches_directory" ); //CTEST
+         String name = cacheType.toString()
+                 + (version == null ? "" : '-' + version + '.' + extension);
+         return new File(conf.saved_caches_directory, name);
+@@ -2504,44 +2734,53 @@ public class DatabaseDescriptor
+ 
+     public static int getDynamicUpdateInterval()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "dynamic_snitch_update_interval_in_ms" ); //CTEST
+         return conf.dynamic_snitch_update_interval_in_ms;
+     }
+     public static void setDynamicUpdateInterval(int dynamicUpdateInterval)
+     {
+         conf.dynamic_snitch_update_interval_in_ms = dynamicUpdateInterval;
++        logger.warn("[CTEST][SET-PARAM] " + "dynamic_snitch_update_interval_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getDynamicResetInterval()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "dynamic_snitch_reset_interval_in_ms" ); //CTEST
+         return conf.dynamic_snitch_reset_interval_in_ms;
+     }
+     public static void setDynamicResetInterval(int dynamicResetInterval)
+     {
+         conf.dynamic_snitch_reset_interval_in_ms = dynamicResetInterval;
++        logger.warn("[CTEST][SET-PARAM] " + "dynamic_snitch_reset_interval_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static double getDynamicBadnessThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "dynamic_snitch_badness_threshold" ); //CTEST
+         return conf.dynamic_snitch_badness_threshold;
+     }
+ 
+     public static void setDynamicBadnessThreshold(double dynamicBadnessThreshold)
+     {
+         conf.dynamic_snitch_badness_threshold = dynamicBadnessThreshold;
++        logger.warn("[CTEST][SET-PARAM] " + "dynamic_snitch_badness_threshold" + getStackTrace()); //CTEST
+     }
+ 
+     public static EncryptionOptions.ServerEncryptionOptions getInternodeMessagingEncyptionOptions()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "server_encryption_options" ); //CTEST
+         return conf.server_encryption_options;
+     }
+ 
+     public static void setInternodeMessagingEncyptionOptions(EncryptionOptions.ServerEncryptionOptions encryptionOptions)
+     {
+         conf.server_encryption_options = encryptionOptions;
++        logger.warn("[CTEST][SET-PARAM] " + "server_encryption_options" + getStackTrace()); //CTEST
+     }
+ 
+     public static EncryptionOptions getNativeProtocolEncryptionOptions()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "client_encryption_options" ); //CTEST
+         return conf.client_encryption_options;
+     }
+ 
+@@ -2549,35 +2788,42 @@ public class DatabaseDescriptor
+     public static void updateNativeProtocolEncryptionOptions(Function<EncryptionOptions, EncryptionOptions> update)
+     {
+         conf.client_encryption_options = update.apply(conf.client_encryption_options);
++        logger.warn("[CTEST][SET-PARAM] " + "client_encryption_options" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getHintedHandoffThrottleInKB()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "hinted_handoff_throttle_in_kb" ); //CTEST
+         return conf.hinted_handoff_throttle_in_kb;
+     }
+ 
+     public static void setHintedHandoffThrottleInKB(int throttleInKB)
+     {
+         conf.hinted_handoff_throttle_in_kb = throttleInKB;
++        logger.warn("[CTEST][SET-PARAM] " + "hinted_handoff_throttle_in_kb" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getBatchlogReplayThrottleInKB()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "batchlog_replay_throttle_in_kb" ); //CTEST
+         return conf.batchlog_replay_throttle_in_kb;
+     }
+ 
+     public static void setBatchlogReplayThrottleInKB(int throttleInKB)
+     {
+         conf.batchlog_replay_throttle_in_kb = throttleInKB;
++        logger.warn("[CTEST][SET-PARAM] " + "batchlog_replay_throttle_in_kb" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getMaxHintsDeliveryThreads()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "max_hints_delivery_threads" ); //CTEST
+         return conf.max_hints_delivery_threads;
+     }
+ 
+     public static int getHintsFlushPeriodInMS()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "hints_flush_period_in_ms" ); //CTEST
+         return conf.hints_flush_period_in_ms;
+     }
+ 
+@@ -2588,26 +2834,31 @@ public class DatabaseDescriptor
+ 
+     public static ParameterizedClass getHintsCompression()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "hints_compression" ); //CTEST
+         return conf.hints_compression;
+     }
+ 
+     public static void setHintsCompression(ParameterizedClass parameterizedClass)
+     {
+         conf.hints_compression = parameterizedClass;
++        logger.warn("[CTEST][SET-PARAM] " + "hints_compression" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean isIncrementalBackupsEnabled()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "incremental_backups" ); //CTEST
+         return conf.incremental_backups;
+     }
+ 
+     public static void setIncrementalBackupsEnabled(boolean value)
+     {
+         conf.incremental_backups = value;
++        logger.warn("[CTEST][SET-PARAM] " + "incremental_backups" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean getFileCacheEnabled()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "file_cache_enabled" ); //CTEST
+         return conf.file_cache_enabled;
+     }
+ 
+@@ -2620,6 +2871,7 @@ public class DatabaseDescriptor
+             return 0;
+         }
+ 
++        logger.warn("[CTEST][GET-PARAM] " + "file_cache_size_in_mb" ); //CTEST
+         return conf.file_cache_size_in_mb;
+     }
+ 
+@@ -2631,6 +2883,7 @@ public class DatabaseDescriptor
+             assert DatabaseDescriptor.isClientInitialized();
+             return 0;
+         }
++        logger.warn("[CTEST][GET-PARAM] " + "networking_cache_size_in_mb" ); //CTEST
+         return conf.networking_cache_size_in_mb;
+     }
+ 
+@@ -2643,6 +2896,7 @@ public class DatabaseDescriptor
+             return false;
+         }
+ 
++        logger.warn("[CTEST][GET-PARAM] " + "file_cache_round_up" ); //CTEST
+         return conf.file_cache_round_up;
+     }
+ 
+@@ -2653,40 +2907,48 @@ public class DatabaseDescriptor
+ 
+     public static double getDiskOptimizationEstimatePercentile()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "disk_optimization_estimate_percentile" ); //CTEST
+         return conf.disk_optimization_estimate_percentile;
+     }
+ 
+     public static long getTotalCommitlogSpaceInMB()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "commitlog_total_space_in_mb" ); //CTEST
+         return conf.commitlog_total_space_in_mb;
+     }
+ 
+     public static boolean shouldMigrateKeycacheOnCompaction()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "key_cache_migrate_during_compaction" ); //CTEST
+         return conf.key_cache_migrate_during_compaction;
+     }
+ 
+     public static void setMigrateKeycacheOnCompaction(boolean migrateCacheEntry)
+     {
+         conf.key_cache_migrate_during_compaction = migrateCacheEntry;
++        logger.warn("[CTEST][SET-PARAM] " + "key_cache_migrate_during_compaction" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getSSTablePreemptiveOpenIntervalInMB()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "sstable_preemptive_open_interval_in_mb" ); //CTEST
+         return FBUtilities.isWindows ? -1 : conf.sstable_preemptive_open_interval_in_mb;
+     }
+     public static void setSSTablePreemptiveOpenIntervalInMB(int mb)
+     {
+         conf.sstable_preemptive_open_interval_in_mb = mb;
++        logger.warn("[CTEST][SET-PARAM] " + "sstable_preemptive_open_interval_in_mb" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean getTrickleFsync()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "trickle_fsync" ); //CTEST
+         return conf.trickle_fsync;
+     }
+ 
+     public static int getTrickleFsyncIntervalInKb()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "trickle_fsync_interval_in_kb" ); //CTEST
+         return conf.trickle_fsync_interval_in_kb;
+     }
+ 
+@@ -2702,31 +2964,37 @@ public class DatabaseDescriptor
+ 
+     public static int getKeyCacheSavePeriod()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "key_cache_save_period" ); //CTEST
+         return conf.key_cache_save_period;
+     }
+ 
+     public static void setKeyCacheSavePeriod(int keyCacheSavePeriod)
+     {
+         conf.key_cache_save_period = keyCacheSavePeriod;
++        logger.warn("[CTEST][SET-PARAM] " + "key_cache_save_period" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getKeyCacheKeysToSave()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "key_cache_keys_to_save" ); //CTEST
+         return conf.key_cache_keys_to_save;
+     }
+ 
+     public static void setKeyCacheKeysToSave(int keyCacheKeysToSave)
+     {
+         conf.key_cache_keys_to_save = keyCacheKeysToSave;
++        logger.warn("[CTEST][SET-PARAM] " + "key_cache_keys_to_save" + getStackTrace()); //CTEST
+     }
+ 
+     public static String getRowCacheClassName()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "row_cache_class_name" ); //CTEST
+         return conf.row_cache_class_name;
+     }
+ 
+     public static long getRowCacheSizeInMB()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "row_cache_size_in_mb" ); //CTEST
+         return conf.row_cache_size_in_mb;
+     }
+ 
+@@ -2734,20 +3002,24 @@ public class DatabaseDescriptor
+     public static void setRowCacheSizeInMB(long val)
+     {
+         conf.row_cache_size_in_mb = val;
++        logger.warn("[CTEST][SET-PARAM] " + "row_cache_size_in_mb" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getRowCacheSavePeriod()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "row_cache_save_period" ); //CTEST
+         return conf.row_cache_save_period;
+     }
+ 
+     public static void setRowCacheSavePeriod(int rowCacheSavePeriod)
+     {
+         conf.row_cache_save_period = rowCacheSavePeriod;
++        logger.warn("[CTEST][SET-PARAM] " + "row_cache_save_period" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getRowCacheKeysToSave()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "row_cache_keys_to_save" ); //CTEST
+         return conf.row_cache_keys_to_save;
+     }
+ 
+@@ -2759,20 +3031,24 @@ public class DatabaseDescriptor
+     public static void setRowCacheKeysToSave(int rowCacheKeysToSave)
+     {
+         conf.row_cache_keys_to_save = rowCacheKeysToSave;
++        logger.warn("[CTEST][SET-PARAM] " + "row_cache_keys_to_save" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getCounterCacheSavePeriod()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "counter_cache_save_period" ); //CTEST
+         return conf.counter_cache_save_period;
+     }
+ 
+     public static void setCounterCacheSavePeriod(int counterCacheSavePeriod)
+     {
+         conf.counter_cache_save_period = counterCacheSavePeriod;
++        logger.warn("[CTEST][SET-PARAM] " + "counter_cache_save_period" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getCacheLoadTimeout()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "cache_load_timeout_seconds" ); //CTEST
+         return conf.cache_load_timeout_seconds;
+     }
+ 
+@@ -2780,30 +3056,36 @@ public class DatabaseDescriptor
+     public static void setCacheLoadTimeout(int seconds)
+     {
+         conf.cache_load_timeout_seconds = seconds;
++        logger.warn("[CTEST][SET-PARAM] " + "cache_load_timeout_seconds" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getCounterCacheKeysToSave()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "counter_cache_keys_to_save" ); //CTEST
+         return conf.counter_cache_keys_to_save;
+     }
+ 
+     public static void setCounterCacheKeysToSave(int counterCacheKeysToSave)
+     {
+         conf.counter_cache_keys_to_save = counterCacheKeysToSave;
++        logger.warn("[CTEST][SET-PARAM] " + "counter_cache_keys_to_save" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getStreamingKeepAlivePeriod()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "streaming_keep_alive_period_in_secs" ); //CTEST
+         return conf.streaming_keep_alive_period_in_secs;
+     }
+ 
+     public static int getStreamingConnectionsPerHost()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "streaming_connections_per_host" ); //CTEST
+         return conf.streaming_connections_per_host;
+     }
+ 
+     public static boolean streamEntireSSTables()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "stream_entire_sstables" ); //CTEST
+         return conf.stream_entire_sstables;
+     }
+ 
+@@ -2814,41 +3096,49 @@ public class DatabaseDescriptor
+ 
+     public static Comparator<Replica> getLocalComparator()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "localComparator" ); //CTEST
+         return localComparator;
+     }
+ 
+     public static Config.InternodeCompression internodeCompression()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "internode_compression" ); //CTEST
+         return conf.internode_compression;
+     }
+ 
+     public static void setInternodeCompression(Config.InternodeCompression compression)
+     {
+         conf.internode_compression = compression;
++        logger.warn("[CTEST][SET-PARAM] " + "internode_compression" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean getInterDCTcpNoDelay()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "inter_dc_tcp_nodelay" ); //CTEST
+         return conf.inter_dc_tcp_nodelay;
+     }
+ 
+     public static long getMemtableHeapSpaceInMb()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "memtable_heap_space_in_mb" ); //CTEST
+         return conf.memtable_heap_space_in_mb;
+     }
+ 
+     public static long getMemtableOffheapSpaceInMb()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "memtable_offheap_space_in_mb" ); //CTEST
+         return conf.memtable_offheap_space_in_mb;
+     }
+ 
+     public static Config.MemtableAllocationType getMemtableAllocationType()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "memtable_allocation_type" ); //CTEST
+         return conf.memtable_allocation_type;
+     }
+ 
+     public static int getRepairSessionMaxTreeDepth()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "repair_session_max_tree_depth" ); //CTEST
+         return conf.repair_session_max_tree_depth;
+     }
+ 
+@@ -2861,10 +3151,12 @@ public class DatabaseDescriptor
+             logger.warn("repair_session_max_tree_depth of " + depth + " > 20 could lead to excessive memory usage");
+ 
+         conf.repair_session_max_tree_depth = depth;
++        logger.warn("[CTEST][SET-PARAM] " + "repair_session_max_tree_depth" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getRepairSessionSpaceInMegabytes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "repair_session_space_in_mb" ); //CTEST
+         return conf.repair_session_space_in_mb;
+     }
+ 
+@@ -2878,21 +3170,25 @@ public class DatabaseDescriptor
+                         " megabytes is likely to cause heap pressure.");
+ 
+         conf.repair_session_space_in_mb = sizeInMegabytes;
++        logger.warn("[CTEST][SET-PARAM] " + "repair_session_space_in_mb" + getStackTrace()); //CTEST
+     }
+ 
+     public static Float getMemtableCleanupThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "memtable_cleanup_threshold" ); //CTEST
+         return conf.memtable_cleanup_threshold;
+     }
+ 
+     public static int getIndexSummaryResizeIntervalInMinutes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "index_summary_resize_interval_in_minutes" ); //CTEST
+         return conf.index_summary_resize_interval_in_minutes;
+     }
+ 
+     public static void setIndexSummaryResizeIntervalInMinutes(int value)
+     {
+         conf.index_summary_resize_interval_in_minutes = value;
++        logger.warn("[CTEST][SET-PARAM] " + "index_summary_resize_interval_in_minutes" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean hasLargeAddressSpace()
+@@ -2913,16 +3209,19 @@ public class DatabaseDescriptor
+ 
+     public static int getTracetypeRepairTTL()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "tracetype_repair_ttl" ); //CTEST
+         return conf.tracetype_repair_ttl;
+     }
+ 
+     public static int getTracetypeQueryTTL()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "tracetype_query_ttl" ); //CTEST
+         return conf.tracetype_query_ttl;
+     }
+ 
+     public static int getWindowsTimerInterval()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "windows_timer_interval" ); //CTEST
+         return conf.windows_timer_interval;
+     }
+ 
+@@ -2933,76 +3232,91 @@ public class DatabaseDescriptor
+ 
+     public static boolean enableUserDefinedFunctions()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "enable_user_defined_functions" ); //CTEST
+         return conf.enable_user_defined_functions;
+     }
+ 
+     public static boolean enableScriptedUserDefinedFunctions()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "enable_scripted_user_defined_functions" ); //CTEST
+         return conf.enable_scripted_user_defined_functions;
+     }
+ 
+     public static void enableScriptedUserDefinedFunctions(boolean enableScriptedUserDefinedFunctions)
+     {
+         conf.enable_scripted_user_defined_functions = enableScriptedUserDefinedFunctions;
++        logger.warn("[CTEST][SET-PARAM] " + "enable_scripted_user_defined_functions" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean enableUserDefinedFunctionsThreads()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "enable_user_defined_functions_threads" ); //CTEST
+         return conf.enable_user_defined_functions_threads;
+     }
+ 
+     public static long getUserDefinedFunctionWarnTimeout()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "user_defined_function_warn_timeout" ); //CTEST
+         return conf.user_defined_function_warn_timeout;
+     }
+ 
+     public static void setUserDefinedFunctionWarnTimeout(long userDefinedFunctionWarnTimeout)
+     {
+         conf.user_defined_function_warn_timeout = userDefinedFunctionWarnTimeout;
++        logger.warn("[CTEST][SET-PARAM] " + "user_defined_function_warn_timeout" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean allowInsecureUDFs()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "allow_insecure_udfs" ); //CTEST
+         return conf.allow_insecure_udfs;
+     }
+ 
+     public static boolean allowExtraInsecureUDFs()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "allow_extra_insecure_udfs" ); //CTEST
+         return conf.allow_extra_insecure_udfs;
+     }
+ 
+     public static boolean getEnableMaterializedViews()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "enable_materialized_views" ); //CTEST
+         return conf.enable_materialized_views;
+     }
+ 
+     public static void setEnableMaterializedViews(boolean enableMaterializedViews)
+     {
+         conf.enable_materialized_views = enableMaterializedViews;
++        logger.warn("[CTEST][SET-PARAM] " + "enable_materialized_views" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean getEnableSASIIndexes()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "enable_sasi_indexes" ); //CTEST
+         return conf.enable_sasi_indexes;
+     }
+ 
+     public static void setEnableSASIIndexes(boolean enableSASIIndexes)
+     {
+         conf.enable_sasi_indexes = enableSASIIndexes;
++        logger.warn("[CTEST][SET-PARAM] " + "enable_sasi_indexes" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean isTransientReplicationEnabled()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "enable_transient_replication" ); //CTEST
+         return conf.enable_transient_replication;
+     }
+ 
+     public static void setTransientReplicationEnabledUnsafe(boolean enabled)
+     {
+         conf.enable_transient_replication = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "enable_transient_replication" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean enableDropCompactStorage()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "enable_drop_compact_storage" ); //CTEST
+         return conf.enable_drop_compact_storage;
+     }
+ 
+@@ -3010,36 +3324,43 @@ public class DatabaseDescriptor
+     public static void setEnableDropCompactStorage(boolean enableDropCompactStorage)
+     {
+         conf.enable_drop_compact_storage = enableDropCompactStorage;
++        logger.warn("[CTEST][SET-PARAM] " + "enable_drop_compact_storage" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getUserDefinedFunctionFailTimeout()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "user_defined_function_fail_timeout" ); //CTEST
+         return conf.user_defined_function_fail_timeout;
+     }
+ 
+     public static void setUserDefinedFunctionFailTimeout(long userDefinedFunctionFailTimeout)
+     {
+         conf.user_defined_function_fail_timeout = userDefinedFunctionFailTimeout;
++        logger.warn("[CTEST][SET-PARAM] " + "user_defined_function_fail_timeout" + getStackTrace()); //CTEST
+     }
+ 
+     public static Config.UserFunctionTimeoutPolicy getUserFunctionTimeoutPolicy()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "user_function_timeout_policy" ); //CTEST
+         return conf.user_function_timeout_policy;
+     }
+ 
+     public static void setUserFunctionTimeoutPolicy(Config.UserFunctionTimeoutPolicy userFunctionTimeoutPolicy)
+     {
+         conf.user_function_timeout_policy = userFunctionTimeoutPolicy;
++        logger.warn("[CTEST][SET-PARAM] " + "user_function_timeout_policy" + getStackTrace()); //CTEST
+     }
+ 
+     public static long getGCLogThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "gc_log_threshold_in_ms" ); //CTEST
+         return conf.gc_log_threshold_in_ms;
+     }
+ 
+     public static void setGCLogThreshold(int gcLogThreshold)
+     {
+         conf.gc_log_threshold_in_ms = gcLogThreshold;
++        logger.warn("[CTEST][SET-PARAM] " + "gc_log_threshold_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static EncryptionContext getEncryptionContext()
+@@ -3049,16 +3370,19 @@ public class DatabaseDescriptor
+ 
+     public static long getGCWarnThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "gc_warn_threshold_in_ms" ); //CTEST
+         return conf.gc_warn_threshold_in_ms;
+     }
+ 
+     public static void setGCWarnThreshold(int threshold)
+     {
+         conf.gc_warn_threshold_in_ms = threshold;
++        logger.warn("[CTEST][SET-PARAM] " + "gc_warn_threshold_in_ms" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean isCDCEnabled()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "cdc_enabled" ); //CTEST
+         return conf.cdc_enabled;
+     }
+ 
+@@ -3066,15 +3390,18 @@ public class DatabaseDescriptor
+     public static void setCDCEnabled(boolean cdc_enabled)
+     {
+         conf.cdc_enabled = cdc_enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "cdc_enabled" + getStackTrace()); //CTEST
+     }
+ 
+     public static String getCDCLogLocation()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "cdc_raw_directory" ); //CTEST
+         return conf.cdc_raw_directory;
+     }
+ 
+     public static int getCDCSpaceInMB()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "cdc_total_space_in_mb" ); //CTEST
+         return conf.cdc_total_space_in_mb;
+     }
+ 
+@@ -3082,10 +3409,12 @@ public class DatabaseDescriptor
+     public static void setCDCSpaceInMB(int input)
+     {
+         conf.cdc_total_space_in_mb = input;
++        logger.warn("[CTEST][SET-PARAM] " + "cdc_total_space_in_mb" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getCDCDiskCheckInterval()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "cdc_free_space_check_interval_ms" ); //CTEST
+         return conf.cdc_free_space_check_interval_ms;
+     }
+ 
+@@ -3107,51 +3436,61 @@ public class DatabaseDescriptor
+ 
+     public static boolean diagnosticEventsEnabled()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "diagnostic_events_enabled" ); //CTEST
+         return conf.diagnostic_events_enabled;
+     }
+ 
+     public static void setDiagnosticEventsEnabled(boolean enabled)
+     {
+         conf.diagnostic_events_enabled = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "diagnostic_events_enabled" + getStackTrace()); //CTEST
+     }
+ 
+     public static ConsistencyLevel getIdealConsistencyLevel()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "ideal_consistency_level" ); //CTEST
+         return conf.ideal_consistency_level;
+     }
+ 
+     public static void setIdealConsistencyLevel(ConsistencyLevel cl)
+     {
+         conf.ideal_consistency_level = cl;
++        logger.warn("[CTEST][SET-PARAM] " + "ideal_consistency_level" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getRepairCommandPoolSize()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "repair_command_pool_size" ); //CTEST
+         return conf.repair_command_pool_size;
+     }
+ 
+     public static Config.RepairCommandPoolFullStrategy getRepairCommandPoolFullStrategy()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "repair_command_pool_full_strategy" ); //CTEST
+         return conf.repair_command_pool_full_strategy;
+     }
+ 
+     public static FullQueryLoggerOptions getFullQueryLogOptions()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "full_query_logging_options" ); //CTEST
+         return  conf.full_query_logging_options;
+     }
+ 
+     public static boolean getBlockForPeersInRemoteDatacenters()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "block_for_peers_in_remote_dcs" ); //CTEST
+         return conf.block_for_peers_in_remote_dcs;
+     }
+ 
+     public static int getBlockForPeersTimeoutInSeconds()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "block_for_peers_timeout_in_secs" ); //CTEST
+         return conf.block_for_peers_timeout_in_secs;
+     }
+ 
+     public static boolean automaticSSTableUpgrade()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "automatic_sstable_upgrade" ); //CTEST
+         return conf.automatic_sstable_upgrade;
+     }
+ 
+@@ -3160,10 +3499,12 @@ public class DatabaseDescriptor
+         if (conf.automatic_sstable_upgrade != enabled)
+             logger.debug("Changing automatic_sstable_upgrade to {}", enabled);
+         conf.automatic_sstable_upgrade = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "automatic_sstable_upgrade" + getStackTrace()); //CTEST
+     }
+ 
+     public static int maxConcurrentAutoUpgradeTasks()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "max_concurrent_automatic_sstable_upgrades" ); //CTEST
+         return conf.max_concurrent_automatic_sstable_upgrades;
+     }
+ 
+@@ -3173,6 +3514,7 @@ public class DatabaseDescriptor
+             logger.debug("Changing max_concurrent_automatic_sstable_upgrades to {}", value);
+         validateMaxConcurrentAutoUpgradeTasksConf(value);
+         conf.max_concurrent_automatic_sstable_upgrades = value;
++        logger.warn("[CTEST][SET-PARAM] " + "max_concurrent_automatic_sstable_upgrades" + getStackTrace()); //CTEST
+     }
+ 
+     private static void validateMaxConcurrentAutoUpgradeTasksConf(int value)
+@@ -3182,75 +3524,89 @@ public class DatabaseDescriptor
+         if (value > getConcurrentCompactors())
+             logger.warn("max_concurrent_automatic_sstable_upgrades ({}) is larger than concurrent_compactors ({})", value, getConcurrentCompactors());
+     }
+-    
++
+     public static AuditLogOptions getAuditLoggingOptions()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "audit_logging_options" ); //CTEST
+         return conf.audit_logging_options;
+     }
+ 
+     public static void setAuditLoggingOptions(AuditLogOptions auditLoggingOptions)
+     {
+         conf.audit_logging_options = auditLoggingOptions;
++        logger.warn("[CTEST][SET-PARAM] " + "audit_logging_options" + getStackTrace()); //CTEST
+     }
+ 
+     public static Config.CorruptedTombstoneStrategy getCorruptedTombstoneStrategy()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "corrupted_tombstone_strategy" ); //CTEST
+         return conf.corrupted_tombstone_strategy;
+     }
+ 
+     public static void setCorruptedTombstoneStrategy(Config.CorruptedTombstoneStrategy strategy)
+     {
+         conf.corrupted_tombstone_strategy = strategy;
++        logger.warn("[CTEST][SET-PARAM] " + "corrupted_tombstone_strategy" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean getRepairedDataTrackingForRangeReadsEnabled()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "repaired_data_tracking_for_range_reads_enabled" ); //CTEST
+         return conf.repaired_data_tracking_for_range_reads_enabled;
+     }
+ 
+     public static void setRepairedDataTrackingForRangeReadsEnabled(boolean enabled)
+     {
+         conf.repaired_data_tracking_for_range_reads_enabled = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "repaired_data_tracking_for_range_reads_enabled" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean getRepairedDataTrackingForPartitionReadsEnabled()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "repaired_data_tracking_for_partition_reads_enabled" ); //CTEST
+         return conf.repaired_data_tracking_for_partition_reads_enabled;
+     }
+ 
+     public static void setRepairedDataTrackingForPartitionReadsEnabled(boolean enabled)
+     {
+         conf.repaired_data_tracking_for_partition_reads_enabled = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "repaired_data_tracking_for_partition_reads_enabled" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean snapshotOnRepairedDataMismatch()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "snapshot_on_repaired_data_mismatch" ); //CTEST
+         return conf.snapshot_on_repaired_data_mismatch;
+     }
+ 
+     public static void setSnapshotOnRepairedDataMismatch(boolean enabled)
+     {
+         conf.snapshot_on_repaired_data_mismatch = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "snapshot_on_repaired_data_mismatch" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean snapshotOnDuplicateRowDetection()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "snapshot_on_duplicate_row_detection" ); //CTEST
+         return conf.snapshot_on_duplicate_row_detection;
+     }
+ 
+     public static void setSnapshotOnDuplicateRowDetection(boolean enabled)
+     {
+         conf.snapshot_on_duplicate_row_detection = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "snapshot_on_duplicate_row_detection" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean reportUnconfirmedRepairedDataMismatches()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "report_unconfirmed_repaired_data_mismatches" ); //CTEST
+         return conf.report_unconfirmed_repaired_data_mismatches;
+     }
+ 
+     public static void reportUnconfirmedRepairedDataMismatches(boolean enabled)
+     {
+         conf.report_unconfirmed_repaired_data_mismatches = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "report_unconfirmed_repaired_data_mismatches" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean strictRuntimeChecks()
+@@ -3260,6 +3616,7 @@ public class DatabaseDescriptor
+ 
+     public static boolean useOffheapMerkleTrees()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "use_offheap_merkle_trees" ); //CTEST
+         return conf.use_offheap_merkle_trees;
+     }
+ 
+@@ -3267,6 +3624,7 @@ public class DatabaseDescriptor
+     {
+         logger.info("Setting use_offheap_merkle_trees to {}", value);
+         conf.use_offheap_merkle_trees = value;
++        logger.warn("[CTEST][SET-PARAM] " + "use_offheap_merkle_trees" + getStackTrace()); //CTEST
+     }
+ 
+     public static Function<CommitLog, AbstractCommitLogSegmentManager> getCommitLogSegmentMgrProvider()
+@@ -3323,67 +3681,80 @@ public class DatabaseDescriptor
+ 
+     public static int getValidationPreviewPurgeHeadStartInSec()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "validation_preview_purge_head_start_in_sec" ); //CTEST
+         int seconds = conf.validation_preview_purge_head_start_in_sec;
+         return Math.max(seconds, 0);
+     }
+ 
+     public static boolean checkForDuplicateRowsDuringReads()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "check_for_duplicate_rows_during_reads" ); //CTEST
+         return conf.check_for_duplicate_rows_during_reads;
+     }
+ 
+     public static void setCheckForDuplicateRowsDuringReads(boolean enabled)
+     {
+         conf.check_for_duplicate_rows_during_reads = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "check_for_duplicate_rows_during_reads" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean checkForDuplicateRowsDuringCompaction()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "check_for_duplicate_rows_during_compaction" ); //CTEST
+         return conf.check_for_duplicate_rows_during_compaction;
+     }
+ 
+     public static void setCheckForDuplicateRowsDuringCompaction(boolean enabled)
+     {
+         conf.check_for_duplicate_rows_during_compaction = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "check_for_duplicate_rows_during_compaction" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getRepairPendingCompactionRejectThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "reject_repair_compaction_threshold" ); //CTEST
+         return conf.reject_repair_compaction_threshold;
+     }
+ 
+     public static void setRepairPendingCompactionRejectThreshold(int value)
+     {
+         conf.reject_repair_compaction_threshold = value;
++        logger.warn("[CTEST][SET-PARAM] " + "reject_repair_compaction_threshold" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getInitialRangeTombstoneListAllocationSize()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "initial_range_tombstone_list_allocation_size" ); //CTEST
+         return conf.initial_range_tombstone_list_allocation_size;
+     }
+ 
+     public static void setInitialRangeTombstoneListAllocationSize(int size)
+     {
+         conf.initial_range_tombstone_list_allocation_size = size;
++        logger.warn("[CTEST][SET-PARAM] " + "initial_range_tombstone_list_allocation_size" + getStackTrace()); //CTEST
+     }
+ 
+     public static double getRangeTombstoneListGrowthFactor()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "range_tombstone_list_growth_factor" ); //CTEST
+         return conf.range_tombstone_list_growth_factor;
+     }
+ 
+     public static void setRangeTombstoneListGrowthFactor(double resizeFactor)
+     {
+         conf.range_tombstone_list_growth_factor = resizeFactor;
++        logger.warn("[CTEST][SET-PARAM] " + "range_tombstone_list_growth_factor" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean getAutocompactionOnStartupEnabled()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "autocompaction_on_startup_enabled" ); //CTEST
+         return conf.autocompaction_on_startup_enabled;
+     }
+ 
+     public static boolean autoOptimiseIncRepairStreams()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "auto_optimise_inc_repair_streams" ); //CTEST
+         return conf.auto_optimise_inc_repair_streams;
+     }
+ 
+@@ -3392,10 +3763,12 @@ public class DatabaseDescriptor
+         if (enabled != conf.auto_optimise_inc_repair_streams)
+             logger.info("Changing auto_optimise_inc_repair_streams from {} to {}", conf.auto_optimise_inc_repair_streams, enabled);
+         conf.auto_optimise_inc_repair_streams = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "auto_optimise_inc_repair_streams" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean autoOptimiseFullRepairStreams()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "auto_optimise_full_repair_streams" ); //CTEST
+         return conf.auto_optimise_full_repair_streams;
+     }
+ 
+@@ -3404,10 +3777,12 @@ public class DatabaseDescriptor
+         if (enabled != conf.auto_optimise_full_repair_streams)
+             logger.info("Changing auto_optimise_full_repair_streams from {} to {}", conf.auto_optimise_full_repair_streams, enabled);
+         conf.auto_optimise_full_repair_streams = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "auto_optimise_full_repair_streams" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean autoOptimisePreviewRepairStreams()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "auto_optimise_preview_repair_streams" ); //CTEST
+         return conf.auto_optimise_preview_repair_streams;
+     }
+ 
+@@ -3416,40 +3791,48 @@ public class DatabaseDescriptor
+         if (enabled != conf.auto_optimise_preview_repair_streams)
+             logger.info("Changing auto_optimise_preview_repair_streams from {} to {}", conf.auto_optimise_preview_repair_streams, enabled);
+         conf.auto_optimise_preview_repair_streams = enabled;
++        logger.warn("[CTEST][SET-PARAM] " + "auto_optimise_preview_repair_streams" + getStackTrace()); //CTEST
+     }
+ 
+     public static int tableCountWarnThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "table_count_warn_threshold" ); //CTEST
+         return conf.table_count_warn_threshold;
+     }
+ 
+     public static void setTableCountWarnThreshold(int value)
+     {
+         conf.table_count_warn_threshold = value;
++        logger.warn("[CTEST][SET-PARAM] " + "table_count_warn_threshold" + getStackTrace()); //CTEST
+     }
+ 
+     public static int keyspaceCountWarnThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "keyspace_count_warn_threshold" ); //CTEST
+         return conf.keyspace_count_warn_threshold;
+     }
+ 
+     public static void setKeyspaceCountWarnThreshold(int value)
+     {
+         conf.keyspace_count_warn_threshold = value;
++        logger.warn("[CTEST][SET-PARAM] " + "keyspace_count_warn_threshold" + getStackTrace()); //CTEST
+     }
+ 
+     public static int getConsecutiveMessageErrorsThreshold()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "consecutive_message_errors_threshold" ); //CTEST
+         return conf.consecutive_message_errors_threshold;
+     }
+ 
+     public static void setConsecutiveMessageErrorsThreshold(int value)
+     {
+         conf.consecutive_message_errors_threshold = value;
++        logger.warn("[CTEST][SET-PARAM] " + "consecutive_message_errors_threshold" + getStackTrace()); //CTEST
+     }
+ 
+     public static boolean getForceNewPreparedStatementBehaviour()
+     {
++        logger.warn("[CTEST][GET-PARAM] " + "force_new_prepared_statement_behaviour" ); //CTEST
+         return conf.force_new_prepared_statement_behaviour;
+     }
+ 
+@@ -3459,6 +3842,18 @@ public class DatabaseDescriptor
+         {
+             logger.info("Setting force_new_prepared_statement_behaviour to {}", value);
+             conf.force_new_prepared_statement_behaviour = value;
++            logger.warn("[CTEST][SET-PARAM] " + "force_new_prepared_statement_behaviour" + getStackTrace()); //CTEST
++        }
++    }
++
++    // CTEST
++    private static String getStackTrace() {
++        String stacktrace = " ";
++        for (StackTraceElement element : Thread.currentThread().getStackTrace()) {
++            stacktrace = stacktrace.concat(
++                element.getClassName() + "#" + element.getMethodName() + "#" + element.getLineNumber() + "\t"
++            );
+         }
++        return stacktrace;
+     }
+ }
diff --git a/core/run_ctest_java/.gitignore b/core/run_ctest_java/.gitignore
index 91a2d359..3f185448 100644
--- a/core/run_ctest_java/.gitignore
+++ b/core/run_ctest_java/.gitignore
@@ -24,6 +24,7 @@
 
 # Maven (from: https://github.com/github/gitignore/blob/master/Maven.gitignore)
 target/
+build/
 pom.xml.tag
 pom.xml.releaseBackup
 pom.xml.versionsBackup
@@ -32,3 +33,6 @@ release.properties
 dependency-reduced-pom.xml
 buildNumber.properties
 .mvn/timing.properties
+
+# Target Project
+app/
diff --git a/core/run_ctest_java/README.md b/core/run_ctest_java/README.md
index d6b1d9b2..d4dde5c2 100644
--- a/core/run_ctest_java/README.md
+++ b/core/run_ctest_java/README.md
@@ -68,5 +68,16 @@ mvn exec:java -q \
 -Dproject.args=-q
 ```
 
+Example with 1 Success and 1 Fail. `testCqlBatch_MultipleTablesAuditing` is failed because `num_tokens must be >= 1`
+```
+mvn exec:java -q \
+-Dproject.name=cassandra \
+-Dproject.path=app/cassandra \
+-Dmapping.path=resources/supported/cassandra/param_unset_getter_map.json \
+-Dconf.file=examples/example-config.yaml \
+-Dtest.file=examples/example-test.txt \
+-Dproject.props=use.jdk11=true
+```
+
 ## How To Support New Project
 Check out instructions in [here](./docs/Support-New-Project.md)
diff --git a/core/run_ctest_java/docs/Support-New-Project.md b/core/run_ctest_java/docs/Support-New-Project.md
index 6b9ac3a2..680083b7 100644
--- a/core/run_ctest_java/docs/Support-New-Project.md
+++ b/core/run_ctest_java/docs/Support-New-Project.md
@@ -10,7 +10,7 @@ Using the following instructions to add support for new project.
 ## Instrument Target Project
 - You may need to modify the source code of target project, so the target project will load the modified configuration values when it is running.
     - One way is to use the project build-in function to load modified configuration files during runtime. Check out example [git patch](../../patch/hadoop-common/interception.patch).
-    - Another way is to first load the default configuration values as a Map object then load the modified configuration files as another Map object, and merge them together, then pass the merged one into downstream operation.
+    - Another way is to first load the default configuration values as a Map object then load the modified configuration files as another Map object, and merge them together, then pass the merged one into downstream operation. Check out example [git patch](../../patch/cassandra/interception.patch)
 - Pack the modification as a git patch for future reference.
 
 ## Implement CTest Logic
diff --git a/core/run_ctest_java/resources/supported/README.md b/core/run_ctest_java/resources/supported/README.md
index 4ec559e6..6255b286 100644
--- a/core/run_ctest_java/resources/supported/README.md
+++ b/core/run_ctest_java/resources/supported/README.md
@@ -1,7 +1,10 @@
 # CTest Supported Project
 The following is a list of currently supported project/module by CTest. You can find the general information about the specific project/module in their own directory.
-- Note: the format of supported modules is `parent project/module name`.
+- Note: the naming format of modules is `parent-project/module-name`.
 
-Modules:
+Supported Projects:
+- [cassandra](./cassandra/README.md)
+
+Supported Modules:
 - [hadoop/hadoop-common](./hadoop-common/README.md)
 - [hadoop/hadoop-hdfs](./hadoop-hdfs/README.md)
diff --git a/core/run_ctest_java/resources/supported/cassandra/README.md b/core/run_ctest_java/resources/supported/cassandra/README.md
new file mode 100644
index 00000000..29479a6a
--- /dev/null
+++ b/core/run_ctest_java/resources/supported/cassandra/README.md
@@ -0,0 +1,20 @@
+# How to set up Cassandra for CTest
+Prerequisites:
+- Java 11
+- Ant 1.10.7
+
+Steps:
+1. run setup script, `./setup.sh`
+2. (Optional) go to cassandra directory and verify setup, `ant testsome -Dtest.name=org.apache.cassandra.hints.HintsCatalogTest -Dtest.methods=deleteHintsTest -Duse.jdk11=true`
+
+# Additional Parameters For CTest
+For running CTest, please refer to [doc](../../../README.md#how-to-run-ctest)
+
+## project.props
+- `use.jdk11=true`
+    - required
+
+## project.args
+- `-q`
+    - recommended
+    - suppress INFO level log
diff --git a/core/run_ctest_java/resources/supported/cassandra/param_unset_getter_map.json b/core/run_ctest_java/resources/supported/cassandra/param_unset_getter_map.json
new file mode 100644
index 00000000..bcd26f05
--- /dev/null
+++ b/core/run_ctest_java/resources/supported/cassandra/param_unset_getter_map.json
@@ -0,0 +1,30719 @@
+{
+  "storage_port": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_nodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_racks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testUnsupportedPartitioner",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs2",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_single_rack_or_single_rf",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs4",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs3",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.tools.GenerateTokensTest#testMain",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_unbalanced_racks",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs1",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "concurrent_validations": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_nodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_racks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testUnsupportedPartitioner",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs2",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_single_rack_or_single_rf",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs4",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs3",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.tools.GenerateTokensTest#testMain",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_unbalanced_racks",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs1",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "concurrent_compactors": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_nodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_racks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testUnsupportedPartitioner",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs2",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_single_rack_or_single_rf",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs4",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs3",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.tools.GenerateTokensTest#testMain",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_unbalanced_racks",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs1",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "partitioner": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_nodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_racks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testUnsupportedPartitioner",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs2",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_single_rack_or_single_rf",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs4",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs3",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.tools.GenerateTokensTest#testMain",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_unbalanced_racks",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs1",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "listen_address": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.utils.FBUtilitiesTest#testGetBroadcastNativeAddress",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "listen_interface": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.utils.FBUtilitiesTest#testGetBroadcastNativeAddress",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "broadcast_address": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.utils.FBUtilitiesTest#testGetBroadcastNativeAddress",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "rpc_address": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.utils.FBUtilitiesTest#testGetBroadcastNativeAddress",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "rpc_interface": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.utils.FBUtilitiesTest#testGetBroadcastNativeAddress",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "broadcast_rpc_address": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.utils.FBUtilitiesTest#testGetBroadcastNativeAddress",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "dynamic_snitch_update_interval_in_ms": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_nodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_racks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testUnsupportedPartitioner",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs2",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_single_rack_or_single_rf",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs4",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs3",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.tools.GenerateTokensTest#testMain",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_unbalanced_racks",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs1",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "dynamic_snitch_reset_interval_in_ms": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_nodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_racks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testUnsupportedPartitioner",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs2",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_single_rack_or_single_rf",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs4",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs3",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.tools.GenerateTokensTest#testMain",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_unbalanced_racks",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs1",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "dynamic_snitch_badness_threshold": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_nodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_racks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testUnsupportedPartitioner",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs2",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_single_rack_or_single_rf",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs4",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs3",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.tools.GenerateTokensTest#testMain",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_unbalanced_racks",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs1",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "initial_token": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "transparent_data_encryption_options": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_nodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_more_rf_than_racks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testUnsupportedPartitioner",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs2",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_single_rack_or_single_rf",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs4",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs3",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.tools.GenerateTokensTest#testMain",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_unbalanced_racks",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs1",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "server_encryption_options": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "client_encryption_options": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "authenticator": [
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForEmptyGraph",
+    "org.apache.cassandra.dht.RangeTest#testContainsRange",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.gms.SerializationsTest#testEndpointStateRead",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.utils.MerkleTreesTest#testDifference",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testPublish",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIterator",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#stoppedWorkersProcessTasksWhenConcurrencyIncreases",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchOldWraps",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashInner",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractFromFullRingRange",
+    "org.apache.cassandra.dht.RangeTest#testByteTokensCompare",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackConsolidation",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllWithWrapAround",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchBothWrap",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAll",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.dht.RangeTest#testIntersectsWrapping",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldWarnOnHigherReplicationFactorThanNodesInDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.gms.SerializationsTest#testGossipDigestRead",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.locator.TokenMetadataTest#testConcurrentInvalidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.utils.MerkleTreesTest#testInvalids",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseSimpleRF",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNewWraps",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionContains",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputation",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.locator.GossipingPropertyFileSnitchTest#testLoadConfig",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionWithAll",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.dht.RangeTest#testRandomOrderedRangeContainmentChecker",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashRandom",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribe",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testCalculateEndpoints",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.dht.RangeTest#testNoIntersection",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSort",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterTable",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadedReadConsistency",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.dht.RangeTest#testGroupIntersect",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionTwoWraps",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.locator.TokenMetadataTest#testEndpointSizes",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testLargeCluster",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.utils.MerkleTreesTest#testSplit",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeNoop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.locator.TokenMetadataTest#testRingIteratorIncludeMin",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testForceHeapSpaceOom",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testFailedCrc",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.nodetool.SjkTest#sjkHelpReturnsRc0",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_BothWrapAround",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeSimpleOverlap",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeByType",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithSingleSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivalRangeLocalHostStreaming",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashDegenerate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testPropertiesWithEmptyDC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testResetCrc",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.dht.RangeTest#testCompareTo_SameObject_WrapAround",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.utils.MerkleTreesTest#testIntersectingRanges",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testSubscribeAll",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.dht.RangeTest#testIntersects",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.dht.RangeTest#testContainsWrapping",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeUnwrap",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testTrivialRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#shutdownTest",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testEnabled",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.locator.TokenMetadataTest#testTopologyUpdate_RackExpansion",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.RangeTest#testGroupSubtract",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNonOverlappingSource",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForMultipleRoundsComputationWithLocalHost",
+    "org.apache.cassandra.utils.SerializationsTest#testEstimatedHistogramRead",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForLocalDC",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithRFThreeReplacement",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.dht.RangeTest#testContains",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.dht.RangeTest#testSubtractAllFromFullRingRange",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.dht.RangeTest#testBoundariesORCC",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldFailOnInvalidRF",
+    "org.apache.cassandra.gms.EndpointStateTest#testMultiThreadWriteConsistency",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.utils.MerkleTreesTest#testHashPartial",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeWrapping",
+    "org.apache.cassandra.hints.ChecksummedDataInputTest#testReadMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoLiveSource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testForRemoteDC",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplit",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.diag.DiagnosticEventServiceTest#testCleanup",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.dht.RangeTest#testNormalizeComplex",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#shouldRejectReplicationFactorOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.ToolsEnvsConfigsTest#testJDKEnvInfoDefaultCleaners",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testProperties",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testWithNoSourceWithLocal",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.dht.RangeTest#testIntersectionOneWraps",
+    "org.apache.cassandra.dht.RangeTest#testDifferenceToFetchNoWrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.dht.RangeFetchMapCalculatorTest#testNotEnoughEndpointsForTrivialRange",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testKill",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#changingMaxWorkersMeetsConcurrencyGoalsTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.utils.SerializationsTest#testBloomFilterRead1000",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.dht.RangeTest#testContainsRangeOneWrapping"
+  ],
+  "commitlog_compression": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "data_file_directories": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testUnicodeArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testColorArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testPKArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultipleExcludePKArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testOnlySstableArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testCQLRowArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testExcludePKArg",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testScanArg",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultiplePKArg",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testPKOnlyArg",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "local_system_data_file_directory": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testUnicodeArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testColorArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testPKArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultipleExcludePKArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testOnlySstableArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testCQLRowArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testExcludePKArg",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testScanArg",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultiplePKArg",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testPKOnlyArg",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "commitlog_directory": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "hints_directory": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "saved_caches_directory": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "cdc_enabled": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "commitlog_sync": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "cdc_raw_directory": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "commitlog_max_compression_buffers_in_pool": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "commitlog_segment_size_in_mb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "commitlog_total_space_in_mb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.gms.GossiperTest#testPaddingIntact",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.gms.GossiperTest#testHasVersion3Nodes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testLongTokenInverse",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitExceedMaximumCase",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.dht.Murmur3PartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.dht.OrderPreservingPartitionerTest#testCompare",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.AuditLogViewerTest#testNoArgs",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.dht.RandomPartitionerTest#testSplitWrapping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.CompactionStressTest#testNoArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "enable_user_defined_functions_threads": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "cluster_name": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "diagnostic_events_enabled": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapAndLeavePermutationsWithVnodes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testUnsupportedPartitioner",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostDc",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_single_rack_or_single_rf",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testRemoveHost",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.gms.ExpireEndpointTest#testExpireEndpoint",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeDefault",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.locator.PendingRangesTest#testBootstrapLeaveAndMovePermutationsWithoutVnodes",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.tools.GenerateTokensTest#testMain",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.locator.PendingRangesTest#calculatePendingRangesForConcurrentReplacements",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.dht.tokenallocator.OfflineTokenAllocatorTest#testTokenGenerator_unbalanced_racks",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testChangeHostRack",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.PropertyFileSnitchTest#testAddHost",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeaveAndMove",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.locator.PendingRangesTest#testConcurrentAdjacentLeavingNodes",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "native_transport_port": [
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiEqRestrictions",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiEqAndSingleSliceRestrictions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiInRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndInRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneAscendingAndOneDescendingClusteringColumns",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSeveralMultiColumnRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoDescendingClusteringColumns",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneInRestrictionsAndOneClusteringColumn",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithAscendingDescendingColumnMix",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndSliceRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSliceRestrictionsAndOneDescendingClusteringColumn",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoClusteringColumn",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithTwoAscendingAndTwoDescendingClusteringColumns",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneClusteringColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithOneEqRestrictionsAndTwoClusteringColumns",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithSingleEqAndMultiINRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithNoRestrictions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.restrictions.ClusteringColumnRestrictionsTest#testBoundsAsClusteringWithMultiSliceRestrictionsWithOneDescendingAndOneAscendingClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "authorizer": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue"
+  ],
+  "max_mutation_size_in_kb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfRowMutations",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfColumnFamilies",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#noTriggerMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentCfColumnFamilies",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeyDifferentKsRowMutations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#sameKeySameCfPartialRowMutations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.triggers.TriggerExecutorTest#differentKeyColumnFamilies",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "concurrent_materialized_view_writes": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.locator.ReplicaPlansTest#testWriteEachQuorum",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "memtable_flush_writers": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "read_request_timeout_in_ms": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "write_request_timeout_in_ms": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "memtable_heap_space_in_mb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "memtable_offheap_space_in_mb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "memtable_cleanup_threshold": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "memtable_allocation_type": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.gms.GossiperTest#testDuplicatedStateUpdate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.gms.GossiperTest#testNotFireDuplicatedNotificationsWithUpdateContainsOldAndNewState",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "audit_logging_options": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsNoArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "max_hints_delivery_threads": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "hints_compression": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "hints_flush_period_in_ms": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "tombstone_failure_threshold": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "tombstone_warn_threshold": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.dht.StreamStateStoreTest#testUpdateAndQueryAvailableRanges",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDefaultCall",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testSizeArg",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testListFilesArgs",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testDefaultCall",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testCleanupArg",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.tools.SSTableExpiredBlockersTest#testWrongArgsIgnored",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.tools.StandaloneSSTableUtilTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.tools.TopPartitionsTest#testServiceTopPartitionsSingleTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableLevelResetterTest#testDefaultCall",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testDefaultCall",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testWrongFilename",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDryrunArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.SSTableOfflineRelevelTest#testDefaultCall",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "request_timeout_in_ms": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "range_request_timeout_in_ms": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "counter_write_request_timeout_in_ms": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "truncate_request_timeout_in_ms": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "listen_on_broadcast_address": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "internode_socket_receive_buffer_size_in_bytes": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.gms.ShadowRoundTest#testBadAckInShadow",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "file_cache_size_in_mb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "networking_cache_size_in_mb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsunrepairedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testFilesArg",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.tools.SSTableRepairedAtSetterTest#testIsrepairedArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "auto_bootstrap": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.gms.ShadowRoundTest#testPreviouslyAssassinatedInShadow",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "min_free_space_per_drive_in_mb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "file_cache_round_up": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "file_cache_enabled": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testPKArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultipleExcludePKArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testCQLRowArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testExcludePKArg",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testScanArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultiplePKArg",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "trickle_fsync": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "trickle_fsync_interval_in_kb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "flush_compression": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "disk_access_mode": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testPKArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultipleExcludePKArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testCQLRowArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testExcludePKArg",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testScanArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultiplePKArg",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "column_index_cache_size_in_kb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "column_index_size_in_kb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "compaction_large_partition_warning_threshold_mb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "disk_optimization_estimate_percentile": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testPKArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultipleExcludePKArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testCQLRowArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testExcludePKArg",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testScanArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultiplePKArg",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "key_cache_keys_to_save": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "key_cache_save_period": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "row_cache_size_in_mb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "row_cache_class_name": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "row_cache_keys_to_save": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "row_cache_save_period": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "counter_cache_keys_to_save": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "counter_cache_save_period": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "incremental_backups": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "concurrent_materialized_view_builders": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.tools.StandaloneUpgraderTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testVerboseArg",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testExtendedArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testQuickArg",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testDefaultCall",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testDebugArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.tools.StandaloneVerifierTest#testRepairStatusArg",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testFlagArgs",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.tools.StandaloneSplitterTest#testFlagArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.StandaloneScrubberTest#testHeaderFixArg",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "automatic_sstable_upgrade": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.gms.FailureDetectorTest#testConvictAfterLeft",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "corrupted_tombstone_strategy": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testPKArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultipleExcludePKArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testCQLRowArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testExcludePKArg",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testScanArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultiplePKArg",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "allocate_tokens_for_keyspace": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "allocate_tokens_for_local_replication_factor": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "num_tokens": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldRoundTripParseTransientRF",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.locator.ReplicationFactorTest#shouldParseValidRF",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.locator.NetworkTopologyStrategyTest#testTransientReplica",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact"
+  ],
+  "max_value_size_in_mb": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.auth.CassandraRoleManagerTest#getGrantedRolesImplMinimizesReads",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testStringEndpoints",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testPKArg",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.locator.SimpleStrategyTest#shouldReturnNoEndpointsForEmptyRing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.hints.HintWriteTTLTest#hintIsLive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testEndpointsWereCached",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.hints.HintsCompressionTest#snappyCompressor",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#newKsContainsCfWithTrigger",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addNewCfWithTriggerToKs",
+    "org.apache.cassandra.hints.HintsReaderTest#testNormalRead",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cache.CacheProviderTest#testSerializingCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.hints.HintMessageTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.hints.HintsCatalogTest#deleteHintsTest",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.hints.HintWriteTTLTest#bufferIterator",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testMultiDCSimpleStrategyEndpoints",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#removeTriggerFromCf",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintsCatalogTest#loadCompletenessAndOrderTest",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultipleExcludePKArg",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cache.CacheProviderTest#testKeys",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.locator.ReplicationStrategyEndpointCacheTest#testCacheRespectsTokenChanges",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.dht.KeyCollisionTest#testGetSliceWithCollision",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.triggers.TriggersSchemaTest#addTriggerToCf",
+    "org.apache.cassandra.locator.SimpleStrategyTest#transientReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.hints.HintMessageTest#testEncodedSerializer",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testGetEndpointsDuringBootstrap",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.hints.HintsEncryptionTest#encryptedHints",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testSimpleStrategyThrowsConfigurationException",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFileNotAllZeros",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.hints.HintsCompressionTest#lz4Compressor",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testCQLRowArg",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testExcludePKArg",
+    "org.apache.cassandra.locator.SimpleStrategyTest#tryValidKeyspace",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.tools.SSTableMetadataViewerTest#testScanArg",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.locator.SimpleStrategyTest#testBigIntegerEndpoints",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.tools.SSTableExportSchemaLoadingTest#testMultiplePKArg",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.hints.HintsCatalogTest#exciseHintFiles",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.hints.HintsReaderTest#corruptFile",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.hints.HintsCompressionTest#deflateCompressor",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.hints.HintWriteTTLTest#isLive",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "rpc_keepalive": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "native_transport_flush_in_batches_legacy": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "native_transport_max_threads": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "native_transport_max_concurrent_requests_in_bytes": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "batchlog_replay_throttle_in_kb": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "native_transport_max_concurrent_connections": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "native_transport_max_concurrent_connections_per_ip": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "native_transport_idle_timeout_in_ms": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "native_transport_max_frame_size_in_mb": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "native_transport_allow_older_protocols": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "native_transport_max_concurrent_requests_in_bytes_per_ip": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "repaired_data_tracking_for_range_reads_enabled": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "concurrent_reads": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "slow_query_log_timeout_in_ms": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "check_for_duplicate_rows_during_reads": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing"
+  ],
+  "snapshot_on_duplicate_row_detection": [
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes"
+  ],
+  "keyspace_count_warn_threshold": [
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetSamePath",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueriesQuery",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#createSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNegativeTime",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testNonBlocking",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.tools.NodeProbeTest#testCheckJobs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyText",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanRead",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueWeight",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testBlocking",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQueryWithKeyspace",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testEnabledStop",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#roleNameTest",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNull",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullType",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithoutKeyspaceOption",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listRolesSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripBatchWithKeyspaceNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidTableWithKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetCleansPaths",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptySmallInt",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureOverExistingFile",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#customOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testMarkerPgFail",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyTime",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanExecute",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCleansDirectory",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidSnapshotName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNegativeTime",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#alterSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#stopWithoutConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValuesValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_simple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogQueryNullQueryOptions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_AllAndName",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullValues",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_RollOverNanos",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#standardOptionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testLogBatchNullQueries",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testResetWithoutConfigure",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#listPermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testUnparseable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#grantRevokePermissionsSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullPath",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNull",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidMaxQueueLogSize",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.cql3.EmptyValuesTest#testEmptyDate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testInvalidKeyspacesWithKeyspaceTableListOptions",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testCanWrite",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.utils.StatusLoggerTest#testStatusLoggerPrintsStatusOnlyOnceWhenInvokedConcurrently",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_BorkedClock",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.RoleSyntaxTest#dropSyntaxTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testDoubleConfigure",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureInvalidRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative",
+    "org.apache.cassandra.cql3.ListsTest#testPrecisionTime_getNext_Mulitple",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.fql.FullQueryLoggerTest#testConfigureNullRollCycle",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes"
+  ],
+  "snapshot_before_compaction": [
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes"
+  ],
+  "compaction_throughput_mb_per_sec": [
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes"
+  ],
+  "check_for_duplicate_rows_during_compaction": [
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes"
+  ],
+  "sstable_preemptive_open_interval_in_mb": [
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue"
+  ],
+  "key_cache_migrate_during_compaction": [
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlAggregateAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.hints.HintTest#testApplyWithRegularExpiration",
+    "org.apache.cassandra.hints.HintTest#testApplyWithGCGSReducedLater",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.ViewTest#testNonExistingOnes",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.tools.CompactionStressTest#testWriteAndCompact",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.hints.HintTest#testSerializer",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue"
+  ],
+  "table_count_warn_threshold": [
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClause",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rangeTombstone",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDynamicCompactTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testIdentifiers",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithTwoClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceOldFormat",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBoolean",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNanInfinityValues",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondWarnThresholdSelect",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testStaticColumns",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testBatch",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testModify",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#collectionDeletionTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#baseCheck",
+    "org.apache.cassandra.cql3.SimpleQueryTest#staticDistinctTest",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithReverseClusteringOrder",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableDie",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRowFilteringOnStaticColumn",
+    "org.apache.cassandra.cql3.NonNativeTimestampTest#setServerTimestampForNonCqlNativeStatements",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testColumnNameValidation",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowTombstone",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRow",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithOneClustering",
+    "org.apache.cassandra.cql3.QueryWithIndexedSSTableTest#queryIndexedSSTableTest",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_HugeList",
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInvalidSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testExpiredTombstones",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithLargePartition",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testMinMaxtimestampRange",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableStop",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectUDTLiteral",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testAllShadowedSelect",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithWhereClauseOnStaticColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFunctionWithNull",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testLiveShadowedCellsSelect",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testSStableTimestampOrdering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testEmptyBlob",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testBlobAsFunction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testConversionFunctions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testReservedKeywords",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testUnescapedString",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBeyondThresholdSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testTableWithoutClustering",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarker",
+    "org.apache.cassandra.cql3.SimpleQueryTest#limitWithMultigetTest",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTableMetadataTrackingTest#testTrackMetadata_rowMarkerDelete",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectLiteral",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinctWithDeletions",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClustering",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testDistinct",
+    "org.apache.cassandra.cql3.OutOfSpaceTest#testFlushUnwriteableIgnore",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testChangingCrcCheckChanceNewFormat",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.cql3.NodeLocalConsistencyTest#testSelect",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testTableOptions",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testMultipleArgumentFunction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.TombstonesTest#testBelowThresholdSelect",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testFloatWithExponent",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.SerializationMirrorTest#testManyClusterings",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleInsert",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.SimpleQueryTest#restrictionOnRegularColumnWithStaticColumnPresentTest",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.validation.operations.SelectTest#testSingleClusteringReversed",
+    "org.apache.cassandra.cql3.validation.miscellaneous.OverflowTest#testNullSupport",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.cql3.ListsTest#testPrepender_SmallList",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate",
+    "org.apache.cassandra.cql3.DistinctQueryPagingTest#testSelectDistinct",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testCollectionLiteralsWithDurations",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexes"
+  ],
+  "force_new_prepared_statement_behaviour": [
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testSelectPrepared",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude"
+  ],
+  "auto_snapshot": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue"
+  ],
+  "snapshot_links_per_second": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlKeyspaceAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissingAndMulticellColumn",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testKeyspaceTableListOption",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#testPagingOnPartitionsWithoutClusteringColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMulticellColumn",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRows",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlIndexAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlSelectAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveMultiple",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnMemTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsSaveKeysForDroppedTableIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndNullColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMixedMemtableSStablesASC",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredIndexInfoOnHeap",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionCells",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableSkippingPkOnly",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifySingleKeyspace",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilters",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSkipFlushOption",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionPartitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSSTablesOnlyASC",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_RemoveByName",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellsDeletion",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithPartitionRestriction",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactStaticTable",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing",
+    "org.apache.cassandra.hints.HintsReaderTest#testDroppedTableRead",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testTableOption",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#testKeyCacheNonClusteredShallowIndexEntry",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectRetainsLCSLevel",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFiltersTransitions",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter",
+    "org.apache.cassandra.cql3.GcCompactionTest#testLocalDeletionTime",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRowDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTriggerAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testSinglePartitionQuery",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTypeAuditing",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesASC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithAlterTableStatement",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlTableAuditing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testMultiplePartitionsDESC",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableCellUpdate",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnSameSSTable",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cql3.IndexQueryPagingTest#pagingOnRegularColumnWithClusteringRestrictions",
+    "org.apache.cassandra.hints.HintTest#testApplyWithTruncation",
+    "org.apache.cassandra.tools.ClearSnapshotTest#testClearSnapshot_NoArgs",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotWithName",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGarbageCollectOrder",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndPartitionTombstones",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotAllKeyspaces",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testOverlappingSStablesDESC",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionComplexColumn",
+    "org.apache.cassandra.audit.BinAuditLoggerTest#testSelectRoundTripQuery",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompositeCompactTableWithMultipleRegularColumns",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumn",
+    "org.apache.cassandra.cql3.validation.miscellaneous.CrcCheckChanceTest#testDropDuringCompaction",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.tools.nodetool.SnapshotTest#testSnapshotSpecifyMultipleKeyspaces",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnValueMissing",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue"
+  ],
+  "ideal_consistency_level": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing"
+  ],
+  "concurrent_writes": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlDeleteAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testAuditLogFilterIncludeExclude",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlUpdateAuditing"
+  ],
+  "batch_size_warn_threshold_in_kb": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatchAuditing",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlBatch_MultipleTablesAuditing"
+  ],
+  "enable_materialized_views": [
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing"
+  ],
+  "initial_range_tombstone_list_allocation_size": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnOverlappingIndexedSSTable",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithStaticColumnAndRangeDeletion",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlMVAuditing",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.cql3.SimpleQueryTest#testRangeTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableWithClusteringColumnAndMultipleRegularColumnsAndRowRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testDeletionOnIndexedSSTableDESC",
+    "org.apache.cassandra.cql3.SimpleQueryTest#test2ndaryIndexBug",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testNonCompactTableRangeDeletion"
+  ],
+  "enable_user_defined_functions": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.PgStringTest#testPgSyleFunction",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing"
+  ],
+  "enable_scripted_user_defined_functions": [
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.audit.AuditLoggerTest#testCqlFunctionAuditing"
+  ],
+  "use_offheap_merkle_trees": [
+    "org.apache.cassandra.utils.MerkleTreesTest#testSerialization"
+  ],
+  "disk_failure_policy": [
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs",
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#fileHandleTest",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs2",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithQuorumTest",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#raceOnRemoveDatacenterNotCausesUnavailable",
+    "org.apache.cassandra.gms.GossiperTest#testReloadSeeds",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensForKeyspace",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs4",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#increaseReplicationFactorShouldNotCausesUnavailableTest",
+    "org.apache.cassandra.utils.JVMStabilityInspectorTest#testOutOfMemoryHandling",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyThreeRacks",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#addDatacenterShouldNotCausesUnavailableWithEachQuorumTest",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRack",
+    "org.apache.cassandra.dht.BootStrapperTest#testSourceTargetComputation",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensNetworkStrategyOneRackOneReplica",
+    "org.apache.cassandra.locator.AssureSufficientLiveNodesTest#insufficientLiveNodesTest",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs3",
+    "org.apache.cassandra.dht.tokenallocator.TokenAllocationTest#testAllocateTokensMultipleKeyspaces",
+    "org.apache.cassandra.tools.BulkLoaderTest#testBulkLoader_WithArgs1"
+  ],
+  "internode_compression": [
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable"
+  ],
+  "internode_socket_send_buffer_size_in_bytes": [
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable"
+  ],
+  "internode_tcp_connect_timeout_in_ms": [
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable"
+  ],
+  "internode_tcp_user_timeout_in_ms": [
+    "org.apache.cassandra.locator.ReconnectableSnitchHelperTest#failedAuthentication",
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable"
+  ],
+  "internode_max_message_size_in_bytes": [
+    "org.apache.cassandra.hints.HintTest#testChangedTopology",
+    "org.apache.cassandra.gms.GossiperTest#testLargeGenerationJump",
+    "org.apache.cassandra.hints.HintTest#testChangedTopologyNotHintable"
+  ],
+  "tracetype_query_ttl": [
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing"
+  ],
+  "tracetype_repair_ttl": [
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitWithResultFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.SEPExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testLocalStatePropagation",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testSubmitFutureTaskWhileTracing",
+    "org.apache.cassandra.concurrent.DebuggableThreadPoolExecutorTest#testExecuteFutureTaskWhileTracing"
+  ],
+  "roles_validity_in_ms": [
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache"
+  ],
+  "roles_update_interval_in_ms": [
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache"
+  ],
+  "roles_cache_max_entries": [
+    "org.apache.cassandra.auth.RolesTest#superuserStatusIsCached",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleResourcesAreCached",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.auth.RolesTest#grantedRoleDetailsAreCached",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter",
+    "org.apache.cassandra.auth.RolesTest#loginPrivilegeIsCached",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache"
+  ],
+  "credentials_validity_in_ms": [
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue"
+  ],
+  "credentials_update_interval_in_ms": [
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue"
+  ],
+  "credentials_cache_max_entries": [
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULUsername0",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyPassword",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testCheckpw",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testEmptyUsername",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword0",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testNULPassword1",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidUpperBoundHashingRoundsValue",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.auth.PasswordAuthenticatorTest#testInvalidLowerBoundHashingRoundsValue"
+  ],
+  "permissions_validity_in_ms": [
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#readAttribute",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#executeMethod",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.auth.jmx.JMXAuthTest#writeAttribute",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "permissions_update_interval_in_ms": [
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "permissions_cache_max_entries": [
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenSubjectIsNull",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButAuthzNotRequired",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectMethodsWithoutMBeanArgumentIfPermissionsNotGranted",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenAuthSetupIsNotComplete",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIntersectsWithWildcardTarget",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissionsButIsSuperuser",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#superUser",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantIsDisjointWithWildcardTarget",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#create",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversExactTarget",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#drop",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasNoPermissions",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenWildcardGrantDoesNotCoverExactTarget",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeWhenWildcardGrantCoversWildcardTarget",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#cantLogin",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfRestrictedMethods",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeOnTargetWildcardWithPermissionOnRoot",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermissionOnRootResource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasOtherPermissionOnRootResource",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectWhenSubjectNotAuthenticated",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#getLoginPrivilegeFromRolesCache",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleHasRequiredPermission",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#rejectInvocationOfUnknownMethod",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#roleDoesNotHaveRequiredPermission",
+    "org.apache.cassandra.auth.CassandraAuthorizerTest#testListPermissionsOfChildByParent",
+    "org.apache.cassandra.auth.jmx.AuthorizationProxyTest#authorizeMethodsWithoutMBeanArgumentIfPermissionsGranted",
+    "org.apache.cassandra.auth.CassandraNetworkAuthorizerTest#alter"
+  ],
+  "hinted_handoff_enabled": [
+    "org.apache.cassandra.hints.HintTest#testChangedTopology"
+  ],
+  "hinted_handoff_disabled_datacenters": [
+    "org.apache.cassandra.hints.HintTest#testChangedTopology"
+  ],
+  "full_query_logging_options": [
+    "org.apache.cassandra.tools.GetFullQueryLogTest#resetFullQueryLogTest",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#enableFullQueryLogTest",
+    "org.apache.cassandra.tools.GetFullQueryLogTest#getFullQueryLogTest"
+  ],
+  "inter_dc_stream_throughput_outbound_megabits_per_sec": [
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative"
+  ],
+  "stream_throughput_outbound_megabits_per_sec": [
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testPositive",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testNegative",
+    "org.apache.cassandra.tools.nodetool.SetGetInterDCStreamThroughputTest#testZero",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testPositive",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testMaxValue",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testZero",
+    "org.apache.cassandra.tools.nodetool.SetGetStreamThroughputTest#testNegative"
+  ],
+  "cache_load_timeout_seconds": [
+    "org.apache.cassandra.cql3.KeyCacheCqlTest#test2iKeyCachePathsIndexInfoOnHeap",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache0kB",
+    "org.apache.cassandra.cache.AutoSavingCacheTest#testSerializeAndLoadKeyCache"
+  ],
+  "range_tombstone_list_growth_factor": [
+    "org.apache.cassandra.cql3.GcCompactionTest#testGcCompactionRanges"
+  ],
+  "cdc_free_space_check_interval_ms": [
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate"
+  ],
+  "cdc_total_space_in_mb": [
+    "org.apache.cassandra.cql3.CDCStatementTest#testDisableOnAlter",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnAlter",
+    "org.apache.cassandra.cql3.CDCStatementTest#testEnableOnCreate"
+  ],
+  "user_defined_function_warn_timeout": [
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testConstantFunctionArgs",
+    "org.apache.cassandra.cql3.selection.SelectionColumnMappingTest#testSelectionColumnMapping",
+    "org.apache.cassandra.cql3.selection.TermSelectionTest#testInsertUpdateDelete"
+  ],
+  "enable_drop_compact_storage": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellUpdate",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableSkipping",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRowOverRangeDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithMultipleRegularColumnsAndColumnDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableDeleteOverlappingSSTables",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableRangeOverRowDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableCellDeletion",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithPartitionTombstones",
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactTableWithClusteringColumnAndColumnDeletion"
+  ],
+  "concurrent_counter_writes": [
+    "org.apache.cassandra.cql3.validation.miscellaneous.SSTablesIteratedTest#testCompactAndNonCompactTableWithCounter"
+  ]
+}
diff --git a/core/run_ctest_java/resources/supported/cassandra/setup.sh b/core/run_ctest_java/resources/supported/cassandra/setup.sh
new file mode 100755
index 00000000..0a4e6594
--- /dev/null
+++ b/core/run_ctest_java/resources/supported/cassandra/setup.sh
@@ -0,0 +1,5 @@
+APP_PATH=$(git rev-parse --show-toplevel)
+[ ! -d "$APP_PATH/core/run_ctest_java/app/cassandra" ] && git clone https://github.com/CornDavid5/cassandra.git "$APP_PATH/core/run_ctest_java/app/cassandra"
+cd "$APP_PATH/core/run_ctest_java/app/cassandra"
+git fetch && git checkout ctest-injection
+CASSANDRA_USE_JDK11=true ant
\ No newline at end of file
diff --git a/core/run_ctest_java/src/main/java/uiuc/xlab/openctest/runctest/supported/CTestSupported.java b/core/run_ctest_java/src/main/java/uiuc/xlab/openctest/runctest/supported/CTestSupported.java
index adb344e2..25d4f596 100644
--- a/core/run_ctest_java/src/main/java/uiuc/xlab/openctest/runctest/supported/CTestSupported.java
+++ b/core/run_ctest_java/src/main/java/uiuc/xlab/openctest/runctest/supported/CTestSupported.java
@@ -19,9 +19,11 @@ public static CTestRunnable getCTestRunner(final String project) {
                 return new HadoopCommon();
             case "hadoop-hdfs":
                 return new HadoopHDFS();
+            case "cassandra":
+                return new Cassandra();
             default:
                 throw new IllegalStateException(String.format(
-                        "run-ctest doesn't support {}", project));
+                        "run-ctest doesn't support %s", project));
         }
     }
 }
diff --git a/core/run_ctest_java/src/main/java/uiuc/xlab/openctest/runctest/supported/Cassandra.java b/core/run_ctest_java/src/main/java/uiuc/xlab/openctest/runctest/supported/Cassandra.java
new file mode 100644
index 00000000..3871e6e8
--- /dev/null
+++ b/core/run_ctest_java/src/main/java/uiuc/xlab/openctest/runctest/supported/Cassandra.java
@@ -0,0 +1,279 @@
+package uiuc.xlab.openctest.runctest.supported;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.javatuples.Pair;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.SAXException;
+
+import uiuc.xlab.openctest.runctest.interfaces.CTestRunnable;
+
+public final class Cassandra implements CTestRunnable {
+    /**
+     * logger for this class.
+     */
+    private static final Logger LOGGER =
+            LoggerFactory.getLogger(Cassandra.class);
+    /**
+     * JUnit file name template.
+     */
+    private static final String JUNIT_OUTPUT_XML = "TEST-@-#.xml";
+    /**
+     * root path of the target project.
+     */
+    private Path rootPath;
+    /**
+     * path to junit directory.
+     */
+    private Path junitPath;
+    /**
+     * path to the ctest injected configuration file.
+     */
+    private Path configInjectionPath;
+
+    @Override
+    public void setProjectRootPath(final Path targetPath) {
+        this.rootPath = targetPath;
+        junitPath = Path.of(targetPath.toString(), "build/test/output");
+        configInjectionPath = Path.of(
+                targetPath.toString(),
+                "test/conf",
+                "ctest-injection.yaml");
+    }
+
+    @Override
+    public void injectConfig(final Map<String, Object> updatedConfig) {
+        // cassandra using yaml to store configuration
+        try {
+            // delete old ctest-injection.yaml file
+            Files.deleteIfExists(configInjectionPath);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        // write out
+        try (FileWriter fw = new FileWriter(configInjectionPath.toFile())) {
+            for (Map.Entry<String, Object> conf : updatedConfig.entrySet()) {
+                fw.write(String.format(
+                        "%s: %s%n",
+                        conf.getKey(),
+                        conf.getValue().toString()));
+            }
+
+            LOGGER.info(
+                    "Injected modified config into: {}", configInjectionPath);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void runCTest(
+            final Map<String, String> context,
+            final Set<String> affectedTest) {
+        Map<String, String> classTestMap = getClassTestMap(affectedTest);
+        String cassandraBuildFile =
+                rootPath.resolve("build.xml").toAbsolutePath().toString();
+        String antArgs = getAntArgs(context);
+        String antProps = getAntProps(context);
+
+        try {
+            for (Map.Entry<String, String> classTest
+                    : classTestMap.entrySet()) {
+                String className = classTest.getKey();
+                String testStr = classTest.getValue();
+                String cmd = String.format(
+                        "ant %s %s -buildfile %s testsome -Dtest.name=%s -Dtest.methods=%s",
+                        antArgs,
+                        antProps,
+                        cassandraBuildFile,
+                        className,
+                        testStr);
+
+                Process process = Runtime.getRuntime().exec(cmd);
+
+                // redirect ant output to standard output
+                String line = null;
+                BufferedReader is = new BufferedReader(
+                        new InputStreamReader(process.getInputStream()));
+
+                while ((line = is.readLine()) != null) {
+                    System.out.println(line);
+                }
+
+                process.waitFor();
+            }
+        } catch (IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public Pair<Map<String, String>, Map<String, String>> parseResult(
+            final Set<String> affectedTest) {
+        Map<String, String> successfulTest = new HashMap<>();
+        Map<String, String> failedTest = new HashMap<>();
+
+        for (String test : affectedTest) {
+            String[] cm = test.split("#");
+            String className = cm[0];
+            String methodName = cm[1];
+
+            String resultFileName = JUNIT_OUTPUT_XML
+                    .replace("@", className)
+                    .replace("#", methodName);
+            Path resultFilePath = Path.of(junitPath.toString(), resultFileName);
+            if (!resultFilePath.toFile().exists()) {
+                LOGGER.info(
+                        "Cannot locate junit report file in: {}",
+                        resultFilePath);
+                return new Pair<>(successfulTest, failedTest);
+            }
+            LOGGER.info("Reading result from {}", resultFilePath);
+
+            try {
+                // parse result xml file
+                DocumentBuilderFactory docFactory =
+                        DocumentBuilderFactory.newInstance();
+
+                // completely disable DOCTYPE declaration
+                docFactory.setFeature(
+                        "http://apache.org/xml/features/disallow-doctype-decl",
+                        true);
+
+                DocumentBuilder db = docFactory.newDocumentBuilder();
+                Document doc = db.parse(resultFilePath.toFile());
+
+                // get testsuite node
+                Element testsuite = doc.getDocumentElement();
+
+                // get testcase nodes
+                NodeList testcases = testsuite.getElementsByTagName("testcase");
+                if (testcases.getLength() != 1) {
+                    LOGGER.info("Cannot find result for test: {}", test);
+                    continue;
+                }
+
+                // get individual testcase node
+                Node testcaseNode = testcases.item(0);
+                if (testcaseNode.getNodeType() == Node.ELEMENT_NODE) {
+                    Element testcase = (Element) testcaseNode;
+                    String executionDuration = testcase.getAttribute("time");
+                    String testedMethodName = testcase.getAttribute("name");
+
+                    // in the junit report file, some failed tests methods have
+                    // different names than that of the original test methods.
+                    // Typically, it results from modified parameters causing
+                    // the test to fail before executing the test itself.
+                    // The name displayed in surefire report could be any
+                    // one of the following:
+                    // 1. test class initialization method name
+                    // 2. test class name
+                    // 3. empty string
+                    if (methodName.equals(testedMethodName)) {
+                        // populate runningTimes map
+                        successfulTest.put(
+                                className + "#" + methodName,
+                                executionDuration);
+                    } else {
+                        // populate errors map
+                        NodeList errorNodes =
+                                testcase.getElementsByTagName("error");
+                        if (errorNodes.getLength() != 0) {
+                            failedTest.put(
+                                    className + "#" + methodName,
+                                    errorNodes.item(0).getTextContent());
+                        }
+                        NodeList failureNodes =
+                                testcase.getElementsByTagName("failure");
+                        if (failureNodes.getLength() != 0) {
+                            failedTest.put(
+                                    className + "#" + methodName,
+                                    failureNodes.item(0).getTextContent());
+                        }
+                    }
+                }
+            } catch (ParserConfigurationException
+                     | SAXException
+                     | IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        return new Pair<>(successfulTest, failedTest);
+    }
+
+    private Map<String, String> getClassTestMap(
+            final Set<String> affectedTest) {
+        // Cassandra uses ant to manage the project and ant allow
+        // running multiple tests within the same class at once.
+        // In here, we group those tests together.
+        Map<String, List<String>> associatedMethods = new HashMap<>();
+        affectedTest.forEach(test -> {
+            String[] cm = test.split("#");
+            String className = cm[0];
+            String methodName = cm[1];
+
+            associatedMethods.computeIfAbsent(
+                    className,
+                    k -> new ArrayList<>()).add(methodName);
+        });
+
+        // group tests by their class to resue test fixure
+        Map<String, String> testMap = new HashMap<>();
+        associatedMethods.forEach((className, methods) ->
+            testMap.put(className, String.join(",", methods))
+        );
+
+        return testMap;
+    }
+
+    private String getAntArgs(final Map<String, String> context) {
+        Set<String> antArgs = new HashSet<>();
+
+        if (!context.containsKey("args")) {
+            return "";
+        }
+
+        String[] args = context.get("args").split(",");
+        antArgs.addAll(Arrays.asList(args));
+        return String.join(" ", antArgs);
+    }
+
+    private String getAntProps(final Map<String, String> context) {
+        if (!context.containsKey("props")) {
+            return "";
+        }
+
+        String[] props = context.get("props").split(",");
+        StringBuilder sb = new StringBuilder();
+        sb.append("-D");
+        for (String prop : props) {
+            sb.append(prop);
+            sb.append(" ");
+        }
+
+        return sb.toString();
+    }
+}