# Copyright (c) Meta Platforms, Inc. and affiliates. # SPDX-License-Identifier: LGPL-2.1-or-later import math import operator import struct from drgn import ( AbsenceReason, FaultError, NoDefaultProgramError, Object, ObjectAbsentError, OutOfBoundsError, Qualifiers, TypeMember, cast, reinterpret, sizeof, ) from tests import ( MockMemorySegment, MockObject, MockProgramTestCase, assertReprPrettyEqualsStr, mock_program, with_default_prog, ) class TestInit(MockProgramTestCase): def test_type_stays_alive(self): obj = Object(self.prog, self.prog.int_type("int", 4, True), value=0) self.assertIdentical(obj.type_, self.prog.int_type("int", 4, True)) type_ = obj.type_ del obj self.assertIdentical(type_, self.prog.int_type("int", 4, True)) def test_type(self): self.assertRaisesRegex( TypeError, "type must be Type, str, or None", Object, self.prog, 1, value=0 ) self.assertRaisesRegex( ValueError, "reference must have type", Object, self.prog, address=0 ) self.assertRaisesRegex( ValueError, "absent object must have type", Object, self.prog ) def test_address_value_absence_reason_nand(self): self.assertRaisesRegex( ValueError, "object cannot have address and value", Object, self.prog, "int", 0, address=0, ) self.assertRaisesRegex( ValueError, "object cannot have address and value", Object, self.prog, "int", value=0, address=0, ) self.assertRaisesRegex( ValueError, "object cannot have address and absence reason", Object, self.prog, "int", address=0, absence_reason=AbsenceReason.OTHER, ) self.assertRaisesRegex( ValueError, "object cannot have value and absence reason", Object, self.prog, "int", value=0, absence_reason=AbsenceReason.OTHER, ) self.assertRaisesRegex( ValueError, "object cannot have address, value, and absence reason", Object, self.prog, "int", value=0, address=0, absence_reason=AbsenceReason.OTHER, ) def test_integer_address(self): self.assertRaises(TypeError, Object, self.prog, "int", address="NULL") def test_bit_field_size(self): self.assertRaises( TypeError, Object, self.prog, "int", address=0, bit_field_size="1" ) self.assertRaisesRegex( ValueError, "bit field size cannot be zero", Object, self.prog, "int", address=0, bit_field_size=0, ) def test_bit_offset(self): self.assertRaisesRegex( ValueError, "value cannot have bit offset", Object, self.prog, "int", value=0, bit_offset=4, ) self.assertRaisesRegex( ValueError, "value cannot have bit offset", Object, self.prog, self.point_type, value={}, bit_offset=4, ) self.assertRaisesRegex( ValueError, "absent object cannot have bit offset", Object, self.prog, "int", bit_offset=4, ) def test_integer_size(self): self.assertRaisesRegex( ValueError, "unsupported integer bit size", Object, self.prog, self.prog.int_type("ZERO", 0, True), ) self.assertRaisesRegex( ValueError, "unsupported integer bit size", Object, self.prog, self.prog.int_type("BIGGEST", 1024**3, True), ) def test_float_size(self): self.assertRaisesRegex( ValueError, "unsupported floating-point bit size", Object, self.prog, self.prog.float_type("ZERO", 0), ) self.assertRaisesRegex( ValueError, "unsupported floating-point bit size", Object, self.prog, self.prog.float_type("BIGGEST", 32 + 1), ) def _int_bits_cases(prog): for signed in (True, False): for byteorder in ("little", "big"): for bit_size in range(1, 129): if bit_size <= 8: size = 1 else: size = 1 << ((bit_size - 1).bit_length() - 3) type = prog.int_type( "" if signed else "u" + f"int{size}", size, signed, byteorder ) if signed: values = ( 0xF8935CF44C45202748DE66B49BA0CBAC % (1 << (bit_size - 1)), ~0xF8935CF44C45202748DE66B49BA0CBAC % (1 << (bit_size - 1)), -0xC256D5AAFFDC3179A6AC84E7154A215D % -(1 << (bit_size - 1)), ~-0xC256D5AAFFDC3179A6AC84E7154A215D % -(1 << (bit_size - 1)), ) else: values = ( 0xF8935CF44C45202748DE66B49BA0CBAC % (1 << bit_size), ~0xF8935CF44C45202748DE66B49BA0CBAC % (1 << bit_size), ) for value in values: # value_bytes is the value converted to bytes. if byteorder == "little": value_bytes = (value & ((1 << bit_size) - 1)).to_bytes( (bit_size + 7) // 8, byteorder ) else: value_bytes = (value << (-bit_size % 8)).to_bytes( (bit_size + 7) // 8, byteorder, signed=signed ) for bit_offset in range(8): # source_bytes is a buffer containing the value at the # given bit offset, with extra bits that should be # ignored. if byteorder == "little": source_bytes = bytearray( (value << bit_offset).to_bytes( (bit_offset + bit_size + 7) // 8, byteorder, signed=signed, ) ) source_bytes[0] |= (1 << bit_offset) - 1 if (bit_offset + bit_size) % 8 != 0: source_bytes[-1] ^= ( 0xFF << ((bit_offset + bit_size) % 8) ) & 0xFF else: source_bytes = bytearray( (value << (-(bit_offset + bit_size) % 8)).to_bytes( (bit_offset + bit_size + 7) // 8, byteorder, signed=signed, ) ) source_bytes[0] ^= (0xFF00 >> bit_offset) & 0xFF if (bit_offset + bit_size) % 8 != 0: source_bytes[-1] |= ( 1 << (-(bit_offset + bit_size) % 8) ) - 1 yield signed, byteorder, bit_size, type, bit_offset, value, value_bytes, source_bytes class TestReference(MockProgramTestCase): def test_basic(self): self.add_memory_segment((1000).to_bytes(4, "little"), virt_addr=0xFFFF0000) obj = Object(self.prog, "int", address=0xFFFF0000) self.assertIs(obj.prog_, self.prog) self.assertIdentical(obj.type_, self.prog.type("int")) self.assertFalse(obj.absent_) self.assertEqual(obj.address_, 0xFFFF0000) self.assertEqual(obj.bit_offset_, 0) self.assertIsNone(obj.bit_field_size_) self.assertEqual(obj.value_(), 1000) self.assertEqual(repr(obj), "Object(prog, 'int', address=0xffff0000)") self.assertIdentical(obj.read_(), Object(self.prog, "int", value=1000)) obj = Object( self.prog, self.prog.int_type("sbe32", 4, True, "big"), address=0xFFFF0000 ) self.assertEqual(obj.value_(), -402456576) obj = Object(self.prog, "unsigned int", address=0xFFFF0000, bit_field_size=4) self.assertEqual(obj.bit_offset_, 0) self.assertEqual(obj.bit_field_size_, 4) self.assertEqual(obj.value_(), 8) self.assertEqual( repr(obj), "Object(prog, 'unsigned int', address=0xffff0000, bit_field_size=4)", ) self.assertRaises(TypeError, sizeof, obj) obj = Object( self.prog, "unsigned int", address=0xFFFF0000, bit_field_size=4, bit_offset=4, ) self.assertEqual(obj.bit_offset_, 4) self.assertEqual(obj.bit_field_size_, 4) self.assertEqual(obj.value_(), 14) self.assertEqual( repr(obj), "Object(prog, 'unsigned int', address=0xffff0000, bit_offset=4, bit_field_size=4)", ) def test_overflow(self): Object(self.prog, "char", address=0xFFFFFFFFFFFFFFFF) Object( self.prog, "char", address=0xFFFFFFFFFFFFFFFF, bit_field_size=1, bit_offset=7, ) def test_signed_big(self): buffer = (-4).to_bytes(16, "little", signed=True) self.add_memory_segment(buffer, virt_addr=0xFFFF0000) obj = Object( self.prog, self.prog.int_type("__int128", 16, True), address=0xFFFF0000, ) self.assertIs(obj.prog_, self.prog) self.assertFalse(obj.absent_) self.assertEqual(obj.address_, 0xFFFF0000) self.assertEqual(obj.bit_offset_, 0) self.assertIsNone(obj.bit_field_size_) self.assertEqual(obj.type_.size, 16) self.assertEqual(obj.value_(), -4) self.assertEqual(obj.to_bytes_(), buffer) self.assertEqual(repr(obj), "Object(prog, '__int128', address=0xffff0000)") self.assertIdentical( obj.read_(), Object(self.prog, self.prog.int_type("__int128", 16, True), value=-4), ) def test_unsigned_big(self): buffer = (1000).to_bytes(16, "little") self.add_memory_segment(buffer, virt_addr=0xFFFF0000) obj = Object( self.prog, self.prog.int_type("unsigned __int128", 16, False), address=0xFFFF0000, ) self.assertIs(obj.prog_, self.prog) self.assertFalse(obj.absent_) self.assertEqual(obj.address_, 0xFFFF0000) self.assertEqual(obj.bit_offset_, 0) self.assertIsNone(obj.bit_field_size_) self.assertEqual(obj.type_.size, 16) self.assertEqual(obj.value_(), 1000) self.assertEqual(obj.to_bytes_(), buffer) self.assertEqual( repr(obj), "Object(prog, 'unsigned __int128', address=0xffff0000)" ) self.assertIdentical( obj.read_(), Object( self.prog, self.prog.int_type("unsigned __int128", 16, False), value=1000, ), ) def test_int_bits(self): buffer = bytearray(17) self.add_memory_segment(buffer, virt_addr=0xFFFF0000) for ( signed, byteorder, bit_size, type, bit_offset, value, value_bytes, source_bytes, ) in _int_bits_cases(self.prog): with self.subTest( signed=signed, byteorder=byteorder, bit_size=bit_size, bit_offset=bit_offset, value=value, ): buffer[: len(source_bytes)] = source_bytes obj = Object( self.prog, type, address=0xFFFF0000, bit_offset=bit_offset, bit_field_size=bit_size, ) self.assertEqual(obj.value_(), value) self.assertEqual(obj.to_bytes_(), value_bytes) def test_read_float(self): pi32 = struct.unpack("f", struct.pack("f", math.pi))[0] for bit_size in [32, 64]: for bit_offset in range(8): for byteorder in ["little", "big"]: if bit_size == 64: fmt = "") + "d", math.e), ) def test_float32_value_to_bytes(self): for byteorder in ("little", "big"): with self.subTest(byteorder=byteorder): self.assertEqual( Object( self.prog, self.prog.float_type("float", 4, byteorder), math.e ).to_bytes_(), struct.pack(("<" if byteorder == "little" else ">") + "f", math.e), ) def test_struct_value_to_bytes(self): self.assertEqual( Object(self.prog, self.point_type, {"x": 1, "y": 2}).to_bytes_(), b"\x01\x00\x00\x00\x02\x00\x00\x00", ) def test_int_reference_to_bytes(self): self.add_memory_segment(b"\x78\x56\x34\x12", virt_addr=0xFFFF0000) self.assertEqual( Object(self.prog, "int", address=0xFFFF0000).to_bytes_(), b"\x78\x56\x34\x12", ) def test_int_reference_bit_offset_to_bytes(self): self.add_memory_segment(b"\xe0Y\xd1H\x00", virt_addr=0xFFFF0000) self.assertEqual( Object(self.prog, "int", address=0xFFFF0000, bit_offset=2).to_bytes_(), b"\x78\x56\x34\x12", ) def test_int_reference_big_endian_bit_offset_to_bytes(self): self.add_memory_segment(b"\x04\x8d\x15\x9e\x00", virt_addr=0xFFFF0000) self.assertEqual( Object( self.prog, self.prog.int_type("int", 4, True, "big"), address=0xFFFF0000, bit_offset=2, ).to_bytes_(), b"\x12\x34\x56\x78", ) def test_struct_reference_to_bytes(self): self.add_memory_segment( b"\x01\x00\x00\x00\x02\x00\x00\x00", virt_addr=0xFFFF0000 ) self.assertEqual( Object(self.prog, self.point_type, address=0xFFFF0000).to_bytes_(), b"\x01\x00\x00\x00\x02\x00\x00\x00", ) def test_int_from_bytes(self): for byteorder in ("little", "big"): with self.subTest(byteorder=byteorder): type_ = self.prog.int_type("int", 4, True, byteorder) self.assertIdentical( Object.from_bytes_( self.prog, type_, (0x12345678).to_bytes(4, byteorder) ), Object(self.prog, type_, 0x12345678), ) def test_int_from_bytes_bit_offset(self): self.assertIdentical( Object.from_bytes_(self.prog, "int", b"\xe0Y\xd1H\x00", bit_offset=2), Object(self.prog, "int", 0x12345678), ) def test_int_from_bytes_big_endian_bit_offset(self): self.assertIdentical( Object.from_bytes_( self.prog, self.prog.int_type("int", 4, True, "big"), b"\x04\x8d\x15\x9e\x00", bit_offset=2, ), Object(self.prog, self.prog.int_type("int", 4, True, "big"), 0x12345678), ) def test_int_from_bytes_bit_field(self): self.assertIdentical( Object.from_bytes_(self.prog, "int", b"\xcc", bit_field_size=8), Object(self.prog, "int", 0xCC, bit_field_size=8), ) def test_float64_from_bytes(self): for byteorder in ("little", "big"): with self.subTest(byteorder=byteorder): type_ = self.prog.float_type("double", 8, byteorder) self.assertIdentical( Object.from_bytes_( self.prog, type_, struct.pack( ("<" if byteorder == "little" else ">") + "d", math.e ), ), Object(self.prog, type_, math.e), ) def test_float32_from_bytes(self): for byteorder in ("little", "big"): with self.subTest(byteorder=byteorder): type_ = self.prog.float_type("float", 4, byteorder) self.assertIdentical( Object.from_bytes_( self.prog, type_, struct.pack( ("<" if byteorder == "little" else ">") + "f", math.e ), ), Object(self.prog, type_, math.e), ) def test_struct_from_bytes(self): self.assertIdentical( Object.from_bytes_( self.prog, self.point_type, b"\x01\x00\x00\x00\x02\x00\x00\x00" ), Object(self.prog, self.point_type, {"x": 1, "y": 2}), ) def test_struct_from_bytes_bit_offset(self): self.assertIdentical( Object.from_bytes_( self.prog, self.point_type, b"\xff\x01\x00\x00\x00\x02\x00\x00\x00", bit_offset=8, ), Object(self.prog, self.point_type, {"x": 1, "y": 2}), ) def test_struct_from_bytes_invalid_bit_offset(self): self.assertRaisesRegex( ValueError, "non-scalar must be byte-aligned", Object.from_bytes_, self.prog, self.point_type, b"\xff\x01\x00\x00\x00\x02\x00\x00\x00", bit_offset=2, ) def test_from_bytes_invalid_bit_field_size(self): self.assertRaisesRegex( ValueError, "bit field size cannot be zero", Object.from_bytes_, self.prog, "int", b"", bit_field_size=0, ) def test_from_bytes_buffer_too_small(self): self.assertRaisesRegex( ValueError, "buffer is too small", Object.from_bytes_, self.prog, "int", bytes(3), ) def test_from_bytes_incomplete_type(self): self.assertRaisesRegex( TypeError, "cannot create object with void type", Object.from_bytes_, self.prog, "void", b"", ) def test_from_bytes_bad_type(self): self.assertRaises(TypeError, Object.from_bytes_, self.prog, None, b"") class TestInvalidBitField(MockProgramTestCase): def test_integer(self): self.assertRaisesRegex( ValueError, "bit field size is larger than type size", Object, self.prog, "int", value=0, bit_field_size=64, ) self.assertRaisesRegex( ValueError, "bit field size is larger than type size", Object, self.prog, "int", address=0, bit_field_size=64, ) self.assertRaisesRegex( ValueError, "bit field size is larger than type size", Object, self.prog, "unsigned int", value=0, bit_field_size=64, ) self.assertRaisesRegex( ValueError, "bit field size is larger than type size", Object, self.prog, "unsigned int", address=0, bit_field_size=64, ) def test_float(self): self.assertRaisesRegex( ValueError, "bit field must be integer", Object, self.prog, "float", value=0, bit_field_size=16, ) self.assertRaisesRegex( ValueError, "bit field must be integer", Object, self.prog, "float", address=0, bit_field_size=16, ) def test_reference(self): self.assertRaisesRegex( ValueError, "bit field must be integer", Object, self.prog, self.point_type, address=0, bit_field_size=4, ) self.assertRaisesRegex( ValueError, "bit field must be integer", Object, self.prog, self.point_type, value={}, bit_field_size=4, ) class TestGenericOperators(MockProgramTestCase): def setUp(self): super().setUp() self.add_memory_segment( b"".join(i.to_bytes(4, "little") for i in range(4)), virt_addr=0xFFFF0000 ) def test_len(self): self.assertEqual(len(Object(self.prog, "int [0]", address=0)), 0) self.assertEqual(len(Object(self.prog, "int [10]", address=0)), 10) self.assertRaisesRegex( TypeError, "'int' has no len()", len, Object(self.prog, "int", address=0) ) self.assertRaisesRegex( TypeError, r"'int \[\]' has no len()", len, Object(self.prog, "int []", address=0), ) def test_address_of(self): obj = Object(self.prog, "int", address=0xFFFF0000) self.assertIdentical( obj.address_of_(), Object(self.prog, "int *", value=0xFFFF0000) ) obj = obj.read_() self.assertRaisesRegex( ValueError, "cannot take address of value", obj.address_of_ ) obj = Object(self.prog, "int", address=0xFFFF0000, bit_field_size=4) self.assertRaisesRegex( ValueError, "cannot take address of bit field", obj.address_of_ ) obj = Object(self.prog, "int", address=0xFFFF0000, bit_offset=4) self.assertRaisesRegex( ValueError, "cannot take address of bit field", obj.address_of_ ) def test_subscript(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) for obj in [arr, incomplete_arr, ptr]: for i in range(5): self.assertIdentical( obj[i], Object(self.prog, "int", address=0xFFFF0000 + 4 * i) ) if i < 4: self.assertIdentical( obj[i].read_(), Object(self.prog, "int", value=i) ) else: self.assertRaises(FaultError, obj[i].read_) obj = arr.read_() for i in range(4): self.assertIdentical(obj[i], Object(self.prog, "int", value=i)) self.assertRaisesRegex(OutOfBoundsError, "out of bounds", obj.__getitem__, 4) obj = Object(self.prog, "int", value=0) self.assertRaises(TypeError, obj.__getitem__, 0) def test_negative_subscript(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) for obj in [arr, incomplete_arr, ptr]: self.assertIdentical(obj[-1], Object(self.prog, "int", address=0xFFFEFFFC)) obj = arr.read_() self.assertRaisesRegex(OutOfBoundsError, "out of bounds", obj.__getitem__, -1) def test_slice(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) for obj in [arr, incomplete_arr, ptr]: self.assertIdentical( obj[1:3], Object(self.prog, "int [2]", address=0xFFFF0004) ) obj = arr.read_() self.assertIdentical(obj[1:3], Object(self.prog, "int [2]", [1, 2])) def test_slice_step(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) for obj in [arr, incomplete_arr, ptr]: self.assertIdentical( obj[1:3:1], Object(self.prog, "int [2]", address=0xFFFF0004) ) def test_slice_invalid_step(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) with self.assertRaisesRegex(ValueError, "object slice step must be 1"): arr[0:4:2] def test_slice_negative_start(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) for obj in [arr, incomplete_arr, ptr]: self.assertIdentical( obj[-2:2], Object(self.prog, "int [4]", address=0xFFFEFFF8) ) obj = arr.read_() with self.assertRaisesRegex(OutOfBoundsError, "out of bounds"): obj[-2:2] def test_slice_both_negative(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) for obj in [arr, incomplete_arr, ptr]: self.assertIdentical( obj[-4:-2], Object(self.prog, "int [2]", address=0xFFFEFFF0) ) obj = arr.read_() with self.assertRaisesRegex(OutOfBoundsError, "out of bounds"): obj[-4:-2] def test_slice_both_none(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) self.assertIdentical(arr[:], Object(self.prog, "int [4]", address=0xFFFF0000)) with self.assertRaisesRegex(TypeError, "has no length"): incomplete_arr[:] with self.assertRaisesRegex(TypeError, "has no length"): ptr[:] self.assertIdentical(arr.read_()[:], Object(self.prog, "int [4]", [0, 1, 2, 3])) def test_slice_start_none(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) for obj in [arr, incomplete_arr, ptr]: self.assertIdentical( obj[:3], Object(self.prog, "int [3]", address=0xFFFF0000) ) self.assertIdentical(arr.read_()[:3], Object(self.prog, "int [3]", [0, 1, 2])) def test_slice_stop_none(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) self.assertIdentical(arr[1:], Object(self.prog, "int [3]", address=0xFFFF0004)) with self.assertRaisesRegex(TypeError, "has no length"): incomplete_arr[1:] with self.assertRaisesRegex(TypeError, "has no length"): ptr[1:] self.assertIdentical(arr.read_()[1:], Object(self.prog, "int [3]", [1, 2, 3])) def test_slice_start_negative_stop_none(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) self.assertIdentical(arr[-2:], Object(self.prog, "int [6]", address=0xFFFEFFF8)) with self.assertRaisesRegex(TypeError, "has no length"): incomplete_arr[-2:] with self.assertRaisesRegex(TypeError, "has no length"): ptr[-2:] obj = arr.read_() with self.assertRaisesRegex(OutOfBoundsError, "out of bounds"): obj[-2:] def test_slice_start_none_stop_negative(self): arr = Object(self.prog, "int [4]", address=0xFFFF0000) incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000) ptr = Object(self.prog, "int *", value=0xFFFF0000) for obj in [arr, incomplete_arr, ptr]: self.assertIdentical( obj[:-2], Object(self.prog, "int [0]", address=0xFFFF0000) ) self.assertIdentical(arr.read_()[:-2], Object(self.prog, "int [0]", [])) def test_cast_primitive_value(self): obj = Object(self.prog, "long", value=2**32 + 1) self.assertIdentical(cast("int", obj), Object(self.prog, "int", value=1)) self.assertIdentical( cast("int", obj.read_()), Object(self.prog, "int", value=1) ) self.assertIdentical( cast("const int", Object(self.prog, "int", value=1)), Object(self.prog, "const int", value=1), ) self.assertRaisesRegex( TypeError, "cannot cast to 'struct point'", cast, self.point_type, Object(self.prog, "int", value=1), ) def test_cast_compound_value(self): obj = Object(self.prog, self.point_type, address=0xFFFF0000).read_() self.assertRaisesRegex( TypeError, "cannot cast to 'struct point'", cast, self.point_type, obj, ) self.assertRaisesRegex( TypeError, "cannot convert 'struct point' to 'enum color'", cast, self.color_type, obj, ) def test_cast_to_incomplete_type(self): self.assertRaisesRegex( TypeError, "cannot cast to incomplete enumerated type", cast, self.prog.enum_type("foo"), Object(self.prog, "int", 1), ) def test_reinterpret_reference(self): obj = Object(self.prog, "int", address=0xFFFF0000) self.assertIdentical(reinterpret("int", obj), obj) self.assertIdentical( reinterpret(self.prog.int_type("int", 4, True, "big"), obj), Object( self.prog, self.prog.int_type("int", 4, True, "big"), address=0xFFFF0000 ), ) obj = Object(self.prog, "int []", address=0xFFFF0000) self.assertIdentical( reinterpret("int [4]", obj), Object(self.prog, "int [4]", address=0xFFFF0000), ) def test_reinterpret_value(self): self.types.append(self.point_type) self.types.append( self.prog.struct_type( "foo", 8, (TypeMember(self.prog.int_type("long", 8, True), "counter"),) ), ) obj = Object(self.prog, "struct point", address=0xFFFF0008).read_() self.assertIdentical( reinterpret("struct foo", obj), Object(self.prog, "struct foo", address=0xFFFF0008).read_(), ) self.assertIdentical(reinterpret("int", obj), Object(self.prog, "int", value=2)) self.assertIdentical( reinterpret(self.prog.int_type("int", 4, True, "big"), obj), Object( self.prog, self.prog.int_type("int", 4, True, "big"), value=33554432 ), ) def test_reinterpret_primitive_value_to_same_size_primitive(self): for byteorder in ("little", "big"): with self.subTest(byteorder=byteorder): self.assertIdentical( reinterpret( self.prog.int_type("long long", 8, True, byteorder), Object( self.prog, self.prog.int_type( "unsigned long long", 8, False, byteorder ), 0xFFFFFFFFFFFFFFF3, ), ), Object( self.prog, self.prog.int_type("long long", 8, True, byteorder), -13, ), ) def test_reinterpret_primitive_value_to_smaller_primitive(self): with self.subTest(byteorder="little"): self.assertIdentical( reinterpret( self.prog.int_type("int", 4, True), Object( self.prog, self.prog.int_type("unsigned long long", 8, False), 0x000027100000029A, ), ), Object(self.prog, self.prog.int_type("int", 4, True), 666), ) with self.subTest(byteorder="big"): self.assertIdentical( reinterpret( self.prog.int_type("int", 4, True, "big"), Object( self.prog, self.prog.int_type("unsigned long long", 8, False, "big"), 0x000027100000029A, ), ), Object(self.prog, self.prog.int_type("int", 4, True, "big"), 10000), ) def test_reinterpret_primitive_value_to_same_size_compound(self): with self.subTest(byteorder="little"): self.assertIdentical( reinterpret( self.point_type, Object( self.prog, self.prog.int_type("unsigned long long", 8, False), 0x000027100000029A, ), ), Object(self.prog, self.point_type, {"x": 666, "y": 10000}), ) with self.subTest(byteorder="big"): point_type = self.prog.struct_type( "point", 8, ( TypeMember(self.prog.int_type("int", 4, True, "big"), "x", 0), TypeMember(self.prog.int_type("int", 4, True, "big"), "y", 32), ), ) self.assertIdentical( reinterpret( point_type, Object( self.prog, self.prog.int_type("unsigned long long", 8, False, "big"), 0x000027100000029A, ), ), Object(self.prog, point_type, {"x": 10000, "y": 666}), ) def test_reinterpret_primitive_value_to_smaller_compound(self): with self.subTest(byteorder="little"): small_point_type = self.prog.struct_type( "small_point", 4, ( TypeMember(self.prog.int_type("short", 2, True), "x", 0), TypeMember(self.prog.int_type("short", 2, True), "y", 16), ), ) self.assertIdentical( reinterpret( small_point_type, Object( self.prog, self.prog.int_type("unsigned long long", 8, False), 0x123456782710029A, ), ), Object(self.prog, small_point_type, {"x": 666, "y": 10000}), ) with self.subTest(byteorder="big"): small_point_type = self.prog.struct_type( "small_point", 4, ( TypeMember(self.prog.int_type("short", 2, True, "big"), "x", 0), TypeMember(self.prog.int_type("short", 2, True, "big"), "y", 16), ), ) self.assertIdentical( reinterpret( small_point_type, Object( self.prog, self.prog.int_type("unsigned long long", 8, False, "big"), 0x123456782710029A, ), ), Object(self.prog, small_point_type, {"x": 0x1234, "y": 0x5678}), ) def test_reinterpret_bit_field_value_to_same_size_primitive(self): for byteorder in ("little", "big"): with self.subTest(byteorder=byteorder): self.assertIdentical( reinterpret( self.prog.int_type("uint24", 3, False, byteorder), Object( self.prog, self.prog.int_type("unsigned int", 4, False, byteorder), 0xABCDEF, bit_field_size=24, ), ), Object( self.prog, self.prog.int_type("uint24", 3, False, byteorder), 0xABCDEF, ), ) def test_reinterpret_bit_field_value_to_smaller_primitive(self): with self.subTest(byteorder="little"): self.assertIdentical( reinterpret( self.prog.int_type("unsigned short", 2, False), Object( self.prog, self.prog.int_type("unsigned int", 4, False), 0xABCDEF, bit_field_size=24, ), ), Object( self.prog, self.prog.int_type("unsigned short", 2, False), 0xCDEF, ), ) with self.subTest(byteorder="big"): self.assertIdentical( reinterpret( self.prog.int_type("unsigned short", 2, False, "big"), Object( self.prog, self.prog.int_type("unsigned int", 4, False, "big"), 0xABCDEF, bit_field_size=24, ), ), Object( self.prog, self.prog.int_type("unsigned short", 2, False, "big"), 0xABCD, ), ) def test_member(self): reference = Object(self.prog, self.point_type, address=0xFFFF0000) unnamed_reference = Object( self.prog, self.prog.struct_type( "point", 8, ( TypeMember( self.prog.struct_type(None, 8, self.point_type.members), None ), ), ), address=0xFFFF0000, ) ptr = Object( self.prog, self.prog.pointer_type(self.point_type), value=0xFFFF0000 ) for obj in [reference, unnamed_reference, ptr]: self.assertIdentical( obj.member_("x"), Object(self.prog, "int", address=0xFFFF0000) ) self.assertIdentical(obj.member_("x"), obj.x) self.assertIdentical( obj.member_("y"), Object(self.prog, "int", address=0xFFFF0004) ) self.assertIdentical(obj.member_("y"), obj.y) self.assertRaisesRegex( LookupError, "'struct point' has no member 'z'", obj.member_, "z" ) self.assertRaisesRegex( AttributeError, "'struct point' has no member 'z'", getattr, obj, "z" ) obj = reference.read_() self.assertIdentical(obj.x, Object(self.prog, "int", value=0)) self.assertIdentical(obj.y, Object(self.prog, "int", value=1)) obj = Object(self.prog, "int", value=1) self.assertRaisesRegex( TypeError, "'int' is not a structure, union, or class", obj.member_, "x" ) self.assertRaisesRegex(AttributeError, "no attribute", getattr, obj, "x") def test_bit_field_member(self): self.add_memory_segment(b"\x07\x10\x5e\x5f\x1f\0\0\0", virt_addr=0xFFFF8000) type_ = self.prog.struct_type( "bits", 8, ( TypeMember( Object( self.prog, self.prog.int_type("int", 4, True), bit_field_size=4 ), "x", 0, ), TypeMember( Object( self.prog, self.prog.int_type("int", 4, True, qualifiers=Qualifiers.CONST), bit_field_size=28, ), "y", 4, ), TypeMember( Object( self.prog, self.prog.int_type("int", 4, True), bit_field_size=5 ), "z", 32, ), ), ) obj = Object(self.prog, type_, address=0xFFFF8000) self.assertIdentical( obj.x, Object( self.prog, self.prog.int_type("int", 4, True), address=0xFFFF8000, bit_field_size=4, ), ) self.assertIdentical( obj.y, Object( self.prog, self.prog.int_type("int", 4, True, qualifiers=Qualifiers.CONST), address=0xFFFF8000, bit_field_size=28, bit_offset=4, ), ) self.assertIdentical( obj.z, Object( self.prog, self.prog.int_type("int", 4, True), address=0xFFFF8004, bit_field_size=5, ), ) def test_member_out_of_bounds(self): obj = Object( self.prog, self.prog.struct_type("foo", 4, self.point_type.members), address=0xFFFF0000, ).read_() self.assertRaisesRegex(OutOfBoundsError, "out of bounds", getattr, obj, "y") def test_string(self): self.add_memory_segment( b"\x00\x00\xff\xff\x00\x00\x00\x00", virt_addr=0xFFFEFFF8 ) self.add_memory_segment(b"hello\0world\0", virt_addr=0xFFFF0000) strings = [ (Object(self.prog, "char *", address=0xFFFEFFF8), b"hello"), (Object(self.prog, "char [2]", address=0xFFFF0000), b"he"), (Object(self.prog, "char [8]", address=0xFFFF0000), b"hello"), ] for obj, expected in strings: with self.subTest(obj=obj): self.assertEqual(obj.string_(), expected) self.assertEqual(obj.read_().string_(), expected) strings = [ Object(self.prog, "char []", address=0xFFFF0000), Object(self.prog, "int []", address=0xFFFF0000), Object(self.prog, "int [2]", address=0xFFFF0000), Object(self.prog, "int *", value=0xFFFF0000), ] for obj in strings: self.assertEqual(obj.string_(), b"hello") self.assertRaisesRegex( TypeError, "must be an array or pointer", Object(self.prog, "int", value=1).string_, ) def test_format_invalid_integer_base(self): obj = Object(self.prog, "int", 1) for integer_base in ( 0, 1, -(2**31), 2**31 - 1, -(2**32), 2**32, 2**128, -(2**128), ): with self.subTest(integer_base=integer_base): self.assertRaisesRegex( ValueError, "invalid integer base", obj.format_, integer_base=integer_base, ) self.assertRaises(TypeError, obj.format_, integer_base="hex") def test_sizeof_default_prog(self): self.objects.append(MockObject("foo", self.prog.int_type("int", 4, True), 1)) self.assertRaises(NoDefaultProgramError, sizeof, "foo") with with_default_prog(self.prog): self.assertEqual(sizeof("foo"), 4) class TestSpecialMethods(MockProgramTestCase): def test_dir(self): obj = Object(self.prog, "int", value=0) self.assertEqual(dir(obj), sorted(object.__dir__(obj))) obj = Object(self.prog, self.point_type, address=0xFFFF0000) self.assertEqual(dir(obj), sorted(object.__dir__(obj) + ["x", "y"])) self.assertEqual(dir(obj.address_of_()), dir(obj)) def test_round(self): for func in [round, math.trunc, math.floor, math.ceil]: for value in [0.0, -0.0, -0.4, 0.4, 0.5, -0.5, 0.6, -0.6, 1.0, -1.0]: self.assertEqual( func(Object(self.prog, "double", value=value)), func(value) ) self.assertEqual( func(Object(self.prog, "int", value=value)), func(int(value)) ) self.assertIdentical( round(Object(self.prog, "int", value=1), 2), Object(self.prog, "int", value=1), ) self.assertIdentical( round(Object(self.prog, "double", value=0.123), 2), Object(self.prog, "double", value=0.12), ) def test_iter(self): obj = Object(self.prog, "int [4]", value=[0, 1, 2, 3]) for i, element in enumerate(obj): self.assertIdentical(element, Object(self.prog, "int", value=i)) self.assertRaisesRegex( TypeError, "'int' is not iterable", iter, Object(self.prog, "int", value=0) ) self.assertRaisesRegex( TypeError, r"'int \[\]' is not iterable", iter, Object(self.prog, "int []", address=0), ) def test_iter_length_hint(self): it = iter(Object(self.prog, "int [3]", value=[0, 1, 2])) for i in range(3, 0, -1): self.assertEqual(operator.length_hint(it), i) next(it) self.assertEqual(operator.length_hint(it), 0) def test_reversed(self): obj = Object(self.prog, "int [4]", value=[0, 1, 2, 3]) for i, element in zip(range(3, -1, -1), reversed(obj)): self.assertIdentical(element, Object(self.prog, "int", value=i)) self.assertRaisesRegex( TypeError, "'int' is not iterable", reversed, Object(self.prog, "int", value=0), ) self.assertRaisesRegex( TypeError, r"'int \[\]' is not iterable", reversed, Object(self.prog, "int []", address=0), ) def test_reversed_length_hint(self): it = reversed(Object(self.prog, "int [3]", value=[0, 1, 2])) for i in range(3, 0, -1): self.assertEqual(operator.length_hint(it), i) next(it) self.assertEqual(operator.length_hint(it), 0) def test__repr_pretty_(self): obj = Object(self.prog, "int", value=0) assertReprPrettyEqualsStr(obj)