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() == '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,
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'
# PETSc and SLEPc is being explicitly checked above
local_checks = [
'platform', 'compiler', 'mesh_mode', 'ad_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', '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])
# 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)
else:
self.setStatus(self.skip)
return False
# Check the return values of the derived classes
self._runnable = self.checkRunnable(options)
return self._runnable
import os
import sys
import re
import argparse
import subprocess
import multiprocessing
import extensions
import commands
import mooseutils
# Check for the necessary packages, this does a load so they should all get loaded.
if mooseutils.check_configuration(['yaml', 'jinja2', 'markdown', 'markdown_include', 'mdx_math', 'bs4']):
sys.exit(1)
import yaml
from MarkdownTable import MarkdownTable
from MooseApplicationSyntax import MooseApplicationSyntax
from MooseLinkDatabase import MooseLinkDatabase
import logging
log = logging.getLogger(__name__)
log.addHandler(logging.NullHandler())
MOOSE_DIR = os.getenv('MOOSE_DIR', os.path.join(os.getcwd(), '..', 'moose'))
if not os.path.exists(MOOSE_DIR):
MOOSE_DIR = os.path.join(os.getenv('HOME'), 'projects', 'moose')
ROOT_DIR = subprocess.check_output(['git', 'rev-parse', '--show-toplevel'], stderr=subprocess.STDOUT).strip('\n')
class MooseDocsFormatter(logging.Formatter):
####################################################################################################
#pylint: enable=missing-docstring
import os
import sys
import re
import argparse
import subprocess
import multiprocessing
import collections
import logging
import mooseutils
# Check for the necessary packages, this does a load so they should all get loaded.
if mooseutils.check_configuration([
'yaml', 'jinja2', 'markdown', 'mdx_math', 'pybtex', 'jinja2',
'livereload', 'bs4', 'lxml', 'pylatexenc', 'anytree'
]):
sys.exit(1)
import yaml #pylint: disable=wrong-import-position
MOOSE_DIR = os.getenv('MOOSE_DIR', os.path.join(os.getcwd(), '..', 'moose'))
if not os.path.exists(MOOSE_DIR):
MOOSE_DIR = os.path.join(os.getenv('HOME'), 'projects', 'moose')
ROOT_DIR = subprocess.check_output(['git', 'rev-parse', '--show-toplevel'],
cwd=os.getcwd(),
stderr=subprocess.STDOUT).strip('\n')
TEMP_DIR = os.path.abspath(
os.path.join(os.getenv('HOME'), '.local', 'share', 'moose'))
# See COPYRIGHT for full restrictions #
####################################################################################################
#pylint: enable=missing-docstring
import os
import sys
import re
import argparse
import subprocess
import multiprocessing
import collections
import logging
import mooseutils
# Check for the necessary packages, this does a load so they should all get loaded.
if mooseutils.check_configuration(['yaml', 'jinja2', 'markdown', 'mdx_math', 'pybtex',
'pandas', 'livereload', 'bs4', 'lxml', 'pylatexenc', 'anytree']):
sys.exit(1)
import yaml #pylint: disable=wrong-import-position
MOOSE_DIR = os.getenv('MOOSE_DIR', os.path.join(os.getcwd(), '..', 'moose'))
if not os.path.exists(MOOSE_DIR):
MOOSE_DIR = os.path.join(os.getenv('HOME'), 'projects', 'moose')
ROOT_DIR = subprocess.check_output(['git', 'rev-parse', '--show-toplevel'],
cwd=os.getcwd(),
stderr=subprocess.STDOUT).strip('\n')
TEMP_DIR = os.path.abspath(os.path.join(os.getenv('HOME'), '.local', 'share', 'moose'))
DEPRECATED_MARKDOWN = [(re.compile(r'(?P<command>^!input|!text|!clang)\s'), '!listing'),
#pylint: enable=missing-docstring
import os
import sys
import re
import argparse
import subprocess
import multiprocessing
import collections
import logging
from MooseMarkdown import MooseMarkdown
import mooseutils
# Check for the necessary packages, this does a load so they should all get loaded.
if mooseutils.check_configuration(['yaml', 'jinja2', 'markdown', 'mdx_math', 'bs4', 'lxml',
'pylatexenc']):
sys.exit(1)
import yaml #pylint: disable=wrong-import-position
MOOSE_DIR = os.getenv('MOOSE_DIR', os.path.join(os.getcwd(), '..', 'moose'))
if not os.path.exists(MOOSE_DIR):
MOOSE_DIR = os.path.join(os.getenv('HOME'), 'projects', 'moose')
ROOT_DIR = subprocess.check_output(['git', 'rev-parse', '--show-toplevel'],
cwd=os.getcwd(),
stderr=subprocess.STDOUT).strip('\n')
TEMP_DIR = os.path.abspath(os.path.join(os.getenv('HOME'), '.local', 'share', 'moose'))
def abspath(*args):
