code: def __executionTest(self):
      listCase = list(self.data.keys())
  
      print("######## Starting queries ...########")
  
      concurrent_list = (
          self.configLocal.is_concurrent
          if isinstance(self.configLocal.is_concurrent, list)
          else [self.configLocal.is_concurrent]
      )
  
      for concurrent in concurrent_list:
          print("CONCURRENT: " + str(concurrent))
          self.configLocal.is_concurrent = concurrent
  
          for n in range(0, len(self.configLocal.data_types)):
              fileSchemaType = self.configLocal.data_types[n]
  
              if self.__skip_test(fileSchemaType, self.configLocal):
                  continue
  
              createSchema.create_tables(
                  self.bc,
                  self.dir_data_file,
                  fileSchemaType,
                  tables=list(self.tables),
              )
  
              for test_name in listCase:
                  test_case = self.data[test_name]
  
                  configTest = self.__loadTestCaseConfig(
                      test_name, fileSchemaType
                  )
  
                  if self.__skip_test(fileSchemaType, configTest):
                      continue
  
                  query = self.__getQuery(test_case)
                  engine = (
                      self.drill
                      if configTest.compare_with == "drill"
                      else self.spark
                  )
  
                  if (
                      not Settings.execution_mode
                      == ExecutionMode.GENERATOR
                  ):
                      print("==>> Run query for test case", self.name)
                      if configTest.message_validation == "":
                          print("PLAN:")
                          print(self.bc.explain(query, True))
  
                  if configTest.is_concurrent:
                      name_token = test_name + "_" + fileSchemaType.name
                      self.config_concurrent[
                          name_token
                      ] = ConfigConcurrent()
  
                      self.config_concurrent[
                          name_token
                      ].token = self.bc.sql(query, return_token=True)
                      self.config_concurrent[
                          name_token
                      ].fileSchemaType = fileSchemaType
                      self.config_concurrent[
                          name_token
                      ].test_name = test_name
                      self.config_concurrent[name_token].query = query
                      self.config_concurrent[
                          name_token
                      ].configTest = copy.deepcopy(configTest)
  
                  else:
                      runTest.run_query(
                          self.bc,
                          engine,
                          query,
                          test_name,
                          self.name,
                          configTest.apply_order,
                          configTest.order_by_col,
                          configTest.acceptable_difference,
                          configTest.use_percentage,
                          fileSchemaType,
                          print_result=configTest.print_result,
                          query_spark=configTest.spark_query,
                          comparing=configTest.comparing,
                          message_validation=configTest.message_validation,
                      )
  
              if configTest.is_concurrent:
                  self.__fetch_results()
  
imports: from Configuration import Settings
  from Utils import gpuMemory
  from Runner import runTest
  from DataBase import createSchema
  from Configuration import ExecutionMode, Settings
  from blazingsql import DataType
  from itertools import chain
  from os import listdir
  from os.path import isfile, join
  from sql_metadata import get_query_tables
  import os
  import yaml
  import re
  import copy
  import sys
label_desc: Use image node_id 9 for calling the TestCase obj's underlying member method code with example usage: obj.__executionTest() without return types