def add_test_dimensions(cls):
   super(TestComputeStats, cls).add_test_dimensions()
   cls.ImpalaTestMatrix.add_dimension(create_single_exec_option_dimension())
   # Do not run these tests using all dimensions because the expected results
   # are different for different file formats.
   cls.ImpalaTestMatrix.add_dimension(
       create_uncompressed_text_dimension(cls.get_workload()))

  def add_test_dimensions(cls):
    super(TestHdfsCachingDdl, cls).add_test_dimensions()
    cls.TestMatrix.add_dimension(create_single_exec_option_dimension())

    cls.TestMatrix.add_constraint(lambda v:\
        v.get_value('table_format').file_format == 'text' and \
        v.get_value('table_format').compression_codec == 'none')

 def add_test_dimensions(cls):
   super(TestHiddenFiles, cls).add_test_dimensions()
   cls.TestMatrix.add_dimension(create_single_exec_option_dimension())
   cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))
   # Only run in exhaustive mode on hdfs since this test takes a long time.
   if cls.exploration_strategy() != 'exhaustive' and not IS_S3:
     cls.TestMatrix.clear()

  def add_test_dimensions(cls):
    super(TestRefreshPartition, cls).add_test_dimensions()

    # There is no reason to run these tests using all dimensions.
    cls.ImpalaTestMatrix.add_dimension(create_single_exec_option_dimension())
    cls.ImpalaTestMatrix.add_dimension(
        create_uncompressed_text_dimension(cls.get_workload()))

  def add_test_dimensions(cls):
    super(TestMultipleFilesystems, cls).add_test_dimensions()
    cls.ImpalaTestMatrix.add_dimension(create_single_exec_option_dimension())

    cls.ImpalaTestMatrix.add_constraint(lambda v:\
        v.get_value('table_format').file_format == 'text' and \
        v.get_value('table_format').compression_codec == 'none')

 def add_test_dimensions(cls):
   super(TestCodegenMemLimit, cls).add_test_dimensions()
   # Run with num_nodes=1 to avoid races between fragments allocating memory.
   cls.ImpalaTestMatrix.add_dimension(create_single_exec_option_dimension(
       num_nodes=1, disable_codegen_rows_threshold=0))
   # Only run the query for parquet
   cls.ImpalaTestMatrix.add_constraint(
     lambda v: v.get_value('table_format').file_format == 'parquet')

 def add_test_dimensions(cls):
   super(TestUnsupportedTableWriters, cls).add_test_dimensions()
   cls.ImpalaTestMatrix.add_dimension(create_single_exec_option_dimension())
   # This class tests different formats, but doesn't use constraints.
   # The constraint added below is only to make sure that the test file runs once.
   cls.ImpalaTestMatrix.add_constraint(lambda v:
       (v.get_value('table_format').file_format =='text' and
       v.get_value('table_format').compression_codec == 'none'))

  def add_test_dimensions(cls):
    super(TestCatalogServiceClient, cls).add_test_dimensions()
    cls.TestMatrix.add_dimension(create_single_exec_option_dimension())

    # There is no reason to run these tests using all dimensions.
    cls.TestMatrix.add_constraint(lambda v:\
        v.get_value('table_format').file_format == 'parquet' and\
        v.get_value('table_format').compression_codec == 'none')

  def add_test_dimensions(cls):
    super(TestPartitioning, cls).add_test_dimensions()
    cls.ImpalaTestMatrix.add_dimension(create_single_exec_option_dimension())

    # There is no reason to run these tests using all dimensions.
    cls.ImpalaTestMatrix.add_constraint(lambda v:\
        v.get_value('table_format').file_format == 'text' and\
        v.get_value('table_format').compression_codec == 'none')

 def add_test_dimensions(cls):
     super(TestUnmatchedSchema, cls).add_test_dimensions()
     # TODO: Does it add anything to enumerate all the supported compression codecs
     # for each table format?
     cls.TestMatrix.add_dimension(cls.create_table_info_dimension("exhaustive"))
     cls.TestMatrix.add_dimension(create_single_exec_option_dimension())
     # Avro has a more advanced schema evolution process which is covered in more depth
     # in the test_avro_schema_evolution test suite.
     cls.TestMatrix.add_constraint(lambda v: v.get_value("table_format").file_format != "avro")

  def add_test_dimensions(cls):
    super(TestUdfs, cls).add_test_dimensions()
    # Without limiting the test suite to a single exec option, the tests will fail
    # because the same test case may be executed in parallel with different exec option
    # values leading to conflicting DDL ops.
    cls.TestMatrix.add_dimension(create_single_exec_option_dimension())

    # There is no reason to run these tests using all dimensions.
    cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))

 def add_test_dimensions(cls):
   super(TestTableWriters, cls).add_test_dimensions()
   cls.TestMatrix.add_dimension(create_single_exec_option_dimension())
   # This class tests many formats, but doesn't use the contraints
   # Each format is tested within one test file, we constrain to text/none
   # as each test file only needs to be run once.
   cls.TestMatrix.add_constraint(lambda v:
       (v.get_value('table_format').file_format =='text' and
       v.get_value('table_format').compression_codec == 'none'))

  def add_test_dimensions(cls):
    super(TestTpchQuery, cls).add_test_dimensions()
    cls.TestMatrix.add_dimension(create_single_exec_option_dimension())

    # The tpch tests take a long time to execute so restrict the combinations they
    # execute over.
    # TODO: the planner tests are based on text and need this.
    if cls.exploration_strategy() == 'core':
      cls.TestMatrix.add_constraint(lambda v:\
          v.get_value('table_format').file_format in ['text', 'parquet', 'kudu'])

 def add_test_dimensions(cls):
   super(TestTpcdsInsert, cls).add_test_dimensions()
   cls.TestMatrix.add_dimension(create_single_exec_option_dimension())
   cls.TestMatrix.add_constraint(lambda v:\
       is_supported_insert_format(v.get_value('table_format')))
   if cls.exploration_strategy() == 'core' and not pytest.config.option.table_formats:
     # Don't run on core, unless the user explicitly wants to validate a specific table
     # format. Each test vector takes > 30s to complete and it doesn't add much
     # additional coverage on top of what's in the functional insert test suite
     cls.TestMatrix.add_constraint(lambda v: False);

  def add_test_dimensions(cls):
    super(TestHmsIntegration, cls).add_test_dimensions()

    if cls.exploration_strategy() != 'exhaustive':
      pytest.skip("Should only run in exhaustive due to long execution time.")

    # There is no reason to run these tests using all dimensions.
    cls.TestMatrix.add_dimension(create_single_exec_option_dimension())
    cls.TestMatrix.add_dimension(
        create_uncompressed_text_dimension(cls.get_workload()))

    def add_test_dimensions(cls):
        super(TestAdmissionController, cls).add_test_dimensions()
        cls.TestMatrix.add_dimension(create_single_exec_option_dimension())

        # There's no reason to test this on other file formats/compression codecs right now
        cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))

        cls.TestMatrix.add_dimension(TestDimension("num_queries", *NUM_QUERIES))
        cls.TestMatrix.add_dimension(TestDimension("round_robin_submission", *ROUND_ROBIN_SUBMISSION))

        cls.TestMatrix.add_dimension(TestDimension("submission_delay_ms", *SUBMISSION_DELAY_MS))
        if cls.exploration_strategy() == "core":
            cls.TestMatrix.add_constraint(lambda v: v.get_value("submission_delay_ms") == 0)
            cls.TestMatrix.add_constraint(lambda v: v.get_value("num_queries") == 30)
            cls.TestMatrix.add_constraint(lambda v: v.get_value("round_robin_submission") == True)

  def add_test_dimensions(cls):
    super(TestAdmissionController, cls).add_test_dimensions()
    cls.TestMatrix.add_dimension(create_single_exec_option_dimension())
    cls.TestMatrix.add_dimension(TestDimension('num_queries', *NUM_QUERIES))
    cls.TestMatrix.add_dimension(
        TestDimension('round_robin_submission', *ROUND_ROBIN_SUBMISSION))

    # There's no reason to test this on other file formats/compression codecs right now
    cls.TestMatrix.add_constraint(lambda v:\
        v.get_value('table_format').file_format == 'text' and\
        v.get_value('table_format').compression_codec == 'none')

    cls.TestMatrix.add_dimension(
        TestDimension('submission_delay_ms', *SUBMISSION_DELAY_MS))
    if cls.exploration_strategy() == 'core':
      cls.TestMatrix.add_constraint(lambda v: v.get_value('submission_delay_ms') == 0)

  def add_test_dimensions(cls):
    super(TestHdfsEncryption, cls).add_test_dimensions()
    cls.TestMatrix.add_dimension(create_single_exec_option_dimension())
    cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))

    PARTITIONED = [True, False]
    # For 'core', just test loading from a directory that is encrypted.
    KEY_LOAD_DIR = ["testkey1"]
    KEY_TBL_DIR = [None]

    if cls.exploration_strategy() == 'exhaustive':
      KEY_LOAD_DIR = [None, "testkey1", "testkey2"]
      KEY_TBL_DIR = [None, "testkey1", "testkey2"]

    cls.TestMatrix.add_dimension(TestDimension('partitioned', *PARTITIONED))
    cls.TestMatrix.add_dimension(TestDimension('key_load_dir', *KEY_LOAD_DIR))
    cls.TestMatrix.add_dimension(TestDimension('key_tbl_dir', *KEY_TBL_DIR))
    cls.TestMatrix.add_constraint(lambda v:\
        v.get_value('key_load_dir') is not None or\
        v.get_value('key_tbl_dir') is not None)

 def add_test_dimensions(cls):
   super(TestAdmissionController, cls).add_test_dimensions()
   cls.TestMatrix.add_dimension(create_single_exec_option_dimension())
   # There's no reason to test this on other file formats/compression codecs right now
   cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))

 def add_test_dimensions(cls):
   super(TestScanMemLimit, cls).add_test_dimensions()
   cls.ImpalaTestMatrix.add_dimension(create_single_exec_option_dimension())
   cls.ImpalaTestMatrix.add_dimension(create_avro_snappy_dimension(cls.get_workload()))