Debian Codegraph @

tests/test_program.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3 import ctypes
4 import itertools
5 import os
6 import sys
7 import tempfile
8 import unittest.mock
9
10 from _drgn_util.elf import ET, PT
11 from drgn import (
12 Architecture,
13 FaultError,
14 FindObjectFlags,
15 Language,
16 NoDefaultProgramError,
17 Object,
18 ObjectNotFoundError,
19 Platform,
20 PlatformFlags,
21 Program,
22 ProgramFlags,
23 Qualifiers,
24 TypeKind,
25 TypeMember,
26 get_default_prog,
27 host_platform,
28 set_default_prog,
29 )
30 from tests import (
31 DEFAULT_LANGUAGE,
32 MOCK_32BIT_PLATFORM,
33 MOCK_PLATFORM,
34 MockMemorySegment,
35 MockObject,
36 MockProgramTestCase,
37 TestCase,
38 mock_program,
39 )
40 from tests.elfwriter import ElfSection, create_elf_file
41
42
43 def zero_memory_read(address, count, offset, physical):
44 return bytes(count)
45
46
47 class TestProgram(TestCase):
48 def test_default_program(self):
49 self.assertRaises(NoDefaultProgramError, get_default_prog)
50 prog = Program()
51 prog2 = Program()
52 try:
53 set_default_prog(prog)
54 self.assertIs(get_default_prog(), prog)
55 set_default_prog(prog2)
56 self.assertIs(get_default_prog(), prog2)
57 finally:
58 set_default_prog(None)
59 self.assertRaises(NoDefaultProgramError, get_default_prog)
60
61 def test_default_program_reference_counting(self):
62 try:
63 set_default_prog(Program())
64 self.assertGreater(sys.getrefcount(get_default_prog()), 1)
65 finally:
66 set_default_prog(None)
67
68 def test_set_pid(self):
69 # Debug the running Python interpreter itself.
70 prog = Program()
71 self.assertIsNone(prog.platform)
72 self.assertFalse(prog.flags & ProgramFlags.IS_LIVE)
73 prog.set_pid(os.getpid())
74 self.assertIsNone(prog.core_dump_path)
75 self.assertEqual(prog.platform, host_platform)
76 self.assertTrue(prog.flags & ProgramFlags.IS_LIVE)
77 self.assertRaisesRegex(
78 ValueError,
79 "program memory was already initialized",
80 prog.set_pid,
81 os.getpid(),
82 )
83
84 def test_pid_memory(self):
85 data = b"hello, world!"
86 buf = ctypes.create_string_buffer(data)
87 address = ctypes.addressof(buf)
88
89 # QEMU user-mode emulation doesn't seem to emulate /proc/$pid/mem
90 # correctly on a 64-bit host with a 32-bit guest; see
91 # https://gitlab.com/qemu-project/qemu/-/issues/698. Packit uses mock
92 # to cross-compile and test packages, which in turn uses QEMU user-mode
93 # emulation. Skip this test if /proc/$pid/mem doesn't work so that
94 # those builds succeed.
95 try:
96 with open("/proc/self/mem", "rb") as f:
97 f.seek(address)
98 functional_proc_pid_mem = f.read(len(data)) == data
99 except OSError:
100 functional_proc_pid_mem = False
101 if not functional_proc_pid_mem:
102 self.skipTest("/proc/$pid/mem is not functional")
103
104 prog = Program()
105 prog.set_pid(os.getpid())
106
107 self.assertEqual(prog.read(ctypes.addressof(buf), len(data)), data)
108
109 def test_object_not_found_error(self):
110 prog = mock_program()
111
112 with self.assertRaisesRegex(
113 ObjectNotFoundError, "^could not find constant 'foo'$"
114 ) as cm:
115 prog.constant("foo")
116 self.assertEqual(cm.exception.name, "foo")
117
118 with self.assertRaisesRegex(
119 ObjectNotFoundError, "^could not find constant 'foo' in 'foo.c'$"
120 ) as cm:
121 prog.constant("foo", "foo.c")
122 self.assertEqual(cm.exception.name, "foo")
123
124 with self.assertRaisesRegex(
125 ObjectNotFoundError, "^could not find function 'foo'$"
126 ) as cm:
127 prog.function("foo")
128 self.assertEqual(cm.exception.name, "foo")
129
130 with self.assertRaisesRegex(
131 ObjectNotFoundError, "^could not find function 'foo' in 'foo.c'$"
132 ) as cm:
133 prog.function("foo", "foo.c")
134 self.assertEqual(cm.exception.name, "foo")
135
136 with self.assertRaisesRegex(
137 ObjectNotFoundError, "^could not find variable 'foo'$"
138 ) as cm:
139 prog.variable("foo")
140 self.assertEqual(cm.exception.name, "foo")
141
142 with self.assertRaisesRegex(
143 ObjectNotFoundError, "^could not find variable 'foo' in 'foo.c'$"
144 ) as cm:
145 prog.variable("foo", "foo.c")
146 self.assertEqual(cm.exception.name, "foo")
147
148 with self.assertRaisesRegex(
149 ObjectNotFoundError, "^could not find 'foo'$"
150 ) as cm:
151 prog["foo"]
152 self.assertEqual(cm.exception.name, "foo")
153
154 # If name isn't a string, prog.object(name) should raise TypeError, and
155 # prog[name] should raise KeyError (not ObjectNotFoundError).
156 self.assertRaises(TypeError, prog.object, 9)
157 with self.assertRaises(KeyError) as cm:
158 prog[9]
159 self.assertIs(type(cm.exception), KeyError)
160
161 def test_type_lookup_error(self):
162 prog = mock_program()
163
164 self.assertRaisesRegex(LookupError, "^could not find 'foo'$", prog.type, "foo")
165 self.assertRaisesRegex(
166 LookupError, "^could not find 'foo' in 'foo.c'$", prog.type, "foo", "foo.c"
167 )
168
169 def test_flags(self):
170 self.assertIsInstance(mock_program().flags, ProgramFlags)
171
172 def test_debug_info(self):
173 Program().load_debug_info([])
174
175 def test_language(self):
176 prog = Program()
177 self.assertEqual(prog.language, DEFAULT_LANGUAGE)
178 prog.language = Language.CPP
179 self.assertEqual(prog.language, Language.CPP)
180 prog.language = Language.C
181 self.assertEqual(prog.language, Language.C)
182 self.assertRaisesRegex(
183 TypeError, "language must be Language", setattr, prog, "language", "CPP"
184 )
185
186 def test_language_del(self):
187 with self.assertRaises(AttributeError):
188 del Program().language
189
190 def test_address_size(self):
191 self.assertEqual(mock_program().address_size(), 8)
192 self.assertEqual(mock_program(MOCK_32BIT_PLATFORM).address_size(), 4)
193 self.assertRaisesRegex(
194 ValueError, "address size is not known", Program().address_size
195 )
196
197
198 class TestMemory(TestCase):
199 def test_simple_read(self):
200 data = b"hello, world"
201 prog = mock_program(segments=[MockMemorySegment(data, 0xFFFF0000, 0xA0)])
202 self.assertEqual(prog.read(0xFFFF0000, len(data)), data)
203 self.assertEqual(prog.read(0xA0, len(data), True), data)
204
205 def test_read_c_string(self):
206 data = b"hello, world"
207 prog = mock_program(
208 segments=[MockMemorySegment(data + b"\0", 0xFFFF0000, 0xA0)]
209 )
210 self.assertEqual(prog.read_c_string(0xFFFF0000), data)
211 self.assertEqual(prog.read_c_string(0xA0, True), data)
212
213 def test_read_c_string_max_size(self):
214 for data in (b"hello, world", b"hell", b"he"):
215 with self.subTest(data=data):
216 prog = mock_program(
217 segments=[
218 MockMemorySegment(
219 data + (b"\0" if len(data) < 4 else b""), 0xFFFF0000, 0xA0
220 )
221 ]
222 )
223 self.assertEqual(prog.read_c_string(0xFFFF0000, max_size=4), data[:4])
224 self.assertEqual(prog.read_c_string(0xA0, True, max_size=4), data[:4])
225
226 def test_read_unsigned(self):
227 data = b"\x01\x02\x03\x04\x05\x06\x07\x08"
228 for word_size in [8, 4]:
229 for byteorder in ["little", "big"]:
230 flags = PlatformFlags(0)
231 if word_size == 8:
232 flags |= PlatformFlags.IS_64_BIT
233 if byteorder == "little":
234 flags |= PlatformFlags.IS_LITTLE_ENDIAN
235 prog = mock_program(
236 Platform(Architecture.UNKNOWN, flags),
237 segments=[MockMemorySegment(data, 0xFFFF0000, 0xA0)],
238 )
239 for size in [1, 2, 4, 8]:
240 read_fn = getattr(prog, f"read_u{8 * size}")
241 value = int.from_bytes(data[:size], byteorder)
242 self.assertEqual(read_fn(0xFFFF0000), value)
243 self.assertEqual(read_fn(0xA0, True), value)
244 if size == word_size:
245 self.assertEqual(prog.read_word(0xFFFF0000), value)
246 self.assertEqual(prog.read_word(0xA0, True), value)
247
248 prog = mock_program(
249 MOCK_32BIT_PLATFORM, segments=[MockMemorySegment(data, 0xFFFF0000, 0xA0)]
250 )
251
252 def test_bad_address(self):
253 data = b"hello, world!"
254 prog = mock_program(segments=[MockMemorySegment(data, 0xFFFF0000)])
255 self.assertRaisesRegex(
256 FaultError, "could not find memory segment", prog.read, 0xDEADBEEF, 4
257 )
258 self.assertRaisesRegex(
259 FaultError,
260 "could not find physical memory segment",
261 prog.read,
262 0xFFFF0000,
263 4,
264 True,
265 )
266
267 def test_segment_overflow(self):
268 data = b"hello, world!"
269 prog = mock_program(segments=[MockMemorySegment(data, 0xFFFF0000)])
270 self.assertRaisesRegex(
271 FaultError,
272 "could not find memory segment",
273 prog.read,
274 0xFFFF0000,
275 len(data) + 1,
276 )
277
278 def test_adjacent_segments(self):
279 data = b"hello, world!\0foobar"
280 prog = mock_program(
281 segments=[
282 MockMemorySegment(data[:4], 0xFFFF0000),
283 MockMemorySegment(data[4:14], 0xFFFF0004),
284 MockMemorySegment(data[14:], 0xFFFFF000),
285 ]
286 )
287 self.assertEqual(prog.read(0xFFFF0000, 14), data[:14])
288
289 def test_address_overflow(self):
290 for bits in (64, 32):
291 with self.subTest(bits=bits):
292 prog = mock_program(
293 segments=[
294 MockMemorySegment(b"cd", 0x0),
295 MockMemorySegment(b"abyz", 2**bits - 2),
296 ],
297 platform=MOCK_PLATFORM if bits == 64 else MOCK_32BIT_PLATFORM,
298 )
299 for start in range(3):
300 for size in range(4 - start):
301 self.assertEqual(
302 prog.read((2**bits - 2 + start) % 2**64, size),
303 b"abcd"[start : start + size],
304 )
305
306 def test_overlap_same_address_smaller_size(self):
307 # Existing segment: |_______|
308 # New segment: |___|
309 prog = Program(MOCK_PLATFORM)
310 segment1 = unittest.mock.Mock(side_effect=zero_memory_read)
311 segment2 = unittest.mock.Mock(side_effect=zero_memory_read)
312 prog.add_memory_segment(0xFFFF0000, 128, segment1)
313 prog.add_memory_segment(0xFFFF0000, 64, segment2)
314 prog.read(0xFFFF0000, 128)
315 segment1.assert_called_once_with(0xFFFF0040, 64, 64, False)
316 segment2.assert_called_once_with(0xFFFF0000, 64, 0, False)
317
318 def test_overlap_within_segment(self):
319 # Existing segment: |_______|
320 # New segment: |___|
321 prog = Program(MOCK_PLATFORM)
322 segment1 = unittest.mock.Mock(side_effect=zero_memory_read)
323 segment2 = unittest.mock.Mock(side_effect=zero_memory_read)
324 prog.add_memory_segment(0xFFFF0000, 128, segment1)
325 prog.add_memory_segment(0xFFFF0020, 64, segment2)
326 prog.read(0xFFFF0000, 128)
327 segment1.assert_has_calls(
328 [
329 unittest.mock.call(0xFFFF0000, 32, 00, False),
330 unittest.mock.call(0xFFFF0060, 32, 96, False),
331 ]
332 )
333 segment2.assert_called_once_with(0xFFFF0020, 64, 0, False)
334
335 def test_overlap_same_segment(self):
336 # Existing segment: |_______|
337 # New segment: |_______|
338 prog = Program(MOCK_PLATFORM)
339 segment1 = unittest.mock.Mock(side_effect=zero_memory_read)
340 segment2 = unittest.mock.Mock(side_effect=zero_memory_read)
341 prog.add_memory_segment(0xFFFF0000, 128, segment1)
342 prog.add_memory_segment(0xFFFF0000, 128, segment2)
343 prog.read(0xFFFF0000, 128)
344 segment1.assert_not_called()
345 segment2.assert_called_once_with(0xFFFF0000, 128, 0, False)
346
347 def test_overlap_same_address_larger_size(self):
348 # Existing segment: |___|
349 # New segment: |_______|
350 prog = Program(MOCK_PLATFORM)
351 segment1 = unittest.mock.Mock(side_effect=zero_memory_read)
352 segment2 = unittest.mock.Mock(side_effect=zero_memory_read)
353 prog.add_memory_segment(0xFFFF0000, 64, segment1)
354 prog.add_memory_segment(0xFFFF0000, 128, segment2)
355 prog.read(0xFFFF0000, 128)
356 segment1.assert_not_called()
357 segment2.assert_called_once_with(0xFFFF0000, 128, 0, False)
358
359 def test_overlap_segment_tail(self):
360 # Existing segment: |_______|
361 # New segment: |_______|
362 prog = Program(MOCK_PLATFORM)
363 segment1 = unittest.mock.Mock(side_effect=zero_memory_read)
364 segment2 = unittest.mock.Mock(side_effect=zero_memory_read)
365 prog.add_memory_segment(0xFFFF0000, 128, segment1)
366 prog.add_memory_segment(0xFFFF0040, 128, segment2)
367 prog.read(0xFFFF0000, 192)
368 segment1.assert_called_once_with(0xFFFF0000, 64, 0, False)
369 segment2.assert_called_once_with(0xFFFF0040, 128, 0, False)
370
371 def test_overlap_subsume_after(self):
372 # Existing segments: |_|_|_|_|
373 # New segment: |_______|
374 prog = Program(MOCK_PLATFORM)
375 segment1 = unittest.mock.Mock(side_effect=zero_memory_read)
376 segment2 = unittest.mock.Mock(side_effect=zero_memory_read)
377 segment3 = unittest.mock.Mock(side_effect=zero_memory_read)
378 prog.add_memory_segment(0xFFFF0020, 32, segment1)
379 prog.add_memory_segment(0xFFFF0040, 32, segment1)
380 prog.add_memory_segment(0xFFFF0060, 32, segment1)
381 prog.add_memory_segment(0xFFFF0080, 64, segment2)
382 prog.add_memory_segment(0xFFFF0000, 128, segment3)
383 prog.read(0xFFFF0000, 192)
384 segment1.assert_not_called()
385 segment2.assert_called_once_with(0xFFFF0080, 64, 0, False)
386 segment3.assert_called_once_with(0xFFFF0000, 128, 0, False)
387
388 def test_overlap_segment_head(self):
389 # Existing segment: |_______|
390 # New segment: |_______|
391 prog = Program(MOCK_PLATFORM)
392 segment1 = unittest.mock.Mock(side_effect=zero_memory_read)
393 segment2 = unittest.mock.Mock(side_effect=zero_memory_read)
394 prog.add_memory_segment(0xFFFF0040, 128, segment1)
395 prog.add_memory_segment(0xFFFF0000, 128, segment2)
396 prog.read(0xFFFF0000, 192)
397 segment1.assert_called_once_with(0xFFFF0080, 64, 64, False)
398 segment2.assert_called_once_with(0xFFFF0000, 128, 0, False)
399
400 def test_overlap_segment_head_and_tail(self):
401 # Existing segment: |_______||_______|
402 # New segment: |_______|
403 prog = Program(MOCK_PLATFORM)
404 segment1 = unittest.mock.Mock(side_effect=zero_memory_read)
405 segment2 = unittest.mock.Mock(side_effect=zero_memory_read)
406 segment3 = unittest.mock.Mock(side_effect=zero_memory_read)
407 prog.add_memory_segment(0xFFFF0000, 128, segment1)
408 prog.add_memory_segment(0xFFFF0080, 128, segment2)
409 prog.add_memory_segment(0xFFFF0040, 128, segment3)
410 prog.read(0xFFFF0000, 256)
411 segment1.assert_called_once_with(0xFFFF0000, 64, 0, False)
412 segment2.assert_called_once_with(0xFFFF00C0, 64, 64, False)
413 segment3.assert_called_once_with(0xFFFF0040, 128, 0, False)
414
415 def test_overlap_subsume_at_and_after(self):
416 # Existing segments: |_|_|_|_|
417 # New segment: |_______|
418 prog = Program(MOCK_PLATFORM)
419 segment1 = unittest.mock.Mock(side_effect=zero_memory_read)
420 segment2 = unittest.mock.Mock(side_effect=zero_memory_read)
421 prog.add_memory_segment(0xFFFF0000, 32, segment1)
422 prog.add_memory_segment(0xFFFF0020, 32, segment1)
423 prog.add_memory_segment(0xFFFF0040, 32, segment1)
424 prog.add_memory_segment(0xFFFF0060, 32, segment1)
425 prog.add_memory_segment(0xFFFF0000, 128, segment2)
426 prog.read(0xFFFF0000, 128)
427 segment1.assert_not_called()
428 segment2.assert_called_once_with(0xFFFF0000, 128, 0, False)
429
430 def test_invalid_read_fn(self):
431 prog = mock_program()
432
433 self.assertRaises(TypeError, prog.add_memory_segment, 0xFFFF0000, 8, b"foo")
434
435 prog.add_memory_segment(0xFFFF0000, 8, lambda: None)
436 self.assertRaises(TypeError, prog.read, 0xFFFF0000, 8)
437
438 prog.add_memory_segment(
439 0xFFFF0000, 8, lambda address, count, offset, physical: None
440 )
441 self.assertRaises(TypeError, prog.read, 0xFFFF0000, 8)
442
443 prog.add_memory_segment(
444 0xFFFF0000, 8, lambda address, count, offset, physical: "asdf"
445 )
446 self.assertRaises(TypeError, prog.read, 0xFFFF0000, 8)
447
448 prog.add_memory_segment(
449 0xFFFF0000, 8, lambda address, count, offset, physical: b""
450 )
451 self.assertRaisesRegex(
452 ValueError,
453 r"memory read callback returned buffer of length 0 \(expected 8\)",
454 prog.read,
455 0xFFFF0000,
456 8,
457 )
458
459 def test_python_fault_error(self):
460 def fault_memory_reader(address, count, offset, physical):
461 raise FaultError("fault from Python", address)
462
463 prog = Program(MOCK_PLATFORM)
464 prog.add_memory_segment(0xFFFF0000, 8, fault_memory_reader)
465
466 with self.assertRaises(FaultError) as cm:
467 Object(prog, "int", address=0xFFFF0004).read_()
468 self.assertEqual(cm.exception.message, "fault from Python")
469 self.assertEqual(cm.exception.address, 0xFFFF0004)
470
471 # If the FaultError from Python is translated to a drgn_error
472 # correctly, then this shouldn't raise an exception.
473 str(Object(prog, "int *", 0xFFFF0004))
474
475 def test_python_fault_error_invalid_message(self):
476 def fault_memory_reader(address, count, offset, physical):
477 raise FaultError(None, address)
478
479 prog = Program(MOCK_PLATFORM)
480 prog.add_memory_segment(0xFFFF0000, 8, fault_memory_reader)
481
482 # Just test that it doesn't crash.
483 self.assertRaises(Exception, Object(prog, "int", address=0xFFFF0004).read_)
484
485 def test_python_fault_error_invalid_address(self):
486 def fault_memory_reader(address, count, offset, physical):
487 raise FaultError("fault from Python", None)
488
489 prog = Program(MOCK_PLATFORM)
490 prog.add_memory_segment(0xFFFF0000, 8, fault_memory_reader)
491
492 # Just test that it doesn't crash.
493 self.assertRaises(Exception, Object(prog, "int", address=0xFFFF0004).read_)
494
495
496 class TestTypeFinder(TestCase):
497 def test_register(self):
498 prog = Program(MOCK_PLATFORM)
499
500 # We don't test every corner case because the symbol finder tests cover
501 # the shared part.
502 self.assertEqual(prog.registered_type_finders(), {"dwarf"})
503 self.assertEqual(prog.enabled_type_finders(), ["dwarf"])
504
505 prog.register_type_finder(
506 "foo", lambda prog, kinds, name, filename: None, enable_index=-1
507 )
508 self.assertEqual(prog.registered_type_finders(), {"dwarf", "foo"})
509 self.assertEqual(prog.enabled_type_finders(), ["dwarf", "foo"])
510
511 prog.set_enabled_type_finders(["foo"])
512 self.assertEqual(prog.registered_type_finders(), {"dwarf", "foo"})
513 self.assertEqual(prog.enabled_type_finders(), ["foo"])
514
515 def test_add_type_finder(self):
516 prog = Program(MOCK_PLATFORM)
517
518 def dummy(kind, name, filename):
519 if kind == TypeKind.TYPEDEF and name == "foo":
520 return prog.typedef_type("foo", prog.void_type())
521 else:
522 return None
523
524 prog.add_type_finder(dummy)
525 self.assertTrue(any("dummy" in name for name in prog.registered_type_finders()))
526 self.assertIn("dummy", prog.enabled_type_finders()[0])
527 self.assertIdentical(
528 prog.type("foo"), prog.typedef_type("foo", prog.void_type())
529 )
530
531 def test_register_invalid(self):
532 prog = Program(MOCK_PLATFORM)
533 self.assertRaises(TypeError, prog.register_type_finder, "foo", "foo")
534 prog.register_type_finder(
535 "foo", lambda prog, kinds, name, filename: "foo", enable_index=0
536 )
537 self.assertRaises(TypeError, prog.type, "int")
538
539 def test_add_invalid(self):
540 prog = Program(MOCK_PLATFORM)
541 self.assertRaises(TypeError, prog.add_type_finder, "foo")
542 prog.add_type_finder(lambda kind, name, filename: "foo")
543 self.assertRaises(TypeError, prog.type, "int")
544
545 def test_register_wrong_program(self):
546 def finder(prog, kinds, name, filename):
547 if TypeKind.TYPEDEF in kinds and name == "foo":
548 prog = Program()
549 return prog.typedef_type("foo", prog.void_type())
550 else:
551 return None
552
553 prog = Program(MOCK_PLATFORM)
554 prog.register_type_finder("foo", finder, enable_index=0)
555 self.assertRaisesRegex(
556 ValueError,
557 "type find callback returned type from wrong program",
558 prog.type,
559 "foo",
560 )
561
562 def test_add_wrong_program(self):
563 def finder(kind, name, filename):
564 if kind == TypeKind.TYPEDEF and name == "foo":
565 prog = Program()
566 return prog.typedef_type("foo", prog.void_type())
567 else:
568 return None
569
570 prog = Program(MOCK_PLATFORM)
571 prog.add_type_finder(finder)
572 self.assertRaisesRegex(
573 ValueError,
574 "type find callback returned type from wrong program",
575 prog.type,
576 "foo",
577 )
578
579 def test_register_wrong_kind(self):
580 prog = Program(MOCK_PLATFORM)
581 prog.register_type_finder(
582 "foo", lambda prog, kinds, name, filename: prog.void_type(), enable_index=0
583 )
584 self.assertRaises(TypeError, prog.type, "int")
585
586 def test_add_wrong_kind(self):
587 prog = Program(MOCK_PLATFORM)
588 prog.add_type_finder(lambda kind, name, filename: prog.void_type())
589 self.assertRaises(TypeError, prog.type, "int")
590
591 def test_register_not_found(self):
592 prog = Program(MOCK_PLATFORM)
593 prog.register_type_finder(
594 "foo", lambda prog, kinds, name, filename: None, enable_index=0
595 )
596 self.assertRaises(LookupError, prog.type, "struct foo")
597
598 def test_add_not_found(self):
599 prog = Program(MOCK_PLATFORM)
600 prog.add_type_finder(lambda kind, name, filename: None)
601 self.assertRaises(LookupError, prog.type, "struct foo")
602
603
604 class TestObjectFinder(TestCase):
605 def test_register(self):
606 prog = Program(MOCK_PLATFORM)
607
608 # We don't test every corner case because the symbol finder tests cover
609 # the shared part.
610 self.assertEqual(prog.registered_object_finders(), {"dwarf"})
611 self.assertEqual(prog.enabled_object_finders(), ["dwarf"])
612
613 prog.register_object_finder(
614 "foo", lambda prog, name, flags, filename: None, enable_index=-1
615 )
616 self.assertEqual(prog.registered_object_finders(), {"dwarf", "foo"})
617 self.assertEqual(prog.enabled_object_finders(), ["dwarf", "foo"])
618
619 prog.set_enabled_object_finders(["foo"])
620 self.assertEqual(prog.registered_object_finders(), {"dwarf", "foo"})
621 self.assertEqual(prog.enabled_object_finders(), ["foo"])
622
623 def test_add_object_finder(self):
624 prog = Program(MOCK_PLATFORM)
625
626 def dummy(prog, name, flags, filename):
627 return Object(prog, "int", 1)
628
629 prog.add_object_finder(dummy)
630 self.assertTrue(
631 any("dummy" in name for name in prog.registered_object_finders())
632 )
633 self.assertIn("dummy", prog.enabled_object_finders()[0])
634 self.assertIdentical(prog.object("foo"), Object(prog, "int", 1))
635
636 def test_register_invalid(self):
637 prog = Program(MOCK_PLATFORM)
638 self.assertRaises(TypeError, prog.register_object_finder, "foo", "foo")
639 prog.register_object_finder(
640 "foo", lambda prog, name, flags, filename: "foo", enable_index=0
641 )
642 self.assertRaises(TypeError, prog.object, "foo")
643
644 def test_add_invalid(self):
645 prog = Program(MOCK_PLATFORM)
646 self.assertRaises(TypeError, prog.add_object_finder, "foo")
647 prog.add_object_finder(lambda prog, name, flags, filename: "foo")
648 self.assertRaises(TypeError, prog.object, "foo")
649
650 def test_wrong_program(self):
651 prog = Program(MOCK_PLATFORM)
652 prog.register_object_finder(
653 "foo",
654 lambda prog, name, flags, filename: Object(
655 Program(MOCK_PLATFORM), "int", 1
656 ),
657 enable_index=0,
658 )
659 self.assertRaisesRegex(
660 ValueError,
661 "different program",
662 prog.object,
663 "foo",
664 )
665
666 def test_not_found(self):
667 prog = Program(MOCK_PLATFORM)
668 self.assertRaises(LookupError, prog.object, "foo")
669 prog.register_object_finder(
670 "foo", lambda prog, name, flags, filename: None, enable_index=0
671 )
672 self.assertRaises(LookupError, prog.object, "foo")
673 self.assertFalse("foo" in prog)
674
675
676 class TestTypes(MockProgramTestCase):
677 def test_already_type(self):
678 self.assertIdentical(
679 self.prog.type(self.prog.pointer_type(self.prog.void_type())),
680 self.prog.pointer_type(self.prog.void_type()),
681 )
682
683 def test_invalid_argument_type(self):
684 self.assertRaises(TypeError, self.prog.type, 1)
685
686 def test_default_primitive_types(self):
687 def spellings(tokens, num_optional=0):
688 for i in range(len(tokens) - num_optional, len(tokens) + 1):
689 for perm in itertools.permutations(tokens[:i]):
690 yield " ".join(perm)
691
692 for word_size in [8, 4]:
693 prog = mock_program(
694 MOCK_PLATFORM if word_size == 8 else MOCK_32BIT_PLATFORM
695 )
696 self.assertIdentical(prog.type("_Bool"), prog.bool_type("_Bool", 1))
697 self.assertIdentical(prog.type("char"), prog.int_type("char", 1, True))
698 for spelling in spellings(["signed", "char"]):
699 self.assertIdentical(
700 prog.type(spelling), prog.int_type("signed char", 1, True)
701 )
702 for spelling in spellings(["unsigned", "char"]):
703 self.assertIdentical(
704 prog.type(spelling), prog.int_type("unsigned char", 1, False)
705 )
706 for spelling in spellings(["short", "signed", "int"], 2):
707 self.assertIdentical(
708 prog.type(spelling), prog.int_type("short", 2, True)
709 )
710 for spelling in spellings(["short", "unsigned", "int"], 1):
711 self.assertIdentical(
712 prog.type(spelling), prog.int_type("unsigned short", 2, False)
713 )
714 for spelling in spellings(["int", "signed"], 1):
715 self.assertIdentical(prog.type(spelling), prog.int_type("int", 4, True))
716 for spelling in spellings(["unsigned", "int"]):
717 self.assertIdentical(
718 prog.type(spelling), prog.int_type("unsigned int", 4, False)
719 )
720 for spelling in spellings(["long", "signed", "int"], 2):
721 self.assertIdentical(
722 prog.type(spelling), prog.int_type("long", word_size, True)
723 )
724 for spelling in spellings(["long", "unsigned", "int"], 1):
725 self.assertIdentical(
726 prog.type(spelling),
727 prog.int_type("unsigned long", word_size, False),
728 )
729 for spelling in spellings(["long", "long", "signed", "int"], 2):
730 self.assertIdentical(
731 prog.type(spelling), prog.int_type("long long", 8, True)
732 )
733 for spelling in spellings(["long", "long", "unsigned", "int"], 1):
734 self.assertIdentical(
735 prog.type(spelling), prog.int_type("unsigned long long", 8, False)
736 )
737 self.assertIdentical(prog.type("float"), prog.float_type("float", 4))
738 self.assertIdentical(prog.type("double"), prog.float_type("double", 8))
739 for spelling in spellings(["long", "double"]):
740 self.assertIdentical(
741 prog.type(spelling), prog.float_type("long double", 16)
742 )
743 self.assertIdentical(
744 prog.type("size_t"),
745 prog.typedef_type(
746 "size_t", prog.int_type("unsigned long", word_size, False)
747 ),
748 )
749 self.assertIdentical(
750 prog.type("ptrdiff_t"),
751 prog.typedef_type("ptrdiff_t", prog.int_type("long", word_size, True)),
752 )
753
754 def test_primitive_type(self):
755 self.types.append(self.prog.int_type("long", 4, True))
756 self.assertIdentical(
757 self.prog.type("long"), self.prog.int_type("long", 4, True)
758 )
759
760 def test_primitive_type_invalid(self):
761 # unsigned long with signed=True isn't valid, so it should be ignored.
762 self.types.append(self.prog.int_type("unsigned long", 4, True))
763 self.assertIdentical(
764 self.prog.type("unsigned long"),
765 self.prog.int_type("unsigned long", 8, False),
766 )
767
768 def test_size_t_and_ptrdiff_t(self):
769 # 64-bit architecture with 4-byte long/unsigned long.
770 types = []
771 prog = mock_program(types=types)
772 types.append(prog.int_type("long", 4, True))
773 types.append(prog.int_type("unsigned long", 4, False))
774 self.assertIdentical(
775 prog.type("size_t"),
776 prog.typedef_type("size_t", prog.type("unsigned long long")),
777 )
778 self.assertIdentical(
779 prog.type("ptrdiff_t"),
780 prog.typedef_type("ptrdiff_t", prog.type("long long")),
781 )
782
783 # 32-bit architecture with 8-byte long/unsigned long.
784 types = []
785 prog = mock_program(MOCK_32BIT_PLATFORM, types=types)
786 types.append(prog.int_type("long", 8, True))
787 types.append(prog.int_type("unsigned long", 8, False))
788 self.assertIdentical(
789 prog.type("size_t"), prog.typedef_type("size_t", prog.type("unsigned int"))
790 )
791 self.assertIdentical(
792 prog.type("ptrdiff_t"), prog.typedef_type("ptrdiff_t", prog.type("int"))
793 )
794
795 # Nonsense sizes.
796 types = []
797 prog = mock_program(types=types)
798 types.append(prog.int_type("int", 1, True))
799 types.append(prog.int_type("unsigned int", 1, False))
800 types.append(prog.int_type("long", 1, True))
801 types.append(prog.int_type("unsigned long", 1, False))
802 types.append(prog.int_type("long long", 2, True))
803 types.append(prog.int_type("unsigned long long", 2, False))
804 self.assertRaisesRegex(
805 ValueError, "no suitable integer type for size_t", prog.type, "size_t"
806 )
807 self.assertRaisesRegex(
808 ValueError, "no suitable integer type for ptrdiff_t", prog.type, "ptrdiff_t"
809 )
810
811 def test_not_size_t_or_ptrdiff_t(self):
812 self.types.append(
813 self.prog.typedef_type(
814 "size_tea", self.prog.int_type("unsigned char", 1, False)
815 )
816 )
817 self.types.append(
818 self.prog.typedef_type("ptrdiff_tee", self.prog.int_type("char", 1, True))
819 )
820 self.assertIdentical(
821 self.prog.type("size_tea"),
822 self.prog.typedef_type(
823 "size_tea", self.prog.int_type("unsigned char", 1, False)
824 ),
825 )
826 self.assertIdentical(
827 self.prog.type("ptrdiff_tee"),
828 self.prog.typedef_type("ptrdiff_tee", self.prog.int_type("char", 1, True)),
829 )
830
831 def test_tagged_type(self):
832 self.types.append(self.point_type)
833 self.types.append(self.option_type)
834 self.types.append(self.color_type)
835 self.assertIdentical(self.prog.type("struct point"), self.point_type)
836 self.assertIdentical(self.prog.type("union option"), self.option_type)
837 self.assertIdentical(self.prog.type("enum color"), self.color_type)
838
839 def test_class_type(self):
840 struct_class = self.prog.struct_type(
841 "class",
842 8,
843 (TypeMember(self.prog.pointer_type(self.prog.void_type()), "ptr"),),
844 )
845 class_point = self.prog.class_type(
846 "Point",
847 8,
848 (
849 TypeMember(self.prog.int_type("int", 4, True), "x", 0),
850 TypeMember(self.prog.int_type("int", 4, True), "y", 32),
851 ),
852 )
853 self.types.append(struct_class)
854 self.types.append(class_point)
855 self.prog.language = Language.C
856 self.assertIdentical(self.prog.type("struct class"), struct_class)
857 self.prog.language = Language.CPP
858 self.assertRaisesRegex(
859 SyntaxError,
860 "expected identifier after 'struct'",
861 self.prog.type,
862 "struct class",
863 )
864 self.assertIdentical(self.prog.type("class Point"), class_point)
865
866 def test_typedef(self):
867 self.types.append(self.pid_type)
868 self.assertIdentical(self.prog.type("pid_t"), self.pid_type)
869
870 def test_pointer(self):
871 self.assertIdentical(
872 self.prog.type("int *"),
873 self.prog.pointer_type(self.prog.int_type("int", 4, True)),
874 )
875
876 def test_pointer_to_const(self):
877 self.assertIdentical(
878 self.prog.type("const int *"),
879 self.prog.pointer_type(
880 self.prog.int_type("int", 4, True, qualifiers=Qualifiers.CONST)
881 ),
882 )
883
884 def test_const_pointer(self):
885 self.assertIdentical(
886 self.prog.type("int * const"),
887 self.prog.pointer_type(
888 self.prog.int_type("int", 4, True), qualifiers=Qualifiers.CONST
889 ),
890 )
891
892 def test_pointer_to_pointer(self):
893 self.assertIdentical(
894 self.prog.type("int **"),
895 self.prog.pointer_type(
896 self.prog.pointer_type(self.prog.int_type("int", 4, True))
897 ),
898 )
899 self.assertIdentical(self.prog.type("int *((*))"), self.prog.type("int **"))
900
901 def test_pointer_to_const_pointer(self):
902 self.assertIdentical(
903 self.prog.type("int * const *"),
904 self.prog.pointer_type(
905 self.prog.pointer_type(
906 self.prog.int_type("int", 4, True), qualifiers=Qualifiers.CONST
907 )
908 ),
909 )
910
911 def test_array(self):
912 self.assertIdentical(
913 self.prog.type("int [20]"),
914 self.prog.array_type(self.prog.int_type("int", 4, True), 20),
915 )
916
917 def test_array_hexadecimal(self):
918 self.assertIdentical(
919 self.prog.type("int [0x20]"),
920 self.prog.array_type(self.prog.int_type("int", 4, True), 32),
921 )
922
923 def test_array_octal(self):
924 self.assertIdentical(
925 self.prog.type("int [020]"),
926 self.prog.array_type(self.prog.int_type("int", 4, True), 16),
927 )
928
929 def test_incomplete_array(self):
930 self.assertIdentical(
931 self.prog.type("int []"),
932 self.prog.array_type(self.prog.int_type("int", 4, True)),
933 )
934
935 def test_array_two_dimensional(self):
936 self.assertIdentical(
937 self.prog.type("int [2][3]"),
938 self.prog.array_type(
939 self.prog.array_type(self.prog.int_type("int", 4, True), 3), 2
940 ),
941 )
942
943 def test_array_three_dimensional(self):
944 self.assertIdentical(
945 self.prog.type("int [2][3][4]"),
946 self.prog.array_type(
947 self.prog.array_type(
948 self.prog.array_type(self.prog.int_type("int", 4, True), 4), 3
949 ),
950 2,
951 ),
952 )
953
954 def test_array_of_pointers(self):
955 self.assertIdentical(
956 self.prog.type("int *[2][3]"),
957 self.prog.array_type(
958 self.prog.array_type(
959 self.prog.pointer_type(self.prog.int_type("int", 4, True)), 3
960 ),
961 2,
962 ),
963 )
964
965 def test_pointer_to_array(self):
966 self.assertIdentical(
967 self.prog.type("int (*)[2]"),
968 self.prog.pointer_type(
969 self.prog.array_type(self.prog.int_type("int", 4, True), 2)
970 ),
971 )
972
973 def test_pointer_to_two_dimensional_array(self):
974 self.assertIdentical(
975 self.prog.type("int (*)[2][3]"),
976 self.prog.pointer_type(
977 self.prog.array_type(
978 self.prog.array_type(self.prog.int_type("int", 4, True), 3), 2
979 )
980 ),
981 )
982
983 def test_pointer_to_pointer_to_array(self):
984 self.assertIdentical(
985 self.prog.type("int (**)[2]"),
986 self.prog.pointer_type(
987 self.prog.pointer_type(
988 self.prog.array_type(self.prog.int_type("int", 4, True), 2)
989 )
990 ),
991 )
992
993 def test_pointer_to_array_of_pointers(self):
994 self.assertIdentical(
995 self.prog.type("int *(*)[2]"),
996 self.prog.pointer_type(
997 self.prog.array_type(
998 self.prog.pointer_type(self.prog.int_type("int", 4, True)), 2
999 )
1000 ),
1001 )
1002 self.assertIdentical(
1003 self.prog.type("int *((*)[2])"), self.prog.type("int *(*)[2]")
1004 )
1005
1006 def test_array_of_pointers_to_array(self):
1007 self.assertIdentical(
1008 self.prog.type("int (*[2])[3]"),
1009 self.prog.array_type(
1010 self.prog.pointer_type(
1011 self.prog.array_type(self.prog.int_type("int", 4, True), 3)
1012 ),
1013 2,
1014 ),
1015 )
1016
1017
1018 class TestObjects(MockProgramTestCase):
1019 def test_constant(self):
1020 self.objects.append(
1021 MockObject("PAGE_SIZE", self.prog.int_type("int", 4, True), value=4096)
1022 )
1023 self.assertIdentical(
1024 self.prog["PAGE_SIZE"],
1025 Object(self.prog, self.prog.int_type("int", 4, True), value=4096),
1026 )
1027 self.assertIdentical(
1028 self.prog.object("PAGE_SIZE", FindObjectFlags.CONSTANT),
1029 self.prog["PAGE_SIZE"],
1030 )
1031 self.assertTrue("PAGE_SIZE" in self.prog)
1032
1033 def test_function(self):
1034 self.objects.append(
1035 MockObject(
1036 "func",
1037 self.prog.function_type(self.prog.void_type(), (), False),
1038 address=0xFFFF0000,
1039 )
1040 )
1041 self.assertIdentical(
1042 self.prog["func"],
1043 Object(
1044 self.prog,
1045 self.prog.function_type(self.prog.void_type(), (), False),
1046 address=0xFFFF0000,
1047 ),
1048 )
1049 self.assertIdentical(
1050 self.prog.object("func", FindObjectFlags.FUNCTION), self.prog["func"]
1051 )
1052 self.assertTrue("func" in self.prog)
1053
1054 def test_variable(self):
1055 self.objects.append(
1056 MockObject(
1057 "counter", self.prog.int_type("int", 4, True), address=0xFFFF0000
1058 )
1059 )
1060 self.assertIdentical(
1061 self.prog["counter"],
1062 Object(self.prog, self.prog.int_type("int", 4, True), address=0xFFFF0000),
1063 )
1064 self.assertIdentical(
1065 self.prog.object("counter", FindObjectFlags.VARIABLE), self.prog["counter"]
1066 )
1067 self.assertTrue("counter" in self.prog)
1068
1069
1070 class TestCoreDump(TestCase):
1071 def test_not_core_dump(self):
1072 prog = Program()
1073 self.assertRaisesRegex(
1074 ValueError, "not an ELF core file", prog.set_core_dump, "/dev/null"
1075 )
1076 with tempfile.NamedTemporaryFile() as f:
1077 f.write(create_elf_file(ET.EXEC, []))
1078 f.flush()
1079 self.assertRaisesRegex(
1080 ValueError, "not an ELF core file", prog.set_core_dump, f.name
1081 )
1082
1083 def test_twice(self):
1084 prog = Program()
1085 with tempfile.NamedTemporaryFile() as f:
1086 f.write(create_elf_file(ET.CORE, []))
1087 f.flush()
1088 prog.set_core_dump(f.name)
1089 self.assertRaisesRegex(
1090 ValueError,
1091 "program memory was already initialized",
1092 prog.set_core_dump,
1093 f.name,
1094 )
1095
1096 def test_simple(self):
1097 data = b"hello, world"
1098 prog = Program()
1099 self.assertIsNone(prog.core_dump_path)
1100 with tempfile.NamedTemporaryFile() as f:
1101 f.write(
1102 create_elf_file(
1103 ET.CORE, [ElfSection(p_type=PT.LOAD, vaddr=0xFFFF0000, data=data)]
1104 )
1105 )
1106 f.flush()
1107 prog.set_core_dump(f.name)
1108 self.assertEqual(prog.core_dump_path, f.name)
1109 self.assertEqual(prog.read(0xFFFF0000, len(data)), data)
1110 self.assertRaises(FaultError, prog.read, 0x0, len(data), physical=True)
1111
1112 def test_physical(self):
1113 data = b"hello, world"
1114 prog = Program()
1115 with tempfile.NamedTemporaryFile() as f:
1116 f.write(
1117 create_elf_file(
1118 ET.CORE,
1119 [
1120 ElfSection(
1121 p_type=PT.LOAD, vaddr=0xFFFF0000, paddr=0xA0, data=data
1122 ),
1123 ],
1124 )
1125 )
1126 f.flush()
1127 prog.set_core_dump(f.name)
1128 self.assertEqual(prog.read(0xFFFF0000, len(data)), data)
1129 self.assertEqual(prog.read(0xA0, len(data), physical=True), data)
1130
1131 def test_unsaved(self):
1132 data = b"hello, world"
1133 prog = Program()
1134 with tempfile.NamedTemporaryFile() as f:
1135 f.write(
1136 create_elf_file(
1137 ET.CORE,
1138 [
1139 ElfSection(
1140 p_type=PT.LOAD,
1141 vaddr=0xFFFF0000,
1142 data=data,
1143 memsz=len(data) + 4,
1144 ),
1145 ],
1146 )
1147 )
1148 f.flush()
1149 prog.set_core_dump(f.name)
1150 with self.assertRaisesRegex(FaultError, "memory not saved in core dump") as cm:
1151 prog.read(0xFFFF0000, len(data) + 4)
1152 self.assertEqual(cm.exception.address, 0xFFFF000C)
1153
1154
1155 def make_vmcoreinfo(
1156 osrelease="6.0.0-test",
1157 pagesize=4096,
1158 swapper_pg_dir=0xFFFFFFFF81000000,
1159 extra_lines=None,
1160 ):
1161 """Create fake vmcoreinfo data with required fields."""
1162 lines = [
1163 f"OSRELEASE={osrelease}",
1164 f"PAGESIZE={pagesize}",
1165 f"SYMBOL(swapper_pg_dir)={swapper_pg_dir:x}",
1166 ]
1167 if extra_lines:
1168 lines.extend(extra_lines)
1169 return ("\n".join(lines) + "\n").encode()
1170
1171
1172 class TestSetLinuxKernelCustom(TestCase):
1173 def test_requires_platform(self):
1174 prog = Program()
1175 self.assertRaisesRegex(
1176 ValueError,
1177 "platform must be set",
1178 prog.set_linux_kernel_custom,
1179 make_vmcoreinfo(),
1180 False,
1181 )
1182
1183 def test_invalid_vmcoreinfo_missing_osrelease(self):
1184 prog = Program(MOCK_PLATFORM)
1185 self.assertRaisesRegex(
1186 Exception,
1187 "VMCOREINFO does not contain valid OSRELEASE",
1188 prog.set_linux_kernel_custom,
1189 b"PAGESIZE=4096\nSYMBOL(swapper_pg_dir)=ffff0000\n",
1190 False,
1191 )
1192
1193 def test_sets_linux_kernel_flag(self):
1194 prog = Program(MOCK_PLATFORM)
1195 self.assertFalse(prog.flags & ProgramFlags.IS_LINUX_KERNEL)
1196 prog.set_linux_kernel_custom(make_vmcoreinfo(), False)
1197 self.assertTrue(prog.flags & ProgramFlags.IS_LINUX_KERNEL)
1198
1199 def test_is_live(self):
1200 prog = Program(MOCK_PLATFORM)
1201 self.assertFalse(prog.flags & ProgramFlags.IS_LIVE)
1202 prog.set_linux_kernel_custom(make_vmcoreinfo(), True)
1203 self.assertTrue(prog.flags & ProgramFlags.IS_LIVE)
1204
1205 def test_not_is_live(self):
1206 prog = Program(MOCK_PLATFORM)
1207 prog.set_linux_kernel_custom(make_vmcoreinfo(), False)
1208 self.assertFalse(prog.flags & ProgramFlags.IS_LIVE)
1209
1210 def test_idempotent(self):
1211 prog = Program(MOCK_PLATFORM)
1212 prog.set_linux_kernel_custom(make_vmcoreinfo(), False)
1213 self.assertTrue(prog.flags & ProgramFlags.IS_LINUX_KERNEL)
1214 prog.set_linux_kernel_custom(make_vmcoreinfo(), False)
1215 self.assertTrue(prog.flags & ProgramFlags.IS_LINUX_KERNEL)
1216
1217 def test_with_vmcoreinfo_in_constructor(self):
1218 vmcoreinfo1 = make_vmcoreinfo(osrelease="5.0.0-first")
1219 vmcoreinfo2 = make_vmcoreinfo(osrelease="6.0.0-second")
1220 prog = Program(MOCK_PLATFORM, vmcoreinfo=vmcoreinfo1)
1221 prog.set_linux_kernel_custom(vmcoreinfo2, False)
1222 self.assertTrue(prog.flags & ProgramFlags.IS_LINUX_KERNEL)
1223
1224 def test_with_physical_memory_segment(self):
1225 prog = Program(MOCK_PLATFORM)
1226 data = b"test data"
1227 prog.add_memory_segment(
1228 0x1000,
1229 len(data),
1230 lambda addr, count, off, phys: data[off : off + count],
1231 True,
1232 )
1233 prog.set_linux_kernel_custom(make_vmcoreinfo(), False)
1234 self.assertTrue(prog.flags & ProgramFlags.IS_LINUX_KERNEL)
1235 self.assertEqual(prog.read(0x1000, len(data), physical=True), data)
1236
1237
1238 def dummy_symbol_finder(prog, name, address, one):
1239 return ()
1240
1241
1242 class TestSymbolFinders(TestCase):
1243 def test_registered(self):
1244 prog = Program()
1245 self.assertEqual(prog.registered_symbol_finders(), {"elf"})
1246 prog.register_symbol_finder("foo", dummy_symbol_finder)
1247 self.assertEqual(prog.registered_symbol_finders(), {"elf", "foo"})
1248
1249 def test_register_duplicate(self):
1250 self.assertRaisesRegex(
1251 ValueError,
1252 "duplicate symbol finder",
1253 Program().register_symbol_finder,
1254 "elf",
1255 dummy_symbol_finder,
1256 )
1257
1258 def test_default_enabled(self):
1259 self.assertEqual(Program().enabled_symbol_finders(), ["elf"])
1260
1261 def test_disable_all(self):
1262 prog = Program()
1263 prog.set_enabled_symbol_finders(())
1264 self.assertEqual(prog.enabled_symbol_finders(), [])
1265
1266 def test_register_then_enable(self):
1267 prog = Program()
1268 prog.register_symbol_finder("foo", dummy_symbol_finder)
1269 self.assertEqual(prog.enabled_symbol_finders(), ["elf"])
1270
1271 prog.set_enabled_symbol_finders(["foo", "elf"])
1272 self.assertEqual(prog.enabled_symbol_finders(), ["foo", "elf"])
1273
1274 def test_register_enable_index(self):
1275 prog = Program()
1276 with self.subTest("None"):
1277 prog.register_symbol_finder("ghost", dummy_symbol_finder, enable_index=None)
1278 self.assertEqual(prog.enabled_symbol_finders(), ["elf"])
1279
1280 with self.subTest("first"):
1281 prog.register_symbol_finder("foo", dummy_symbol_finder, enable_index=0)
1282 self.assertEqual(prog.enabled_symbol_finders(), ["foo", "elf"])
1283
1284 with self.subTest("middle"):
1285 prog.register_symbol_finder("bar", dummy_symbol_finder, enable_index=1)
1286 self.assertEqual(prog.enabled_symbol_finders(), ["foo", "bar", "elf"])
1287
1288 with self.subTest("end"):
1289 prog.register_symbol_finder("baz", dummy_symbol_finder, enable_index=3)
1290 self.assertEqual(
1291 prog.enabled_symbol_finders(), ["foo", "bar", "elf", "baz"]
1292 )
1293
1294 with self.subTest("past end"):
1295 prog.register_symbol_finder("qux", dummy_symbol_finder, enable_index=10)
1296 self.assertEqual(
1297 prog.enabled_symbol_finders(), ["foo", "bar", "elf", "baz", "qux"]
1298 )
1299
1300 with self.subTest("DRGN_HANDLER_REGISTER_DONT_ENABLE"):
1301 prog.register_symbol_finder(
1302 "quux",
1303 dummy_symbol_finder,
1304 enable_index=(2**64 if sys.maxsize > 2**32 else 2**32) - 2,
1305 )
1306 self.assertEqual(
1307 prog.enabled_symbol_finders(),
1308 ["foo", "bar", "elf", "baz", "qux", "quux"],
1309 )
1310
1311 with self.subTest("last"):
1312 prog.register_symbol_finder("quuux", dummy_symbol_finder, enable_index=-1)
1313 self.assertEqual(
1314 prog.enabled_symbol_finders(),
1315 ["foo", "bar", "elf", "baz", "qux", "quux", "quuux"],
1316 )
1317
1318 def test_register_enable_index_invalid(self):
1319 self.assertRaises(
1320 OverflowError,
1321 Program().register_symbol_finder,
1322 "foo",
1323 dummy_symbol_finder,
1324 enable_index=-2,
1325 )