def test_init(self):
#
# Default constructor
#
map1 = MetainfoMap()
self.assertTrue(map1.empty())
self.assertEqual(map1.size(), 0)
#
# Dictionary constructor
#
map2 = MetainfoMap({
"bool": True,
"int": 2,
"double": 5.1,
"string": "str"
})
self.assertFalse(map2.empty())
self.assertTrue(map2.has_key("bool"))
self.assertTrue(map2.has_key("int"))
self.assertTrue(map2.has_key("double"))
self.assertTrue(map2.has_key("string"))
self.assertEqual(map2["bool"], True)
self.assertEqual(map2["int"], 2)
self.assertEqual(map2["double"], 5.1)
self.assertEqual(map2["string"], "str")
def test_to_string(self):
map = MetainfoMap()
map.insert("key1", 1)
mapstr = str(map)
self.assertTrue("key" in mapstr)
self.assertTrue("1" in mapstr)
def __init__(self, mode, directory, prefix):
self.__mode = mode
self.__directory = directory
self.__prefix = prefix
self.__global_metainfo = MetainfoMap()
self.__savepoint_list = []
self.__field_list_of_savepoint = dict()
def test_clear(self):
map = MetainfoMap()
map.insert("key", 1)
self.assertFalse(map.empty())
map.clear()
self.assertTrue(map.empty())
def test_comparison(self):
m1 = MetainfoMap()
m2 = MetainfoMap()
m1.insert("key1", 1)
m2.insert("key1", 2)
self.assertEqual(m1, m1)
self.assertNotEqual(m1, m2)
def test_get_dict(self):
map = MetainfoMap()
map.insert("key1", 1)
map.insert("key2", 2)
map.insert("key_array", [1, 2, 3, 4])
d = map.to_dict()
self.assertEqual(len(d), map.size())
self.assertEqual(d["key1"], 1)
self.assertEqual(d["key2"], 2)
self.assertEqual(d["key_array"], [1, 2, 3, 4])
def test_clone(self):
map_to_clone = MetainfoMap()
map_to_clone.insert("key", 1)
map_clone = map_to_clone.clone()
self.assertEqual(map_clone, map_to_clone)
# Clear 'map_to_clone', assert 'map_clone' is unaffected
map_to_clone.clear()
self.assertTrue(map_to_clone.empty())
self.assertFalse(map_clone.empty())
self.assertEqual(map_clone["key"], 1)
def test_deletion(self):
map = MetainfoMap()
map.insert("key", 2)
self.assertTrue(map.has_key("key"))
del map["key"]
self.assertFalse(map.has_key("key"))
def test_init(self):
# Default constructor
sp1 = Savepoint("sp1")
self.assertEqual(sp1.name, "sp1")
sp2 = Savepoint(name="sp2")
self.assertEqual(sp2.name, "sp2")
# Construct with dictionary
sp3 = Savepoint('sp3', metainfo={"key1": 5.0})
self.assertEqual(sp3.metainfo.to_dict(), {"key1": 5.0})
# Construct with MetainfoMap
metainfomap = MetainfoMap({"key1": 5.0})
sp4 = Savepoint('sp4', metainfo=metainfomap)
self.assertEqual(sp4.metainfo.to_dict(), {"key1": 5.0})
def test_init(self):
# Default constructor
info1 = FieldMetainfo(TypeID.Float64, [12, 13, 14])
self.assertEqual(info1.type, TypeID.Float64)
self.assertEqual(info1.dims, [12, 13, 14])
info2 = FieldMetainfo(4, [12, 13, 14])
self.assertEqual(info2.type, TypeID(4))
self.assertEqual(info2.dims, [12, 13, 14])
# Construct with dictionary
info3 = FieldMetainfo(TypeID.Float64, [12, 13, 14],
metainfo={"key1": 5.0})
self.assertEqual(info3.type, TypeID.Float64)
self.assertEqual(info3.dims, [12, 13, 14])
self.assertEqual(info3.metainfo.to_dict(), {"key1": 5.0})
# Construct with MetainfoMap
metainfomap = MetainfoMap({"key1": 5.0})
info4 = FieldMetainfo(TypeID.Float64, [12, 13, 14],
metainfo=metainfomap)
self.assertEqual(info4.type, TypeID.Float64)
self.assertEqual(info4.dims, [12, 13, 14])
self.assertEqual(info4.metainfo.to_dict(), {"key1": 5.0})
def test_insert(self):
map = MetainfoMap()
#
# Insert keys (deduced typeid)
#
map.insert("bool", True)
map.insert("int", 2)
map.insert("double", 5.1)
map.insert("string", "str")
map.insert("bool_array", [True, False, True])
map.insert("bool_int", [1, 2, 3, 4])
map.insert("bool_double", [2.1, 5.2, 5.3])
map.insert("bool_string", ["str1", "str2"])
self.assertEqual(map["bool"], True)
self.assertEqual(map["int"], 2)
self.assertEqual(map["double"], 5.1)
self.assertEqual(map["string"], "str")
self.assertEqual(map["bool_array"], [True, False, True])
self.assertEqual(map["bool_int"], [1, 2, 3, 4])
self.assertEqual(map["bool_double"], [2.1, 5.2, 5.3])
self.assertEqual(map["bool_string"], ["str1", "str2"])
map.clear()
#
# Insert keys (explicit typeid)
#
map.insert("bool", True, TypeID.Boolean)
map.insert("int32", 32, TypeID.Int32)
map.insert("int64", 64, TypeID.Int64)
map.insert("float32", 32.32, TypeID.Float32)
map.insert("float64", 64.64, TypeID.Float64)
map.insert("string", "str", TypeID.String)
map.insert("array_bool", [True, False], TypeID.ArrayOfBoolean)
map.insert("array_int32", [32, 33], TypeID.ArrayOfInt32)
map.insert("array_int64", [64, 65], TypeID.ArrayOfInt64)
map.insert("array_float32", [32, 33], TypeID.ArrayOfFloat32)
map.insert("array_float64", [64.64, 65.65], TypeID.ArrayOfFloat64)
map.insert("array_string", ["str1", "str2"], TypeID.ArrayOfString)
self.assertEqual(map["bool"], True)
self.assertEqual(map["int32"], 32)
self.assertEqual(map["int64"], 64)
self.assertAlmostEqual(map["float32"], 32.32, places=4)
self.assertEqual(map["float64"], 64.64)
self.assertEqual(map["string"], "str")
self.assertEqual(map["array_bool"], [True, False])
self.assertEqual(map["array_int32"], [32, 33])
self.assertEqual(map["array_int64"], [64, 65])
self.assertEqual(map["array_float32"], [32, 33])
self.assertEqual(map["array_float64"], [64.64, 65.65])
self.assertEqual(map["array_string"], ["str1", "str2"])
map.clear()
#
# Insert existing key -> Error
#
map.insert("key", "value")
self.assertRaises(SerialboxError, map.insert, "key", "value")
#
# TypeID wrong type -> Error
#
self.assertRaises(TypeError, map.insert, "key2", "value2",
"not-a-typeid")
def test_iteration(self):
dic = {"bool": True, "int": 2, "double": 5.1, "string": "str"}
map = MetainfoMap(dic)
for key, value in map:
self.assertEqual(value, dic[key])
class SerializerMock(object):
"""Partial mock implementation of serialbox.Serializer used in sdb.
"""
def __init__(self, mode, directory, prefix):
self.__mode = mode
self.__directory = directory
self.__prefix = prefix
self.__global_metainfo = MetainfoMap()
self.__savepoint_list = []
self.__field_list_of_savepoint = dict()
def add_stencil(self, stencil, num_stages, fieldlist, invocation_count=1):
for ic in range(invocation_count):
for i in range(num_stages):
self.__add_field_to_stage(stencil, "stage-" + str(i), i, ic,
list(fieldlist))
def __add_field_to_stage(self, stencil, stage_name, stage_id,
invocation_count, fieldlist):
"""Add field as in/output of the specfied stage and stencil.
"""
#
# Add stencil to global meta-information
#
if not self.__global_metainfo.has_key("stencils"):
self.__global_metainfo.insert("stencils", [stencil])
elif not stencil in self.__global_metainfo["stencils"]:
stencils = self.__global_metainfo["stencils"]
del self.global_metainfo["stencils"]
self.__global_metainfo.insert("stencils", stencils + [stencil])
#
# Append input savepoint
#
input_savepoint = Savepoint(
stencil + "__in", {
"stage_name": stage_name,
"stage_id": stage_id,
"invocation_count": invocation_count
})
self.__savepoint_list += [input_savepoint]
self.__field_list_of_savepoint[input_savepoint] = fieldlist
#
# Append output savepoint
#
output_savepoint = Savepoint(
stencil + "__out", {
"stage_name": stage_name,
"stage_id": stage_id + 1,
"invocation_count": invocation_count
})
self.__savepoint_list += [output_savepoint]
self.__field_list_of_savepoint[output_savepoint] = fieldlist
@property
def global_metainfo(self):
return self.__global_metainfo
@property
def mode(self):
return self.__mode
@property
def prefix(self):
return self.__prefix
@property
def directory(self):
return self.__directory
@property
def global_metainfo(self):
return self.__global_metainfo
def savepoint_list(self):
return self.__savepoint_list
def fields_at_savepoint(self, savepoint):
return self.__field_list_of_savepoint[savepoint]
def __repr__(self):
s = "<SerializerMock\n metainfo: " + str(
self.__global_metainfo) + "\n savepont_list:\n"
for sp in self.__savepoint_list:
s += " " + str(sp)
return s
def __str__(self):
return self.__repr__()