def test_enum(self):
t = enum_type(
"color",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
)
self.assertPrettyPrint(
t,
"""\
enum color {
RED = 0,
GREEN = 1,
BLUE = 2,
}""",
)
t = enum_type(
"color",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
Qualifiers.CONST,
)
self.assertPrettyPrint(
t,
"""\
const enum color {
RED = 0,
GREEN = 1,
BLUE = 2,
}""",
)
t = enum_type(
None,
int_type("int", 4, True),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", -1),
TypeEnumerator("BLUE", -2),
),
)
self.assertPrettyPrint(
t,
"""\
enum {
RED = 0,
GREEN = -1,
BLUE = -2,
}""",
)
def test_init(self):
e = TypeEnumerator("a", 1)
self.assertEqual(e.name, "a")
self.assertEqual(e.value, 1)
self.assertRaises(TypeError, TypeEnumerator, "a", None)
self.assertRaises(TypeError, TypeEnumerator, None, 1)
def setUp(self):
super().setUp()
self.types = []
self.objects = []
self.prog = mock_program(types=self.types, objects=self.objects)
self.coord_type = self.prog.class_type(
"coord",
12,
(
TypeMember(self.prog.int_type("int", 4, True), "x", 0),
TypeMember(self.prog.int_type("int", 4, True), "y", 32),
TypeMember(self.prog.int_type("int", 4, True), "z", 64),
),
)
self.point_type = self.prog.struct_type(
"point",
8,
(
TypeMember(self.prog.int_type("int", 4, True), "x", 0),
TypeMember(self.prog.int_type("int", 4, True), "y", 32),
),
)
self.line_segment_type = self.prog.struct_type(
"line_segment",
16,
(TypeMember(self.point_type,
"a"), TypeMember(self.point_type, "b", 64)),
)
self.option_type = self.prog.union_type(
"option",
4,
(
TypeMember(self.prog.int_type("int", 4, True), "i"),
TypeMember(self.prog.float_type("float", 4), "f"),
),
)
self.color_type = self.prog.enum_type(
"color",
self.prog.int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
)
self.pid_type = self.prog.typedef_type(
"pid_t", self.prog.int_type("int", 4, True))
def test_enum_anonymous(self):
self.assertPrettyPrint(
self.prog.enum_type(
None,
self.prog.int_type("int", 4, True),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", -1),
TypeEnumerator("BLUE", -2),
),
),
"""\
enum {
RED = 0,
GREEN = -1,
BLUE = -2,
}""",
)
def test_decode_enum_type_flags(self):
prog = Program(MOCK_PLATFORM)
for bit_numbers, flags in (
(True, self.FLAGS_BIT_NUMBERS),
(False, self.FLAGS_VALUES),
):
with self.subTest(bit_numbers=bit_numbers):
type = prog.enum_type(
None,
prog.int_type("int", 4, True),
[TypeEnumerator(*flag) for flag in flags],
)
self.assertEqual(
decode_enum_type_flags(4, type, bit_numbers), "UNDERLINE"
)
self.assertEqual(
decode_enum_type_flags(27, type, bit_numbers), "BOLD|ITALIC|0x18"
)
def test_enum(self):
t = self.prog.enum_type(
"color",
self.prog.int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
)
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.language, DEFAULT_LANGUAGE)
self.assertEqual(t.tag, "color")
self.assertIdentical(t.type,
self.prog.int_type("unsigned int", 4, False))
self.assertEqual(
t.enumerators,
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
)
self.assertTrue(t.is_complete())
self.assertEqual(
repr(t),
"prog.enum_type(tag='color', type=prog.int_type(name='unsigned int', size=4, is_signed=False), enumerators=(TypeEnumerator('RED', 0), TypeEnumerator('GREEN', 1), TypeEnumerator('BLUE', 2)))",
)
self.assertEqual(sizeof(t), 4)
t = self.prog.enum_type("color", None, None)
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.tag, "color")
self.assertIsNone(t.type)
self.assertIsNone(t.enumerators)
self.assertFalse(t.is_complete())
self.assertEqual(
repr(t),
"prog.enum_type(tag='color', type=None, enumerators=None)")
# A type with no enumerators isn't valid in C, but we allow it.
t = self.prog.enum_type("color",
self.prog.int_type("unsigned int", 4, False),
())
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.tag, "color")
self.assertIdentical(t.type,
self.prog.int_type("unsigned int", 4, False))
self.assertEqual(t.enumerators, ())
self.assertTrue(t.is_complete())
self.assertEqual(
repr(t),
"prog.enum_type(tag='color', type=prog.int_type(name='unsigned int', size=4, is_signed=False), enumerators=())",
)
self.assertRaisesRegex(TypeError, "must be Type", self.prog.enum_type,
"color", 4, ())
self.assertRaisesRegex(
ValueError,
"must be integer type",
self.prog.enum_type,
"color",
self.prog.void_type(),
(),
)
self.assertRaisesRegex(
ValueError,
"must be unqualified",
self.prog.enum_type,
"color",
self.prog.int_type("unsigned int",
4,
True,
qualifiers=Qualifiers.CONST),
(),
)
self.assertRaisesRegex(
ValueError,
"must not have compatible type",
self.prog.enum_type,
"color",
self.prog.int_type("unsigned int", 4, False),
None,
)
self.assertRaisesRegex(
ValueError,
"must have compatible type",
self.prog.enum_type,
"color",
None,
(),
)
self.assertRaisesRegex(
TypeError,
"must be sequence or None",
self.prog.enum_type,
"color",
self.prog.int_type("unsigned int", 4, False),
4,
)
self.assertRaisesRegex(
TypeError,
"must be TypeEnumerator",
self.prog.enum_type,
"color",
self.prog.int_type("unsigned int", 4, False),
(4, ),
)
def test_cmp(self):
self.assertEqual(TypeEnumerator("a", 1),
TypeEnumerator(name="a", value=1))
self.assertNotEqual(TypeEnumerator("a", 1), TypeEnumerator("a", 2))
self.assertNotEqual(TypeEnumerator("b", 1), TypeEnumerator("a", 1))
def test_sequence(self):
e = TypeEnumerator("a", 1)
name, value = e
self.assertEqual(name, "a")
self.assertEqual(value, 1)
self.assertEqual(list(e), ["a", 1])
def test_repr(self):
e = TypeEnumerator("a", 1)
self.assertEqual(repr(e), "TypeEnumerator('a', 1)")
)
line_segment_type = struct_type(
"line_segment", 16,
(TypeMember(point_type, "a"), TypeMember(point_type, "b", 64)))
option_type = union_type(
"option",
4,
(
TypeMember(int_type("int", 4, True), "i"),
TypeMember(float_type("float", 4), "f"),
),
)
color_type = enum_type(
"color",
int_type("unsigned int", 4, False),
(TypeEnumerator("RED", 0), TypeEnumerator("GREEN",
1), TypeEnumerator("BLUE", 2)),
)
pid_type = typedef_type("pid_t", int_type("int", 4, True))
MOCK_32BIT_PLATFORM = Platform(Architecture.UNKNOWN,
PlatformFlags.IS_LITTLE_ENDIAN)
MOCK_PLATFORM = Platform(
Architecture.UNKNOWN,
PlatformFlags.IS_64_BIT | PlatformFlags.IS_LITTLE_ENDIAN)
class MockMemorySegment(NamedTuple):
buf: bytes
virt_addr: Optional[int] = None
phys_addr: Optional[int] = None
def test_enum(self):
t = enum_type(
"color",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
)
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.language, DEFAULT_LANGUAGE)
self.assertEqual(t.tag, "color")
self.assertEqual(t.type, int_type("unsigned int", 4, False))
self.assertEqual(
t.enumerators,
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
)
self.assertTrue(t.is_complete())
self.assertEqual(
t,
enum_type(
"color",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
),
)
# Different tag.
self.assertNotEqual(
t,
enum_type(
"COLOR",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
),
)
# One is anonymous.
self.assertNotEqual(
t,
enum_type(
None,
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
),
)
# Different compatible type.
self.assertNotEqual(
t,
enum_type(
"color",
int_type("int", 4, True),
(
TypeEnumerator("RED", 0),
TypeEnumerator("GREEN", 1),
TypeEnumerator("BLUE", 2),
),
),
)
# Different enumerators.
self.assertNotEqual(
t,
enum_type(
"color",
int_type("unsigned int", 4, False),
(
TypeEnumerator("RED", 0),
TypeEnumerator("YELLOW", 1),
TypeEnumerator("BLUE", 2),
),
),
)
# Different number of enumerators.
self.assertNotEqual(
t,
enum_type(
"color",
int_type("unsigned int", 4, False),
(TypeEnumerator("RED", 0), TypeEnumerator("GREEN", 1)),
),
)
# One is incomplete.
self.assertNotEqual(t, enum_type("color"))
self.assertEqual(
repr(t),
"enum_type(tag='color', type=int_type(name='unsigned int', size=4, is_signed=False), enumerators=(TypeEnumerator('RED', 0), TypeEnumerator('GREEN', 1), TypeEnumerator('BLUE', 2)))",
)
self.assertEqual(sizeof(t), 4)
t = enum_type("color", None, None)
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.tag, "color")
self.assertIsNone(t.type)
self.assertIsNone(t.enumerators)
self.assertFalse(t.is_complete())
self.assertEqual(
repr(t), "enum_type(tag='color', type=None, enumerators=None)")
# A type with no enumerators isn't valid in C, but we allow it.
t = enum_type("color", int_type("unsigned int", 4, False), ())
self.assertEqual(t.kind, TypeKind.ENUM)
self.assertIsNone(t.primitive)
self.assertEqual(t.tag, "color")
self.assertEqual(t.type, int_type("unsigned int", 4, False))
self.assertEqual(t.enumerators, ())
self.assertTrue(t.is_complete())
self.assertEqual(
repr(t),
"enum_type(tag='color', type=int_type(name='unsigned int', size=4, is_signed=False), enumerators=())",
)
self.assertRaisesRegex(TypeError, "must be Type", enum_type, "color",
4, ())
self.assertRaisesRegex(ValueError, "must be integer type", enum_type,
"color", void_type(), ())
self.assertRaisesRegex(
ValueError,
"must be unqualified",
enum_type,
"color",
int_type("unsigned int", 4, True, Qualifiers.CONST),
(),
)
self.assertRaisesRegex(
ValueError,
"must not have compatible type",
enum_type,
"color",
int_type("unsigned int", 4, False),
None,
)
self.assertRaisesRegex(ValueError, "must have compatible type",
enum_type, "color", None, ())
self.assertRaisesRegex(
TypeError,
"must be sequence or None",
enum_type,
"color",
int_type("unsigned int", 4, False),
4,
)
self.assertRaisesRegex(
TypeError,
"must be TypeEnumerator",
enum_type,
"color",
int_type("unsigned int", 4, False),
(4, ),
)
