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.
