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

    # add mem_limit as a test dimension.
    new_dimension = TestDimension('mem_limit', *TestKuduMemLimits.TEST_LIMITS)
    cls.TestMatrix.add_dimension(new_dimension)
    cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))

 def add_test_dimensions(cls):
   super(TestComputeStats, cls).add_test_dimensions()
   cls.TestMatrix.add_dimension(create_exec_option_dimension(
     disable_codegen_options=[False], exec_single_node_option=[100]))
   # Do not run these tests using all dimensions because the expected results
   # are different for different file formats.
   cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))

 def add_test_dimensions(cls):
   super(TestInsertQueries, cls).add_test_dimensions()
   # Fix the exec_option vector to have a single value. This is needed should we decide
   # to run the insert tests in parallel (otherwise there will be two tests inserting
   # into the same table at the same time for the same file format).
   # TODO: When we do decide to run these tests in parallel we could create unique temp
   # tables for each test case to resolve the concurrency problems.
   if cls.exploration_strategy() == 'core':
     cls.TestMatrix.add_dimension(create_exec_option_dimension(
         cluster_sizes=[0], disable_codegen_options=[False], batch_sizes=[0],
         sync_ddl=[0]))
     cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))
   else:
     cls.TestMatrix.add_dimension(create_exec_option_dimension(
         cluster_sizes=[0], disable_codegen_options=[False], batch_sizes=[0, 1, 16],
         sync_ddl=[0, 1]))
     cls.TestMatrix.add_dimension(TestDimension("compression_codec", *PARQUET_CODECS));
     # Insert is currently only supported for text and parquet
     # For parquet, we want to iterate through all the compression codecs
     # TODO: each column in parquet can have a different codec.  We could
     # test all the codecs in one table/file with some additional flags.
     cls.TestMatrix.add_constraint(lambda v:\
         v.get_value('table_format').file_format == 'parquet' or \
           (v.get_value('table_format').file_format == 'text' and \
           v.get_value('compression_codec') == 'none'))
     cls.TestMatrix.add_constraint(lambda v:\
         v.get_value('table_format').compression_codec == 'none')
     # Only test other batch sizes for uncompressed parquet to keep the execution time
     # within reasonable bounds.
     cls.TestMatrix.add_constraint(lambda v:\
         v.get_value('exec_option')['batch_size'] == 0 or \
           (v.get_value('table_format').file_format == 'parquet' and \
           v.get_value('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(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(TestUdfExecution, cls).add_test_dimensions()
   cls.TestMatrix.add_dimension(
       create_exec_option_dimension_from_dict({"disable_codegen" : [False, True],
         "exec_single_node_rows_threshold" : [0,100],
         "enable_expr_rewrites" : [False, True]}))
   # 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(TestAggregationQueries, cls).add_test_dimensions()

    cls.TestMatrix.add_dimension(
      create_exec_option_dimension(disable_codegen_options=[False, True]))

    if cls.exploration_strategy() == 'core':
      cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))

 def add_test_dimensions(cls):
   super(TestShowCreateTable, cls).add_test_dimensions()
   # don't use any exec options, running exactly once is fine
   cls.TestMatrix.clear_dimension('exec_option')
   # There is no reason to run these tests using all dimensions.
   cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))
   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(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(TestViewCompatibility, cls).add_test_dimensions()

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

    # don't use any exec options, running exactly once is fine
    cls.TestMatrix.clear_dimension('exec_option')
    # 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(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(TestExprLimits, cls).add_test_dimensions()
    if cls.exploration_strategy() != 'exhaustive':
      # Ensure the test runs with codegen enabled and disabled, even when the
      # exploration strategy is not exhaustive.
      cls.TestMatrix.clear_dimension('exec_option')
      cls.TestMatrix.add_dimension(create_exec_option_dimension(
          cluster_sizes=[0], disable_codegen_options=[False, True], batch_sizes=[0]))

    # 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(TestInsertQueriesWithPermutation, cls).add_test_dimensions()
   # Fix the exec_option vector to have a single value. This is needed should we decide
   # to run the insert tests in parallel (otherwise there will be two tests inserting
   # into the same table at the same time for the same file format).
   # TODO: When we do decide to run these tests in parallel we could create unique temp
   # tables for each test case to resolve the concurrency problems.
   # TODO: do we need to run with multiple file formats? This seems to be really
   # targeting FE behavior.
   cls.TestMatrix.add_dimension(create_exec_option_dimension(
       cluster_sizes=[0], disable_codegen_options=[False], batch_sizes=[0]))
   cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))

  def add_test_dimensions(cls):
    super(TestMetadataQueryStatements, cls).add_test_dimensions()
    sync_ddl_opts = [0, 1]
    if cls.exploration_strategy() != 'exhaustive':
      # Cut down on test runtime by only running with SYNC_DDL=0
      sync_ddl_opts = [0]

    cls.TestMatrix.add_dimension(create_exec_option_dimension(
        cluster_sizes=ALL_NODES_ONLY,
        disable_codegen_options=[False],
        batch_sizes=[0],
        sync_ddl=sync_ddl_opts))
    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(TestDdlBase, cls).add_test_dimensions()
    sync_ddl_opts = [0, 1]
    if cls.exploration_strategy() != 'exhaustive':
      # Only run with sync_ddl on exhaustive since it increases test runtime.
      sync_ddl_opts = [0]

    cls.TestMatrix.add_dimension(create_exec_option_dimension(
        cluster_sizes=ALL_NODES_ONLY,
        disable_codegen_options=[False],
        batch_sizes=[0],
        sync_ddl=sync_ddl_opts))

    # 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(TestQueryMemLimit, cls).add_test_dimensions()
    # Only run the query for text
    cls.TestMatrix.add_dimension(create_uncompressed_text_dimension(cls.get_workload()))

    # add mem_limit as a test dimension.
    if cls.exploration_strategy() == 'core':
      cls.TestMatrix.add_dimension(\
          TestDimension('mem_limit', *TestQueryMemLimit.MEM_LIMITS_CORE))
    else:
      cls.TestMatrix.add_dimension(\
          TestDimension('mem_limit', *TestQueryMemLimit.MEM_LIMITS))

    # Make query a test dimension so we can support more queries.
    cls.TestMatrix.add_dimension(TestDimension('query', *TestQueryMemLimit.QUERIES))
    # This query takes a very long time to finish with a bound on the batch_size.
    # Remove the bound on the batch size.
    cls.TestMatrix.add_constraint(lambda v: v.get_value('exec_option')['batch_size'] == 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(TestResultVerifier, cls).add_test_dimensions()
   cls.ImpalaTestMatrix.add_dimension(
       create_uncompressed_text_dimension(cls.get_workload()))