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):