Debian Codegraph @

tests/test_module.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4 from pathlib import Path
5
6 from drgn import (
7 ExtraModule,
8 MainModule,
9 ModuleFileStatus,
10 Program,
11 RelocatableModule,
12 SharedLibraryModule,
13 VdsoModule,
14 )
15 from tests import IntWrapper, TestCase
16
17
18 class TestModule(TestCase):
19 def _test_module_init_common(self, module):
20 self.assertIsNone(module.address_ranges)
21 self.assertIsNone(module.address_range)
22 self.assertIsNone(module.build_id)
23 self.assertEqual(module.loaded_file_status, ModuleFileStatus.WANT)
24 self.assertIsNone(module.loaded_file_path)
25 self.assertIsNone(module.loaded_file_bias)
26 self.assertEqual(module.debug_file_status, ModuleFileStatus.WANT)
27 self.assertIsNone(module.debug_file_path)
28 self.assertIsNone(module.debug_file_bias)
29 self.assertIsNone(module.supplementary_debug_file_kind)
30 self.assertIsNone(module.supplementary_debug_file_path)
31
32 def test_main_module(self):
33 prog = Program()
34
35 self.assertRaises(LookupError, prog.main_module)
36 self.assertRaises(LookupError, prog.main_module, "/foo/bar")
37
38 module = prog.main_module("/foo/bar", create=True)
39 self.assertIsInstance(module, MainModule)
40
41 self.assertEqual(prog.main_module(), module)
42 self.assertEqual(prog.main_module(create=False), module)
43 self.assertEqual(prog.main_module("/foo/bar"), module)
44 self.assertEqual(prog.main_module(b"/foo/bar"), module)
45 self.assertEqual(prog.main_module(Path("/foo/bar")), module)
46 self.assertEqual(prog.main_module("/foo/bar", create=True), module)
47
48 self.assertRaises(LookupError, prog.main_module, "/foo/baz")
49 self.assertRaises(LookupError, prog.main_module, "/foo/baz", create=True)
50
51 self.assertIs(module.prog, prog)
52 self.assertEqual(module.name, "/foo/bar")
53 self._test_module_init_common(module)
54
55 def test_main_module_invalid(self):
56 prog = Program()
57 self.assertRaises(TypeError, prog.main_module, None)
58 self.assertRaises(TypeError, prog.main_module, create=True)
59 self.assertRaises(TypeError, prog.main_module, "/foo/bar", True)
60
61 def test_shared_library_module(self):
62 prog = Program()
63
64 self.assertRaises(
65 LookupError, prog.shared_library_module, "/foo/bar", 0x10000000
66 )
67
68 module = prog.shared_library_module("/foo/bar", 0x10000000, create=True)
69 self.assertIsInstance(module, SharedLibraryModule)
70
71 self.assertEqual(prog.shared_library_module("/foo/bar", 0x10000000), module)
72 self.assertEqual(prog.shared_library_module(b"/foo/bar", 0x10000000), module)
73 self.assertEqual(
74 prog.shared_library_module(Path("/foo/bar"), IntWrapper(0x10000000)), module
75 )
76 self.assertEqual(
77 prog.shared_library_module("/foo/bar", 0x10000000, create=True), module
78 )
79
80 self.assertRaises(
81 LookupError, prog.shared_library_module, "/foo/bar", 0x20000000
82 )
83 self.assertRaises(
84 LookupError, prog.shared_library_module, "/foo/baz", 0x10000000
85 )
86
87 self.assertNotEqual(
88 prog.shared_library_module("/foo/bar", 0x20000000, create=True), module
89 )
90 self.assertNotEqual(
91 prog.shared_library_module("/foo/baz", 0x10000000, create=True), module
92 )
93 self.assertNotEqual(
94 prog.vdso_module("/foo/bar", 0x10000000, create=True), module
95 )
96
97 self.assertIs(module.prog, prog)
98 self.assertEqual(module.name, "/foo/bar")
99 self.assertEqual(module.dynamic_address, 0x10000000)
100 self._test_module_init_common(module)
101
102 def test_shared_library_module_invalid(self):
103 prog = Program()
104 self.assertRaises(TypeError, prog.shared_library_module)
105 self.assertRaises(TypeError, prog.shared_library_module, "/foo/bar")
106 self.assertRaises(TypeError, prog.shared_library_module, "/foo/bar", None)
107 self.assertRaises(TypeError, prog.shared_library_module, None, 0)
108 self.assertRaises(
109 TypeError, prog.shared_library_module, "/foo/bar", 0x10000000, True
110 )
111
112 def test_vdso_module(self):
113 prog = Program()
114
115 self.assertRaises(LookupError, prog.vdso_module, "/foo/bar", 0x10000000)
116
117 module = prog.vdso_module("/foo/bar", 0x10000000, create=True)
118 self.assertIsInstance(module, VdsoModule)
119
120 self.assertEqual(prog.vdso_module("/foo/bar", 0x10000000), module)
121 self.assertEqual(prog.vdso_module(b"/foo/bar", 0x10000000), module)
122 self.assertEqual(
123 prog.vdso_module(Path("/foo/bar"), IntWrapper(0x10000000)), module
124 )
125 self.assertEqual(prog.vdso_module("/foo/bar", 0x10000000, create=True), module)
126
127 self.assertRaises(LookupError, prog.vdso_module, "/foo/bar", 0x20000000)
128 self.assertRaises(LookupError, prog.vdso_module, "/foo/baz", 0x10000000)
129
130 self.assertNotEqual(
131 prog.vdso_module("/foo/bar", 0x20000000, create=True), module
132 )
133 self.assertNotEqual(
134 prog.vdso_module("/foo/baz", 0x10000000, create=True), module
135 )
136 self.assertNotEqual(
137 prog.shared_library_module("/foo/bar", 0x10000000, create=True), module
138 )
139
140 self.assertIs(module.prog, prog)
141 self.assertEqual(module.name, "/foo/bar")
142 self.assertEqual(module.dynamic_address, 0x10000000)
143 self._test_module_init_common(module)
144
145 def test_vdso_module_invalid(self):
146 prog = Program()
147 self.assertRaises(TypeError, prog.vdso_module)
148 self.assertRaises(TypeError, prog.vdso_module, "/foo/bar")
149 self.assertRaises(TypeError, prog.vdso_module, "/foo/bar", None)
150 self.assertRaises(TypeError, prog.vdso_module, None, 0)
151 self.assertRaises(TypeError, prog.vdso_module, "/foo/bar", 0x10000000, True)
152
153 def test_relocatable_module(self):
154 prog = Program()
155
156 self.assertRaises(LookupError, prog.relocatable_module, "/foo/bar", 0x10000000)
157
158 module = prog.relocatable_module("/foo/bar", 0x10000000, create=True)
159 self.assertIsInstance(module, RelocatableModule)
160
161 self.assertEqual(prog.relocatable_module("/foo/bar", 0x10000000), module)
162 self.assertEqual(prog.relocatable_module(b"/foo/bar", 0x10000000), module)
163 self.assertEqual(
164 prog.relocatable_module(Path("/foo/bar"), IntWrapper(0x10000000)), module
165 )
166 self.assertEqual(
167 prog.relocatable_module("/foo/bar", 0x10000000, create=True), module
168 )
169
170 self.assertRaises(LookupError, prog.relocatable_module, "/foo/bar", 0x20000000)
171 self.assertRaises(LookupError, prog.relocatable_module, "/foo/baz", 0x10000000)
172
173 self.assertNotEqual(
174 prog.relocatable_module("/foo/bar", 0x20000000, create=True), module
175 )
176 self.assertNotEqual(
177 prog.relocatable_module("/foo/baz", 0x10000000, create=True), module
178 )
179 self.assertNotEqual(
180 prog.shared_library_module("/foo/bar", 0x10000000, create=True), module
181 )
182
183 self.assertIs(module.prog, prog)
184 self.assertEqual(module.name, "/foo/bar")
185 self.assertEqual(module.address, 0x10000000)
186 self._test_module_init_common(module)
187
188 def test_section_addresses(self):
189 prog = Program()
190 module = prog.relocatable_module("/foo/bar", 0x10000000, create=True)
191
192 self.assertNotIn(".text", module.section_addresses)
193 self.assertNotIn(1, module.section_addresses)
194
195 with self.assertRaises(KeyError):
196 module.section_addresses[".text"]
197 with self.assertRaises(KeyError):
198 module.section_addresses[1]
199
200 with self.assertRaises(KeyError):
201 del module.section_addresses[".text"]
202 with self.assertRaises(KeyError):
203 del module.section_addresses[1]
204
205 module.section_addresses[".text"] = 0x10000000
206 self.assertIn(".text", module.section_addresses)
207 self.assertEqual(module.section_addresses[".text"], 0x10000000)
208
209 self.assertEqual(len(module.section_addresses), 1)
210 self.assertCountEqual(list(module.section_addresses), [".text"])
211 self.assertCountEqual(list(module.section_addresses.keys()), [".text"])
212 self.assertCountEqual(list(module.section_addresses.values()), [0x10000000])
213 self.assertCountEqual(
214 list(module.section_addresses.items()), [(".text", 0x10000000)]
215 )
216
217 module.section_addresses[".data"] = 0x10001000
218
219 self.assertEqual(len(module.section_addresses), 2)
220 self.assertCountEqual(list(module.section_addresses), [".text", ".data"])
221 self.assertCountEqual(list(module.section_addresses.keys()), [".text", ".data"])
222 self.assertCountEqual(
223 list(module.section_addresses.values()), [0x10000000, 0x10001000]
224 )
225 self.assertCountEqual(
226 list(module.section_addresses.items()),
227 [(".text", 0x10000000), (".data", 0x10001000)],
228 )
229
230 del module.section_addresses[".data"]
231
232 self.assertEqual(len(module.section_addresses), 1)
233 self.assertCountEqual(list(module.section_addresses), [".text"])
234 self.assertCountEqual(list(module.section_addresses.keys()), [".text"])
235 self.assertCountEqual(list(module.section_addresses.values()), [0x10000000])
236 self.assertCountEqual(
237 list(module.section_addresses.items()), [(".text", 0x10000000)]
238 )
239
240 def test_relocatable_module_invalid(self):
241 prog = Program()
242 self.assertRaises(TypeError, prog.relocatable_module)
243 self.assertRaises(TypeError, prog.relocatable_module, "/foo/bar")
244 self.assertRaises(TypeError, prog.relocatable_module, "/foo/bar", None)
245 self.assertRaises(TypeError, prog.relocatable_module, None, 0)
246 self.assertRaises(
247 TypeError, prog.relocatable_module, "/foo/bar", 0x10000000, True
248 )
249
250 def test_extra_module(self):
251 prog = Program()
252
253 self.assertRaises(LookupError, prog.extra_module, "/foo/bar", 1234)
254
255 module = prog.extra_module("/foo/bar", 1234, create=True)
256 self.assertIsInstance(module, ExtraModule)
257
258 self.assertEqual(prog.extra_module("/foo/bar", 1234), module)
259 self.assertEqual(prog.extra_module(b"/foo/bar", 1234), module)
260 self.assertEqual(prog.extra_module(Path("/foo/bar"), IntWrapper(1234)), module)
261 self.assertEqual(prog.extra_module("/foo/bar", 1234, create=True), module)
262
263 self.assertRaises(LookupError, prog.extra_module, "/foo/bar", 5678)
264 self.assertRaises(LookupError, prog.extra_module, "/foo/baz", 1234)
265
266 self.assertNotEqual(prog.extra_module("/foo/bar", 5678, create=True), module)
267 self.assertNotEqual(prog.extra_module("/foo/baz", 1234, create=True), module)
268 self.assertNotEqual(
269 prog.shared_library_module("/foo/bar", 1234, create=True), module
270 )
271 self.assertEqual(prog.extra_module("/foo/bar", create=True).id, 0)
272
273 self.assertIs(module.prog, prog)
274 self.assertEqual(module.name, "/foo/bar")
275 self.assertEqual(module.id, 1234)
276 self._test_module_init_common(module)
277
278 def test_extra_module_invalid(self):
279 prog = Program()
280 self.assertRaises(TypeError, prog.extra_module)
281 self.assertRaises(TypeError, prog.extra_module, "/foo/bar", None)
282 self.assertRaises(TypeError, prog.extra_module, None, 0)
283 self.assertRaises(TypeError, prog.extra_module, "/foo/bar", 1234, True)
284
285 def test_address_range(self):
286 module = Program().extra_module("/foo/bar", create=True)
287
288 module.address_range = (0x10000000, 0x10010000)
289 self.assertEqual(module.address_range, (0x10000000, 0x10010000))
290
291 module.address_range = (0x20000000, 0x20020000)
292 self.assertEqual(module.address_range, (0x20000000, 0x20020000))
293
294 module.address_range = None
295 self.assertIsNone(module.address_range)
296
297 module.address_range = None
298 self.assertIsNone(module.address_range)
299
300 def test_address_range_empty(self):
301 module = Program().extra_module("/foo/bar", create=True)
302
303 module.address_range = (0, 0)
304 self.assertEqual(module.address_range, (0, 0))
305
306 def test_address_range_type_error(self):
307 module = Program().extra_module("/foo/bar", create=True)
308
309 with self.assertRaises(TypeError):
310 module.address_range = 1
311
312 with self.assertRaises(TypeError):
313 module.address_range = (1,)
314
315 with self.assertRaises(TypeError):
316 module.address_range = (1, 2, 3)
317
318 with self.assertRaises(TypeError):
319 module.address_range = ("foo", 1)
320
321 with self.assertRaises(TypeError):
322 module.address_range = (1, "bar")
323
324 def test_address_range_invalid(self):
325 module = Program().extra_module("/foo/bar", create=True)
326
327 with self.assertRaisesRegex(ValueError, "invalid module address range"):
328 module.address_range = (0x10010000, 0x10000000)
329
330 with self.assertRaisesRegex(ValueError, "invalid module address range"):
331 module.address_range = (1, 1)
332
333 with self.assertRaisesRegex(ValueError, "invalid module address range"):
334 module.address_range = (2**64 - 1, 1)
335
336 with self.assertRaisesRegex(ValueError, "invalid module address range"):
337 module.address_range = (2**64 - 1, 2**64 - 1)
338
339 def test_address_range_del(self):
340 module = Program().extra_module("/foo/bar", create=True)
341 with self.assertRaises(AttributeError):
342 del module.address_range
343
344 def test_address_ranges_single(self):
345 module = Program().extra_module("/foo/bar", create=True)
346
347 module.address_ranges = [(0x10000000, 0x10010000)]
348 self.assertEqual(module.address_range, (0x10000000, 0x10010000))
349 self.assertCountEqual(module.address_ranges, [(0x10000000, 0x10010000)])
350
351 module.address_range = (0x20000000, 0x20010000)
352 self.assertCountEqual(module.address_ranges, [(0x20000000, 0x20010000)])
353
354 def test_address_ranges_multiple(self):
355 module = Program().extra_module("/foo/bar", create=True)
356
357 module.address_ranges = [
358 (0x10000000, 0x10010000),
359 (0x20000000, 0x20010000),
360 ]
361 with self.assertRaisesRegex(ValueError, "module has multiple address ranges"):
362 module.address_range
363 self.assertCountEqual(
364 module.address_ranges, [(0x10000000, 0x10010000), (0x20000000, 0x20010000)]
365 )
366
367 def test_address_ranges_empty(self):
368 module = Program().extra_module("/foo/bar", create=True)
369
370 module.address_ranges = ()
371 self.assertEqual(module.address_range, (0, 0))
372 self.assertCountEqual(module.address_ranges, ())
373
374 module.address_range = (0, 0)
375 self.assertCountEqual(module.address_ranges, ())
376
377 def test_address_ranges_type_error(self):
378 module = Program().extra_module("/foo/bar", create=True)
379
380 with self.assertRaises(TypeError):
381 module.address_ranges = 1
382
383 with self.assertRaises(TypeError):
384 module.address_ranges = (1,)
385
386 with self.assertRaises(TypeError):
387 module.address_ranges = ((1,),)
388
389 with self.assertRaises(TypeError):
390 module.address_ranges = ((1, 2, 3),)
391
392 with self.assertRaises(TypeError):
393 module.address_ranges = (("foo", 1),)
394
395 with self.assertRaises(TypeError):
396 module.address_ranges = ((1, "bar"),)
397
398 def test_address_ranges_invalid(self):
399 module = Program().extra_module("/foo/bar", create=True)
400
401 with self.assertRaisesRegex(ValueError, "invalid module address range"):
402 module.address_ranges = ((0x10010000, 0x10000000),)
403
404 with self.assertRaisesRegex(ValueError, "invalid module address range"):
405 module.address_ranges = ((1, 1),)
406
407 with self.assertRaisesRegex(ValueError, "invalid module address range"):
408 module.address_ranges = ((0, 0),)
409
410 def test_address_range_overlap(self):
411 prog = Program()
412 prog.extra_module("/foo/bar", create=True).address_range = (
413 0x10000000,
414 0x10010000,
415 )
416 with self.assertRaisesRegex(ValueError, "overlaps /foo/bar"):
417 prog.extra_module("/foo/baz", create=True).address_range = (
418 0x10001000,
419 0x10010000,
420 )
421
422 def test_address_ranges_overlap(self):
423 prog = Program()
424 prog.extra_module("/foo/bar", create=True).address_range = (
425 0x10000000,
426 0x10010000,
427 )
428 with self.assertRaisesRegex(ValueError, "overlaps /foo/bar"):
429 prog.extra_module("/foo/baz", create=True).address_ranges = (
430 (0x1000000, 0x10000000),
431 (0x10001000, 0x10010000),
432 )
433
434 def test_address_ranges_self_overlap(self):
435 module = Program().extra_module("/foo/bar", create=True)
436 with self.assertRaisesRegex(ValueError, "overlaps"):
437 module.address_ranges = (
438 (0x10000000, 0x10010000),
439 (0x10001000, 0x10020000),
440 )
441
442 def test_address_range_expand(self):
443 module = Program().extra_module("/foo/bar", create=True)
444 module.address_range = (0x10000000, 0x10010000)
445 module.address_range = (0x1000000, 0x10020000)
446 self.assertEqual(module.address_range, (0x1000000, 0x10020000))
447
448 def test_build_id(self):
449 module = Program().extra_module("/foo/bar", create=True)
450
451 module.build_id = b"\x01\x23\x45\x67\x89\xab\xcd\xef"
452 self.assertEqual(module.build_id, b"\x01\x23\x45\x67\x89\xab\xcd\xef")
453
454 module.build_id = b"\xfe\xdc\xba\x98\x76\x54\x32\x10"
455 self.assertEqual(module.build_id, b"\xfe\xdc\xba\x98\x76\x54\x32\x10")
456
457 module.build_id = None
458 self.assertIsNone(module.build_id)
459
460 module.build_id = None
461 self.assertIsNone(module.build_id)
462
463 def test_build_id_type_error(self):
464 module = Program().extra_module("/foo/bar", create=True)
465 with self.assertRaises(TypeError):
466 module.build_id = "abcd"
467
468 def test_build_id_invalid_empty(self):
469 module = Program().extra_module("/foo/bar", create=True)
470 with self.assertRaisesRegex(ValueError, "build ID cannot be empty"):
471 module.build_id = b""
472
473 def test_build_id_del(self):
474 module = Program().extra_module("/foo/bar", create=True)
475 with self.assertRaises(AttributeError):
476 del module.build_id
477
478 def test_find_by_name(self):
479 prog = Program()
480 self.assertRaises(LookupError, prog.module, "foo")
481
482 module1 = prog.extra_module("foo", create=True)
483 self.assertEqual(prog.module("foo"), module1)
484
485 module2 = prog.main_module("foo", create=True)
486 self.assertIn(prog.module("foo"), (module1, module2))
487
488 self.assertRaises(LookupError, prog.module, "bar")
489
490 def test_find_by_address(self):
491 prog = Program()
492 module1 = prog.extra_module("/foo/bar", create=True)
493 module1.address_range = (0x10000000, 0x10010000)
494 module2 = prog.extra_module("/asdf/jkl", create=True)
495 module2.address_range = (0x20000000, 0x20020000)
496
497 self.assertRaises(LookupError, prog.module, 0x0FFFFFFF)
498 self.assertEqual(prog.module(0x10000000), module1)
499 self.assertEqual(prog.module(0x10000001), module1)
500 self.assertEqual(prog.module(0x1000FFFF), module1)
501 self.assertRaises(LookupError, prog.module, 0x10010000)
502
503 self.assertRaises(LookupError, prog.module, 0x1FFFFFFF)
504 self.assertEqual(prog.module(0x20000000), module2)
505 self.assertEqual(prog.module(0x20000001), module2)
506 self.assertEqual(prog.module(0x2001FFFF), module2)
507 self.assertRaises(LookupError, prog.module, 0x20020000)
508
509 # Test all of the state transitions that we can without setting a file.
510 def _test_file_status(self, which):
511 module = Program().extra_module("/foo/bar", create=True)
512
513 status_attr = which + "_file_status"
514 wants_file = getattr(module, f"wants_{which}_file")
515
516 self.assertRaises(TypeError, setattr, module, status_attr, 1)
517
518 setattr(module, status_attr, ModuleFileStatus.WANT)
519 self.assertEqual(getattr(module, status_attr), ModuleFileStatus.WANT)
520 self.assertEqual(wants_file(), True)
521 for status in set(ModuleFileStatus) - {
522 ModuleFileStatus.WANT,
523 ModuleFileStatus.DONT_WANT,
524 ModuleFileStatus.DONT_NEED,
525 }:
526 with self.subTest(from_=ModuleFileStatus.WANT, to=status):
527 self.assertRaises(ValueError, setattr, module, status_attr, status)
528 self.assertEqual(getattr(module, status_attr), ModuleFileStatus.WANT)
529
530 setattr(module, status_attr, ModuleFileStatus.DONT_WANT)
531 self.assertEqual(getattr(module, status_attr), ModuleFileStatus.DONT_WANT)
532 self.assertEqual(wants_file(), False)
533 for status in set(ModuleFileStatus) - {
534 ModuleFileStatus.WANT,
535 ModuleFileStatus.DONT_WANT,
536 ModuleFileStatus.DONT_NEED,
537 }:
538 with self.subTest(from_=ModuleFileStatus.DONT_WANT, to=status):
539 self.assertRaises(ValueError, setattr, module, status_attr, status)
540 self.assertEqual(
541 getattr(module, status_attr), ModuleFileStatus.DONT_WANT
542 )
543
544 setattr(module, status_attr, ModuleFileStatus.DONT_NEED)
545 self.assertEqual(getattr(module, status_attr), ModuleFileStatus.DONT_NEED)
546 self.assertEqual(wants_file(), False)
547 for status in set(ModuleFileStatus) - {
548 ModuleFileStatus.WANT,
549 ModuleFileStatus.DONT_WANT,
550 ModuleFileStatus.DONT_NEED,
551 }:
552 with self.subTest(from_=ModuleFileStatus.DONT_NEED, to=status):
553 self.assertRaises(ValueError, setattr, module, status_attr, status)
554 self.assertEqual(
555 getattr(module, status_attr), ModuleFileStatus.DONT_NEED
556 )
557
558 setattr(module, status_attr, ModuleFileStatus.DONT_WANT)
559 self.assertEqual(getattr(module, status_attr), ModuleFileStatus.DONT_WANT)
560
561 setattr(module, status_attr, ModuleFileStatus.WANT)
562 self.assertEqual(getattr(module, status_attr), ModuleFileStatus.WANT)
563
564 setattr(module, status_attr, ModuleFileStatus.DONT_NEED)
565 self.assertEqual(getattr(module, status_attr), ModuleFileStatus.DONT_NEED)
566
567 setattr(module, status_attr, ModuleFileStatus.WANT)
568 self.assertEqual(getattr(module, status_attr), ModuleFileStatus.WANT)
569
570 self.assertRaises(AttributeError, delattr, module, status_attr)
571
572 def test_loaded_file_status(self):
573 self._test_file_status("loaded")
574
575 def test_debug_file_status(self):
576 self._test_file_status("debug")
577
578
579 class TestCreatedModules(TestCase):
580 def test_empty(self):
581 self.assertEqual(list(Program().modules()), [])
582
583 def test_one(self):
584 module = Program().extra_module("/foo/bar", create=True)
585 self.assertEqual(list(module.prog.modules()), [module])
586
587 def test_multiple(self):
588 prog = Program()
589 modules = [
590 prog.extra_module("/foo/bar", create=True),
591 prog.extra_module("/asdf/jkl", create=True),
592 prog.extra_module("/123/456", create=True),
593 ]
594 self.assertCountEqual(list(prog.modules()), modules)
595
596 def test_same_name(self):
597 prog = Program()
598 modules = [
599 prog.extra_module("foo", id=0, create=True),
600 prog.main_module("foo", create=True),
601 ]
602 actual = list(prog.modules())
603 self.assertCountEqual(actual, modules)
604 self.assertEqual(actual[0], prog.main_module())
605
606 modules.append(prog.extra_module("foo", id=1, create=True))
607 actual = list(prog.modules())
608 self.assertCountEqual(actual, modules)
609 self.assertEqual(actual[0], prog.main_module())
610
611 def test_change_during_iteration(self):
612 prog = Program()
613 prog.extra_module("/foo/bar", create=True)
614 with self.assertRaisesRegex(Exception, "modules changed during iteration"):
615 for module in prog.modules():
616 prog.extra_module("/asdf/jkl", create=True)
617 prog.extra_module("/123/456", create=True)