def deco(func): deco_list = [ timeout_dec(timeout=timeout), unittest.skipIf( (not tools.check_environ_bool('YGG_ENABLE_EXAMPLE_TESTS')), "Example tests not enabled."), ] for i, k in enumerate(iter_over): v = x[i] flag = None msg = None if k == 'comm': flag = tools.is_comm_installed(v) elif k == 'language': flag = True for vv in get_example_languages(name, language=v): if not tools.is_lang_installed(vv): flag = False break if flag is not None: if msg is None: msg = "%s %s not installed." % (k.title(), v) deco_list.append(unittest.skipIf(not flag, msg)) for v in deco_list: func = v(func) return func
def run_language(self, lang): r"""Run a test for the specified language.""" if not tools.check_environ_bool('YGG_ENABLE_EXAMPLE_TESTS'): raise unittest.SkipTest("Example tests not enabled.") self.language = lang self.run_example() self.language = None
def serialize(self, args, header_kwargs=None, add_serializer_info=False, no_metadata=False): r"""Serialize a message. Args: args (obj): List of arguments to be formatted or a ready made message. header_kwargs (dict, optional): Keyword arguments that should be added to the header. Defaults to None and no header is added. add_serializer_info (bool, optional): If True, serializer information will be added to the metadata. Defaults to False. no_metadata (bool, optional): If True, no metadata will be added to the serialized message. Defaults to False. Returns: bytes, str: Serialized message. Raises: TypeError: If returned msg is not bytes type (str on Python 2). """ if header_kwargs is None: header_kwargs = {} if isinstance(args, backwards.bytes_type) and (args == tools.YGG_MSG_EOF): header_kwargs['raw'] = True self.initialize_from_message(args, **header_kwargs) metadata = {'no_metadata': no_metadata} if add_serializer_info: self.debug("serializer_info = %s", str(self.serializer_info)) metadata.update(self.serializer_info) metadata['typedef_base'] = self.typedef if header_kwargs is not None: metadata.update(header_kwargs) if header_kwargs.get('raw', False): data = args else: if self.func_serialize is None: data = args else: data = self.func_serialize(args) if (self.encoded_typedef['type'] == 'bytes'): if not isinstance(data, backwards.bytes_type): raise TypeError( ("Serialization function returned object " + "of type '%s', not required '%s' type.") % (type(data), backwards.bytes_type)) metadata['dont_encode'] = True if not no_metadata: metadata['metadata'] = self.datatype.encode_type( args, typedef=self.typedef) if ((self.initialized and (not tools.check_environ_bool('YGG_VALIDATE_ALL_MESSAGES')))): metadata.setdefault('dont_check', True) out = self.encoded_datatype.serialize(data, **metadata) return out
def run_iteration(self, **kwargs): r"""Run a test for the specified parameters.""" if not tools.check_environ_bool('YGG_ENABLE_EXAMPLE_TESTS'): raise unittest.SkipTest("Example tests not enabled.") self.setup_iteration(**kwargs) try: getattr(self, kwargs.get('method', 'run_example'))() finally: self.teardown_iteration(**kwargs)
def run(self): r"""Run the integration.""" if not tools.check_environ_bool('YGG_ENABLE_DEMO_TESTS'): raise unittest.SkipTest("Demo tests not enabled.") for x in self.languages: check_enabled_languages(x) if not tools.is_lang_installed(x): raise unittest.SkipTest("%s not installed." % x) self.runner = runner.get_runner(self.yamls, namespace=self.name, production_run=True) self.runner.run() assert (not self.runner.error_flag) self.runner = None
def deserialize(self, msg, **kwargs): r"""Deserialize a message. Args: msg (str, bytes): Message to be deserialized. **kwargs: Additional keyword arguments are passed to the deserialize method of the datatype class. Returns: tuple(obj, dict): Deserialized message and header information. Raises: TypeError: If msg is not bytes type (str on Python 2). """ if (((self.func_deserialize is not None) and (self.encoded_typedef['type'] == 'bytes'))): kwargs['dont_decode'] = True if ((self.initialized and (not tools.check_environ_bool('YGG_VALIDATE_ALL_MESSAGES')))): kwargs.setdefault('dont_check', True) out, metadata = self.encoded_datatype.deserialize(msg, **kwargs) if (self.func_deserialize is not None): if metadata['size'] == 0: out = self.empty_msg elif not (metadata.get('incomplete', False) or metadata.get('raw', False)): if 'metadata' in metadata: for k, v in metadata.items(): if k not in ['type', 'precision', 'units', 'metadata']: metadata['metadata'][k] = v metadata = metadata.pop('metadata') if not self.initialized: self.update_serializer(extract=True, **metadata) out = self.func_deserialize(out) # Update serializer typedef_base = metadata.pop('typedef_base', {}) typedef = copy.deepcopy(metadata) typedef.update(typedef_base) if not ((metadata.get('size', 0) == 0) or metadata.get( 'incomplete', False) or metadata.get('raw', False)): self.initialize_serializer(typedef, extract=True) return out, metadata
def run_iteration(self, language=None, datatype=None, comm=None): r"""Run a test for the specified parameters.""" if not tools.check_environ_bool('YGG_ENABLE_EXAMPLE_TESTS'): raise unittest.SkipTest("Example tests not enabled.") if comm and (not tools.is_comm_installed(comm)): raise unittest.SkipTest("%s library not installed." % comm) if language is not None: check_enabled_languages(language) self.language = language self.datatype = datatype if comm is None: self.comm = _default_comm else: self.comm = comm self.set_default_comm(default_comm=comm) try: self.run_example() finally: self.language = None self.datatype = None self.comm = None self.reset_default_comm()
% self.filename) def get_raw_data(self): r"""Get the raw contents of the data file.""" out = '' if os.path.isfile(self.filename): with open(self.filename, 'r') as fd: out = fd.read() return out def time_run(self): r"""Perform a timed run.""" self.instance.time_run(*self.time_run_args, **self.time_run_kwargs) @unittest.skipIf(not tools.check_environ_bool("YGG_TEST_PRODUCTION_RUNS"), 'YGG_TEST_PRODUCTION_RUNS not set') @long_running class TestTimedRun(TimedRunTestBase): r"""Test class for the TimedRun class using existing data.""" platform = _base_environment['platform'] python_ver = _base_environment['python_ver'] comm_type = _base_environment['comm_type'] language = 'python' @property def count(self): r"""int: Number of messages to use for tests.""" return self.instance.base_msg_count
('make', 'make_model.yml'), ('cmake', 'cmake_model.yml'), ('matlab', 'matlab_model.yml'), ('python', 'python_model.yml'), ('error', 'error_model.yml'), ('lpy', 'lpy_model.yml'), ('fortran', 'fortran_model.yml'), ('sbml', 'sbml_model.yml'), ('osr', 'osr_model.yml')] yamls = {k: os.path.join(yaml_dir, v) for k, v in yaml_list} # Makefile if platform._is_win: # pragma: windows makefile0 = os.path.join(script_dir, "Makefile_windows") else: makefile0 = os.path.join(script_dir, "Makefile_linux") shutil.copy(makefile0, os.path.join(script_dir, "Makefile")) # Flag for enabling tests that take a long time or are for extra examples enable_long_tests = tools.check_environ_bool("YGG_ENABLE_LONG_TESTS") skip_extra_examples = tools.check_environ_bool("YGG_SKIP_EXTRA_EXAMPLES") def check_enabled_languages(language, return_decorators=False): r"""Determine if the specified language is enabled by the value or values specified in YGG_TEST_LANGUAGE. Args: language (str): Language to check. return_decorators (bool, optional): If True, a skip error is not raised and a list of decorators is returned. Defaults to False. Raises: unittest.SkipTest: If the specified language is not enabled.