import numpy as np from tempfile import NamedTemporaryFile import pickle import unittest import tfields ATOL = 1e-8 class Base_Check(object): def demand_equal(self, other): raise NotImplementedError(self.__class__) def test_pickle(self): with NamedTemporaryFile(suffix='.pickle') as out_file: pickle.dump(self._inst, out_file) out_file.flush() out_file.seek(0) reloaded = pickle.load(out_file) self.demand_equal(reloaded) def test_implicit_copy(self): copy = type(self._inst)(self._inst) self.demand_equal(copy) # self.assertIsNot(self._inst, copy) def test_explicit_copy(self): copy = self._inst.copy() self.demand_equal(copy) self.assertIsNot(self._inst, copy) def test_save_npz(self): out_file = NamedTemporaryFile(suffix='.npz') self._inst.save(out_file.name) _ = out_file.seek(0) # this is only necessary in the test load_inst = type(self._inst).load(out_file.name) # allow_pickle=True) ? self.demand_equal(load_inst) def test_dict(self): d = self._inst._as_new_dict() other = type(self._inst)._from_new_dict(d) self.demand_equal(other) # d = self._inst._as_dict() # other = type(self._inst)._from_dict(**d) # self.demand_equal(other) def tearDown(self): del self._inst class AbstractNdarray_Check(Base_Check): pass class Tensors_Check(AbstractNdarray_Check): """ Testing derivatives of Tensors """ _inst = None def demand_equal(self, other, atol=False, transformed=False): if atol: self.assertTrue(self._inst.equal(other, atol=ATOL)) else: self.assertTrue(self._inst.equal(other)) if not transformed: self.assertEqual(self._inst.coord_sys, other.coord_sys) self.assertEqual(self._inst.name, other.name) def test_self_equality(self): # Test equality self.demand_equal(self._inst) transformer = self._inst.copy() transformer.transform(tfields.bases.CYLINDER) self.demand_equal(transformer, atol=True, transformed=True) # self.assertIs(self._inst, np.asarray(self._inst)) # TODO investigate def test_cylinderTrafo(self): # Test coordinate transformations in circle transformer = self._inst.copy() transformer.transform(tfields.bases.CYLINDER) if len(self._inst) > 0: self.assertFalse(np.array_equal(self._inst, transformer)) transformer.transform(tfields.bases.CARTESIAN) self.demand_equal(transformer, atol=True, transformed=True) def test_spericalTrafo(self): # Test coordinate transformations in circle transformer = self._inst.copy() transformer.transform(tfields.bases.SPHERICAL) transformer.transform(tfields.bases.CARTESIAN) self.demand_equal(transformer, atol=True, transformed=True) def test_basic_merge(self): # create 3 copies with different coord_sys merge_list = [self._inst.copy() for i in range(3)] merge_list[0].transform(tfields.bases.CARTESIAN) merge_list[1].transform(tfields.bases.CYLINDER) merge_list[2].transform(tfields.bases.SPHERICAL) # merge them and check that the first coord_sys is taken obj = type(self._inst).merged(*merge_list) self.assertTrue(obj.coord_sys == tfields.bases.CARTESIAN) # check that all copies are the same also with new coord_sys for i in range(len(merge_list)): value = np.allclose(merge_list[0], obj[i * len(self._inst): (i + 1) * len(self._inst)], atol=ATOL) self.assertTrue(value) obj_cs = type(self._inst).merged(*merge_list, coord_sys=tfields.bases.CYLINDER) for i in range(len(merge_list)): value = np.allclose(merge_list[1], obj_cs[i * len(self._inst): (i + 1) * len(self._inst)], atol=ATOL) self.assertTrue(value) class TensorFields_Check(Tensors_Check): def test_fields(self): if self._inst.fields: # field is of type list self.assertTrue(isinstance(self._inst.fields, list)) self.assertTrue(len(self._inst.fields) == len(self._fields)) for field, target_field in zip(self._inst.fields, self._fields): self.assertTrue(np.array_equal(field, target_field)) # fields are copied not reffered by a pointer self.assertFalse(field is target_field) class TensorMaps_Check(TensorFields_Check): def test_maps(self): self.assertIsNotNone(self._inst.maps) """ EMPTY TESTS """ class Tensors_Empty_Test(Tensors_Check, unittest.TestCase): def setUp(self): self._inst = tfields.Tensors([], dim=3) class TensorFields_Empty_Test(TensorFields_Check, unittest.TestCase): def setUp(self): self._fields = [] self._inst = tfields.TensorFields([], dim=3) class TensorMaps_Empty_Test(TensorMaps_Check, unittest.TestCase): def setUp(self): self._fields = [] self._inst = tfields.TensorMaps([], dim=3) self._maps = [] self._maps_fields = [] class TensorFields_Test(TensorFields_Empty_Test): def setUp(self): base = [(-5, 5, 11)] * 3 self._fields = [tfields.Tensors.grid(*base, coord_sys='cylinder'), tfields.Tensors(range(11**3))] tensors = tfields.Tensors.grid(*base) self._inst = tfields.TensorFields(tensors, *self._fields) self.assertTrue(self._fields[0].coord_sys, 'cylinder') self.assertTrue(self._fields[1].coord_sys, 'cartesian') class TensorMaps_Test(TensorMaps_Empty_Test): def setUp(self): base = [(-1, 1, 3)] * 3 tensors = tfields.Tensors.grid(*base) self._fields = [tfields.Tensors.grid(*base, coord_sys='cylinder'), tfields.Tensors(range(len(tensors)))] self._maps_tensors = [[[0, 0, 0], [1, 2, 3], [1, 5, 9]], [[0, 4], [1, 3]], [[42]]] self._maps_fields = [[[42., 21., 11]], [[3, 25]], [[111]]] self._maps = [tfields.TensorFields(map_tensors, *map_fields) for map_tensors, map_fields in zip(self._maps_tensors, self._maps_fields)] self._inst = tfields.TensorMaps(tensors, *self._fields, maps=self._maps) class Maps_Test(Base_Check, unittest.TestCase): def demand_equal(self, other): self._inst.equal(other) def setUp(self): self._inst = tfields.Maps( [[[0, 0, 0], [1, 2, 3], [1, 5, 9]], [[0, 4], [1, 3]], [[42]]]) class Container_Check(AbstractNdarray_Check): def demand_equal(self, other): for i, item in enumerate(self._inst.items): if issubclass(type(item), tfields.core.AbstractNdarray): self.assertTrue(other.items[i].equal(item)) else: self.assertEqual(other.items[i], item) try: self._inst.labels[i] except (IndexError, TypeError): pass else: self.assertEqual(other.labels[i], self._inst.labels[i]) def test_item(self): if len(self._inst.items) > 0: self.assertEqual(len(self._inst), len(self._inst)) self.assertEqual(type(self._inst), type(self._inst)) class Container_Test(Container_Check, unittest.TestCase): def setUp(self): sphere = tfields.Mesh3D.grid( (1, 1, 1), (-np.pi, np.pi, 3), (-np.pi / 2, np.pi / 2, 3), coord_sys='spherical') sphere2 = sphere.copy() * 3 self._inst = tfields.Container([sphere, sphere2], labels=['test']) if __name__ == '__main__': unittest.main()