def _compare(self, type_hint, expected_string):
"""Compare generated and expected types."""
# Generate a type string.
dbus_type = get_dbus_type(type_hint)
self.assertEqual(dbus_type, expected_string)
self.assertTrue(GLib.VariantType.string_is_valid(dbus_type))
# Create a variant type from a type hint.
variant_type = get_variant_type(type_hint)
self.assertIsInstance(variant_type, GLib.VariantType)
self.assertEqual(variant_type.dup_string(), expected_string)
expected_type = GLib.VariantType.new(expected_string)
self.assertTrue(expected_type.equal(variant_type))
# Create a variant type from a type string.
variant_type = get_variant_type(expected_string)
self.assertIsInstance(variant_type, GLib.VariantType)
self.assertTrue(expected_type.equal(variant_type))
# Test the is_tuple_of_one function.
expected_value = is_base_type(type_hint, Tuple) \
and len(get_type_arguments(type_hint)) == 1
self.assertEqual(is_tuple_of_one(type_hint), expected_value)
self.assertEqual(is_tuple_of_one(expected_string), expected_value)
self.assertTrue(is_tuple_of_one(Tuple[type_hint]))
self.assertTrue(is_tuple_of_one("({})".format(expected_string)))
def _create_field(cls, field_name, member_hint):
"""Create a representation of a DBus field.
:param field_name: a name of the field
:param member_hint: a type hint of the member
:return: a new instance of DBus field
"""
if is_base_type(member_hint, DBusData):
return DBusDataField(field_name, member_hint)
if is_base_type(member_hint, List):
(arg_hint, ) = get_type_arguments(member_hint)
if is_base_type(arg_hint, DBusData):
return DBusDataListField(field_name, arg_hint)
return DBusField(field_name, member_hint)
def test_base_class(self):
"""Test the base class checks."""
class Data(object):
pass
class DataA(Data):
pass
class DataB(Data):
pass
self.assertEqual(is_base_type(Data, Data), True)
self.assertEqual(is_base_type(DataA, Data), True)
self.assertEqual(is_base_type(DataB, Data), True)
self.assertEqual(is_base_type(Data, DataA), False)
self.assertEqual(is_base_type(Data, DataB), False)
self.assertEqual(is_base_type(DataA, DataB), False)
self.assertEqual(is_base_type(DataB, DataA), False)
self.assertEqual(is_base_type(List[Data], List), True)
self.assertEqual(is_base_type(Tuple[DataA], Tuple), True)
self.assertEqual(is_base_type(Dict[Str, DataB], Dict), True)
def _iterate_out_parameters(cls, member, signature):
"""Iterate over output parameters."""
name = DBusSpecification.RETURN_PARAMETER
direction = DBusSpecification.DIRECTION_OUT
type_hint = signature.return_annotation
# Is the return type defined?
if type_hint is signature.empty:
return
# Is the return type other than None?
if type_hint is None:
return
# Generate multiple output arguments if requested.
if getattr(member, RETURNS_MULTIPLE_ARGUMENTS_ATTRIBUTE, False):
# The return type has to be a tuple.
if not is_base_type(type_hint, Tuple):
raise DBusSpecificationError(
"Expected a tuple of multiple arguments."
)
# The return type has to contain multiple arguments.
type_args = get_type_arguments(type_hint)
if len(type_args) < 2:
raise DBusSpecificationError(
"Expected a tuple of more than one argument."
)
# Iterate over types in the tuple
for i, type_arg in enumerate(type_args):
yield "{}_{}".format(name, i), type_arg, direction
return
# Otherwise, return only one output argument.
yield name, type_hint, direction
def test_base_type(self):
"""Test the base type checks."""
self.assertEqual(is_base_type(Int, Int), True)
self.assertEqual(is_base_type(UInt16, UInt16), True)
self.assertEqual(is_base_type(Variant, Variant), True)
self.assertEqual(is_base_type(Int, Bool), False)
self.assertEqual(is_base_type(Bool, List), False)
self.assertEqual(is_base_type(UInt16, Dict), False)
self.assertEqual(is_base_type(UInt16, Int), False)
self.assertEqual(is_base_type(Variant, Tuple), False)
self.assertEqual(is_base_type(List[Int], List), True)
self.assertEqual(is_base_type(List[Bool], List), True)
self.assertEqual(is_base_type(List[Variant], List), True)
self.assertEqual(is_base_type(Tuple[Int], Tuple), True)
self.assertEqual(is_base_type(Tuple[Bool], Tuple), True)
self.assertEqual(is_base_type(Tuple[Variant], Tuple), True)
self.assertEqual(is_base_type(Dict[Str, Int], Dict), True)
self.assertEqual(is_base_type(Dict[Str, Bool], Dict), True)
self.assertEqual(is_base_type(Dict[Str, Variant], Dict), True)
self.assertEqual(is_base_type(List[Int], Tuple), False)
self.assertEqual(is_base_type(Tuple[Bool], Dict), False)
self.assertEqual(is_base_type(Dict[Str, Variant], List), False)
