Debian Codegraph @

tests/test_object.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 import math
5 import operator
6 import struct
7
8 from drgn import (
9 AbsenceReason,
10 FaultError,
11 NoDefaultProgramError,
12 Object,
13 ObjectAbsentError,
14 OutOfBoundsError,
15 Qualifiers,
16 TypeMember,
17 cast,
18 reinterpret,
19 sizeof,
20 )
21 from tests import (
22 MockMemorySegment,
23 MockObject,
24 MockProgramTestCase,
25 assertReprPrettyEqualsStr,
26 mock_program,
27 with_default_prog,
28 )
29
30
31 class TestInit(MockProgramTestCase):
32 def test_type_stays_alive(self):
33 obj = Object(self.prog, self.prog.int_type("int", 4, True), value=0)
34 self.assertIdentical(obj.type_, self.prog.int_type("int", 4, True))
35 type_ = obj.type_
36 del obj
37 self.assertIdentical(type_, self.prog.int_type("int", 4, True))
38
39 def test_type(self):
40 self.assertRaisesRegex(
41 TypeError, "type must be Type, str, or None", Object, self.prog, 1, value=0
42 )
43 self.assertRaisesRegex(
44 ValueError, "reference must have type", Object, self.prog, address=0
45 )
46 self.assertRaisesRegex(
47 ValueError, "absent object must have type", Object, self.prog
48 )
49
50 def test_address_value_absence_reason_nand(self):
51 self.assertRaisesRegex(
52 ValueError,
53 "object cannot have address and value",
54 Object,
55 self.prog,
56 "int",
57 0,
58 address=0,
59 )
60 self.assertRaisesRegex(
61 ValueError,
62 "object cannot have address and value",
63 Object,
64 self.prog,
65 "int",
66 value=0,
67 address=0,
68 )
69 self.assertRaisesRegex(
70 ValueError,
71 "object cannot have address and absence reason",
72 Object,
73 self.prog,
74 "int",
75 address=0,
76 absence_reason=AbsenceReason.OTHER,
77 )
78 self.assertRaisesRegex(
79 ValueError,
80 "object cannot have value and absence reason",
81 Object,
82 self.prog,
83 "int",
84 value=0,
85 absence_reason=AbsenceReason.OTHER,
86 )
87 self.assertRaisesRegex(
88 ValueError,
89 "object cannot have address, value, and absence reason",
90 Object,
91 self.prog,
92 "int",
93 value=0,
94 address=0,
95 absence_reason=AbsenceReason.OTHER,
96 )
97
98 def test_integer_address(self):
99 self.assertRaises(TypeError, Object, self.prog, "int", address="NULL")
100
101 def test_bit_field_size(self):
102 self.assertRaises(
103 TypeError, Object, self.prog, "int", address=0, bit_field_size="1"
104 )
105 self.assertRaisesRegex(
106 ValueError,
107 "bit field size cannot be zero",
108 Object,
109 self.prog,
110 "int",
111 address=0,
112 bit_field_size=0,
113 )
114
115 def test_bit_offset(self):
116 self.assertRaisesRegex(
117 ValueError,
118 "value cannot have bit offset",
119 Object,
120 self.prog,
121 "int",
122 value=0,
123 bit_offset=4,
124 )
125 self.assertRaisesRegex(
126 ValueError,
127 "value cannot have bit offset",
128 Object,
129 self.prog,
130 self.point_type,
131 value={},
132 bit_offset=4,
133 )
134 self.assertRaisesRegex(
135 ValueError,
136 "absent object cannot have bit offset",
137 Object,
138 self.prog,
139 "int",
140 bit_offset=4,
141 )
142
143 def test_integer_size(self):
144 self.assertRaisesRegex(
145 ValueError,
146 "unsupported integer bit size",
147 Object,
148 self.prog,
149 self.prog.int_type("ZERO", 0, True),
150 )
151 self.assertRaisesRegex(
152 ValueError,
153 "unsupported integer bit size",
154 Object,
155 self.prog,
156 self.prog.int_type("BIGGEST", 1024**3, True),
157 )
158
159 def test_float_size(self):
160 self.assertRaisesRegex(
161 ValueError,
162 "unsupported floating-point bit size",
163 Object,
164 self.prog,
165 self.prog.float_type("ZERO", 0),
166 )
167 self.assertRaisesRegex(
168 ValueError,
169 "unsupported floating-point bit size",
170 Object,
171 self.prog,
172 self.prog.float_type("BIGGEST", 32 + 1),
173 )
174
175
176 def _int_bits_cases(prog):
177 for signed in (True, False):
178 for byteorder in ("little", "big"):
179 for bit_size in range(1, 129):
180 if bit_size <= 8:
181 size = 1
182 else:
183 size = 1 << ((bit_size - 1).bit_length() - 3)
184 type = prog.int_type(
185 "" if signed else "u" + f"int{size}", size, signed, byteorder
186 )
187 if signed:
188 values = (
189 0xF8935CF44C45202748DE66B49BA0CBAC % (1 << (bit_size - 1)),
190 ~0xF8935CF44C45202748DE66B49BA0CBAC % (1 << (bit_size - 1)),
191 -0xC256D5AAFFDC3179A6AC84E7154A215D % -(1 << (bit_size - 1)),
192 ~-0xC256D5AAFFDC3179A6AC84E7154A215D % -(1 << (bit_size - 1)),
193 )
194 else:
195 values = (
196 0xF8935CF44C45202748DE66B49BA0CBAC % (1 << bit_size),
197 ~0xF8935CF44C45202748DE66B49BA0CBAC % (1 << bit_size),
198 )
199 for value in values:
200 # value_bytes is the value converted to bytes.
201 if byteorder == "little":
202 value_bytes = (value & ((1 << bit_size) - 1)).to_bytes(
203 (bit_size + 7) // 8, byteorder
204 )
205 else:
206 value_bytes = (value << (-bit_size % 8)).to_bytes(
207 (bit_size + 7) // 8, byteorder, signed=signed
208 )
209 for bit_offset in range(8):
210 # source_bytes is a buffer containing the value at the
211 # given bit offset, with extra bits that should be
212 # ignored.
213 if byteorder == "little":
214 source_bytes = bytearray(
215 (value << bit_offset).to_bytes(
216 (bit_offset + bit_size + 7) // 8,
217 byteorder,
218 signed=signed,
219 )
220 )
221 source_bytes[0] |= (1 << bit_offset) - 1
222 if (bit_offset + bit_size) % 8 != 0:
223 source_bytes[-1] ^= (
224 0xFF << ((bit_offset + bit_size) % 8)
225 ) & 0xFF
226 else:
227 source_bytes = bytearray(
228 (value << (-(bit_offset + bit_size) % 8)).to_bytes(
229 (bit_offset + bit_size + 7) // 8,
230 byteorder,
231 signed=signed,
232 )
233 )
234 source_bytes[0] ^= (0xFF00 >> bit_offset) & 0xFF
235 if (bit_offset + bit_size) % 8 != 0:
236 source_bytes[-1] |= (
237 1 << (-(bit_offset + bit_size) % 8)
238 ) - 1
239 yield signed, byteorder, bit_size, type, bit_offset, value, value_bytes, source_bytes
240
241
242 class TestReference(MockProgramTestCase):
243 def test_basic(self):
244 self.add_memory_segment((1000).to_bytes(4, "little"), virt_addr=0xFFFF0000)
245
246 obj = Object(self.prog, "int", address=0xFFFF0000)
247 self.assertIs(obj.prog_, self.prog)
248 self.assertIdentical(obj.type_, self.prog.type("int"))
249 self.assertFalse(obj.absent_)
250 self.assertEqual(obj.address_, 0xFFFF0000)
251 self.assertEqual(obj.bit_offset_, 0)
252 self.assertIsNone(obj.bit_field_size_)
253 self.assertEqual(obj.value_(), 1000)
254 self.assertEqual(repr(obj), "Object(prog, 'int', address=0xffff0000)")
255
256 self.assertIdentical(obj.read_(), Object(self.prog, "int", value=1000))
257
258 obj = Object(
259 self.prog, self.prog.int_type("sbe32", 4, True, "big"), address=0xFFFF0000
260 )
261 self.assertEqual(obj.value_(), -402456576)
262
263 obj = Object(self.prog, "unsigned int", address=0xFFFF0000, bit_field_size=4)
264 self.assertEqual(obj.bit_offset_, 0)
265 self.assertEqual(obj.bit_field_size_, 4)
266 self.assertEqual(obj.value_(), 8)
267 self.assertEqual(
268 repr(obj),
269 "Object(prog, 'unsigned int', address=0xffff0000, bit_field_size=4)",
270 )
271 self.assertRaises(TypeError, sizeof, obj)
272
273 obj = Object(
274 self.prog,
275 "unsigned int",
276 address=0xFFFF0000,
277 bit_field_size=4,
278 bit_offset=4,
279 )
280 self.assertEqual(obj.bit_offset_, 4)
281 self.assertEqual(obj.bit_field_size_, 4)
282 self.assertEqual(obj.value_(), 14)
283 self.assertEqual(
284 repr(obj),
285 "Object(prog, 'unsigned int', address=0xffff0000, bit_offset=4, bit_field_size=4)",
286 )
287
288 def test_overflow(self):
289 Object(self.prog, "char", address=0xFFFFFFFFFFFFFFFF)
290 Object(
291 self.prog,
292 "char",
293 address=0xFFFFFFFFFFFFFFFF,
294 bit_field_size=1,
295 bit_offset=7,
296 )
297
298 def test_signed_big(self):
299 buffer = (-4).to_bytes(16, "little", signed=True)
300 self.add_memory_segment(buffer, virt_addr=0xFFFF0000)
301 obj = Object(
302 self.prog,
303 self.prog.int_type("__int128", 16, True),
304 address=0xFFFF0000,
305 )
306 self.assertIs(obj.prog_, self.prog)
307 self.assertFalse(obj.absent_)
308 self.assertEqual(obj.address_, 0xFFFF0000)
309 self.assertEqual(obj.bit_offset_, 0)
310 self.assertIsNone(obj.bit_field_size_)
311 self.assertEqual(obj.type_.size, 16)
312 self.assertEqual(obj.value_(), -4)
313 self.assertEqual(obj.to_bytes_(), buffer)
314 self.assertEqual(repr(obj), "Object(prog, '__int128', address=0xffff0000)")
315
316 self.assertIdentical(
317 obj.read_(),
318 Object(self.prog, self.prog.int_type("__int128", 16, True), value=-4),
319 )
320
321 def test_unsigned_big(self):
322 buffer = (1000).to_bytes(16, "little")
323 self.add_memory_segment(buffer, virt_addr=0xFFFF0000)
324 obj = Object(
325 self.prog,
326 self.prog.int_type("unsigned __int128", 16, False),
327 address=0xFFFF0000,
328 )
329 self.assertIs(obj.prog_, self.prog)
330 self.assertFalse(obj.absent_)
331 self.assertEqual(obj.address_, 0xFFFF0000)
332 self.assertEqual(obj.bit_offset_, 0)
333 self.assertIsNone(obj.bit_field_size_)
334 self.assertEqual(obj.type_.size, 16)
335 self.assertEqual(obj.value_(), 1000)
336 self.assertEqual(obj.to_bytes_(), buffer)
337 self.assertEqual(
338 repr(obj), "Object(prog, 'unsigned __int128', address=0xffff0000)"
339 )
340
341 self.assertIdentical(
342 obj.read_(),
343 Object(
344 self.prog,
345 self.prog.int_type("unsigned __int128", 16, False),
346 value=1000,
347 ),
348 )
349
350 def test_int_bits(self):
351 buffer = bytearray(17)
352 self.add_memory_segment(buffer, virt_addr=0xFFFF0000)
353 for (
354 signed,
355 byteorder,
356 bit_size,
357 type,
358 bit_offset,
359 value,
360 value_bytes,
361 source_bytes,
362 ) in _int_bits_cases(self.prog):
363 with self.subTest(
364 signed=signed,
365 byteorder=byteorder,
366 bit_size=bit_size,
367 bit_offset=bit_offset,
368 value=value,
369 ):
370 buffer[: len(source_bytes)] = source_bytes
371 obj = Object(
372 self.prog,
373 type,
374 address=0xFFFF0000,
375 bit_offset=bit_offset,
376 bit_field_size=bit_size,
377 )
378 self.assertEqual(obj.value_(), value)
379 self.assertEqual(obj.to_bytes_(), value_bytes)
380
381 def test_read_float(self):
382 pi32 = struct.unpack("f", struct.pack("f", math.pi))[0]
383 for bit_size in [32, 64]:
384 for bit_offset in range(8):
385 for byteorder in ["little", "big"]:
386 if bit_size == 64:
387 fmt = "<d"
388 expected = math.pi
389 else:
390 fmt = "<f"
391 expected = pi32
392 tmp = int.from_bytes(struct.pack(fmt, math.pi), "little")
393 if byteorder == "little":
394 tmp <<= bit_offset
395 else:
396 tmp <<= (8 - bit_size - bit_offset) % 8
397 buf = tmp.to_bytes((bit_size + bit_offset + 7) // 8, byteorder)
398 prog = mock_program(segments=[MockMemorySegment(buf, 0)])
399 obj = Object(
400 prog,
401 prog.float_type(
402 "double" if bit_size == 64 else "float",
403 bit_size // 8,
404 byteorder,
405 ),
406 address=0,
407 bit_offset=bit_offset,
408 )
409 self.assertEqual(obj.value_(), expected)
410
411 def test_struct(self):
412 self.add_memory_segment(
413 (
414 (99).to_bytes(4, "little")
415 + (-1).to_bytes(4, "little", signed=True)
416 + (12345).to_bytes(4, "little")
417 + (0).to_bytes(4, "little")
418 ),
419 virt_addr=0xFFFF0000,
420 )
421 self.types.append(self.point_type)
422 obj = Object(self.prog, "struct point", address=0xFFFF0000)
423 self.assertEqual(obj.value_(), {"x": 99, "y": -1})
424 self.assertEqual(sizeof(obj), 8)
425
426 type_ = self.prog.struct_type(
427 "foo",
428 16,
429 (
430 TypeMember(self.point_type, "point"),
431 TypeMember(
432 self.prog.struct_type(
433 None,
434 8,
435 (
436 TypeMember(self.prog.int_type("int", 4, True), "bar"),
437 TypeMember(self.prog.int_type("int", 4, True), "baz", 32),
438 ),
439 ),
440 None,
441 64,
442 ),
443 ),
444 )
445 obj = Object(self.prog, type_, address=0xFFFF0000)
446 self.assertEqual(
447 obj.value_(), {"point": {"x": 99, "y": -1}, "bar": 12345, "baz": 0}
448 )
449
450 def test_read_struct_bit_offset(self):
451 value = 12345678912345678989
452 for bit_size in range(1, 65):
453 for bit_offset in range(8):
454 size = (bit_size + bit_offset + 7) // 8
455 size_mask = (1 << (8 * size)) - 1
456 for byteorder in ["little", "big"]:
457 if byteorder == "little":
458 tmp = value << bit_offset
459 else:
460 tmp = value << (8 - bit_size - bit_offset) % 8
461 tmp &= size_mask
462 buf = tmp.to_bytes(size, byteorder) + b"\0"
463 prog = mock_program(segments=[MockMemorySegment(buf, 0)])
464 obj = Object(
465 prog,
466 prog.struct_type(
467 None,
468 (bit_offset + bit_size + 7) // 8,
469 (
470 TypeMember(
471 Object(
472 prog,
473 prog.int_type(
474 "unsigned long long",
475 8,
476 False,
477 byteorder,
478 ),
479 bit_field_size=bit_size,
480 ),
481 "x",
482 bit_offset=bit_offset,
483 ),
484 ),
485 ),
486 address=0,
487 )
488 self.assertEqual(obj.x.value_(), value & ((1 << bit_size) - 1))
489 self.assertEqual(
490 obj.x.read_().value_(), value & ((1 << bit_size) - 1)
491 )
492 self.assertEqual(
493 obj.read_().x.value_(), value & ((1 << bit_size) - 1)
494 )
495
496 def test_array(self):
497 segment = bytearray()
498 for i in range(10):
499 segment.extend(i.to_bytes(4, "little"))
500 self.add_memory_segment(segment, virt_addr=0xFFFF0000)
501 obj = Object(self.prog, "int [5]", address=0xFFFF0000)
502 self.assertEqual(obj.value_(), [0, 1, 2, 3, 4])
503 self.assertEqual(sizeof(obj), 20)
504
505 obj = Object(self.prog, "int [2][5]", address=0xFFFF0000)
506 self.assertEqual(obj.value_(), [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
507
508 obj = Object(self.prog, "int [2][2][2]", address=0xFFFF0000)
509 self.assertEqual(obj.value_(), [[[0, 1], [2, 3]], [[4, 5], [6, 7]]])
510
511 def test_void(self):
512 obj = Object(self.prog, self.prog.void_type(), address=0)
513 self.assertIs(obj.prog_, self.prog)
514 self.assertIdentical(obj.type_, self.prog.void_type())
515 self.assertEqual(obj.address_, 0)
516 self.assertEqual(obj.bit_offset_, 0)
517 self.assertIsNone(obj.bit_field_size_)
518 self.assertRaisesRegex(
519 TypeError, "cannot read object with void type", obj.value_
520 )
521 self.assertRaisesRegex(
522 TypeError, "cannot read object with void type", obj.read_
523 )
524 self.assertRaises(TypeError, sizeof, obj)
525
526 def test_function(self):
527 obj = Object(
528 self.prog,
529 self.prog.function_type(self.prog.void_type(), (), False),
530 address=0,
531 )
532 self.assertIs(obj.prog_, self.prog)
533 self.assertIdentical(
534 obj.type_, self.prog.function_type(self.prog.void_type(), (), False)
535 )
536 self.assertEqual(obj.address_, 0)
537 self.assertEqual(obj.bit_offset_, 0)
538 self.assertIsNone(obj.bit_field_size_)
539 self.assertRaisesRegex(
540 TypeError, "cannot read object with function type", obj.value_
541 )
542 self.assertRaisesRegex(
543 TypeError, "cannot read object with function type", obj.read_
544 )
545 self.assertRaises(TypeError, sizeof, obj)
546
547 def test_incomplete(self):
548 # It's valid to create references with incomplete type, but not to read
549 # from them.
550 obj = Object(self.prog, self.prog.struct_type("foo"), address=0)
551 self.assertRaisesRegex(
552 TypeError, "cannot read object with incomplete structure type", obj.value_
553 )
554 self.assertRaisesRegex(
555 TypeError, "cannot read object with incomplete structure type", obj.read_
556 )
557 self.assertRaises(TypeError, sizeof, obj)
558
559 obj = Object(self.prog, self.prog.union_type("foo"), address=0)
560 self.assertRaisesRegex(
561 TypeError, "cannot read object with incomplete union type", obj.value_
562 )
563 self.assertRaisesRegex(
564 TypeError, "cannot read object with incomplete union type", obj.read_
565 )
566
567 obj = Object(self.prog, self.prog.enum_type("foo"), address=0)
568 self.assertRaisesRegex(
569 TypeError, "cannot read object with incomplete enumerated type", obj.value_
570 )
571 self.assertRaisesRegex(
572 TypeError, "cannot read object with incomplete enumerated type", obj.read_
573 )
574
575 obj = Object(
576 self.prog,
577 self.prog.array_type(self.prog.int_type("int", 4, True)),
578 address=0,
579 )
580 self.assertRaisesRegex(
581 TypeError, "cannot read object with incomplete array type", obj.value_
582 )
583 self.assertRaisesRegex(
584 TypeError, "cannot read object with incomplete array type", obj.read_
585 )
586
587 def test_non_scalar_bit_offset(self):
588 obj = Object(
589 self.prog,
590 self.prog.struct_type(
591 "weird", 9, (TypeMember(self.point_type, "point", bit_offset=1),)
592 ),
593 address=0xFFFF0000,
594 )
595 self.assertRaisesRegex(
596 ValueError, "non-scalar must be byte-aligned", obj.member_, "point"
597 )
598 self.assertRaisesRegex(
599 ValueError,
600 "non-scalar must be byte-aligned",
601 Object,
602 self.prog,
603 self.point_type,
604 address=0xFFFF0000,
605 bit_offset=1,
606 )
607 self.assertIdentical(
608 Object(self.prog, self.point_type, address=0xFFFF0000, bit_offset=32),
609 Object(self.prog, self.point_type, address=0xFFFF0004),
610 )
611
612 def test_bit_field_of_big_int(self):
613 buffer = (1000).to_bytes(4, "little")
614 self.add_memory_segment(buffer, virt_addr=0xFFFF0000)
615 obj = Object(
616 self.prog,
617 self.prog.int_type("unsigned __int128", 16, False),
618 address=0xFFFF0000,
619 bit_field_size=32,
620 )
621 self.assertIs(obj.prog_, self.prog)
622 self.assertFalse(obj.absent_)
623 self.assertEqual(obj.address_, 0xFFFF0000)
624 self.assertEqual(obj.bit_offset_, 0)
625 self.assertEqual(obj.bit_field_size_, 32)
626 self.assertEqual(obj.value_(), 1000)
627 self.assertIdentical(
628 obj.read_(),
629 Object(
630 self.prog,
631 self.prog.int_type("unsigned __int128", 16, False),
632 bit_field_size=32,
633 value=1000,
634 ),
635 )
636 self.assertEqual(obj.to_bytes_(), buffer)
637 self.assertEqual(
638 repr(obj),
639 "Object(prog, 'unsigned __int128', address=0xffff0000, bit_field_size=32)",
640 )
641
642 def test_non_standard_float(self):
643 for size in (2, 10, 16, 32):
644 buffer = (1000).to_bytes(size, "little")
645 self.add_memory_segment(buffer, virt_addr=0xFFFF0000)
646 obj = Object(
647 self.prog,
648 self.prog.float_type("CUSTOM_FLOAT", size),
649 address=0xFFFF0000,
650 )
651 self.assertIs(obj.prog_, self.prog)
652 self.assertFalse(obj.absent_)
653 self.assertEqual(obj.address_, 0xFFFF0000)
654 self.assertEqual(obj.bit_offset_, 0)
655 self.assertIsNone(obj.bit_field_size_)
656 self.assertEqual(obj.type_.size, size)
657 self.assertRaisesRegex(
658 NotImplementedError,
659 "float values which are not 32 or 64 bits are not yet supported",
660 obj.value_,
661 )
662 self.assertEqual(obj.to_bytes_(), buffer)
663 self.assertEqual(
664 repr(obj), "Object(prog, 'CUSTOM_FLOAT', address=0xffff0000)"
665 )
666
667
668 class TestValue(MockProgramTestCase):
669 def test_positional(self):
670 self.assertIdentical(
671 Object(self.prog, "int", 1), Object(self.prog, "int", value=1)
672 )
673
674 def test_signed(self):
675 obj = Object(self.prog, "int", value=-4)
676 self.assertIs(obj.prog_, self.prog)
677 self.assertIdentical(obj.type_, self.prog.type("int"))
678 self.assertFalse(obj.absent_)
679 self.assertIsNone(obj.absence_reason_)
680 self.assertIsNone(obj.address_)
681 self.assertIsNone(obj.bit_offset_)
682 self.assertIsNone(obj.bit_field_size_)
683 self.assertEqual(obj.value_(), -4)
684 self.assertEqual(repr(obj), "Object(prog, 'int', value=-4)")
685
686 self.assertIdentical(obj.read_(), obj)
687
688 self.assertIdentical(Object(self.prog, "int", value=2**32 - 4), obj)
689 self.assertIdentical(Object(self.prog, "int", value=2**64 - 4), obj)
690 self.assertIdentical(Object(self.prog, "int", value=2**128 - 4), obj)
691 self.assertIdentical(Object(self.prog, "int", value=-4.6), obj)
692
693 self.assertRaisesRegex(
694 TypeError,
695 "'int' value must be number",
696 Object,
697 self.prog,
698 "int",
699 value=b"asdf",
700 )
701
702 obj = Object(self.prog, "int", value=8, bit_field_size=4)
703 self.assertIsNone(obj.bit_offset_)
704 self.assertEqual(obj.bit_field_size_, 4)
705 self.assertEqual(obj.value_(), -8)
706 self.assertEqual(repr(obj), "Object(prog, 'int', value=-8, bit_field_size=4)")
707
708 def test_unsigned(self):
709 obj = Object(self.prog, "unsigned int", value=2**32 - 1)
710 self.assertIs(obj.prog_, self.prog)
711 self.assertIdentical(obj.type_, self.prog.type("unsigned int"))
712 self.assertFalse(obj.absent_)
713 self.assertIsNone(obj.absence_reason_)
714 self.assertIsNone(obj.address_)
715 self.assertIsNone(obj.bit_offset_)
716 self.assertIsNone(obj.bit_field_size_)
717 self.assertEqual(obj.value_(), 2**32 - 1)
718 self.assertEqual(repr(obj), "Object(prog, 'unsigned int', value=4294967295)")
719
720 self.assertIdentical(Object(self.prog, "unsigned int", value=-1), obj)
721 self.assertIdentical(Object(self.prog, "unsigned int", value=2**64 - 1), obj)
722 self.assertIdentical(Object(self.prog, "unsigned int", value=2**65 - 1), obj)
723 self.assertIdentical(
724 Object(self.prog, "unsigned int", value=2**32 - 1 + 0.9), obj
725 )
726
727 self.assertRaisesRegex(
728 TypeError,
729 "'unsigned int' value must be number",
730 Object,
731 self.prog,
732 "unsigned int",
733 value="foo",
734 )
735
736 obj = Object(self.prog, "unsigned int", value=24, bit_field_size=4)
737 self.assertIsNone(obj.bit_offset_)
738 self.assertEqual(obj.bit_field_size_, 4)
739 self.assertEqual(obj.value_(), 8)
740 self.assertEqual(
741 repr(obj), "Object(prog, 'unsigned int', value=8, bit_field_size=4)"
742 )
743
744 value = 12345678912345678989
745 for bit_size in range(1, 65):
746 self.assertEqual(
747 Object(
748 self.prog,
749 "unsigned long long",
750 value=value,
751 bit_field_size=bit_size,
752 ).value_(),
753 value & ((1 << bit_size) - 1),
754 )
755
756 def _test_big_int_operators(self, type):
757 big_obj = Object(self.prog, type, 1000)
758 obj = Object(self.prog, "int", 0)
759 for op in (
760 operator.lt,
761 operator.le,
762 operator.eq,
763 operator.ge,
764 operator.gt,
765 operator.add,
766 operator.and_,
767 operator.lshift,
768 operator.mod,
769 operator.mul,
770 operator.or_,
771 operator.rshift,
772 operator.sub,
773 operator.truediv,
774 operator.xor,
775 ):
776 self.assertRaises(NotImplementedError, op, big_obj, obj)
777 self.assertRaises(NotImplementedError, op, obj, big_obj)
778
779 for op in (
780 operator.inv,
781 operator.neg,
782 operator.pos,
783 ):
784 self.assertRaises(NotImplementedError, op, big_obj)
785
786 self.assertFalse(not big_obj)
787 self.assertTrue(bool(big_obj))
788 for op in (
789 operator.index,
790 round,
791 math.trunc,
792 math.floor,
793 math.ceil,
794 ):
795 self.assertEqual(op(big_obj), 1000)
796
797 def test_signed_big(self):
798 type = self.prog.int_type("__int128", 16, True)
799 obj = Object(self.prog, type, -4)
800 self.assertIs(obj.prog_, self.prog)
801 self.assertIdentical(obj.type_, self.prog.int_type("__int128", 16, True))
802 self.assertFalse(obj.absent_)
803 self.assertIsNone(obj.absence_reason_)
804 self.assertIsNone(obj.address_)
805 self.assertIsNone(obj.bit_offset_)
806 self.assertIsNone(obj.bit_field_size_)
807 self.assertEqual(obj.value_(), -4)
808 self.assertEqual(repr(obj), "Object(prog, '__int128', value=-4)")
809
810 self.assertIdentical(Object(self.prog, type, value=2**128 - 4), obj)
811 self.assertIdentical(Object(self.prog, type, value=-4.6), obj)
812
813 self.assertIdentical(
814 Object(self.prog, type, value=2**128 + 4),
815 Object(self.prog, type, value=4),
816 )
817
818 self.assertRaisesRegex(
819 TypeError,
820 "'__int128' value must be number",
821 Object,
822 self.prog,
823 type,
824 value=b"asdf",
825 )
826
827 self._test_big_int_operators(type)
828
829 def test_unsigned_big(self):
830 type = self.prog.int_type("unsigned __int128", 16, False)
831 obj = Object(self.prog, type, 2**128 - 1)
832 self.assertIs(obj.prog_, self.prog)
833 self.assertIdentical(
834 obj.type_, self.prog.int_type("unsigned __int128", 16, False)
835 )
836 self.assertFalse(obj.absent_)
837 self.assertIsNone(obj.absence_reason_)
838 self.assertIsNone(obj.address_)
839 self.assertIsNone(obj.bit_offset_)
840 self.assertIsNone(obj.bit_field_size_)
841 self.assertEqual(obj.value_(), 2**128 - 1)
842 self.assertEqual(
843 repr(obj),
844 "Object(prog, 'unsigned __int128', value=340282366920938463463374607431768211455)",
845 )
846
847 self.assertIdentical(Object(self.prog, type, value=-1), obj)
848 self.assertIdentical(Object(self.prog, type, value=2**128 - 1), obj)
849 self.assertIdentical(Object(self.prog, type, value=2**129 - 1), obj)
850 self.assertIdentical(
851 Object(self.prog, type, value=0.1), Object(self.prog, type, value=0)
852 )
853
854 self.assertRaisesRegex(
855 TypeError,
856 "'unsigned __int128' value must be number",
857 Object,
858 self.prog,
859 type,
860 value="foo",
861 )
862
863 self._test_big_int_operators(type)
864
865 def test_int_bits(self):
866 for (
867 signed,
868 byteorder,
869 bit_size,
870 type,
871 bit_offset,
872 value,
873 value_bytes,
874 source_bytes,
875 ) in _int_bits_cases(self.prog):
876 with self.subTest(
877 signed=signed,
878 byteorder=byteorder,
879 bit_size=bit_size,
880 bit_offset=bit_offset,
881 value=value,
882 ):
883 obj = Object(self.prog, type, value, bit_field_size=bit_size)
884 self.assertEqual(obj.value_(), value)
885 self.assertEqual(obj.to_bytes_(), value_bytes)
886 self.assertIdentical(
887 Object.from_bytes_(
888 self.prog,
889 obj.type_,
890 source_bytes,
891 bit_offset=bit_offset,
892 bit_field_size=bit_size,
893 ),
894 obj,
895 )
896
897 def test_float(self):
898 obj = Object(self.prog, "double", value=3.14)
899 self.assertIs(obj.prog_, self.prog)
900 self.assertIdentical(obj.type_, self.prog.type("double"))
901 self.assertFalse(obj.absent_)
902 self.assertIsNone(obj.absence_reason_)
903 self.assertIsNone(obj.address_)
904 self.assertEqual(obj.value_(), 3.14)
905 self.assertEqual(repr(obj), "Object(prog, 'double', value=3.14)")
906
907 obj = Object(self.prog, "double", value=-100.0)
908 self.assertIdentical(Object(self.prog, "double", value=-100), obj)
909
910 self.assertRaisesRegex(
911 TypeError,
912 "'double' value must be number",
913 Object,
914 self.prog,
915 "double",
916 value={},
917 )
918
919 self.assertEqual(Object(self.prog, "double", value=math.e).value_(), math.e)
920 self.assertEqual(
921 Object(self.prog, "float", value=math.e).value_(),
922 struct.unpack("f", struct.pack("f", math.e))[0],
923 )
924
925 def test_enum(self):
926 self.assertEqual(Object(self.prog, self.color_type, value=0).value_(), 0)
927
928 def test_incomplete_struct(self):
929 self.assertRaisesRegex(
930 TypeError,
931 "cannot create value with incomplete structure type",
932 Object,
933 self.prog,
934 self.prog.struct_type("foo"),
935 value={},
936 )
937
938 def test_incomplete_union(self):
939 self.assertRaisesRegex(
940 TypeError,
941 "cannot create value with incomplete union type",
942 Object,
943 self.prog,
944 self.prog.union_type("foo"),
945 value={},
946 )
947
948 def test_incomplete_class(self):
949 self.assertRaisesRegex(
950 TypeError,
951 "cannot create value with incomplete class type",
952 Object,
953 self.prog,
954 self.prog.class_type("foo"),
955 value={},
956 )
957
958 def test_incomplete_enum(self):
959 self.assertRaisesRegex(
960 TypeError,
961 "cannot create value with incomplete enumerated type",
962 Object,
963 self.prog,
964 self.prog.enum_type("foo"),
965 value=0,
966 )
967
968 def test_incomplete_array(self):
969 self.assertRaisesRegex(
970 TypeError,
971 "cannot create value with incomplete array type",
972 Object,
973 self.prog,
974 self.prog.array_type(self.prog.int_type("int", 4, True)),
975 value=[],
976 )
977
978 def test_compound(self):
979 obj = Object(self.prog, self.point_type, value={"x": 100, "y": -5})
980 self.assertIdentical(obj.x, Object(self.prog, "int", value=100))
981 self.assertIdentical(obj.y, Object(self.prog, "int", value=-5))
982
983 self.assertIdentical(
984 Object(self.prog, self.point_type, value={}),
985 Object(self.prog, self.point_type, value={"x": 0, "y": 0}),
986 )
987
988 value = {
989 "a": {"x": 1, "y": 2},
990 "b": {"x": 3, "y": 4},
991 }
992 obj = Object(self.prog, self.line_segment_type, value=value)
993 self.assertIdentical(
994 obj.a, Object(self.prog, self.point_type, value={"x": 1, "y": 2})
995 )
996 self.assertIdentical(
997 obj.b, Object(self.prog, self.point_type, value={"x": 3, "y": 4})
998 )
999 self.assertEqual(obj.value_(), value)
1000
1001 invalid_struct = self.prog.struct_type(
1002 "foo",
1003 4,
1004 (
1005 TypeMember(self.prog.int_type("short", 2, True), "a"),
1006 # Straddles the end of the structure.
1007 TypeMember(self.prog.int_type("int", 4, True), "b", 16),
1008 # Beyond the end of the structure.
1009 TypeMember(self.prog.int_type("int", 4, True), "c", 32),
1010 ),
1011 )
1012
1013 Object(self.prog, invalid_struct, value={"a": 0})
1014 self.assertRaisesRegex(
1015 OutOfBoundsError,
1016 "out of bounds of value",
1017 Object,
1018 self.prog,
1019 invalid_struct,
1020 value={"a": 0, "b": 4},
1021 )
1022 self.assertRaisesRegex(
1023 OutOfBoundsError,
1024 "out of bounds of value",
1025 Object,
1026 self.prog,
1027 invalid_struct,
1028 value={"a": 0, "c": 4},
1029 )
1030
1031 self.assertRaisesRegex(
1032 TypeError,
1033 "must be dictionary or mapping",
1034 Object,
1035 self.prog,
1036 self.point_type,
1037 value=1,
1038 )
1039 self.assertRaisesRegex(
1040 TypeError,
1041 "member key must be string",
1042 Object,
1043 self.prog,
1044 self.point_type,
1045 value={0: 0},
1046 )
1047 self.assertRaisesRegex(
1048 TypeError,
1049 "must be number",
1050 Object,
1051 self.prog,
1052 self.point_type,
1053 value={"x": []},
1054 )
1055 self.assertRaisesRegex(
1056 LookupError,
1057 "has no member 'z'",
1058 Object,
1059 self.prog,
1060 self.point_type,
1061 value={"z": 999},
1062 )
1063
1064 def test_compound_offset(self):
1065 value = {"n": 23, "x": 100, "y": -5}
1066 obj = Object(
1067 self.prog,
1068 self.prog.struct_type(
1069 None,
1070 12,
1071 (
1072 TypeMember(self.prog.int_type("int", 4, True), "n"),
1073 TypeMember(self.point_type, None, 32),
1074 ),
1075 ),
1076 value,
1077 )
1078 self.assertEqual(obj.value_(), value)
1079 self.assertIdentical(obj.x, Object(self.prog, "int", value=100))
1080 self.assertIdentical(obj.y, Object(self.prog, "int", value=-5))
1081
1082 def test_compound_float(self):
1083 for byteorder in ("little", "big"):
1084 for type in (
1085 self.prog.float_type("double", 8, byteorder),
1086 self.prog.float_type("float", 4, byteorder),
1087 ):
1088 with self.subTest(byteorder=byteorder, type=type.name):
1089 obj = Object(
1090 self.prog,
1091 self.prog.struct_type(
1092 None,
1093 type.size * 2,
1094 (
1095 TypeMember(type, "a"),
1096 TypeMember(type, "b", type.size * 8),
1097 ),
1098 ),
1099 value={"a": 1234, "b": -3.125},
1100 )
1101 self.assertEqual(obj.a.value_(), 1234.0)
1102 self.assertEqual(obj.b.value_(), -3.125)
1103
1104 def test_compound_bit_fields(self):
1105 a = 0xF8935CF44C45202748DE66B49BA0CBAC
1106 b = -0xC256D5AAFFDC3179A6AC84E7154A215D
1107 for signed in (True, False):
1108 if signed:
1109
1110 def truncate(x, bit_size):
1111 sign = 1 << (bit_size - 1)
1112 return (x & (sign - 1)) - (x & sign)
1113
1114 else:
1115
1116 def truncate(x, bit_size):
1117 return x & ((1 << bit_size) - 1)
1118
1119 for byteorder in ("little", "big"):
1120 for bit_size in range(1, 128):
1121 with self.subTest(
1122 signed=signed, byteorder=byteorder, bit_size=bit_size
1123 ):
1124 type = self.prog.int_type(
1125 ("" if signed else "unsigned ") + "__int128", 16, signed
1126 )
1127 obj = Object(
1128 self.prog,
1129 self.prog.struct_type(
1130 None,
1131 type.size * 2,
1132 (
1133 TypeMember(
1134 Object(
1135 self.prog, type, bit_field_size=bit_size
1136 ),
1137 "a",
1138 ),
1139 TypeMember(
1140 Object(
1141 self.prog,
1142 type,
1143 bit_field_size=128 - bit_size,
1144 ),
1145 "b",
1146 bit_size,
1147 ),
1148 ),
1149 ),
1150 value={"a": a, "b": b},
1151 )
1152 self.assertEqual(obj.a.value_(), truncate(a, bit_size))
1153 self.assertEqual(obj.b.value_(), truncate(b, 128 - bit_size))
1154
1155 def test_pointer(self):
1156 obj = Object(self.prog, "int *", value=0xFFFF0000)
1157 self.assertFalse(obj.absent_)
1158 self.assertIsNone(obj.absence_reason_)
1159 self.assertIsNone(obj.address_)
1160 self.assertEqual(obj.value_(), 0xFFFF0000)
1161 self.assertEqual(repr(obj), "Object(prog, 'int *', value=0xffff0000)")
1162
1163 def test_pointer_typedef(self):
1164 obj = Object(
1165 self.prog,
1166 self.prog.typedef_type("INTP", self.prog.type("int *")),
1167 value=0xFFFF0000,
1168 )
1169 self.assertFalse(obj.absent_)
1170 self.assertIsNone(obj.absence_reason_)
1171 self.assertIsNone(obj.address_)
1172 self.assertEqual(obj.value_(), 0xFFFF0000)
1173 self.assertEqual(repr(obj), "Object(prog, 'INTP', value=0xffff0000)")
1174
1175 def test_array(self):
1176 obj = Object(self.prog, "int [2]", value=[1, 2])
1177 self.assertFalse(obj.absent_)
1178 self.assertIsNone(obj.absence_reason_)
1179 self.assertIsNone(obj.address_)
1180
1181 self.assertIdentical(obj[0], Object(self.prog, "int", value=1))
1182 self.assertIdentical(obj[1], Object(self.prog, "int", value=2))
1183
1184 self.assertIdentical(
1185 Object(self.prog, "int [2]", value=[]),
1186 Object(self.prog, "int [2]", value=[0, 0]),
1187 )
1188
1189 self.assertRaisesRegex(
1190 TypeError, "must be iterable", Object, self.prog, "int [1]", value=1
1191 )
1192 self.assertRaisesRegex(
1193 ValueError,
1194 "too many items in array value",
1195 Object,
1196 self.prog,
1197 "int [1]",
1198 value=[1, 2],
1199 )
1200
1201 def test_non_scalar_bit_offset(self):
1202 obj = Object(
1203 self.prog,
1204 self.prog.struct_type(
1205 "weird", 9, (TypeMember(self.point_type, "point", bit_offset=1),)
1206 ),
1207 value={},
1208 )
1209 self.assertRaisesRegex(
1210 ValueError, "non-scalar must be byte-aligned", obj.member_, "point"
1211 )
1212
1213 def test_small_bit_field_of_big_int(self):
1214 obj = Object(
1215 self.prog,
1216 self.prog.int_type("unsigned __int128", 16, False),
1217 value=1000,
1218 bit_field_size=32,
1219 )
1220 self.assertIsNone(obj.bit_offset_)
1221 self.assertEqual(obj.bit_field_size_, 32)
1222 self.assertEqual(obj.value_(), 1000)
1223 self.assertEqual(
1224 repr(obj),
1225 "Object(prog, 'unsigned __int128', value=1000, bit_field_size=32)",
1226 )
1227
1228 def test_non_standard_float(self):
1229 for size in (2, 10, 16, 32):
1230 type = self.prog.float_type("CUSTOM_FLOAT", size)
1231 self.assertRaisesRegex(
1232 NotImplementedError,
1233 "float values which are not 32 or 64 bits are not yet supported",
1234 Object,
1235 self.prog,
1236 type,
1237 0,
1238 )
1239 self.assertRaisesRegex(
1240 NotImplementedError,
1241 "float values which are not 32 or 64 bits are not yet supported",
1242 Object.from_bytes_,
1243 self.prog,
1244 type,
1245 (0).to_bytes(size, "little"),
1246 )
1247
1248
1249 class TestAbsent(MockProgramTestCase):
1250 def test_basic(self):
1251 for obj in [
1252 Object(self.prog, "int"),
1253 Object(self.prog, "int", value=None, address=None),
1254 ]:
1255 self.assertIs(obj.prog_, self.prog)
1256 self.assertIdentical(obj.type_, self.prog.type("int"))
1257 self.assertTrue(obj.absent_)
1258 self.assertEqual(
1259 Object(self.prog, "int").absence_reason_, AbsenceReason.OTHER
1260 )
1261 self.assertIsNone(obj.address_)
1262 self.assertIsNone(obj.bit_offset_)
1263 self.assertIsNone(obj.bit_field_size_)
1264 self.assertRaises(ObjectAbsentError, obj.value_)
1265 self.assertEqual(repr(obj), "Object(prog, 'int')")
1266
1267 self.assertRaises(ObjectAbsentError, obj.read_)
1268
1269 def test_reason(self):
1270 obj = Object(self.prog, "int", absence_reason=AbsenceReason.OPTIMIZED_OUT)
1271 self.assertEqual(obj.absence_reason_, AbsenceReason.OPTIMIZED_OUT)
1272 self.assertEqual(
1273 repr(obj), "Object(prog, 'int', absence_reason=AbsenceReason.OPTIMIZED_OUT)"
1274 )
1275
1276 def test_bit_field(self):
1277 obj = Object(self.prog, "int", bit_field_size=1)
1278 self.assertIs(obj.prog_, self.prog)
1279 self.assertIdentical(obj.type_, self.prog.type("int"))
1280 self.assertIsNone(obj.address_)
1281 self.assertIsNone(obj.bit_offset_)
1282 self.assertEqual(obj.bit_field_size_, 1)
1283 self.assertEqual(repr(obj), "Object(prog, 'int', bit_field_size=1)")
1284
1285 def test_operators(self):
1286 absent = Object(self.prog, "int")
1287 obj = Object(self.prog, "int", 1)
1288 for op in [
1289 operator.lt,
1290 operator.le,
1291 operator.eq,
1292 operator.ge,
1293 operator.gt,
1294 operator.add,
1295 operator.and_,
1296 operator.lshift,
1297 operator.mod,
1298 operator.mul,
1299 operator.or_,
1300 operator.rshift,
1301 operator.sub,
1302 operator.truediv,
1303 operator.xor,
1304 ]:
1305 self.assertRaises(ObjectAbsentError, op, absent, obj)
1306 self.assertRaises(ObjectAbsentError, op, obj, absent)
1307
1308 for op in [
1309 operator.not_,
1310 operator.truth,
1311 operator.index,
1312 operator.inv,
1313 operator.neg,
1314 operator.pos,
1315 round,
1316 math.trunc,
1317 math.floor,
1318 math.ceil,
1319 ]:
1320 self.assertRaises(ObjectAbsentError, op, absent)
1321
1322 self.assertRaises(ObjectAbsentError, absent.address_of_)
1323
1324 self.assertRaises(
1325 ObjectAbsentError,
1326 operator.getitem,
1327 Object(self.prog, "int [2]"),
1328 0,
1329 )
1330
1331 self.assertRaises(ObjectAbsentError, Object(self.prog, "char [16]").string_)
1332 self.assertRaises(ObjectAbsentError, Object(self.prog, "char *").string_)
1333
1334 def test_big_int(self):
1335 obj = Object(self.prog, self.prog.int_type("BIG", 16, True))
1336 self.assertIs(obj.prog_, self.prog)
1337 self.assertEqual(obj.type_.size, 16)
1338 self.assertIsNone(obj.address_)
1339 self.assertIsNone(obj.bit_offset_)
1340 self.assertIsNone(obj.bit_field_size_)
1341 self.assertEqual(repr(obj), "Object(prog, 'BIG')")
1342
1343 def test_non_standard_float(self):
1344 for size in (2, 10, 16, 32):
1345 obj = Object(self.prog, self.prog.float_type("CUSTOM_FLOAT", size))
1346 self.assertIs(obj.prog_, self.prog)
1347 self.assertEqual(obj.type_.size, size)
1348 self.assertIsNone(obj.address_)
1349 self.assertIsNone(obj.bit_offset_)
1350 self.assertIsNone(obj.bit_field_size_)
1351 self.assertEqual(repr(obj), "Object(prog, 'CUSTOM_FLOAT')")
1352
1353
1354 class TestConversions(MockProgramTestCase):
1355 def test_bool(self):
1356 self.assertTrue(Object(self.prog, "int", value=-1))
1357 self.assertFalse(Object(self.prog, "int", value=0))
1358
1359 self.assertTrue(Object(self.prog, "unsigned int", value=1))
1360 self.assertFalse(Object(self.prog, "unsigned int", value=0))
1361
1362 self.assertTrue(Object(self.prog, "double", value=3.14))
1363 self.assertFalse(Object(self.prog, "double", value=0.0))
1364
1365 self.assertTrue(Object(self.prog, "int *", value=0xFFFF0000))
1366 self.assertFalse(Object(self.prog, "int *", value=0x0))
1367
1368 self.assertRaisesRegex(
1369 TypeError,
1370 "cannot convert 'struct point' to bool",
1371 bool,
1372 Object(self.prog, self.point_type, address=0),
1373 )
1374
1375 def test_int(self):
1376 self.assertEqual(int(Object(self.prog, "int", value=-1)), -1)
1377 self.assertEqual(int(Object(self.prog, "unsigned int", value=1)), 1)
1378 self.assertEqual(int(Object(self.prog, "double", value=9.99)), 9)
1379 self.assertEqual(int(Object(self.prog, "int *", value=0)), 0)
1380
1381 self.assertRaisesRegex(
1382 TypeError,
1383 r"cannot convert 'int \[\]' to int",
1384 int,
1385 Object(self.prog, "int []", address=0),
1386 )
1387
1388 def test_float(self):
1389 self.assertEqual(float(Object(self.prog, "int", value=-1)), -1.0)
1390 self.assertEqual(float(Object(self.prog, "unsigned int", value=1)), 1.0)
1391 self.assertEqual(float(Object(self.prog, "double", value=9.99)), 9.99)
1392
1393 self.assertRaisesRegex(
1394 TypeError,
1395 r"cannot convert 'int \*' to float",
1396 float,
1397 Object(self.prog, "int *", value=0xFFFF0000),
1398 )
1399 self.assertRaisesRegex(
1400 TypeError,
1401 r"cannot convert 'int \[\]' to float",
1402 float,
1403 Object(self.prog, "int []", address=0),
1404 )
1405
1406 def test_index(self):
1407 self.assertEqual(operator.index(Object(self.prog, "int", value=-1)), -1)
1408 self.assertEqual(operator.index(Object(self.prog, "unsigned int", value=1)), 1)
1409 self.assertEqual(operator.index(Object(self.prog, "int *", value=0)), 0)
1410
1411 self.assertRaisesRegex(
1412 TypeError,
1413 "'double' object cannot be interpreted as an integer",
1414 operator.index,
1415 Object(self.prog, "double", value=9.99),
1416 )
1417 self.assertRaisesRegex(
1418 TypeError,
1419 r"'int \[\]' object cannot be interpreted as an integer",
1420 operator.index,
1421 Object(self.prog, "int []", address=0),
1422 )
1423
1424 def test_signed_int_value_to_bytes(self):
1425 for byteorder in ("little", "big"):
1426 with self.subTest(byteorder=byteorder):
1427 self.assertEqual(
1428 Object(
1429 self.prog, self.prog.int_type("int", 4, True, byteorder), -100
1430 ).to_bytes_(),
1431 (-100).to_bytes(4, byteorder, signed=True),
1432 )
1433 self.assertEqual(
1434 Object(
1435 self.prog,
1436 self.prog.int_type("long", 8, True, byteorder),
1437 -(2**32),
1438 ).to_bytes_(),
1439 (-(2**32)).to_bytes(8, byteorder, signed=True),
1440 )
1441
1442 def test_unsigned_int_value_to_bytes(self):
1443 for byteorder in ("little", "big"):
1444 with self.subTest(byteorder=byteorder):
1445 self.assertEqual(
1446 Object(
1447 self.prog,
1448 self.prog.int_type("unsigned int", 4, False, byteorder),
1449 2**31,
1450 ).to_bytes_(),
1451 (2**31).to_bytes(4, byteorder),
1452 )
1453 self.assertEqual(
1454 Object(
1455 self.prog,
1456 self.prog.int_type("unsigned long", 8, False, byteorder),
1457 2**60,
1458 ).to_bytes_(),
1459 (2**60).to_bytes(8, byteorder),
1460 )
1461
1462 def test_float64_value_to_bytes(self):
1463 for byteorder in ("little", "big"):
1464 with self.subTest(byteorder=byteorder):
1465 self.assertEqual(
1466 Object(
1467 self.prog, self.prog.float_type("double", 8, byteorder), math.e
1468 ).to_bytes_(),
1469 struct.pack(("<" if byteorder == "little" else ">") + "d", math.e),
1470 )
1471
1472 def test_float32_value_to_bytes(self):
1473 for byteorder in ("little", "big"):
1474 with self.subTest(byteorder=byteorder):
1475 self.assertEqual(
1476 Object(
1477 self.prog, self.prog.float_type("float", 4, byteorder), math.e
1478 ).to_bytes_(),
1479 struct.pack(("<" if byteorder == "little" else ">") + "f", math.e),
1480 )
1481
1482 def test_struct_value_to_bytes(self):
1483 self.assertEqual(
1484 Object(self.prog, self.point_type, {"x": 1, "y": 2}).to_bytes_(),
1485 b"\x01\x00\x00\x00\x02\x00\x00\x00",
1486 )
1487
1488 def test_int_reference_to_bytes(self):
1489 self.add_memory_segment(b"\x78\x56\x34\x12", virt_addr=0xFFFF0000)
1490 self.assertEqual(
1491 Object(self.prog, "int", address=0xFFFF0000).to_bytes_(),
1492 b"\x78\x56\x34\x12",
1493 )
1494
1495 def test_int_reference_bit_offset_to_bytes(self):
1496 self.add_memory_segment(b"\xe0Y\xd1H\x00", virt_addr=0xFFFF0000)
1497 self.assertEqual(
1498 Object(self.prog, "int", address=0xFFFF0000, bit_offset=2).to_bytes_(),
1499 b"\x78\x56\x34\x12",
1500 )
1501
1502 def test_int_reference_big_endian_bit_offset_to_bytes(self):
1503 self.add_memory_segment(b"\x04\x8d\x15\x9e\x00", virt_addr=0xFFFF0000)
1504 self.assertEqual(
1505 Object(
1506 self.prog,
1507 self.prog.int_type("int", 4, True, "big"),
1508 address=0xFFFF0000,
1509 bit_offset=2,
1510 ).to_bytes_(),
1511 b"\x12\x34\x56\x78",
1512 )
1513
1514 def test_struct_reference_to_bytes(self):
1515 self.add_memory_segment(
1516 b"\x01\x00\x00\x00\x02\x00\x00\x00", virt_addr=0xFFFF0000
1517 )
1518 self.assertEqual(
1519 Object(self.prog, self.point_type, address=0xFFFF0000).to_bytes_(),
1520 b"\x01\x00\x00\x00\x02\x00\x00\x00",
1521 )
1522
1523 def test_int_from_bytes(self):
1524 for byteorder in ("little", "big"):
1525 with self.subTest(byteorder=byteorder):
1526 type_ = self.prog.int_type("int", 4, True, byteorder)
1527 self.assertIdentical(
1528 Object.from_bytes_(
1529 self.prog, type_, (0x12345678).to_bytes(4, byteorder)
1530 ),
1531 Object(self.prog, type_, 0x12345678),
1532 )
1533
1534 def test_int_from_bytes_bit_offset(self):
1535 self.assertIdentical(
1536 Object.from_bytes_(self.prog, "int", b"\xe0Y\xd1H\x00", bit_offset=2),
1537 Object(self.prog, "int", 0x12345678),
1538 )
1539
1540 def test_int_from_bytes_big_endian_bit_offset(self):
1541 self.assertIdentical(
1542 Object.from_bytes_(
1543 self.prog,
1544 self.prog.int_type("int", 4, True, "big"),
1545 b"\x04\x8d\x15\x9e\x00",
1546 bit_offset=2,
1547 ),
1548 Object(self.prog, self.prog.int_type("int", 4, True, "big"), 0x12345678),
1549 )
1550
1551 def test_int_from_bytes_bit_field(self):
1552 self.assertIdentical(
1553 Object.from_bytes_(self.prog, "int", b"\xcc", bit_field_size=8),
1554 Object(self.prog, "int", 0xCC, bit_field_size=8),
1555 )
1556
1557 def test_float64_from_bytes(self):
1558 for byteorder in ("little", "big"):
1559 with self.subTest(byteorder=byteorder):
1560 type_ = self.prog.float_type("double", 8, byteorder)
1561 self.assertIdentical(
1562 Object.from_bytes_(
1563 self.prog,
1564 type_,
1565 struct.pack(
1566 ("<" if byteorder == "little" else ">") + "d", math.e
1567 ),
1568 ),
1569 Object(self.prog, type_, math.e),
1570 )
1571
1572 def test_float32_from_bytes(self):
1573 for byteorder in ("little", "big"):
1574 with self.subTest(byteorder=byteorder):
1575 type_ = self.prog.float_type("float", 4, byteorder)
1576 self.assertIdentical(
1577 Object.from_bytes_(
1578 self.prog,
1579 type_,
1580 struct.pack(
1581 ("<" if byteorder == "little" else ">") + "f", math.e
1582 ),
1583 ),
1584 Object(self.prog, type_, math.e),
1585 )
1586
1587 def test_struct_from_bytes(self):
1588 self.assertIdentical(
1589 Object.from_bytes_(
1590 self.prog, self.point_type, b"\x01\x00\x00\x00\x02\x00\x00\x00"
1591 ),
1592 Object(self.prog, self.point_type, {"x": 1, "y": 2}),
1593 )
1594
1595 def test_struct_from_bytes_bit_offset(self):
1596 self.assertIdentical(
1597 Object.from_bytes_(
1598 self.prog,
1599 self.point_type,
1600 b"\xff\x01\x00\x00\x00\x02\x00\x00\x00",
1601 bit_offset=8,
1602 ),
1603 Object(self.prog, self.point_type, {"x": 1, "y": 2}),
1604 )
1605
1606 def test_struct_from_bytes_invalid_bit_offset(self):
1607 self.assertRaisesRegex(
1608 ValueError,
1609 "non-scalar must be byte-aligned",
1610 Object.from_bytes_,
1611 self.prog,
1612 self.point_type,
1613 b"\xff\x01\x00\x00\x00\x02\x00\x00\x00",
1614 bit_offset=2,
1615 )
1616
1617 def test_from_bytes_invalid_bit_field_size(self):
1618 self.assertRaisesRegex(
1619 ValueError,
1620 "bit field size cannot be zero",
1621 Object.from_bytes_,
1622 self.prog,
1623 "int",
1624 b"",
1625 bit_field_size=0,
1626 )
1627
1628 def test_from_bytes_buffer_too_small(self):
1629 self.assertRaisesRegex(
1630 ValueError,
1631 "buffer is too small",
1632 Object.from_bytes_,
1633 self.prog,
1634 "int",
1635 bytes(3),
1636 )
1637
1638 def test_from_bytes_incomplete_type(self):
1639 self.assertRaisesRegex(
1640 TypeError,
1641 "cannot create object with void type",
1642 Object.from_bytes_,
1643 self.prog,
1644 "void",
1645 b"",
1646 )
1647
1648 def test_from_bytes_bad_type(self):
1649 self.assertRaises(TypeError, Object.from_bytes_, self.prog, None, b"")
1650
1651
1652 class TestInvalidBitField(MockProgramTestCase):
1653 def test_integer(self):
1654 self.assertRaisesRegex(
1655 ValueError,
1656 "bit field size is larger than type size",
1657 Object,
1658 self.prog,
1659 "int",
1660 value=0,
1661 bit_field_size=64,
1662 )
1663 self.assertRaisesRegex(
1664 ValueError,
1665 "bit field size is larger than type size",
1666 Object,
1667 self.prog,
1668 "int",
1669 address=0,
1670 bit_field_size=64,
1671 )
1672 self.assertRaisesRegex(
1673 ValueError,
1674 "bit field size is larger than type size",
1675 Object,
1676 self.prog,
1677 "unsigned int",
1678 value=0,
1679 bit_field_size=64,
1680 )
1681 self.assertRaisesRegex(
1682 ValueError,
1683 "bit field size is larger than type size",
1684 Object,
1685 self.prog,
1686 "unsigned int",
1687 address=0,
1688 bit_field_size=64,
1689 )
1690
1691 def test_float(self):
1692 self.assertRaisesRegex(
1693 ValueError,
1694 "bit field must be integer",
1695 Object,
1696 self.prog,
1697 "float",
1698 value=0,
1699 bit_field_size=16,
1700 )
1701 self.assertRaisesRegex(
1702 ValueError,
1703 "bit field must be integer",
1704 Object,
1705 self.prog,
1706 "float",
1707 address=0,
1708 bit_field_size=16,
1709 )
1710
1711 def test_reference(self):
1712 self.assertRaisesRegex(
1713 ValueError,
1714 "bit field must be integer",
1715 Object,
1716 self.prog,
1717 self.point_type,
1718 address=0,
1719 bit_field_size=4,
1720 )
1721 self.assertRaisesRegex(
1722 ValueError,
1723 "bit field must be integer",
1724 Object,
1725 self.prog,
1726 self.point_type,
1727 value={},
1728 bit_field_size=4,
1729 )
1730
1731
1732 class TestGenericOperators(MockProgramTestCase):
1733 def setUp(self):
1734 super().setUp()
1735 self.add_memory_segment(
1736 b"".join(i.to_bytes(4, "little") for i in range(4)), virt_addr=0xFFFF0000
1737 )
1738
1739 def test_len(self):
1740 self.assertEqual(len(Object(self.prog, "int [0]", address=0)), 0)
1741 self.assertEqual(len(Object(self.prog, "int [10]", address=0)), 10)
1742 self.assertRaisesRegex(
1743 TypeError, "'int' has no len()", len, Object(self.prog, "int", address=0)
1744 )
1745 self.assertRaisesRegex(
1746 TypeError,
1747 r"'int \[\]' has no len()",
1748 len,
1749 Object(self.prog, "int []", address=0),
1750 )
1751
1752 def test_address_of(self):
1753 obj = Object(self.prog, "int", address=0xFFFF0000)
1754 self.assertIdentical(
1755 obj.address_of_(), Object(self.prog, "int *", value=0xFFFF0000)
1756 )
1757 obj = obj.read_()
1758 self.assertRaisesRegex(
1759 ValueError, "cannot take address of value", obj.address_of_
1760 )
1761 obj = Object(self.prog, "int", address=0xFFFF0000, bit_field_size=4)
1762 self.assertRaisesRegex(
1763 ValueError, "cannot take address of bit field", obj.address_of_
1764 )
1765 obj = Object(self.prog, "int", address=0xFFFF0000, bit_offset=4)
1766 self.assertRaisesRegex(
1767 ValueError, "cannot take address of bit field", obj.address_of_
1768 )
1769
1770 def test_subscript(self):
1771 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1772 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1773 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1774 for obj in [arr, incomplete_arr, ptr]:
1775 for i in range(5):
1776 self.assertIdentical(
1777 obj[i], Object(self.prog, "int", address=0xFFFF0000 + 4 * i)
1778 )
1779 if i < 4:
1780 self.assertIdentical(
1781 obj[i].read_(), Object(self.prog, "int", value=i)
1782 )
1783 else:
1784 self.assertRaises(FaultError, obj[i].read_)
1785
1786 obj = arr.read_()
1787 for i in range(4):
1788 self.assertIdentical(obj[i], Object(self.prog, "int", value=i))
1789 self.assertRaisesRegex(OutOfBoundsError, "out of bounds", obj.__getitem__, 4)
1790 obj = Object(self.prog, "int", value=0)
1791 self.assertRaises(TypeError, obj.__getitem__, 0)
1792
1793 def test_negative_subscript(self):
1794 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1795 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1796 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1797 for obj in [arr, incomplete_arr, ptr]:
1798 self.assertIdentical(obj[-1], Object(self.prog, "int", address=0xFFFEFFFC))
1799
1800 obj = arr.read_()
1801 self.assertRaisesRegex(OutOfBoundsError, "out of bounds", obj.__getitem__, -1)
1802
1803 def test_slice(self):
1804 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1805 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1806 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1807 for obj in [arr, incomplete_arr, ptr]:
1808 self.assertIdentical(
1809 obj[1:3], Object(self.prog, "int [2]", address=0xFFFF0004)
1810 )
1811
1812 obj = arr.read_()
1813 self.assertIdentical(obj[1:3], Object(self.prog, "int [2]", [1, 2]))
1814
1815 def test_slice_step(self):
1816 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1817 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1818 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1819 for obj in [arr, incomplete_arr, ptr]:
1820 self.assertIdentical(
1821 obj[1:3:1], Object(self.prog, "int [2]", address=0xFFFF0004)
1822 )
1823
1824 def test_slice_invalid_step(self):
1825 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1826 with self.assertRaisesRegex(ValueError, "object slice step must be 1"):
1827 arr[0:4:2]
1828
1829 def test_slice_negative_start(self):
1830 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1831 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1832 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1833 for obj in [arr, incomplete_arr, ptr]:
1834 self.assertIdentical(
1835 obj[-2:2], Object(self.prog, "int [4]", address=0xFFFEFFF8)
1836 )
1837
1838 obj = arr.read_()
1839 with self.assertRaisesRegex(OutOfBoundsError, "out of bounds"):
1840 obj[-2:2]
1841
1842 def test_slice_both_negative(self):
1843 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1844 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1845 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1846 for obj in [arr, incomplete_arr, ptr]:
1847 self.assertIdentical(
1848 obj[-4:-2], Object(self.prog, "int [2]", address=0xFFFEFFF0)
1849 )
1850
1851 obj = arr.read_()
1852 with self.assertRaisesRegex(OutOfBoundsError, "out of bounds"):
1853 obj[-4:-2]
1854
1855 def test_slice_both_none(self):
1856 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1857 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1858 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1859
1860 self.assertIdentical(arr[:], Object(self.prog, "int [4]", address=0xFFFF0000))
1861 with self.assertRaisesRegex(TypeError, "has no length"):
1862 incomplete_arr[:]
1863 with self.assertRaisesRegex(TypeError, "has no length"):
1864 ptr[:]
1865
1866 self.assertIdentical(arr.read_()[:], Object(self.prog, "int [4]", [0, 1, 2, 3]))
1867
1868 def test_slice_start_none(self):
1869 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1870 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1871 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1872 for obj in [arr, incomplete_arr, ptr]:
1873 self.assertIdentical(
1874 obj[:3], Object(self.prog, "int [3]", address=0xFFFF0000)
1875 )
1876
1877 self.assertIdentical(arr.read_()[:3], Object(self.prog, "int [3]", [0, 1, 2]))
1878
1879 def test_slice_stop_none(self):
1880 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1881 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1882 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1883
1884 self.assertIdentical(arr[1:], Object(self.prog, "int [3]", address=0xFFFF0004))
1885 with self.assertRaisesRegex(TypeError, "has no length"):
1886 incomplete_arr[1:]
1887 with self.assertRaisesRegex(TypeError, "has no length"):
1888 ptr[1:]
1889
1890 self.assertIdentical(arr.read_()[1:], Object(self.prog, "int [3]", [1, 2, 3]))
1891
1892 def test_slice_start_negative_stop_none(self):
1893 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1894 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1895 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1896
1897 self.assertIdentical(arr[-2:], Object(self.prog, "int [6]", address=0xFFFEFFF8))
1898 with self.assertRaisesRegex(TypeError, "has no length"):
1899 incomplete_arr[-2:]
1900 with self.assertRaisesRegex(TypeError, "has no length"):
1901 ptr[-2:]
1902
1903 obj = arr.read_()
1904 with self.assertRaisesRegex(OutOfBoundsError, "out of bounds"):
1905 obj[-2:]
1906
1907 def test_slice_start_none_stop_negative(self):
1908 arr = Object(self.prog, "int [4]", address=0xFFFF0000)
1909 incomplete_arr = Object(self.prog, "int []", address=0xFFFF0000)
1910 ptr = Object(self.prog, "int *", value=0xFFFF0000)
1911 for obj in [arr, incomplete_arr, ptr]:
1912 self.assertIdentical(
1913 obj[:-2], Object(self.prog, "int [0]", address=0xFFFF0000)
1914 )
1915
1916 self.assertIdentical(arr.read_()[:-2], Object(self.prog, "int [0]", []))
1917
1918 def test_cast_primitive_value(self):
1919 obj = Object(self.prog, "long", value=2**32 + 1)
1920 self.assertIdentical(cast("int", obj), Object(self.prog, "int", value=1))
1921 self.assertIdentical(
1922 cast("int", obj.read_()), Object(self.prog, "int", value=1)
1923 )
1924 self.assertIdentical(
1925 cast("const int", Object(self.prog, "int", value=1)),
1926 Object(self.prog, "const int", value=1),
1927 )
1928 self.assertRaisesRegex(
1929 TypeError,
1930 "cannot cast to 'struct point'",
1931 cast,
1932 self.point_type,
1933 Object(self.prog, "int", value=1),
1934 )
1935
1936 def test_cast_compound_value(self):
1937 obj = Object(self.prog, self.point_type, address=0xFFFF0000).read_()
1938 self.assertRaisesRegex(
1939 TypeError,
1940 "cannot cast to 'struct point'",
1941 cast,
1942 self.point_type,
1943 obj,
1944 )
1945 self.assertRaisesRegex(
1946 TypeError,
1947 "cannot convert 'struct point' to 'enum color'",
1948 cast,
1949 self.color_type,
1950 obj,
1951 )
1952
1953 def test_cast_to_incomplete_type(self):
1954 self.assertRaisesRegex(
1955 TypeError,
1956 "cannot cast to incomplete enumerated type",
1957 cast,
1958 self.prog.enum_type("foo"),
1959 Object(self.prog, "int", 1),
1960 )
1961
1962 def test_reinterpret_reference(self):
1963 obj = Object(self.prog, "int", address=0xFFFF0000)
1964 self.assertIdentical(reinterpret("int", obj), obj)
1965 self.assertIdentical(
1966 reinterpret(self.prog.int_type("int", 4, True, "big"), obj),
1967 Object(
1968 self.prog, self.prog.int_type("int", 4, True, "big"), address=0xFFFF0000
1969 ),
1970 )
1971
1972 obj = Object(self.prog, "int []", address=0xFFFF0000)
1973 self.assertIdentical(
1974 reinterpret("int [4]", obj),
1975 Object(self.prog, "int [4]", address=0xFFFF0000),
1976 )
1977
1978 def test_reinterpret_value(self):
1979 self.types.append(self.point_type)
1980 self.types.append(
1981 self.prog.struct_type(
1982 "foo", 8, (TypeMember(self.prog.int_type("long", 8, True), "counter"),)
1983 ),
1984 )
1985 obj = Object(self.prog, "struct point", address=0xFFFF0008).read_()
1986 self.assertIdentical(
1987 reinterpret("struct foo", obj),
1988 Object(self.prog, "struct foo", address=0xFFFF0008).read_(),
1989 )
1990 self.assertIdentical(reinterpret("int", obj), Object(self.prog, "int", value=2))
1991 self.assertIdentical(
1992 reinterpret(self.prog.int_type("int", 4, True, "big"), obj),
1993 Object(
1994 self.prog, self.prog.int_type("int", 4, True, "big"), value=33554432
1995 ),
1996 )
1997
1998 def test_reinterpret_primitive_value_to_same_size_primitive(self):
1999 for byteorder in ("little", "big"):
2000 with self.subTest(byteorder=byteorder):
2001 self.assertIdentical(
2002 reinterpret(
2003 self.prog.int_type("long long", 8, True, byteorder),
2004 Object(
2005 self.prog,
2006 self.prog.int_type(
2007 "unsigned long long", 8, False, byteorder
2008 ),
2009 0xFFFFFFFFFFFFFFF3,
2010 ),
2011 ),
2012 Object(
2013 self.prog,
2014 self.prog.int_type("long long", 8, True, byteorder),
2015 -13,
2016 ),
2017 )
2018
2019 def test_reinterpret_primitive_value_to_smaller_primitive(self):
2020 with self.subTest(byteorder="little"):
2021 self.assertIdentical(
2022 reinterpret(
2023 self.prog.int_type("int", 4, True),
2024 Object(
2025 self.prog,
2026 self.prog.int_type("unsigned long long", 8, False),
2027 0x000027100000029A,
2028 ),
2029 ),
2030 Object(self.prog, self.prog.int_type("int", 4, True), 666),
2031 )
2032 with self.subTest(byteorder="big"):
2033 self.assertIdentical(
2034 reinterpret(
2035 self.prog.int_type("int", 4, True, "big"),
2036 Object(
2037 self.prog,
2038 self.prog.int_type("unsigned long long", 8, False, "big"),
2039 0x000027100000029A,
2040 ),
2041 ),
2042 Object(self.prog, self.prog.int_type("int", 4, True, "big"), 10000),
2043 )
2044
2045 def test_reinterpret_primitive_value_to_same_size_compound(self):
2046 with self.subTest(byteorder="little"):
2047 self.assertIdentical(
2048 reinterpret(
2049 self.point_type,
2050 Object(
2051 self.prog,
2052 self.prog.int_type("unsigned long long", 8, False),
2053 0x000027100000029A,
2054 ),
2055 ),
2056 Object(self.prog, self.point_type, {"x": 666, "y": 10000}),
2057 )
2058 with self.subTest(byteorder="big"):
2059 point_type = self.prog.struct_type(
2060 "point",
2061 8,
2062 (
2063 TypeMember(self.prog.int_type("int", 4, True, "big"), "x", 0),
2064 TypeMember(self.prog.int_type("int", 4, True, "big"), "y", 32),
2065 ),
2066 )
2067 self.assertIdentical(
2068 reinterpret(
2069 point_type,
2070 Object(
2071 self.prog,
2072 self.prog.int_type("unsigned long long", 8, False, "big"),
2073 0x000027100000029A,
2074 ),
2075 ),
2076 Object(self.prog, point_type, {"x": 10000, "y": 666}),
2077 )
2078
2079 def test_reinterpret_primitive_value_to_smaller_compound(self):
2080 with self.subTest(byteorder="little"):
2081 small_point_type = self.prog.struct_type(
2082 "small_point",
2083 4,
2084 (
2085 TypeMember(self.prog.int_type("short", 2, True), "x", 0),
2086 TypeMember(self.prog.int_type("short", 2, True), "y", 16),
2087 ),
2088 )
2089 self.assertIdentical(
2090 reinterpret(
2091 small_point_type,
2092 Object(
2093 self.prog,
2094 self.prog.int_type("unsigned long long", 8, False),
2095 0x123456782710029A,
2096 ),
2097 ),
2098 Object(self.prog, small_point_type, {"x": 666, "y": 10000}),
2099 )
2100 with self.subTest(byteorder="big"):
2101 small_point_type = self.prog.struct_type(
2102 "small_point",
2103 4,
2104 (
2105 TypeMember(self.prog.int_type("short", 2, True, "big"), "x", 0),
2106 TypeMember(self.prog.int_type("short", 2, True, "big"), "y", 16),
2107 ),
2108 )
2109 self.assertIdentical(
2110 reinterpret(
2111 small_point_type,
2112 Object(
2113 self.prog,
2114 self.prog.int_type("unsigned long long", 8, False, "big"),
2115 0x123456782710029A,
2116 ),
2117 ),
2118 Object(self.prog, small_point_type, {"x": 0x1234, "y": 0x5678}),
2119 )
2120
2121 def test_reinterpret_bit_field_value_to_same_size_primitive(self):
2122 for byteorder in ("little", "big"):
2123 with self.subTest(byteorder=byteorder):
2124 self.assertIdentical(
2125 reinterpret(
2126 self.prog.int_type("uint24", 3, False, byteorder),
2127 Object(
2128 self.prog,
2129 self.prog.int_type("unsigned int", 4, False, byteorder),
2130 0xABCDEF,
2131 bit_field_size=24,
2132 ),
2133 ),
2134 Object(
2135 self.prog,
2136 self.prog.int_type("uint24", 3, False, byteorder),
2137 0xABCDEF,
2138 ),
2139 )
2140
2141 def test_reinterpret_bit_field_value_to_smaller_primitive(self):
2142 with self.subTest(byteorder="little"):
2143 self.assertIdentical(
2144 reinterpret(
2145 self.prog.int_type("unsigned short", 2, False),
2146 Object(
2147 self.prog,
2148 self.prog.int_type("unsigned int", 4, False),
2149 0xABCDEF,
2150 bit_field_size=24,
2151 ),
2152 ),
2153 Object(
2154 self.prog,
2155 self.prog.int_type("unsigned short", 2, False),
2156 0xCDEF,
2157 ),
2158 )
2159 with self.subTest(byteorder="big"):
2160 self.assertIdentical(
2161 reinterpret(
2162 self.prog.int_type("unsigned short", 2, False, "big"),
2163 Object(
2164 self.prog,
2165 self.prog.int_type("unsigned int", 4, False, "big"),
2166 0xABCDEF,
2167 bit_field_size=24,
2168 ),
2169 ),
2170 Object(
2171 self.prog,
2172 self.prog.int_type("unsigned short", 2, False, "big"),
2173 0xABCD,
2174 ),
2175 )
2176
2177 def test_member(self):
2178 reference = Object(self.prog, self.point_type, address=0xFFFF0000)
2179 unnamed_reference = Object(
2180 self.prog,
2181 self.prog.struct_type(
2182 "point",
2183 8,
2184 (
2185 TypeMember(
2186 self.prog.struct_type(None, 8, self.point_type.members), None
2187 ),
2188 ),
2189 ),
2190 address=0xFFFF0000,
2191 )
2192 ptr = Object(
2193 self.prog, self.prog.pointer_type(self.point_type), value=0xFFFF0000
2194 )
2195 for obj in [reference, unnamed_reference, ptr]:
2196 self.assertIdentical(
2197 obj.member_("x"), Object(self.prog, "int", address=0xFFFF0000)
2198 )
2199 self.assertIdentical(obj.member_("x"), obj.x)
2200 self.assertIdentical(
2201 obj.member_("y"), Object(self.prog, "int", address=0xFFFF0004)
2202 )
2203 self.assertIdentical(obj.member_("y"), obj.y)
2204
2205 self.assertRaisesRegex(
2206 LookupError, "'struct point' has no member 'z'", obj.member_, "z"
2207 )
2208 self.assertRaisesRegex(
2209 AttributeError, "'struct point' has no member 'z'", getattr, obj, "z"
2210 )
2211
2212 obj = reference.read_()
2213 self.assertIdentical(obj.x, Object(self.prog, "int", value=0))
2214 self.assertIdentical(obj.y, Object(self.prog, "int", value=1))
2215
2216 obj = Object(self.prog, "int", value=1)
2217 self.assertRaisesRegex(
2218 TypeError, "'int' is not a structure, union, or class", obj.member_, "x"
2219 )
2220 self.assertRaisesRegex(AttributeError, "no attribute", getattr, obj, "x")
2221
2222 def test_bit_field_member(self):
2223 self.add_memory_segment(b"\x07\x10\x5e\x5f\x1f\0\0\0", virt_addr=0xFFFF8000)
2224 type_ = self.prog.struct_type(
2225 "bits",
2226 8,
2227 (
2228 TypeMember(
2229 Object(
2230 self.prog, self.prog.int_type("int", 4, True), bit_field_size=4
2231 ),
2232 "x",
2233 0,
2234 ),
2235 TypeMember(
2236 Object(
2237 self.prog,
2238 self.prog.int_type("int", 4, True, qualifiers=Qualifiers.CONST),
2239 bit_field_size=28,
2240 ),
2241 "y",
2242 4,
2243 ),
2244 TypeMember(
2245 Object(
2246 self.prog, self.prog.int_type("int", 4, True), bit_field_size=5
2247 ),
2248 "z",
2249 32,
2250 ),
2251 ),
2252 )
2253
2254 obj = Object(self.prog, type_, address=0xFFFF8000)
2255 self.assertIdentical(
2256 obj.x,
2257 Object(
2258 self.prog,
2259 self.prog.int_type("int", 4, True),
2260 address=0xFFFF8000,
2261 bit_field_size=4,
2262 ),
2263 )
2264 self.assertIdentical(
2265 obj.y,
2266 Object(
2267 self.prog,
2268 self.prog.int_type("int", 4, True, qualifiers=Qualifiers.CONST),
2269 address=0xFFFF8000,
2270 bit_field_size=28,
2271 bit_offset=4,
2272 ),
2273 )
2274 self.assertIdentical(
2275 obj.z,
2276 Object(
2277 self.prog,
2278 self.prog.int_type("int", 4, True),
2279 address=0xFFFF8004,
2280 bit_field_size=5,
2281 ),
2282 )
2283
2284 def test_member_out_of_bounds(self):
2285 obj = Object(
2286 self.prog,
2287 self.prog.struct_type("foo", 4, self.point_type.members),
2288 address=0xFFFF0000,
2289 ).read_()
2290 self.assertRaisesRegex(OutOfBoundsError, "out of bounds", getattr, obj, "y")
2291
2292 def test_string(self):
2293 self.add_memory_segment(
2294 b"\x00\x00\xff\xff\x00\x00\x00\x00", virt_addr=0xFFFEFFF8
2295 )
2296 self.add_memory_segment(b"hello\0world\0", virt_addr=0xFFFF0000)
2297 strings = [
2298 (Object(self.prog, "char *", address=0xFFFEFFF8), b"hello"),
2299 (Object(self.prog, "char [2]", address=0xFFFF0000), b"he"),
2300 (Object(self.prog, "char [8]", address=0xFFFF0000), b"hello"),
2301 ]
2302 for obj, expected in strings:
2303 with self.subTest(obj=obj):
2304 self.assertEqual(obj.string_(), expected)
2305 self.assertEqual(obj.read_().string_(), expected)
2306
2307 strings = [
2308 Object(self.prog, "char []", address=0xFFFF0000),
2309 Object(self.prog, "int []", address=0xFFFF0000),
2310 Object(self.prog, "int [2]", address=0xFFFF0000),
2311 Object(self.prog, "int *", value=0xFFFF0000),
2312 ]
2313 for obj in strings:
2314 self.assertEqual(obj.string_(), b"hello")
2315
2316 self.assertRaisesRegex(
2317 TypeError,
2318 "must be an array or pointer",
2319 Object(self.prog, "int", value=1).string_,
2320 )
2321
2322 def test_format_invalid_integer_base(self):
2323 obj = Object(self.prog, "int", 1)
2324 for integer_base in (
2325 0,
2326 1,
2327 -(2**31),
2328 2**31 - 1,
2329 -(2**32),
2330 2**32,
2331 2**128,
2332 -(2**128),
2333 ):
2334 with self.subTest(integer_base=integer_base):
2335 self.assertRaisesRegex(
2336 ValueError,
2337 "invalid integer base",
2338 obj.format_,
2339 integer_base=integer_base,
2340 )
2341 self.assertRaises(TypeError, obj.format_, integer_base="hex")
2342
2343 def test_sizeof_default_prog(self):
2344 self.objects.append(MockObject("foo", self.prog.int_type("int", 4, True), 1))
2345 self.assertRaises(NoDefaultProgramError, sizeof, "foo")
2346 with with_default_prog(self.prog):
2347 self.assertEqual(sizeof("foo"), 4)
2348
2349
2350 class TestSpecialMethods(MockProgramTestCase):
2351 def test_dir(self):
2352 obj = Object(self.prog, "int", value=0)
2353 self.assertEqual(dir(obj), sorted(object.__dir__(obj)))
2354
2355 obj = Object(self.prog, self.point_type, address=0xFFFF0000)
2356 self.assertEqual(dir(obj), sorted(object.__dir__(obj) + ["x", "y"]))
2357 self.assertEqual(dir(obj.address_of_()), dir(obj))
2358
2359 def test_round(self):
2360 for func in [round, math.trunc, math.floor, math.ceil]:
2361 for value in [0.0, -0.0, -0.4, 0.4, 0.5, -0.5, 0.6, -0.6, 1.0, -1.0]:
2362 self.assertEqual(
2363 func(Object(self.prog, "double", value=value)), func(value)
2364 )
2365 self.assertEqual(
2366 func(Object(self.prog, "int", value=value)), func(int(value))
2367 )
2368 self.assertIdentical(
2369 round(Object(self.prog, "int", value=1), 2),
2370 Object(self.prog, "int", value=1),
2371 )
2372 self.assertIdentical(
2373 round(Object(self.prog, "double", value=0.123), 2),
2374 Object(self.prog, "double", value=0.12),
2375 )
2376
2377 def test_iter(self):
2378 obj = Object(self.prog, "int [4]", value=[0, 1, 2, 3])
2379 for i, element in enumerate(obj):
2380 self.assertIdentical(element, Object(self.prog, "int", value=i))
2381 self.assertRaisesRegex(
2382 TypeError, "'int' is not iterable", iter, Object(self.prog, "int", value=0)
2383 )
2384 self.assertRaisesRegex(
2385 TypeError,
2386 r"'int \[\]' is not iterable",
2387 iter,
2388 Object(self.prog, "int []", address=0),
2389 )
2390
2391 def test_iter_length_hint(self):
2392 it = iter(Object(self.prog, "int [3]", value=[0, 1, 2]))
2393 for i in range(3, 0, -1):
2394 self.assertEqual(operator.length_hint(it), i)
2395 next(it)
2396 self.assertEqual(operator.length_hint(it), 0)
2397
2398 def test_reversed(self):
2399 obj = Object(self.prog, "int [4]", value=[0, 1, 2, 3])
2400 for i, element in zip(range(3, -1, -1), reversed(obj)):
2401 self.assertIdentical(element, Object(self.prog, "int", value=i))
2402 self.assertRaisesRegex(
2403 TypeError,
2404 "'int' is not iterable",
2405 reversed,
2406 Object(self.prog, "int", value=0),
2407 )
2408 self.assertRaisesRegex(
2409 TypeError,
2410 r"'int \[\]' is not iterable",
2411 reversed,
2412 Object(self.prog, "int []", address=0),
2413 )
2414
2415 def test_reversed_length_hint(self):
2416 it = reversed(Object(self.prog, "int [3]", value=[0, 1, 2]))
2417 for i in range(3, 0, -1):
2418 self.assertEqual(operator.length_hint(it), i)
2419 next(it)
2420 self.assertEqual(operator.length_hint(it), 0)
2421
2422 def test__repr_pretty_(self):
2423 obj = Object(self.prog, "int", value=0)
2424 assertReprPrettyEqualsStr(obj)