def testNullableNullObjectInUnionSerialization(self):
u = test_unions_mojom.ObjectUnion(f_nullable=None)
(data, handles) = u.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.ObjectUnion.Deserialize(context)
self.assertEquals(u, decoded)
def testNonNullableEmptyMapSerialization(self):
struct = sample_service_mojom.NonNullableMapStruct(map_field={})
(data, handles) = struct.Serialize()
context = serialization.RootDeserializationContext(data, handles)
struct2 = sample_service_mojom.NonNullableMapStruct.Deserialize(
context)
self.assertEquals(struct, struct2)
def testUnionUnknownTag(self):
u = test_unions_mojom.NewUnion(f_int16=10)
(data, handles) = u.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.OldUnion.Deserialize(context)
self.assertTrue(decoded.IsUnknown())
def testArrayInUnionSerialization(self):
u = test_unions_mojom.ObjectUnion(f_array_int8=[1, 2, 3, 4, 5])
(data, handles) = u.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.ObjectUnion.Deserialize(context)
self.assertEquals(u, decoded)
def _RunMessageOrClosePipe(manager, message):
payload = message.payload
query = (interface_control_messages_mojom.RunOrClosePipeMessageParams.
Deserialize(
serialization.RootDeserializationContext(
payload.data, payload.handles)))
return query.require_version.version <= manager.interface_manager.version
def doBoolInUnionSerializationTest(self, bool_value):
u = test_unions_mojom.PodUnion(f_bool=bool_value)
data, handles = u.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.PodUnion.Deserialize(context)
self.assertEquals(u, decoded)
def testPodUnionSerialization(self):
u = test_unions_mojom.PodUnion(f_uint32=32)
(data, handles) = u.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.PodUnion.Deserialize(context)
self.assertFalse(decoded.IsUnknown())
self.assertEquals(u, decoded)
def testObjectInUnionSerialization(self):
u = test_unions_mojom.ObjectUnion(
f_dummy=test_unions_mojom.DummyStruct())
u.f_dummy.f_int8 = 8
(data, handles) = u.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.ObjectUnion.Deserialize(context)
self.assertEquals(u, decoded)
def testNestedUnionSerialization(self):
u = test_unions_mojom.ObjectUnion(
f_pod_union=test_unions_mojom.PodUnion(f_int32=32))
(data, handles) = u.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.ObjectUnion.Deserialize(context)
self.assertEquals(u, decoded)
def testObjectInUnionInObjectSerialization(self):
s = test_unions_mojom.SmallObjStruct()
s.obj_union = test_unions_mojom.ObjectUnion(
f_dummy=test_unions_mojom.DummyStruct())
s.obj_union.f_dummy.f_int8 = 25
(data, handles) = s.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.SmallObjStruct.Deserialize(context)
self.assertEquals(s, decoded)
def testMapInUnionSerialization(self):
u = test_unions_mojom.ObjectUnion(f_map_int8={
'one': 1,
'two': 2,
'three': 3
})
(data, handles) = u.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.ObjectUnion.Deserialize(context)
self.assertEquals(u, decoded)
def DeserializeFidlFileGraph(serialized_bytes):
"""Deserializes a mojom_files.FidlFileGraph.
Args:
serialized_bytes: {str} The serialized mojom_files.FidlFileGraph returned
by mojom parser
Returns:
{mojom_files.FidlFileGraph} The deserialized FidlFileGraph.
"""
data = bytearray(serialized_bytes)
context = serialization.RootDeserializationContext(data, [])
return fidl_files_fidl.FidlFileGraph.Deserialize(context)
def testUnionInMap(self):
s = test_unions_mojom.SmallStruct()
s.pod_union_map = {
'f_uint32': test_unions_mojom.PodUnion(f_uint32=32),
'f_uint16': test_unions_mojom.PodUnion(f_uint16=16),
'f_uint64': test_unions_mojom.PodUnion(f_uint64=64),
}
(data, handles) = s.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.SmallStruct.Deserialize(context)
self.assertEquals(s, decoded)
def ReadMojomFileGraphFromFile(fp):
"""Reads a mojom_files_mojom.MojomFileGraph from a file.
Args:
fp: A file pointer from which a serialized mojom_fileS_mojom.MojomFileGraph
can be read.
Returns:
The mojom_files_mojom.MojomFileGraph that was deserialized from the file.
"""
data = bytearray(fp.read())
context = serialization.RootDeserializationContext(data, [])
return mojom_files_mojom.MojomFileGraph.Deserialize(context)
def testNullableNullUnionInArray(self):
s = test_unions_mojom.SmallStruct()
s.nullable_pod_union_array = [
test_unions_mojom.PodUnion(f_uint32=32),
None,
test_unions_mojom.PodUnion(f_uint64=64),
]
(data, handles) = s.Serialize()
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.SmallStruct.Deserialize(context)
self.assertEquals(s, decoded)
def testUnionInObject(self):
s = test_unions_mojom.SmallStruct()
s.pod_union = test_unions_mojom.PodUnion(f_uint32=32)
(data, handles) = s.Serialize()
# This is where the data should be serialized to.
size, tag, value = struct.unpack_from('<IIQ', buffer(data), 16)
self.assertEquals(16, size)
self.assertEquals(6, tag)
self.assertEquals(32, value)
context = serialization.RootDeserializationContext(data, handles)
decoded = test_unions_mojom.SmallStruct.Deserialize(context)
self.assertEquals(s, decoded)
def testDefaultsTestSerializationDeserialization(self):
v1 = sample_service_mojom.DefaultsTest()
v1.a18 = []
v1.a19 = ""
v1.a21 = sample_import_mojom.Point()
v1.a22.location = sample_import_mojom.Point()
v1.a22.size = sample_import2_mojom.Size()
(data, handles) = v1.Serialize()
context = serialization.RootDeserializationContext(data, handles)
v2 = sample_service_mojom.DefaultsTest.Deserialize(context)
# NaN needs to be a special case.
self.assertNotEquals(v1, v2)
self.assertTrue(math.isnan(v2.a28))
self.assertTrue(math.isnan(v2.a31))
v1.a28 = v2.a28 = v1.a31 = v2.a31 = 0
self.assertEquals(v1, v2)
def Accept(self, message, responder=None):
try:
header = message.header
assert header.expects_response == bool(responder)
if header.message_type == interface_control_messages_mojom.RUN_MESSAGE_ID:
return _RunMessage(self.impl.manager, message, responder)
if (header.message_type == interface_control_messages_mojom.
RUN_OR_CLOSE_PIPE_MESSAGE_ID):
return _RunMessageOrClosePipe(self.impl.manager, message)
assert header.message_type in methods_by_ordinal
method = methods_by_ordinal[header.message_type]
payload = message.payload
parameters = method.parameters_struct.Deserialize(
serialization.RootDeserializationContext(
payload.data, payload.handles)).AsDict()
response = getattr(self.impl, method.name)(**parameters)
if header.expects_response:
@promise. async
def SendResponse(response):
if isinstance(response, dict):
response_message = _GetMessage(
method, messaging.MESSAGE_IS_RESPONSE_FLAG,
header.request_id, **response)
else:
response_message = _GetMessage(
method, messaging.MESSAGE_IS_RESPONSE_FLAG,
header.request_id, response)
return responder.Accept(response_message)
p = SendResponse(response)
if self.impl.manager:
# Close the connection in case of error.
p.Catch(lambda _: self.impl.manager.Close())
return True
# pylint: disable=W0702
except:
# Close the connection in case of error.
logging.warning(
'Error occured in accept method. Connection will be closed.')
logging.debug("Exception", exc_info=True)
if self.impl.manager:
self.impl.manager.Close()
return False
def Accept(message):
try:
assert message.header.message_type == method.ordinal
payload = message.payload
response = method.response_struct.Deserialize(
serialization.RootDeserializationContext(
payload.data, payload.handles))
as_dict = response.AsDict()
if len(as_dict) == 1:
value = as_dict.values()[0]
if not isinstance(value, dict):
response = value
resolve(response)
return True
except Exception as e:
# Adding traceback similarly to python 3.0 (pep-3134)
e.__traceback__ = sys.exc_info()[2]
reject(e)
return False
finally:
self._error_handler.RemoveCallback(reject)
def Accept(self, message, responder=None):
try:
header = message.header
assert header.expects_response == bool(responder)
assert header.message_type in methods_by_ordinal
method = methods_by_ordinal[header.message_type]
payload = message.payload
parameters = method.parameters_struct.Deserialize(
serialization.RootDeserializationContext(
payload.data, payload.handles)).AsDict()
response = getattr(self.impl, method.name)(**parameters)
if header.expects_response:
def SendResponse(response):
if isinstance(response, dict):
response_message = _GetMessage(
method, messaging.MESSAGE_IS_RESPONSE_FLAG,
**response)
else:
response_message = _GetMessage(
method, messaging.MESSAGE_IS_RESPONSE_FLAG,
response)
response_message.header.request_id = header.request_id
responder.Accept(response_message)
p = promise.Promise.Resolve(response).Then(SendResponse)
if self.impl.manager:
# Close the connection in case of error.
p.Catch(lambda _: self.impl.manager.Close())
return True
# pylint: disable=W0702
except:
# Close the connection in case of error.
logging.warning(
'Error occured in accept method. Connection will be closed.')
if self.impl.manager:
self.impl.manager.Close()
return False
def testFooSerializationDeserialization(self):
foo1 = _NewFoo()
(data, handles) = foo1.Serialize()
context = serialization.RootDeserializationContext(data, handles)
foo2 = sample_service_mojom.Foo.Deserialize(context)
self.assertEquals(foo1, foo2)
def testFooDeserialization(self):
(data, handles) = _NewFoo().Serialize()
context = serialization.RootDeserializationContext(data, handles)
self.assertTrue(sample_service_mojom.Foo.Deserialize(context))
def SerializeAndDeserialize(self, target_class, input_instance):
(data, handles) = input_instance.Serialize()
context = serialization.RootDeserializationContext(data, handles)
return target_class.Deserialize(context)
