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%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%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 confMap = new HashMap<>(); ++ URL url; ++ Yaml yaml = new Yaml(); ++ try (InputStream is = storageConfigURL.openStream()) { ++ configBytes = ByteStreams.toByteArray(is); ++ Map 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 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, Map> 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 fromMap(Map map, Class klass) +- { ++ public static T fromMap(Map map, Class klass) { + return fromMap(map, true, klass); + } + +- @SuppressWarnings("unchecked") //getSingleData returns Object, not T +- public static T fromMap(Map map, boolean shouldCheck, Class klass) +- { ++ @SuppressWarnings("unchecked") // getSingleData returns Object, not T ++ public static T fromMap(Map map, boolean shouldCheck, Class klass) { + Constructor constructor = new YamlConfigurationLoader.CustomConstructor(klass, klass.getClassLoader()); + Map, Map> 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 createDefaultList(int initSize) +- { ++ protected List createDefaultList(int initSize) { + return Lists.newCopyOnWriteArrayList(); + } + + @Override +- protected Map createDefaultMap(int initSize) +- { ++ protected Map createDefaultMap(int initSize) { + return Maps.newConcurrentMap(); + } + + @Override +- protected Set createDefaultSet(int initSize) +- { ++ protected Set 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 missingProperties = new HashSet<>(); + + private final Set nullProperties = new HashSet<>(); +@@ -223,115 +242,100 @@ public class YamlConfigurationLoader implements ConfigurationLoader + + private final Map, Map> replacements; + +- public PropertiesChecker(Map, Map> replacements) +- { ++ public PropertiesChecker(Map, Map> replacements) { + this.replacements = Objects.requireNonNull(replacements, "Replacements should not be null"); + setSkipMissingProperties(true); + } + + @Override +- public Property getProperty(Class type, String name) +- { ++ public Property getProperty(Class type, String name) { + final Property result; + Map 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 getAnnotations() +- { ++ public List getAnnotations() { + return null; + } + + @Override +- public A getAnnotation(Class aClass) +- { ++ public A getAnnotation(Class 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 getAnnotations() +- { ++ public List getAnnotations() { + return Collections.EMPTY_LIST; + } + + @Override +- public A getAnnotation(Class aClass) +- { ++ public A getAnnotation(Class 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, Map> getNameReplacements(Class klass) +- { ++ private static Map, Map> getNameReplacements(Class klass) { + List replacements = getReplacements(klass); + Map, Map> objectOldNames = new HashMap<>(); +- for (Replacement r : replacements) +- { ++ for (Replacement r : replacements) { + Map 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 getReplacements(Class klass) +- { ++ private static List getReplacements(Class klass) { + List 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 replacements, +- String newName, +- Replaces r) +- { ++ List 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 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 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 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 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 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 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 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 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 context, + final Set affectedTest) { + Map classTestMap = getClassTestMap(affectedTest); + String cassandraBuildFile = + rootPath.resolve("build.xml").toAbsolutePath().toString(); + String antArgs = getAntArgs(context); + String antProps = getAntProps(context); + + try { + for (Map.Entry 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> parseResult( + final Set affectedTest) { + Map successfulTest = new HashMap<>(); + Map 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 getClassTestMap( + final Set 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> 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 testMap = new HashMap<>(); + associatedMethods.forEach((className, methods) -> + testMap.put(className, String.join(",", methods)) + ); + + return testMap; + } + + private String getAntArgs(final Map context) { + Set 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 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(); + } +}