def test_contains(self):
values = [1,2,3]
t = IonTag('foo',3,'int', self.mesh)
for v in vertices(self.mesh):
# testing setter
t[v] = values
v = MeshEntity(self.mesh,0,1)
# testing getter
self.assertTrue((t[v] == values).all())
#---------------------------------------------------------------------------------------
# Delete a tag entry (for an entity)
#---------------------------------------------------------------------------------------
# choose an entity to delete
entity_tuple = (v.dim(),v.index())
# check that tag has the entity, v, in it
self.assertTrue(t.__contains__(entity_tuple))
del t._entity_values[entity_tuple]
# check that the tag no longer has the entity, v, in it
self.assertFalse(t.__contains__(entity_tuple))
def test_iter(self):
# test the iterator and verify that the correct type is passed back
#------------------------------------------------------------
# Initial step: Feed in values to the vertices in the mesh
#------------------------------------------------------------
t = IonTag('foo',1,'int', self.mesh)
for x,v in enumerate(vertices(self.mesh)):
t[v] = (x,)
#------------------------------------------------------------
# Test the iteration over the tags
#------------------------------------------------------------
for key, item in t.iteritems():
self.assertEqual(t[ key ], item )
self.assertTrue(isinstance(key, MeshEntity))
self.assertTrue(isinstance(item[0], int ))
def test_get_set_del(self):
#Test the getter, setter and delete method
values = [1,2,3]
t = IonTag('foo',3,'int', self.mesh)
for v in vertices(self.mesh):
# test the setter
t[v] = values
# choose an entity in the mesh
v = MeshEntity(self.mesh,0,1)
# test the getter
self.assertTrue((t[v] == values).all())
#---------------------------------------------------------------------------------------
# Check delete of a tag entry (for an entity)
#---------------------------------------------------------------------------------------
# choose an entity to delete
entity_tuple = (v.dim(),v.index())
# check that tag has the entity, v, in it
self.assertTrue(t._entity_values.has_key(entity_tuple))
# delete a tag entry for an entity
del t[entity_tuple]
# check that the tag no longer has the entity, v, in it
self.assertFalse(t._entity_values.has_key(entity_tuple))
#---------------------------------------------------------------------------------------
# Add less number of values than the size defined in the tag object
#---------------------------------------------------------------------------------------
values = [1]
t = IonTag('foo',3,'int', self.mesh)
v = MeshEntity(self.mesh,0,1)
#@todo check to see why self.assertRaises is not working for unittest:
# with self.assertRaises(ValueError):
# t[v] = values
try:
t[v] = values
except ValueError:
pass
else:
raise AssertionError('A Value Error should have been raised!')
#---------------------------------------------------------------------------------------
# Add more number of values that the size defined in the tag object
#---------------------------------------------------------------------------------------
values = [1,2,3,4]
size = 2
t = IonTag('foo',size,'int', self.mesh)
v = MeshEntity(self.mesh,0,1)
t[v] = values
for key, value in t.iteritems():
self.assertEqual(len(value), size)
def test_types(self):
# test with different types:
#@todo for each type check that input is cast to type
#---------------------------------------------------------------------------------------
# Ints
#---------------------------------------------------------------------------------------
t = IonTag('foo',3,'int', self.mesh)
self.assertEqual(t._type, 'int')
# Add some float values to the tag, and check if they are converted to
# int tag values
values = [1.23,2.232,3.323] # a list of int values
v = MeshEntity(self.mesh,0,1)
t[v] = values
for key, item in t.iteritems():
for num in item:
self.assertTrue(isinstance(num, int))
#---------------------------------------------------------------------------------------
# Floats
#---------------------------------------------------------------------------------------
t = IonTag('foo',3,'float', self.mesh)
self.assertEqual(t._type, 'float')
# Add some int values to the tag, and check if they are converted to
# float tag values
values = [1,2,3] # a list of int values
v = MeshEntity(self.mesh,0,1)
t[v] = values
for key, item in t.iteritems():
for num in item:
self.assertTrue(isinstance(num, float))
# now pass in complex values
values = [complex(1,2), complex(3,4), complex(5,6), complex(7,8)]
try:
t[v] = values
except TypeError:
pass
else:
raise AssertionError('Did not raise type error. Python should complain when converting from complex to float')
for key, item in t.iteritems():
for num in item:
self.assertTrue(isinstance(num, float))
#---------------------------------------------------------------------------------------
# Complex
#---------------------------------------------------------------------------------------
t = IonTag('foo',3,'complex', self.mesh)
self.assertEqual(t._type, 'complex')
values = [1,2,3,4,5]
v = MeshEntity(self.mesh,0,1)
t[v] = values
for key, item in t.iteritems():
for num in item:
self.assertTrue(isinstance(num, complex))