src/developer/ffx/lib/fuchsia-controller/tests/encode.py - fuchsia - Git at Google

 # Copyright 2023 The Fuchsia Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.

 # Import needed for tests to work
 import typing
 import unittest  # NOQA

 import common
 from fidl_codec import decode_fidl_request, encode_fidl_message, method_ordinal


 class EncodeObj(object):
     """Just a generic object to be used for encoding tests."""


 class Encode(common.FuchsiaControllerTest):
     """Fuchsia Controller FIDL Encoding Tests"""

     def test_encode_noop_function(self) -> None:
         EXPECTED = bytearray.fromhex(
             "020000000200000139300000000000000600000000000000ffffffffffffffff666f6f6261720000"
         )
         obj = EncodeObj()
         setattr(obj, "value", "foobar")
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoStringNoopRequest",
             txid=2,
             ordinal=12345,
         )
         self.assertEqual(b, EXPECTED)
         self.assertEqual(h, [])

     def test_encode_struct_missing_field(self) -> None:
         with self.assertRaises(AttributeError):
             encode_fidl_message(
                 object=object(),
                 library="fuchsia.controller.test",
                 type_name="fuchsia.controller.test/NoopDoStringNoopRequest",
                 txid=1,
                 ordinal=12345,
             )

     def test_encode_non_nullable_value(self) -> None:
         obj = EncodeObj()
         setattr(obj, "value", None)
         with self.assertRaises(TypeError):
             encode_fidl_message(
                 object=obj,
                 library="fuchsia.controller.test",
                 type_name="fuchsia.controller.test/NoopDoIntNoopRequest",
                 txid=3,
                 ordinal=12345,
             )

     def test_encode_table_and_union(self) -> None:
         EXPECTED = bytearray.fromhex(
             "4d00000002000001b8220000000000000300000000000000ffffffffffffffff0000004000000100180000000000000018000000000000000600000000000000ffffffffffffffff666f6f6261720000030000000000000008000000000000000500000000000000"
         )
         obj = typing.cast(typing.Any, EncodeObj())
         setattr(obj, "tab", EncodeObj())
         setattr(obj.tab, "dub", 2.0)
         setattr(obj.tab, "str_", "foobar")
         setattr(obj.tab, "union_field", EncodeObj())
         setattr(obj.tab.union_field, "union_int", 5)

         # This intentionally omits the integer field rather than explicitly setting it to None.
         # This test covers that the error bit is successfully cleared when converting a table to
         # something where an attribute is missing rather than set to None. Without clearing the
         # error properly this will raise an exception. This is the same reason union_int is used
         # above. When iterating over the object, "union_str" will be checked first, which will
         # return nullptr and set a "AttributeError" exception.
         def encode_fn(x: typing.Any) -> typing.Any:
             return encode_fidl_message(
                 object=x,
                 library="fuchsia.controller.test",
                 type_name="fuchsia.controller.test/NoopDoTableNoopRequest",
                 txid=77,
                 ordinal=8888,
             )

         (b, h) = encode_fn(obj)
         self.assertEqual(b, EXPECTED)
         self.assertEqual(h, [])

         # Encode again with an explicit None to verify the behavior is the same as omitting a field
         # altogether.
         setattr(obj.tab, "integer", None)
         (b, h) = encode_fn(obj)
         self.assertEqual(b, EXPECTED)
         self.assertEqual(h, [])

     def test_encode_decode_table_and_union(self) -> None:
         obj = typing.cast(typing.Any, EncodeObj())
         setattr(obj, "tab", EncodeObj())
         setattr(obj.tab, "dub", 2.0)
         setattr(obj.tab, "str_", "foobar")
         setattr(obj.tab, "union_field", EncodeObj())
         setattr(obj.tab.union_field, "union_int", 5)
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoTableNoopRequest",
             txid=5,
             ordinal=method_ordinal(
                 protocol="fuchsia.controller.test/Noop", method="DoTableNoop"
             ),
         )

         self.assertEqual(h, [])
         msg = decode_fidl_request(bytes=b, handles=h)
         self.assertEqual(
             msg,
             {
                 "tab": {
                     "dub": 2.0,
                     "integer": None,
                     "str_": "foobar",
                     "union_field": {
                         "union_int": 5,
                     },
                 }
             },
         )

     def test_encode_handle(self) -> None:
         EXPECTED = bytearray.fromhex(
             "7b000000020000010f27000000000000ffffffff00000000"
         )
         obj = EncodeObj()
         setattr(obj, "server_end", 5)
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoHandleNoopRequest",
             txid=123,
             ordinal=9999,
         )
         self.assertEqual(b, EXPECTED)
         self.assertEqual(len(h), 1)
         self.assertEqual(h[0][1], 5)

     def test_encode_decode_handle(self) -> None:
         obj = EncodeObj()
         setattr(obj, "server_end", 10)
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoHandleNoopRequest",
             txid=22,
             ordinal=method_ordinal(
                 protocol="fuchsia.controller.test/Noop", method="DoHandleNoop"
             ),
         )
         updated_handles = [hdl[1] for hdl in h]
         msg = decode_fidl_request(bytes=b, handles=updated_handles)
         self.assertEqual(msg, {"server_end": 10})

     def test_encode_string_vector(self) -> None:
         EXPECTED = bytearray.fromhex(
             "3930000002000001b3150000000000000400000000000000ffffffffffffffff0300000000000000ffffffffffffffff0300000000000000ffffffffffffffff0300000000000000ffffffffffffffff0300000000000000ffffffffffffffff666f6f0000000000626172000000000062617a00000000007175780000000000"
         )
         obj = Encode()
         setattr(obj, "v", ["foo", "bar", "baz", "qux"])
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoVectorNoopRequest",
             txid=12345,
             ordinal=5555,
         )
         self.assertEqual(b, EXPECTED)
         self.assertEqual(h, [])

     def test_handle_overflow(self) -> None:
         obj = Encode()
         # Should be too large for a u32.
         setattr(obj, "server_end", 0xFFFFFFFFFF)
         with self.assertRaises(OverflowError):
             encode_fidl_message(
                 object=obj,
                 library="fuchsia.controller.test",
                 type_name="fuchsia.controller.test/NoopDoHandleNoopRequest",
                 txid=1234,
                 ordinal=5555,
             )

     def test_bits_overflow(self) -> None:
         obj = Encode()
         setattr(obj, "b", 0xFFFFFFFFFFFFFFFFFFFFFF)
         with self.assertRaises(OverflowError):
             encode_fidl_message(
                 object=obj,
                 library="fuchsia.controller.test",
                 type_name="fuchsia.controller.test/NoopDoBitsNoopRequest",
                 txid=2222,
                 ordinal=3333,
             )

     def test_encode_method_call_no_args(self) -> None:
         (b, h) = encode_fidl_message(
             object=None, library=None, type_name=None, txid=123, ordinal=345
         )

     def test_encode_decode_string_vector(self) -> None:
         obj = Encode()
         setattr(obj, "v", ["foo", "bar", "baz", "qux"])
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoVectorNoopRequest",
             txid=12345,
             ordinal=method_ordinal(
                 protocol="fuchsia.controller.test/Noop", method="DoVectorNoop"
             ),
         )
         msg = decode_fidl_request(bytes=b, handles=h)
         self.assertEqual(msg, {"v": ["foo", "bar", "baz", "qux"]})

     def test_encode_decode_string_vector_with_sequence(self) -> None:
         """
         We accept not just lists, but also more generally sequences as input
         for FIDL arrays and vectors. Strings themselves, in Python, are also
         sequences of bytes. The docs say that since there is no separate
         "character" class, strings of length 1 are used to represent
         characters. Therefore, the expected outcome should be that we accept
         a string for a vector, and chunk it into its individual characters
         in FIDL.
         Ref: https://docs.python.org/3/library/stdtypes.html#textseq
         """
         obj = Encode()
         setattr(obj, "v", "sequence")
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoVectorNoopRequest",
             txid=12345,
             ordinal=method_ordinal(
                 protocol="fuchsia.controller.test/Noop", method="DoVectorNoop"
             ),
         )
         msg = decode_fidl_request(bytes=b, handles=h)
         self.assertEqual(msg, {"v": ["s", "e", "q", "u", "e", "n", "c", "e"]})

     def test_encode_decode_int_array_with_list(self) -> None:
         obj = Encode()
         setattr(obj, "a", [1, 2, 3, 4])
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoArrayNoopRequest",
             txid=12345,
             ordinal=method_ordinal(
                 protocol="fuchsia.controller.test/Noop", method="DoArrayNoop"
             ),
         )
         msg = decode_fidl_request(bytes=b, handles=h)
         self.assertEqual(msg, {"a": [1, 2, 3, 4]})

     def test_encode_decode_int_array_with_sequence(self) -> None:
         """
         We accept not just lists, but also more generally sequences as input
         for FIDL arrays and vectors. The `bytes` type is a common example of
         a sequence that is _not_ a list, so use it in the test here.
         """
         obj = Encode()
         setattr(obj, "a", bytes([1, 2, 3, 4]))
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoArrayNoopRequest",
             txid=12345,
             ordinal=method_ordinal(
                 protocol="fuchsia.controller.test/Noop", method="DoArrayNoop"
             ),
         )
         msg = decode_fidl_request(bytes=b, handles=h)
         self.assertEqual(msg, {"a": [1, 2, 3, 4]})

     def test_encode_decode_string(self) -> None:
         obj = EncodeObj()
         setattr(obj, "value", "foobar")
         ordinal = method_ordinal(
             protocol="fuchsia.controller.test/Noop", method="DoStringNoop"
         )
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoStringNoopRequest",
             txid=3,
             ordinal=ordinal,
         )
         msg = decode_fidl_request(bytes=b, handles=h)
         self.assertEqual(msg, {"value": "foobar"})

     def test_encode_decode_int(self) -> None:
         obj = EncodeObj()
         setattr(obj, "value", 2)
         ordinal = method_ordinal(
             protocol="fuchsia.controller.test/Noop", method="DoIntNoop"
         )
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.test",
             type_name="fuchsia.controller.test/NoopDoIntNoopRequest",
             txid=3,
             ordinal=ordinal,
         )
         msg = decode_fidl_request(bytes=b, handles=h)
         self.assertEqual(msg, {"value": 2})

     def test_encode_decode_negative_enum(self) -> None:
         obj = EncodeObj()
         # This is a sepcial case because there is also a positive 2 represented in this enum.
         # without a negative value check in the encoder path, this test will fail.
         setattr(obj, "enum_thing", -2)
         ordinal = method_ordinal(
             protocol="fuchsia.controller.othertest/CrossLibraryNoop",
             method="EnumMethod",
         )
         (b, h) = encode_fidl_message(
             object=obj,
             library="fuchsia.controller.othertest",
             type_name="fuchsia.controller.othertest/CrossLibraryNoopEnumMethodRequest",
             txid=5,
             ordinal=ordinal,
         )
         msg = decode_fidl_request(bytes=b, handles=h)
         self.assertEqual(msg, {"enum_thing": -2})
	# Copyright 2023 The Fuchsia Authors. All rights reserved.
	# Use of this source code is governed by a BSD-style license that can be
	# found in the LICENSE file.

	# Import needed for tests to work
	import typing
	import unittest # NOQA

	import common
	from fidl_codec import decode_fidl_request, encode_fidl_message, method_ordinal


	class EncodeObj(object):
	"""Just a generic object to be used for encoding tests."""


	class Encode(common.FuchsiaControllerTest):
	"""Fuchsia Controller FIDL Encoding Tests"""

	def test_encode_noop_function(self) -> None:
	EXPECTED = bytearray.fromhex(
	"020000000200000139300000000000000600000000000000ffffffffffffffff666f6f6261720000"
	)
	obj = EncodeObj()
	setattr(obj, "value", "foobar")
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoStringNoopRequest",
	txid=2,
	ordinal=12345,
	)
	self.assertEqual(b, EXPECTED)
	self.assertEqual(h, [])

	def test_encode_struct_missing_field(self) -> None:
	with self.assertRaises(AttributeError):
	encode_fidl_message(
	object=object(),
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoStringNoopRequest",
	txid=1,
	ordinal=12345,
	)

	def test_encode_non_nullable_value(self) -> None:
	obj = EncodeObj()
	setattr(obj, "value", None)
	with self.assertRaises(TypeError):
	encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoIntNoopRequest",
	txid=3,
	ordinal=12345,
	)

	def test_encode_table_and_union(self) -> None:
	EXPECTED = bytearray.fromhex(
	"4d00000002000001b8220000000000000300000000000000ffffffffffffffff0000004000000100180000000000000018000000000000000600000000000000ffffffffffffffff666f6f6261720000030000000000000008000000000000000500000000000000"
	)
	obj = typing.cast(typing.Any, EncodeObj())
	setattr(obj, "tab", EncodeObj())
	setattr(obj.tab, "dub", 2.0)
	setattr(obj.tab, "str_", "foobar")
	setattr(obj.tab, "union_field", EncodeObj())
	setattr(obj.tab.union_field, "union_int", 5)

	# This intentionally omits the integer field rather than explicitly setting it to None.
	# This test covers that the error bit is successfully cleared when converting a table to
	# something where an attribute is missing rather than set to None. Without clearing the
	# error properly this will raise an exception. This is the same reason union_int is used
	# above. When iterating over the object, "union_str" will be checked first, which will
	# return nullptr and set a "AttributeError" exception.
	def encode_fn(x: typing.Any) -> typing.Any:
	return encode_fidl_message(
	object=x,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoTableNoopRequest",
	txid=77,
	ordinal=8888,
	)

	(b, h) = encode_fn(obj)
	self.assertEqual(b, EXPECTED)
	self.assertEqual(h, [])

	# Encode again with an explicit None to verify the behavior is the same as omitting a field
	# altogether.
	setattr(obj.tab, "integer", None)
	(b, h) = encode_fn(obj)
	self.assertEqual(b, EXPECTED)
	self.assertEqual(h, [])

	def test_encode_decode_table_and_union(self) -> None:
	obj = typing.cast(typing.Any, EncodeObj())
	setattr(obj, "tab", EncodeObj())
	setattr(obj.tab, "dub", 2.0)
	setattr(obj.tab, "str_", "foobar")
	setattr(obj.tab, "union_field", EncodeObj())
	setattr(obj.tab.union_field, "union_int", 5)
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoTableNoopRequest",
	txid=5,
	ordinal=method_ordinal(
	protocol="fuchsia.controller.test/Noop", method="DoTableNoop"
	),
	)

	self.assertEqual(h, [])
	msg = decode_fidl_request(bytes=b, handles=h)
	self.assertEqual(
	msg,
	{
	"tab": {
	"dub": 2.0,
	"integer": None,
	"str_": "foobar",
	"union_field": {
	"union_int": 5,
	},
	}
	},
	)

	def test_encode_handle(self) -> None:
	EXPECTED = bytearray.fromhex(
	"7b000000020000010f27000000000000ffffffff00000000"
	)
	obj = EncodeObj()
	setattr(obj, "server_end", 5)
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoHandleNoopRequest",
	txid=123,
	ordinal=9999,
	)
	self.assertEqual(b, EXPECTED)
	self.assertEqual(len(h), 1)
	self.assertEqual(h[0][1], 5)

	def test_encode_decode_handle(self) -> None:
	obj = EncodeObj()
	setattr(obj, "server_end", 10)
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoHandleNoopRequest",
	txid=22,
	ordinal=method_ordinal(
	protocol="fuchsia.controller.test/Noop", method="DoHandleNoop"
	),
	)
	updated_handles = [hdl[1] for hdl in h]
	msg = decode_fidl_request(bytes=b, handles=updated_handles)
	self.assertEqual(msg, {"server_end": 10})

	def test_encode_string_vector(self) -> None:
	EXPECTED = bytearray.fromhex(
	"3930000002000001b3150000000000000400000000000000ffffffffffffffff0300000000000000ffffffffffffffff0300000000000000ffffffffffffffff0300000000000000ffffffffffffffff0300000000000000ffffffffffffffff666f6f0000000000626172000000000062617a00000000007175780000000000"
	)
	obj = Encode()
	setattr(obj, "v", ["foo", "bar", "baz", "qux"])
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoVectorNoopRequest",
	txid=12345,
	ordinal=5555,
	)
	self.assertEqual(b, EXPECTED)
	self.assertEqual(h, [])

	def test_handle_overflow(self) -> None:
	obj = Encode()
	# Should be too large for a u32.
	setattr(obj, "server_end", 0xFFFFFFFFFF)
	with self.assertRaises(OverflowError):
	encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoHandleNoopRequest",
	txid=1234,
	ordinal=5555,
	)

	def test_bits_overflow(self) -> None:
	obj = Encode()
	setattr(obj, "b", 0xFFFFFFFFFFFFFFFFFFFFFF)
	with self.assertRaises(OverflowError):
	encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoBitsNoopRequest",
	txid=2222,
	ordinal=3333,
	)

	def test_encode_method_call_no_args(self) -> None:
	(b, h) = encode_fidl_message(
	object=None, library=None, type_name=None, txid=123, ordinal=345
	)

	def test_encode_decode_string_vector(self) -> None:
	obj = Encode()
	setattr(obj, "v", ["foo", "bar", "baz", "qux"])
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoVectorNoopRequest",
	txid=12345,
	ordinal=method_ordinal(
	protocol="fuchsia.controller.test/Noop", method="DoVectorNoop"
	),
	)
	msg = decode_fidl_request(bytes=b, handles=h)
	self.assertEqual(msg, {"v": ["foo", "bar", "baz", "qux"]})

	def test_encode_decode_string_vector_with_sequence(self) -> None:
	"""
	We accept not just lists, but also more generally sequences as input
	for FIDL arrays and vectors. Strings themselves, in Python, are also
	sequences of bytes. The docs say that since there is no separate
	"character" class, strings of length 1 are used to represent
	characters. Therefore, the expected outcome should be that we accept
	a string for a vector, and chunk it into its individual characters
	in FIDL.
	Ref: https://docs.python.org/3/library/stdtypes.html#textseq
	"""
	obj = Encode()
	setattr(obj, "v", "sequence")
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoVectorNoopRequest",
	txid=12345,
	ordinal=method_ordinal(
	protocol="fuchsia.controller.test/Noop", method="DoVectorNoop"
	),
	)
	msg = decode_fidl_request(bytes=b, handles=h)
	self.assertEqual(msg, {"v": ["s", "e", "q", "u", "e", "n", "c", "e"]})

	def test_encode_decode_int_array_with_list(self) -> None:
	obj = Encode()
	setattr(obj, "a", [1, 2, 3, 4])
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoArrayNoopRequest",
	txid=12345,
	ordinal=method_ordinal(
	protocol="fuchsia.controller.test/Noop", method="DoArrayNoop"
	),
	)
	msg = decode_fidl_request(bytes=b, handles=h)
	self.assertEqual(msg, {"a": [1, 2, 3, 4]})

	def test_encode_decode_int_array_with_sequence(self) -> None:
	"""
	We accept not just lists, but also more generally sequences as input
	for FIDL arrays and vectors. The `bytes` type is a common example of
	a sequence that is _not_ a list, so use it in the test here.
	"""
	obj = Encode()
	setattr(obj, "a", bytes([1, 2, 3, 4]))
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoArrayNoopRequest",
	txid=12345,
	ordinal=method_ordinal(
	protocol="fuchsia.controller.test/Noop", method="DoArrayNoop"
	),
	)
	msg = decode_fidl_request(bytes=b, handles=h)
	self.assertEqual(msg, {"a": [1, 2, 3, 4]})

	def test_encode_decode_string(self) -> None:
	obj = EncodeObj()
	setattr(obj, "value", "foobar")
	ordinal = method_ordinal(
	protocol="fuchsia.controller.test/Noop", method="DoStringNoop"
	)
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoStringNoopRequest",
	txid=3,
	ordinal=ordinal,
	)
	msg = decode_fidl_request(bytes=b, handles=h)
	self.assertEqual(msg, {"value": "foobar"})

	def test_encode_decode_int(self) -> None:
	obj = EncodeObj()
	setattr(obj, "value", 2)
	ordinal = method_ordinal(
	protocol="fuchsia.controller.test/Noop", method="DoIntNoop"
	)
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.test",
	type_name="fuchsia.controller.test/NoopDoIntNoopRequest",
	txid=3,
	ordinal=ordinal,
	)
	msg = decode_fidl_request(bytes=b, handles=h)
	self.assertEqual(msg, {"value": 2})

	def test_encode_decode_negative_enum(self) -> None:
	obj = EncodeObj()
	# This is a sepcial case because there is also a positive 2 represented in this enum.
	# without a negative value check in the encoder path, this test will fail.
	setattr(obj, "enum_thing", -2)
	ordinal = method_ordinal(
	protocol="fuchsia.controller.othertest/CrossLibraryNoop",
	method="EnumMethod",
	)
	(b, h) = encode_fidl_message(
	object=obj,
	library="fuchsia.controller.othertest",
	type_name="fuchsia.controller.othertest/CrossLibraryNoopEnumMethodRequest",
	txid=5,
	ordinal=ordinal,
	)
	msg = decode_fidl_request(bytes=b, handles=h)
	self.assertEqual(msg, {"enum_thing": -2})