def testSerializableSuperClass(self):
self.assertEqual(
serialization.deserialize(
serialization.serialize(SerializableFromSuperClassOne())),
SerializableFromSuperClassOne())
self.assertEqual(
serialization.deserialize(
serialization.serialize(SerializableFromSuperClassTwo())),
SerializableFromSuperClassTwo())
self.assertEqual(
serialization.deserialize(
serialization.serialize(SerializableFromSuperClassThree())),
SerializableFromSuperClassThree())
def experimental_as_proto(self):
serialized_elements = [
serialization.serialize(element) for element in self.elements
]
proto = serialization_test_pb2.MyCompositeRepresentation(
elements=serialized_elements)
return proto
def experimental_as_proto(self) -> default_types_pb2.SerializedDict:
return default_types_pb2.SerializedDict(
keys=[
Literal(k).experimental_as_proto()
for k in self.mapping.keys()
],
values=[serialization.serialize(v) for v in self.mapping.values()])
def testCustomClassDeserialization(self):
original = MyCustomClass(1234, "my_name")
serialized = serialization.serialize(original)
deserialized = serialization.deserialize(serialized)
self.assertIsInstance(deserialized, MyCustomClass)
self.assertEqual(deserialized.index, original.index)
self.assertEqual(deserialized.name, original.name)
def testTupleSerialization(self):
tuple_original = default_types.Tuple(default_types.Literal(1),
default_types.Literal(2),
default_types.Literal(3))
self.assertEqual(
serialization.deserialize(serialization.serialize(tuple_original)),
tuple_original)
def testListSerialization(self):
list_original = default_types.List(default_types.Literal(1),
default_types.Literal(2),
default_types.Literal(3))
self.assertEqual(
serialization.deserialize(serialization.serialize(list_original)),
list_original)
def testWrongProto(self):
class ClassReturningWrongProto(serialization.Serializable):
@classmethod
def experimental_type_proto(cls):
return serialization.SerializedTraceType
@classmethod
def experimental_from_proto(cls, proto):
raise NotImplementedError
def experimental_as_proto(self):
return serialization_test_pb2.MyCustomRepresentation()
with self.assertRaisesRegex(
ValueError,
("ClassReturningWrongProto returned different type of proto than "
"specified by experimental_type_proto()")):
serialization.serialize(ClassReturningWrongProto())
def testLiteralSerialization(self):
literal_bool = default_types.Literal(True)
literal_int = default_types.Literal(1)
literal_float = default_types.Literal(1.2)
literal_str = default_types.Literal('a')
self.assertEqual(
serialization.deserialize(serialization.serialize(literal_bool)),
literal_bool)
self.assertEqual(
serialization.deserialize(serialization.serialize(literal_int)),
literal_int)
self.assertEqual(
serialization.deserialize(serialization.serialize(literal_float)),
literal_float)
self.assertEqual(
serialization.deserialize(serialization.serialize(literal_str)),
literal_str)
def testCompositeClassSerialization(self):
my_composite = MyCompositeClass(MyCustomClass(1, "name_1"),
MyCustomClass(2, "name_2"),
MyCustomClass(3, "name_3"))
serialized = serialization.serialize(my_composite)
self.assertTrue(
serialized.representation.Is(
serialization_test_pb2.MyCompositeRepresentation.DESCRIPTOR))
proto = serialization_test_pb2.MyCompositeRepresentation()
serialized.representation.Unpack(proto)
self.assertEqual(proto.elements[0],
serialization.serialize(MyCustomClass(1, "name_1")))
self.assertEqual(proto.elements[1],
serialization.serialize(MyCustomClass(2, "name_2")))
self.assertEqual(proto.elements[2],
serialization.serialize(MyCustomClass(3, "name_3")))
def testDictSerialization(self):
dict_original = default_types.Dict({
'a': default_types.Literal(1),
'b': default_types.Literal(2),
'c': default_types.Literal(3)
})
self.assertEqual(
serialization.deserialize(serialization.serialize(dict_original)),
dict_original)
def testCustomClassSerialization(self):
my_custom = MyCustomClass(1234, "my_name")
serialized = serialization.serialize(my_custom)
self.assertTrue(
serialized.representation.Is(
serialization_test_pb2.MyCustomRepresentation.DESCRIPTOR))
proto = serialization_test_pb2.MyCustomRepresentation()
serialized.representation.Unpack(proto)
self.assertEqual(proto.index, my_custom.index)
self.assertEqual(proto.name, my_custom.name)
def testCompositeClassDeserialization(self):
original = MyCompositeClass(MyCustomClass(1, "name_1"),
MyCustomClass(2, "name_2"),
MyCustomClass(3, "name_3"))
serialized = serialization.serialize(original)
deserialized = serialization.deserialize(serialized)
self.assertIsInstance(deserialized, MyCompositeClass)
self.assertEqual(deserialized.elements[0].index, 1)
self.assertEqual(deserialized.elements[1].index, 2)
self.assertEqual(deserialized.elements[2].index, 3)
self.assertEqual(deserialized.elements[0].name, "name_1")
self.assertEqual(deserialized.elements[1].name, "name_2")
self.assertEqual(deserialized.elements[2].name, "name_3")
def testReferencetSerialization(self):
ref_original = default_types.Reference(default_types.Literal(3), 1)
self.assertEqual(
serialization.deserialize(serialization.serialize(ref_original)),
ref_original)
def to_proto(self) -> default_types_pb2.SerializedReference:
return default_types_pb2.SerializedReference(
identifier=Literal(self.identifier).to_proto(),
base=serialization.serialize(self.base))
def to_proto(self) -> default_types_pb2.SerializedTuple:
return default_types_pb2.SerializedTuple(
components=[serialization.serialize(c) for c in self.components])
