def assertUnitsEqual(self, first, second, msg=None):
r"""Assertion for equality in case of objects with units."""
if units.has_units(first) and units.has_units(second):
first = units.convert_to(first, units.get_units(second))
self.assertEqual(units.get_data(first),
units.get_data(second),
msg=msg)
def _getAssertEqualityFunc(self, first, second):
# Allow comparison of tuple to list and units to anything
if (type(first), type(second)) in [(list, tuple), (tuple, list)]:
return self.assertSequenceEqual
elif units.has_units(first) or units.has_units(second):
return self.assertUnitsEqual
return super(WrappedTestCase, self)._getAssertEqualityFunc(first, second)
def test_add_units(self):
r"""Test add_units."""
for v in self._vars_nounits:
x = units.add_units(v, 'cm')
assert (units.has_units(x))
self.assert_equal(units.add_units(1.0, ''), 1.0)
self.assert_equal(units.add_units(1.0, 'n/a'), 1.0)
def test_add_units(self, vars_nounits):
r"""Test add_units."""
for v in vars_nounits:
x = units.add_units(v, 'cm')
assert (units.has_units(x))
assert (units.add_units(1.0, '') == 1.0)
assert (units.add_units(1.0, 'n/a') == 1.0)
def __call__(self, x):
r"""Call filter on the provided message.
Args:
x (object): Message object to filter.
Returns:
bool: True if the message will pass through the filter, False otherwise.
"""
try:
out = self.evaluate_filter(x)
except ValueError:
if backwards.PY2 and units.has_units(x):
out = self.evaluate_filter(units.get_data(x))
else:
raise # pragma: debug
if isinstance(out, np.ndarray):
assert (out.dtype == bool)
out = bool(out.all())
elif isinstance(out, np.bool_):
out = bool(out)
try:
assert (isinstance(out, bool))
except AssertionError: # pragma: debug
print(out, type(out))
raise
return out
def has_units(self, obj):
if isinstance(obj, (list, tuple)):
for x in obj:
if self.has_units(x):
return True
elif isinstance(obj, dict):
for x in obj.values():
if self.has_units(x):
return True
else:
return units.has_units(obj)
return False
def assert_equal(x, y):
r"""Assert that two messages are equivalent.
Args:
x (object): Python object to compare against y.
y (object): Python object to compare against x.
Raises:
AssertionError: If the two messages are not equivalent.
"""
if isinstance(y, (list, tuple)):
assert(isinstance(x, (list, tuple)))
ut.assertEqual(len(x), len(y))
for ix, iy in zip(x, y):
assert_equal(ix, iy)
elif isinstance(y, dict):
assert(issubclass(y.__class__, dict))
# ut.assertEqual(type(x), type(y))
ut.assertEqual(len(x), len(y))
for k, iy in y.items():
ix = x[k]
assert_equal(ix, iy)
elif isinstance(y, (np.ndarray, pd.DataFrame)):
if units.has_units(y) and (not units.has_units(x)): # pragma: debug
y = units.get_data(y)
elif (not units.has_units(y)) and units.has_units(x):
x = units.get_data(x)
np.testing.assert_array_equal(x, y)
else:
if units.has_units(y) and units.has_units(x):
x = units.convert_to(x, units.get_units(y))
assert_equal(units.get_data(x), units.get_data(y))
else:
if units.has_units(y) and (not units.has_units(x)): # pragma: debug
y = units.get_data(y)
elif (not units.has_units(y)) and units.has_units(x):
x = units.get_data(x)
ut.assertEqual(x, y)
def _file_send(self, msg):
assert (isinstance(msg, dict))
for k, v in msg.items():
if isinstance(v, np.ndarray):
dims = []
v = self.transform_type_send(v)
for i, d in enumerate(v.shape):
if i == 0:
idim = k
else:
idim = '%s%d' % (k, i)
dims.append(idim)
self._fd_netcdf.createDimension(idim, d)
var = self._fd_netcdf.createVariable(k, v.dtype, dims)
var[:] = v
if units.has_units(v):
var.units = units.get_units(v)
else: # pragma: debug
raise TypeError("Type '%s' no supported." % type(msg))
self._last_size = self.file_size
self.fd.seek(self._last_size)
def test_has_units(self):
r"""Test has_units."""
for v in self._vars_nounits: # + ['string']:
assert (not units.has_units(v))
for v in self._vars_units:
assert (units.has_units(v))
def test_has_units(self, vars_nounits, vars_units):
r"""Test has_units."""
for v in vars_nounits:
assert (not units.has_units(v))
for v in vars_units:
assert (units.has_units(v))
