def filter(cls, config, msg, tc): """ Acquire valgrind tool for the test to be run based on configuration and test requirements """ vg_tool, kwargs = ctx.get_requirement(tc, 'enabled_valgrind', NONE) disabled = ctx.get_requirement(tc, 'disabled_valgrind', NONE) if config.force_enable: if vg_tool and vg_tool != config.force_enable: raise futils.Skip("test enables the '{}' Valgrind tool while " "execution configuration forces '{}'".format( vg_tool, config.force_enable)) elif config.force_enable in disabled: raise futils.Skip( "forced Valgrind tool '{}' is disabled by test".format( config.force_enable)) else: vg_tool = config.force_enable return [ cls(vg_tool, tc.cwd, tc.testnum, **kwargs), ]
def filter(cls, config, msg, tc): """ Initialize DevDaxes class for the test to be run based on configuration and test requirements. Args: config: configuration as returned by Configurator class msg (Message): level based logger class instance tc (BaseTest): test case, from which the dax device run requirements are obtained Returns: Initialized DevDaxes class as single element list for type compliance """ dax_devices, _ = ctx.get_requirement(tc, 'devdax', ()) cls.check_fs_exec, _ = ctx.get_requirement(tc, 'require_fs_exec', None) req_real_pmem, _ = ctx.get_requirement(tc, 'require_real_pmem', False) if not dax_devices: return ctx.NO_CONTEXT elif sys.platform == 'win32' and tc.enabled: raise futils.Fail('dax device functionality required by "{}" is ' 'not available on Windows. Please disable the ' 'test for this platform'.format(tc)) if not config.device_dax_path: raise futils.Skip('No dax devices defined in testconfig') if len(dax_devices) > len(config.device_dax_path): raise futils.Skip('Not enough dax devices defined in testconfig ' '({} needed)'.format(len(dax_devices))) ndctl = tools.Ndctl() for c in config.device_dax_path: if not ndctl.is_devdax(c): raise futils.Fail('{} is not a dax device'.format(c)) assigned = _try_assign_by_requirements(config.device_dax_path, dax_devices) # filter out the emulated devdaxes from the assigned ones if req_real_pmem: assigned_filtered = [] for dd in assigned: if not ndctl.is_emulated(dd.path): assigned_filtered.append(dd) assigned = tuple(assigned_filtered) if not assigned: raise futils.Skip('Dax devices in test configuration do not ' 'meet test requirements') return [DevDaxes(*assigned)]
def _check_real_pmem_req_is_met(self, tc): req_real_pmem, _ = ctx.get_requirement(tc, 'require_real_pmem', False) if not req_real_pmem: return True devdaxes, _ = ctx.get_requirement(tc, 'require_devdax', None) # devdax cases should be dealt in devdax module if devdaxes is not None: return True if Ndctl().is_emulated(self.dir_): raise futils.Skip('skip emulated pmem') return True
def filter(cls, config, msg, tc): dax_devices, _ = ctx.get_requirement(tc, 'devdax', ()) if not dax_devices: return ctx.NO_CONTEXT elif sys.platform == 'win32' and tc.enabled: raise futils.Fail('dax device functionality required by "{}" is ' 'not available on Windows. Please disable the ' 'test for this platform'.format(tc)) if not config.device_dax_path: raise futils.Skip('No dax devices defined in testconfig') if len(dax_devices) > len(config.device_dax_path): raise futils.Skip('Not enough dax devices defined in testconfig ' '({} needed)'.format(len(dax_devices))) ndctl = tools.Ndctl() for c in config.device_dax_path: if not ndctl.is_devdax(c): raise futils.Fail('{} is not a dax device'.format(c)) assigned = _try_assign_by_requirements(config.device_dax_path, dax_devices) if not assigned: raise futils.Skip('Dax devices in test configuration do not ' 'meet test requirements') return [ DevDaxes(*assigned), ]
def filter(cls, config, msg, tc): dax_devices, _ = ctx.get_requirement(tc, 'devdax', ()) if not dax_devices: return ctx.NO_CONTEXT elif sys.platform == 'win32' and tc.enabled: raise futils.Fail('dax device functionality required by "{}" is ' 'not available on Windows. Please disable the ' 'test for this platform'.format(tc)) if not config.device_dax_path: raise futils.Skip('No dax devices defined in testconfig') if len(dax_devices) > len(config.device_dax_path): raise futils.Skip('Not enough dax devices defined in testconfig ' '({} needed)'.format(len(dax_devices))) ndctl = tools.Ndctl() for dd, cddp in zip(dax_devices, config.device_dax_path): dd.path = cddp if not ndctl.is_devdax(cddp): raise futils.Fail('{} is not a dax device'.format(cddp)) dd.size = ndctl.get_dev_size(cddp) dd.alignment = ndctl.get_dev_alignment(cddp) return [ DevDaxes(*dax_devices), ]
def filter(cls, config, msg, tc): """ Initialize granularity classes for the test to be run based on configuration and test requirements. Args: config: configuration as returned by Configurator class msg (Message): level based logger class instance tc (BaseTest): test case, from which the granularity requirements are obtained Returns: list of granularities on which the test should be run """ req_gran, kwargs = ctx.get_requirement(tc, 'granularity', None) # remove granularities if respective test directories in # test config are not defined conf_defined = [c for c in config.granularity if c.testdir_defined(config)] if req_gran == Non: return [Non(**kwargs), ] if req_gran == _CACHELINE_OR_LESS: tmp_req_gran = [Byte, CacheLine] elif req_gran == _PAGE_OR_LESS: tmp_req_gran = [Byte, CacheLine, Page] elif req_gran == [ctx.Any, ]: tmp_req_gran = ctx.Any.get(conf_defined) else: tmp_req_gran = req_gran filtered = ctx.filter_contexts(conf_defined, tmp_req_gran) kwargs['tc_dirname'] = tc.tc_dirname if len(filtered) > 1 and req_gran == _CACHELINE_OR_LESS or \ req_gran == _PAGE_OR_LESS: def order_by_smallest(elem): ordered = [Byte, CacheLine, Page] return ordered.index(elem) # take the smallest available granularity filtered.sort(key=order_by_smallest) filtered = [filtered[0], ] gs = [] for g in filtered: try: gran = g(**kwargs) gran._check_usc_req_is_met(tc) gran._check_real_pmem_req_is_met(tc) gs.append(gran) except futils.Skip as s: msg.print_verbose('{}: SKIP: {}'.format(tc, s)) return gs
def filter(cls, config, msg, tc): req_builds, kwargs = ctx.get_requirement(tc, 'build', None) builds = [] for b in ctx.filter_contexts(config.build, req_builds): try: builds.append(b(**kwargs)) except futils.Skip as s: msg.print('{}: SKIP: {}'.format(tc, s)) return builds
def filter(cls, config, msg, tc): """ Acquire file system granularity for the test to be run based on configuration and test requirements """ req_gran, kwargs = ctx.get_requirement(tc, 'granularity', None) # remove granularities if respective test directories in # test config are not defined conf_defined = [ c for c in config.granularity if c.testdir_defined(config) ] if req_gran == Non: return [ Non(**kwargs), ] if req_gran == _CACHELINE_OR_LESS: tmp_req_gran = [Byte, CacheLine] elif req_gran == _PAGE_OR_LESS: tmp_req_gran = [Byte, CacheLine, Page] elif req_gran == ctx.Any: tmp_req_gran = [ ctx.Any.get(conf_defined), ] else: tmp_req_gran = req_gran filtered = ctx.filter_contexts(conf_defined, tmp_req_gran) kwargs['tc_dirname'] = tc.tc_dirname if len(filtered) > 1 and req_gran == _CACHELINE_OR_LESS or \ req_gran == _PAGE_OR_LESS: def order_by_smallest(elem): ordered = [Byte, CacheLine, Page] return ordered.index(elem) # take the smallest available granularity filtered.sort(key=order_by_smallest) filtered = [ filtered[0], ] gs = [] for g in filtered: try: gs.append(g(**kwargs)) except futils.Skip as s: msg.print_verbose('{}: SKIP: {}'.format(tc, s)) return gs
def _check_ndctl_req_is_met(self, tc): """ Check if all conditions for the ndctl requirement are met """ require_ndctl, _ = ctx.get_requirement(tc, 'require_ndctl', ()) if not require_ndctl: return True self.check_ndctl_enable() self.check_ndctl() return True
def filter(cls, config, msg, tc): """ Acquire Valgrind tool for the test to be run with. Takes into account configuration 'force-enable' options, and Valgrind tools enabled or disabled by test requirements. Args: config: configuration as returned by Configurator class msg (Message): level based logger class instance tc (BaseTest): test case, from which the Valgrind requirements are obtained Returns: list of initialized Valgrind tool classes with which the test should be run """ vg_tool, kwargs = ctx.get_requirement(tc, 'enabled_valgrind', NONE) disabled, _ = ctx.get_requirement(tc, 'disabled_valgrind', ()) if config.force_enable: if vg_tool and vg_tool != config.force_enable: raise futils.Skip("test enables the '{}' Valgrind tool while " "execution configuration forces '{}'".format( vg_tool, config.force_enable)) elif config.force_enable in disabled: raise futils.Skip( "forced Valgrind tool '{}' is disabled by test".format( config.force_enable)) else: vg_tool = config.force_enable return [ cls(vg_tool, tc.cwd, tc.testnum, **kwargs), ]
def _check_ndctl_req_is_met(self, tc): """ Check if all conditions for the ndctl requirement are met """ require_ndctl, kwargs = ctx.get_requirement(tc, 'require_ndctl', ()) if not require_ndctl: return True self.check_ndctl_enable() self.check_ndctl() if kwargs.get('require_namespace', False): self.check_namespace() return True
def _check_ndctl_req_is_met(self, tc): """ Check if all conditions for the ndctl requirement are met """ require_ndctl, _ = ctx.get_requirement(tc, 'require_ndctl', ()) if not require_ndctl: return True ndctl_enable = os.environ.get('NDCTL_ENABLE') if ndctl_enable == 'n': raise futils.Skip('libndctl is disabled (NDCTL_ENABLE == \'n\')') is_ndctl = self._check_pkgconfig('libndctl', NDCTL_MIN_VERSION) if not is_ndctl: raise futils.Skip( 'libndctl (>=v{}) is not installed'.format(NDCTL_MIN_VERSION)) return True
def filter(cls, config, msg, tc): req_fs, kwargs = ctx.get_requirement(tc, 'fs', None) kwargs['tc_dirname'] = tc.tc_dirname if req_fs == Non: return [ Non(**kwargs), ] else: fss = [] for f in ctx.filter_contexts(config.fs, req_fs): try: fss.append(f(**kwargs)) except futils.Skip as s: msg.print_verbose('{}: SKIP: {}'.format(tc, s)) return fss
def _check_admin_req_is_met(self, tc): """ Check if all conditions for the admin requirement are met """ require_admin, _ = ctx.get_requirement(tc, 'require_admin', ()) if not require_admin: # admin is not required return True if not self.cfg.enable_admin_tests: raise futils.Skip('admin tests are not enabled in config ' '(enable_admin_tests)') if not self._check_is_admin(): raise futils.Fail('Error: admin tests are enabled in config, ' 'but the user does not have administrative ' 'privileges') # user is admin return True
def _check_usc_req_is_met(self, tc): require_usc, _ = ctx.get_requirement(tc, 'require_usc', False) if not require_usc: return True basedir = self.testdir.replace(self.testdir, '') filepath = os.path.join(basedir, "__usc_test_file") f = open(filepath, 'w') f.close() check = self.tools.usc_permission_check(filepath) usc_available = check.returncode == 0 os.remove(filepath) if not usc_available: raise futils.Skip('unsafe shutdown count is not available') return usc_available