Source code for cis_interface.metaschema.datatypes.tests.test_ScalarMetaschemaType
import copy
import numpy as np
from cis_interface import units
from cis_interface.metaschema.datatypes.tests import test_MetaschemaType as parent
from cis_interface.metaschema.properties.ScalarMetaschemaProperties import (
_valid_types)
[docs]class TestScalarMetaschemaType(parent.TestMetaschemaType):
r"""Test class for ScalarMetaschemaType class with float."""
_mod = 'ScalarMetaschemaType'
_cls = 'ScalarMetaschemaType'
_prec = 32
_type = 'float'
_shape = 1
_array_contents = None
def __init__(self, *args, **kwargs):
super(TestScalarMetaschemaType, self).__init__(*args, **kwargs)
if not self._explicit:
self._typedef['subtype'] = self._type
if self._type == 'bytes':
dtype = 'S%d' % (self._prec // 8)
elif self._type == 'unicode':
dtype = 'U%d' % (self._prec // 32)
else:
dtype = '%s%d' % (self._type, self._prec)
if self._array_contents is None:
self._array = np.ones(self._shape, dtype)
else:
self._array = np.array(self._array_contents, dtype)
if self._type in ['bytes', 'unicode']:
dtype_invalid = 'float'
else:
dtype_invalid = 'S10'
self._invalid_array = np.ones(self._shape, dtype_invalid)
if 'Array' not in self._cls:
self._value = self._array[0]
self._invalid_decoded.append(self._array)
self._invalid_decoded.append(self._invalid_array[0])
else:
self._value = self._array
if self._array.ndim == 1:
self._invalid_decoded.append(self._array[0])
self._invalid_decoded.append(np.ones((3, 4), dtype))
else:
self._invalid_decoded.append(self._array[0][0])
self._invalid_decoded.append(self._array[0])
self._invalid_decoded.append(self._invalid_array)
self._valid_encoded = [{'type': self.import_cls.name,
'precision': self._prec,
'units': '',
'data': self._value.tobytes()}]
if not self._explicit:
self._valid_encoded[0]['subtype'] = self._type
self._valid_decoded = [self._value]
if self._type == 'bytes':
new_dtype = 'S%d' % (self._prec * 2 // 8)
elif self._type == 'unicode':
new_dtype = 'U%d' % (self._prec * 2 // 32)
else:
new_dtype = '%s%d' % (self._type, self._prec * 2)
prec_array = self._array.astype(new_dtype)
if 'Array' not in self._cls:
self._prec_value = prec_array[0]
else:
self._prec_value = prec_array
self._compatible_objects = [
(self._value, self._value, None)]
if not self._explicit:
self._compatible_objects.append(
(self._value, self._prec_value, {'subtype': self._type,
'precision': self._prec * 2}))
else:
self._compatible_objects.append(
(self._value, self._prec_value, {'precision': self._prec * 2}))
if 'Array' not in self._cls:
if self._explicit:
if self._type == 'bytes':
self._valid_normalize = [(1, b'1'),
(u'1', b'1')]
elif self._type == 'unicode':
self._valid_normalize = [(1, u'1'),
(b'1', u'1')]
else:
self._valid_normalize = [(str(self._value), self._value),
('hello', 'hello')]
if self._explicit and ('Array' not in self._cls):
self._invalid_encoded.append({'type': 'scalar',
'subtype': 'invalid'})
self._invalid_validate.append(np.array([None, 1, list()]))
[docs] def test_from_array(self):
r"""Test getting object from array."""
test_val = self._value
test_kws = {}
if 'units' in self._typedef:
test_val = units.add_units(test_val, self._typedef['units'])
test_kws['unit_str'] = self._typedef['units']
self.assert_equal(self.instance.from_array(self._array, **test_kws),
test_val)
# Dynamically create tests for dynamic and explicitly typed scalars
for t in _valid_types.keys():
iattr_imp = {'_type': t}
if t == 'complex':
iattr_imp['_prec'] = 64
elif t in ('bytes', 'unicode'):
iattr_imp['_array_contents'] = ['one', 'two', 'three']
max_len = len(max(iattr_imp['_array_contents'], key=len))
if t == 'unicode':
iattr_imp['_prec'] = max_len * 32
else:
iattr_imp['_prec'] = max_len * 8
iattr_exp = copy.deepcopy(iattr_imp)
iattr_exp['_cls'] = '%sMetaschemaType' % t.title()
iattr_exp['_explicit'] = True
cls_imp = type('TestScalarMetaschemaType_%s' % t,
(TestScalarMetaschemaType, ), iattr_imp)
cls_exp = type('Test%s' % iattr_exp['_cls'],
(TestScalarMetaschemaType, ), iattr_exp)
globals()[cls_imp.__name__] = cls_imp
globals()[cls_exp.__name__] = cls_exp
del cls_imp, cls_exp
[docs]class TestScalarMetaschemaType_prec(TestScalarMetaschemaType):
r"""Test class for ScalarMetaschemaType class with precision."""
def __init__(self, *args, **kwargs):
super(TestScalarMetaschemaType_prec, self).__init__(*args, **kwargs)
self._typedef['precision'] = self._prec
self._valid_encoded.append(copy.deepcopy(self._valid_encoded[0]))
for x in self._invalid_encoded:
x['precision'] = self._prec / 2 # compatible precision
# Version with incorrect precision
self._invalid_encoded.append(copy.deepcopy(self._valid_encoded[0]))
self._invalid_encoded[-1]['precision'] = self._prec * 2
self._invalid_decoded.append(self._prec_value)
[docs]class TestScalarMetaschemaType_units(TestScalarMetaschemaType):
r"""Test class for ScalarMetaschemaType class with units."""
def __init__(self, *args, **kwargs):
super(TestScalarMetaschemaType_units, self).__init__(*args, **kwargs)
self._typedef['units'] = 'cm'
self._valid_encoded.append(copy.deepcopy(self._valid_encoded[0]))
self._valid_encoded[-1]['units'] = 'cm'
self._valid_encoded.append(copy.deepcopy(self._valid_encoded[0]))
self._valid_encoded[-1]['units'] = 'm'
self._valid_decoded.append(copy.deepcopy(self._valid_decoded[0]))
self._valid_decoded[-1] = units.add_units(self._valid_decoded[-1], 'm')
# Version with incorrect units
self._invalid_encoded.append(copy.deepcopy(self._valid_encoded[0]))
self._invalid_encoded[-1]['units'] = 's'