def checkRunnableBase(self, options):
"""
Method to check for caveats that would prevent this tester from
executing correctly (or not at all).
DO NOT override this method. Instead, see .checkRunnable()
"""
reasons = {}
checks = options._checks
tag_match = False
for t in self.tags:
if t in options.runtags:
tag_match = True
break
if len(options.runtags) > 0 and not tag_match:
self.setStatus(self.silent)
return False
# If something has already deemed this test a failure or is silent, return now
if self.isFail() or self.isSilent():
return False
# Check if we only want to run failed tests
if options.failed_tests and options.results_storage is not None:
result_key = options.results_storage.get(self.getTestDir(), {})
status = result_key.get(self.getTestName(), {}).get('FAIL', '')
if not status:
self.setStatus(self.silent)
return False
# Check if we only want to run syntax tests
if options.check_input and not self.specs['check_input']:
self.setStatus(self.silent)
return False
# Check if we want to exclude syntax tests
if options.no_check_input and self.specs['check_input']:
self.setStatus(self.silent)
return False
# Are we running only tests in a specific group?
if options.group <> 'ALL' and options.group not in self.specs['group']:
self.setStatus(self.silent)
return False
if options.not_group <> '' and options.not_group in self.specs['group']:
self.setStatus(self.silent)
return False
# Store regexp for matching tests if --re is used
if options.reg_exp:
match_regexp = re.compile(options.reg_exp)
# If --re then only test matching regexp. Needs to run before other SKIP methods
# This also needs to be in its own bucket group. We normally print skipped messages.
# But we do not want to print tests that didn't match regex.
if options.reg_exp and not match_regexp.search(self.specs['test_name']):
self.setStatus(self.silent)
return False
# Short circuit method and run this test if we are ignoring all caveats
if options.ignored_caveats == 'all':
# Still, we should abide by the derived classes
return self.checkRunnable(options)
# Check for deleted tests
if self.specs.isValid('deleted'):
reasons['deleted'] = str(self.specs['deleted'])
# Skipped by external means (example: TestHarness part2 with --check-input)
if self.isSkip() and self.getStatusMessage():
reasons['skip'] = self.getStatusMessage()
# Test is skipped
elif self.specs.type('skip') is bool and self.specs['skip']:
# Backwards compatible (no reason)
reasons['skip'] = 'no reason'
elif self.specs.type('skip') is not bool and self.specs.isValid('skip'):
reasons['skip'] = self.specs['skip']
# If were testing for SCALE_REFINE, then only run tests with a SCALE_REFINE set
elif (options.scaling) and self.specs['scale_refine'] == 0:
self.setStatus(self.silent)
return False
# If we're testing with valgrind, then skip tests that require parallel or threads or don't meet the valgrind setting
elif options.valgrind_mode != '':
tmp_reason = ''
if self.specs['valgrind'].upper() == 'NONE':
tmp_reason = 'Valgrind==NONE'
elif self.specs['valgrind'].upper() == 'HEAVY' and options.valgrind_mode.upper() == 'NORMAL':
tmp_reason = 'Valgrind==HEAVY'
elif int(self.specs['min_parallel']) > 1 or int(self.specs['min_threads']) > 1:
tmp_reason = 'Valgrind requires serial'
elif self.specs["check_input"]:
tmp_reason = 'check_input==True'
if tmp_reason != '':
reasons['valgrind'] = tmp_reason
# If we're running in recover mode skip tests that have recover = false
elif options.enable_recover and self.specs['recover'] == False:
reasons['recover'] = 'NO RECOVER'
# Check for PETSc versions
(petsc_status, logic_reason, petsc_version) = util.checkPetscVersion(checks, self.specs)
if not petsc_status:
reasons['petsc_version'] = 'using PETSc ' + str(checks['petsc_version']) + ' REQ: ' + logic_reason + ' ' + petsc_version
# Check for SLEPc versions
(slepc_status, logic_reason, slepc_version) = util.checkSlepcVersion(checks, self.specs)
if not slepc_status and len(self.specs['slepc_version']) != 0:
if slepc_version != None:
reasons['slepc_version'] = 'using SLEPc ' + str(checks['slepc_version']) + ' REQ: ' + logic_reason + ' ' + slepc_version
elif slepc_version == None:
reasons['slepc_version'] = 'SLEPc is not installed'
# PETSc and SLEPc is being explicitly checked above
local_checks = ['platform', 'compiler', 'mesh_mode', 'method', 'library_mode', 'dtk', 'unique_ids', 'vtk', 'tecplot', \
'petsc_debug', 'curl', 'tbb', 'superlu', 'cxx11', 'asio', 'unique_id', 'slepc', 'petsc_version_release', 'boost', 'fparser_jit']
for check in local_checks:
test_platforms = set()
operator_display = '!='
inverse_set = False
for x in self.specs[check]:
if x[0] == '!':
if inverse_set:
reasons[check] = 'Multiple Negation Unsupported'
inverse_set = True
operator_display = '=='
x = x[1:] # Strip off the !
x_upper = x.upper()
if x_upper in test_platforms:
reasons[x_upper] = 'Duplicate Entry or Negative of Existing Entry'
test_platforms.add(x.upper())
match_found = len(test_platforms.intersection(checks[check])) > 0
# Either we didn't find the match when we were using normal "include" logic
# or we did find the match when we wanted to exclude it
if inverse_set == match_found:
reasons[check] = re.sub(r'\[|\]', '', check).upper() + operator_display + ', '.join(test_platforms)
# Check for heavy tests
if options.all_tests or options.heavy_tests:
if not self.specs['heavy'] and options.heavy_tests:
reasons['heavy'] = 'NOT HEAVY'
elif self.specs['heavy']:
reasons['heavy'] = 'HEAVY'
# There should only be one entry in self.specs['dof_id_bytes']
for x in self.specs['dof_id_bytes']:
if x != 'ALL' and not x in checks['dof_id_bytes']:
reasons['dof_id_bytes'] = '--with-dof-id-bytes!=' + x
# Check to make sure depend files exist
for file in self.specs['depend_files']:
if not os.path.isfile(os.path.join(self.specs['base_dir'], file)):
reasons['depend_files'] = 'DEPEND FILES'
# We calculate the exe_objects only if we need them
if self.specs["required_objects"] and checks["exe_objects"] is None:
checks["exe_objects"] = util.getExeObjects(self.specs["executable"])
# Check to see if we have the required object names
for var in self.specs['required_objects']:
if var not in checks["exe_objects"]:
reasons['required_objects'] = '%s not found in executable' % var
break
# We extract the registered apps only if we need them
if self.specs["required_applications"] and checks["registered_apps"] is None:
checks["registered_apps"] = util.getExeRegisteredApps(self.specs["executable"])
# Check to see if we have the required application names
for var in self.specs['required_applications']:
if var not in checks["registered_apps"]:
reasons['required_applications'] = 'App %s not registered in executable' % var
break
# Check to make sure required submodules are initialized
for var in self.specs['required_submodule']:
if var not in checks["submodules"]:
reasons['required_submodule'] = '%s submodule not initialized' % var
# Check to make sure environment variable exists
for var in self.specs['env_vars']:
if not os.environ.has_key(var):
reasons['env_vars'] = 'ENV VAR NOT SET'
# Check for display
if self.specs['display_required'] and not os.getenv('DISPLAY', False):
reasons['display_required'] = 'NO DISPLAY'
# Remove any matching user supplied caveats from accumulated checkRunnable caveats that
# would normally produce a skipped test.
caveat_list = set()
if options.ignored_caveats:
caveat_list = set([x.lower() for x in options.ignored_caveats.split()])
if len(set(reasons.keys()) - caveat_list) > 0:
tmp_reason = []
for key, value in reasons.iteritems():
if key.lower() not in caveat_list:
tmp_reason.append(value)
flat_reason = ', '.join(tmp_reason)
# If the test is deleted we still need to treat this differently
self.addCaveats(flat_reason)
if 'deleted' in reasons.keys():
self.setStatus(self.deleted)
else:
self.setStatus(self.skip)
return False
# Check the return values of the derived classes
self._runnable = self.checkRunnable(options)
return self._runnable
def checkRunnableBase(self, options):
"""
Method to check for caveats that would prevent this tester from
executing correctly (or not at all).
DO NOT override this method. Instead, see .checkRunnable()
"""
reasons = {}
checks = options._checks
tag_match = False
for t in self.tags:
if t in options.runtags:
tag_match = True
break
if len(options.runtags) > 0 and not tag_match:
self.setStatus(self.silent)
return False
# If something has already deemed this test a failure or is silent, return now
if self.isFail() or self.isSilent():
return False
# Check if we only want to run failed tests
if options.failed_tests and options.results_storage is not None:
result_key = options.results_storage.get(self.getTestDir(), {})
status = result_key.get(self.getTestName(), {}).get('FAIL', '')
if not status:
self.setStatus(self.silent)
return False
# Check if we only want to run syntax tests
if options.check_input and not self.specs['check_input']:
self.setStatus(self.silent)
return False
# Check if we want to exclude syntax tests
if options.no_check_input and self.specs['check_input']:
self.setStatus(self.silent)
return False
# Are we running only tests in a specific group?
if options.group <> 'ALL' and options.group not in self.specs['group']:
self.setStatus(self.silent)
return False
if options.not_group <> '' and options.not_group in self.specs['group']:
self.setStatus(self.silent)
return False
# Store regexp for matching tests if --re is used
if options.reg_exp:
match_regexp = re.compile(options.reg_exp)
# If --re then only test matching regexp. Needs to run before other SKIP methods
# This also needs to be in its own bucket group. We normally print skipped messages.
# But we do not want to print tests that didn't match regex.
if options.reg_exp and not match_regexp.search(
self.specs['test_name']):
self.setStatus(self.silent)
return False
# Short circuit method and run this test if we are ignoring all caveats
if options.ignored_caveats == 'all':
# Still, we should abide by the derived classes
return self.checkRunnable(options)
# Check for deleted tests
if self.specs.isValid('deleted'):
reasons['deleted'] = str(self.specs['deleted'])
# Skipped by external means (example: TestHarness part2 with --check-input)
if self.isSkip() and self.getStatusMessage():
reasons['skip'] = self.getStatusMessage()
# Test is skipped
elif self.specs.type('skip') is bool and self.specs['skip']:
# Backwards compatible (no reason)
reasons['skip'] = 'no reason'
elif self.specs.type('skip') is not bool and self.specs.isValid(
'skip'):
reasons['skip'] = self.specs['skip']
# If were testing for SCALE_REFINE, then only run tests with a SCALE_REFINE set
elif (options.scaling) and self.specs['scale_refine'] == 0:
self.setStatus(self.silent)
return False
# If we're testing with valgrind, then skip tests that require parallel or threads or don't meet the valgrind setting
elif options.valgrind_mode != '':
tmp_reason = ''
if self.specs['valgrind'].upper() == 'NONE':
tmp_reason = 'Valgrind==NONE'
elif self.specs['valgrind'].upper(
) == 'HEAVY' and options.valgrind_mode.upper() == 'NORMAL':
tmp_reason = 'Valgrind==HEAVY'
elif int(self.specs['min_threads']) > 1:
tmp_reason = 'Valgrind requires non-threaded'
elif self.specs["check_input"]:
tmp_reason = 'check_input==True'
if tmp_reason != '':
reasons['valgrind'] = tmp_reason
# If we're running in recover mode skip tests that have recover = false
elif options.enable_recover and self.specs['recover'] == False:
reasons['recover'] = 'NO RECOVER'
# Check for PETSc versions
(petsc_status, logic_reason,
petsc_version) = util.checkPetscVersion(checks, self.specs)
if not petsc_status:
reasons['petsc_version'] = 'using PETSc ' + str(
checks['petsc_version']
) + ' REQ: ' + logic_reason + ' ' + petsc_version
# Check for SLEPc versions
(slepc_status, logic_reason,
slepc_version) = util.checkSlepcVersion(checks, self.specs)
if not slepc_status and len(self.specs['slepc_version']) != 0:
if slepc_version != None:
reasons['slepc_version'] = 'using SLEPc ' + str(
checks['slepc_version']
) + ' REQ: ' + logic_reason + ' ' + slepc_version
elif slepc_version == None:
reasons['slepc_version'] = 'SLEPc is not installed'
# PETSc and SLEPc is being explicitly checked above
local_checks = ['platform', 'compiler', 'mesh_mode', 'method', 'library_mode', 'dtk', 'unique_ids', 'vtk', 'tecplot', \
'petsc_debug', 'curl', 'superlu', 'cxx11', 'asio', 'unique_id', 'slepc', 'petsc_version_release', 'boost', 'fparser_jit',
'parmetis', 'chaco', 'party', 'ptscotch', 'threading']
for check in local_checks:
test_platforms = set()
operator_display = '!='
inverse_set = False
for x in self.specs[check]:
if x[0] == '!':
if inverse_set:
reasons[check] = 'Multiple Negation Unsupported'
inverse_set = True
operator_display = '=='
x = x[1:] # Strip off the !
x_upper = x.upper()
if x_upper in test_platforms:
reasons[
x_upper] = 'Duplicate Entry or Negative of Existing Entry'
test_platforms.add(x.upper())
match_found = len(test_platforms.intersection(checks[check])) > 0
# Either we didn't find the match when we were using normal "include" logic
# or we did find the match when we wanted to exclude it
if inverse_set == match_found:
reasons[check] = re.sub(r'\[|\]', '', check).upper(
) + operator_display + ', '.join(test_platforms)
# Check for heavy tests
if options.all_tests or options.heavy_tests:
if not self.specs['heavy'] and options.heavy_tests:
reasons['heavy'] = 'NOT HEAVY'
elif self.specs['heavy']:
reasons['heavy'] = 'HEAVY'
# There should only be one entry in self.specs['dof_id_bytes']
for x in self.specs['dof_id_bytes']:
if x != 'ALL' and not x in checks['dof_id_bytes']:
reasons['dof_id_bytes'] = '--with-dof-id-bytes!=' + x
# Check to make sure depend files exist
for file in self.specs['depend_files']:
if not os.path.isfile(os.path.join(self.specs['base_dir'], file)):
reasons['depend_files'] = 'DEPEND FILES'
# We calculate the exe_objects only if we need them
if self.specs["required_objects"] and checks["exe_objects"] is None:
checks["exe_objects"] = util.getExeObjects(
self.specs["executable"])
# Check to see if we have the required object names
for var in self.specs['required_objects']:
if var not in checks["exe_objects"]:
reasons[
'required_objects'] = '%s not found in executable' % var
break
# We extract the registered apps only if we need them
if self.specs[
"required_applications"] and checks["registered_apps"] is None:
checks["registered_apps"] = util.getExeRegisteredApps(
self.specs["executable"])
# Check to see if we have the required application names
for var in self.specs['required_applications']:
if var not in checks["registered_apps"]:
reasons[
'required_applications'] = 'App %s not registered in executable' % var
break
# Check to make sure required submodules are initialized
for var in self.specs['required_submodule']:
if var not in checks["submodules"]:
reasons[
'required_submodule'] = '%s submodule not initialized' % var
# Check to make sure environment variable exists
for var in self.specs['env_vars']:
if not os.environ.has_key(var):
reasons['env_vars'] = 'ENV VAR NOT SET'
# Check for display
if self.specs['display_required'] and not os.getenv('DISPLAY', False):
reasons['display_required'] = 'NO DISPLAY'
# Remove any matching user supplied caveats from accumulated checkRunnable caveats that
# would normally produce a skipped test.
caveat_list = set()
if options.ignored_caveats:
caveat_list = set(
[x.lower() for x in options.ignored_caveats.split()])
if len(set(reasons.keys()) - caveat_list) > 0:
tmp_reason = []
for key, value in reasons.iteritems():
if key.lower() not in caveat_list:
tmp_reason.append(value)
flat_reason = ', '.join(tmp_reason)
# If the test is deleted we still need to treat this differently
self.addCaveats(flat_reason)
if 'deleted' in reasons.keys():
self.setStatus(self.deleted)
else:
self.setStatus(self.skip)
return False
# Check the return values of the derived classes
self._runnable = self.checkRunnable(options)
return self._runnable
def checkRunnableBase(self, options):
"""
Method to check for caveats that would prevent this tester from
executing correctly (or not at all).
DO NOT override this method. Instead, see .checkRunnable()
"""
reasons = {}
checks = options._checks
tag_match = False
for t in self.tags:
if t in options.runtags:
tag_match = True
break
if len(options.runtags) > 0 and not tag_match:
self.setStatus(self.silent)
return False
# If something has already deemed this test a failure
if self.isFail():
return False
# Check if we only want to run syntax tests
if options.check_input and not self.specs['check_input']:
self.setStatus(self.silent)
return False
# Check if we want to exclude syntax tests
if options.no_check_input and self.specs['check_input']:
self.setStatus(self.silent)
return False
# Are we running only tests in a specific group?
if options.group != 'ALL' and options.group not in self.specs['group']:
self.setStatus(self.silent)
return False
if options.not_group != '' and options.not_group in self.specs['group']:
self.setStatus(self.silent)
return False
# Store regexp for matching tests if --re is used
if options.reg_exp:
match_regexp = re.compile(options.reg_exp)
# If --re then only test matching regexp. Needs to run before other SKIP methods
# This also needs to be in its own bucket group. We normally print skipped messages.
# But we do not want to print tests that didn't match regex.
if options.reg_exp and not match_regexp.search(self.specs['test_name']):
self.setStatus(self.silent)
return False
# Short circuit method and run this test if we are ignoring all caveats
if options.ignored_caveats == 'all':
# Still, we should abide by the derived classes
return self.checkRunnable(options)
# Check for deleted tests
if self.specs.isValid('deleted'):
reasons['deleted'] = str(self.specs['deleted'])
# Skipped by external means (example: TestHarness part2 with --check-input)
if self.isSkip() and self.getStatusMessage():
reasons['skip'] = self.getStatusMessage()
# Test is skipped
elif self.specs.type('skip') is bool and self.specs['skip']:
# Backwards compatible (no reason)
reasons['skip'] = 'no reason'
elif self.specs.type('skip') is not bool and self.specs.isValid('skip'):
reasons['skip'] = self.specs['skip']
# If were testing for SCALE_REFINE, then only run tests with a SCALE_REFINE set
elif (options.scaling) and self.specs['scale_refine'] == 0:
self.setStatus(self.silent)
return False
# If we're testing with valgrind, then skip tests that require parallel or threads or don't meet the valgrind setting
elif options.valgrind_mode != '':
tmp_reason = ''
if self.specs['valgrind'].upper() != options.valgrind_mode.upper():
tmp_reason = 'Valgrind==' + self.specs['valgrind'].upper()
elif int(self.specs['min_threads']) > 1:
tmp_reason = 'Valgrind requires non-threaded'
elif self.specs["check_input"]:
tmp_reason = 'check_input==True'
if tmp_reason != '':
reasons['valgrind'] = tmp_reason
# If we're running in recover mode skip tests that have recover = false
elif options.enable_recover and self.specs['recover'] == False:
reasons['recover'] = 'NO RECOVER'
# AD size check
ad_size = int(util.getMooseConfigOption(self.specs['moose_dir'], 'ad_size').pop())
min_ad_size = self.specs['min_ad_size']
if min_ad_size is not None and int(min_ad_size) > ad_size:
reasons['min_ad_size'] = "Minimum AD size %d needed, but MOOSE is configured with %d" % (int(min_ad_size), ad_size)
# Check for PETSc versions
(petsc_status, petsc_version) = util.checkPetscVersion(checks, self.specs)
if not petsc_status:
reasons['petsc_version'] = 'using PETSc ' + str(checks['petsc_version']) + ' REQ: ' + petsc_version
# Check for SLEPc versions
(slepc_status, slepc_version) = util.checkSlepcVersion(checks, self.specs)
if not slepc_status and len(self.specs['slepc_version']) != 0:
if slepc_version != None:
reasons['slepc_version'] = 'using SLEPc ' + str(checks['slepc_version']) + ' REQ: ' + slepc_version
elif slepc_version == None:
reasons['slepc_version'] = 'SLEPc is not installed'
# Check for ExodusII versions
(exodus_status, exodus_version) = util.checkExodusVersion(checks, self.specs)
if not exodus_status:
if checks['exodus_version'] != None:
reasons['exodus_version'] = 'using ExodusII ' + str(checks['exodus_version']) + ' REQ: ' + exodus_version
else:
reasons['exodus_version'] = 'Exodus version not detected. REQ: ' + exodus_version
# PETSc and SLEPc is being explicitly checked above
local_checks = ['platform', 'compiler', 'mesh_mode', 'ad_mode', 'ad_indexing_type', 'method', 'library_mode', 'dtk', 'unique_ids', 'vtk', 'tecplot',
'petsc_debug', 'curl', 'superlu', 'mumps', 'strumpack', 'cxx11', 'asio', 'unique_id', 'slepc', 'petsc_version_release', 'boost', 'fparser_jit',
'parmetis', 'chaco', 'party', 'ptscotch', 'threading', 'libpng']
for check in local_checks:
test_platforms = set()
operator_display = '!='
inverse_set = False
for x in self.specs[check]:
if x[0] == '!':
if inverse_set:
reasons[check] = 'Multiple Negation Unsupported'
inverse_set = True
operator_display = '=='
x = x[1:] # Strip off the !
x_upper = x.upper()
if x_upper in test_platforms:
reasons[x_upper] = 'Duplicate Entry or Negative of Existing Entry'
test_platforms.add(x.upper())
match_found = len(test_platforms.intersection(checks[check])) > 0
# Either we didn't find the match when we were using normal "include" logic
# or we did find the match when we wanted to exclude it
if inverse_set == match_found:
reasons[check] = re.sub(r'\[|\]', '', check).upper() + operator_display + ', '.join(test_platforms)
# Check for heavy tests
if options.all_tests or options.heavy_tests:
if not self.specs['heavy'] and options.heavy_tests:
reasons['heavy'] = 'NOT HEAVY'
elif self.specs['heavy']:
reasons['heavy'] = 'HEAVY'
# There should only be one entry in self.specs['dof_id_bytes']
for x in self.specs['dof_id_bytes']:
if x != 'ALL' and not x in checks['dof_id_bytes']:
reasons['dof_id_bytes'] = '--with-dof-id-bytes!=' + x
# Check to make sure depend files exist
for file in self.specs['depend_files']:
if not os.path.isfile(os.path.join(self.specs['base_dir'], file)):
reasons['depend_files'] = 'DEPEND FILES'
# We calculate the exe_objects only if we need them
if self.specs["required_objects"] and checks["exe_objects"] is None:
checks["exe_objects"] = util.getExeObjects(self.specs["executable"])
# Check to see if we have the required object names
for var in self.specs['required_objects']:
if var not in checks["exe_objects"]:
reasons['required_objects'] = '%s not found in executable' % var
break
# We extract the registered apps only if we need them
if self.specs["required_applications"] and checks["registered_apps"] is None:
checks["registered_apps"] = util.getExeRegisteredApps(self.specs["executable"])
# Check to see if we have the required application names
for var in self.specs['required_applications']:
if var not in checks["registered_apps"]:
reasons['required_applications'] = 'App %s not registered in executable' % var
break
# Check to make sure required submodules are initialized
for var in self.specs['required_submodule']:
if var not in checks["submodules"]:
reasons['required_submodule'] = '%s submodule not initialized' % var
# Check to make sure environment variable exists
for var in self.specs['env_vars']:
if not os.environ.get(var):
reasons['env_vars'] = 'ENV VAR NOT SET'
# Check for display
if self.specs['display_required'] and not os.getenv('DISPLAY', False):
reasons['display_required'] = 'NO DISPLAY'
# Check python version
py_version = self.specs['python']
if (py_version is not None):
if isinstance(py_version, int) and (py_version != sys.version_info[0]):
reasons['python'] = 'PYTHON != {}'.format(py_version)
elif isinstance(py_version, float) and (py_version != float('{}.{}'.format(*sys.version_info[0:2]))):
reasons['python'] = 'PYTHON != {}'.format(py_version)
elif isinstance(py_version, str):
ver = py_version.split('.')
if any(sys.version_info[i] != int(v) for i, v in enumerate(ver)):
reasons['python'] = 'PYTHON != {}'.format(py_version)
# Check python packages
py_packages = self.specs['required_python_packages']
if py_packages is not None:
missing = mooseutils.check_configuration(py_packages.split(), message=False)
if missing:
reasons['python_packages_required'] = ', '.join(['no {}'.format(p) for p in missing])
# Check for programs
programs = self.specs['requires']
if (programs is not None):
missing = []
for prog in programs.split():
if shutil.which(prog) is None:
missing.append(prog)
if missing:
reasons['requires'] = ', '.join(['no {}'.format(p) for p in missing])
# Verify working_directory is relative and available
if self.specs['working_directory']:
if self.specs['working_directory'][:1] == os.path.sep:
self.setStatus(self.fail, 'ABSOLUTE PATH DETECTED')
elif not os.path.exists(self.getTestDir()):
self.setStatus(self.fail, 'WORKING DIRECTORY NOT FOUND')
##### The below must be performed last to register all above caveats #####
# Remove any matching user supplied caveats from accumulated checkRunnable caveats that
# would normally produce a skipped test.
caveat_list = set()
if options.ignored_caveats:
caveat_list = set([x.lower() for x in options.ignored_caveats.split()])
if len(set(reasons.keys()) - caveat_list) > 0:
tmp_reason = []
for key, value in reasons.items():
if key.lower() not in caveat_list:
tmp_reason.append(value)
flat_reason = ', '.join(tmp_reason)
# If the test is deleted we still need to treat this differently
self.addCaveats(flat_reason)
if 'deleted' in reasons.keys():
if options.extra_info:
self.setStatus(self.deleted)
else:
self.setStatus(self.silent)
elif self.getStatus() == self.fail:
return False
else:
self.setStatus(self.skip)
return False
# Check the return values of the derived classes
self._runnable = self.checkRunnable(options)
return self._runnable
