Debian Codegraph @

Lib/test/test_asyncio/test_tools.py

raw
1 import unittest
2
3 from asyncio import tools
4
5 from collections import namedtuple
6
7 FrameInfo = namedtuple('FrameInfo', ['funcname', 'filename', 'lineno'])
8 CoroInfo = namedtuple('CoroInfo', ['call_stack', 'task_name'])
9 TaskInfo = namedtuple('TaskInfo', ['task_id', 'task_name', 'coroutine_stack', 'awaited_by'])
10 AwaitedInfo = namedtuple('AwaitedInfo', ['thread_id', 'awaited_by'])
11
12
13 # mock output of get_all_awaited_by function.
14 TEST_INPUTS_TREE = [
15 [
16 # test case containing a task called timer being awaited in two
17 # different subtasks part of a TaskGroup (root1 and root2) which call
18 # awaiter functions.
19 (
20 AwaitedInfo(
21 thread_id=1,
22 awaited_by=[
23 TaskInfo(
24 task_id=2,
25 task_name="Task-1",
26 coroutine_stack=[],
27 awaited_by=[]
28 ),
29 TaskInfo(
30 task_id=3,
31 task_name="timer",
32 coroutine_stack=[],
33 awaited_by=[
34 CoroInfo(
35 call_stack=[
36 FrameInfo("awaiter3", "/path/to/app.py", 130),
37 FrameInfo("awaiter2", "/path/to/app.py", 120),
38 FrameInfo("awaiter", "/path/to/app.py", 110)
39 ],
40 task_name=4
41 ),
42 CoroInfo(
43 call_stack=[
44 FrameInfo("awaiterB3", "/path/to/app.py", 190),
45 FrameInfo("awaiterB2", "/path/to/app.py", 180),
46 FrameInfo("awaiterB", "/path/to/app.py", 170)
47 ],
48 task_name=5
49 ),
50 CoroInfo(
51 call_stack=[
52 FrameInfo("awaiterB3", "/path/to/app.py", 190),
53 FrameInfo("awaiterB2", "/path/to/app.py", 180),
54 FrameInfo("awaiterB", "/path/to/app.py", 170)
55 ],
56 task_name=6
57 ),
58 CoroInfo(
59 call_stack=[
60 FrameInfo("awaiter3", "/path/to/app.py", 130),
61 FrameInfo("awaiter2", "/path/to/app.py", 120),
62 FrameInfo("awaiter", "/path/to/app.py", 110)
63 ],
64 task_name=7
65 )
66 ]
67 ),
68 TaskInfo(
69 task_id=8,
70 task_name="root1",
71 coroutine_stack=[],
72 awaited_by=[
73 CoroInfo(
74 call_stack=[
75 FrameInfo("_aexit", "", 0),
76 FrameInfo("__aexit__", "", 0),
77 FrameInfo("main", "", 0)
78 ],
79 task_name=2
80 )
81 ]
82 ),
83 TaskInfo(
84 task_id=9,
85 task_name="root2",
86 coroutine_stack=[],
87 awaited_by=[
88 CoroInfo(
89 call_stack=[
90 FrameInfo("_aexit", "", 0),
91 FrameInfo("__aexit__", "", 0),
92 FrameInfo("main", "", 0)
93 ],
94 task_name=2
95 )
96 ]
97 ),
98 TaskInfo(
99 task_id=4,
100 task_name="child1_1",
101 coroutine_stack=[],
102 awaited_by=[
103 CoroInfo(
104 call_stack=[
105 FrameInfo("_aexit", "", 0),
106 FrameInfo("__aexit__", "", 0),
107 FrameInfo("blocho_caller", "", 0),
108 FrameInfo("bloch", "", 0)
109 ],
110 task_name=8
111 )
112 ]
113 ),
114 TaskInfo(
115 task_id=6,
116 task_name="child2_1",
117 coroutine_stack=[],
118 awaited_by=[
119 CoroInfo(
120 call_stack=[
121 FrameInfo("_aexit", "", 0),
122 FrameInfo("__aexit__", "", 0),
123 FrameInfo("blocho_caller", "", 0),
124 FrameInfo("bloch", "", 0)
125 ],
126 task_name=8
127 )
128 ]
129 ),
130 TaskInfo(
131 task_id=7,
132 task_name="child1_2",
133 coroutine_stack=[],
134 awaited_by=[
135 CoroInfo(
136 call_stack=[
137 FrameInfo("_aexit", "", 0),
138 FrameInfo("__aexit__", "", 0),
139 FrameInfo("blocho_caller", "", 0),
140 FrameInfo("bloch", "", 0)
141 ],
142 task_name=9
143 )
144 ]
145 ),
146 TaskInfo(
147 task_id=5,
148 task_name="child2_2",
149 coroutine_stack=[],
150 awaited_by=[
151 CoroInfo(
152 call_stack=[
153 FrameInfo("_aexit", "", 0),
154 FrameInfo("__aexit__", "", 0),
155 FrameInfo("blocho_caller", "", 0),
156 FrameInfo("bloch", "", 0)
157 ],
158 task_name=9
159 )
160 ]
161 )
162 ]
163 ),
164 AwaitedInfo(thread_id=0, awaited_by=[])
165 ),
166 (
167 [
168 [
169 "└── (T) Task-1",
170 " └── main",
171 " └── __aexit__",
172 " └── _aexit",
173 " ├── (T) root1",
174 " │ └── bloch",
175 " │ └── blocho_caller",
176 " │ └── __aexit__",
177 " │ └── _aexit",
178 " │ ├── (T) child1_1",
179 " │ │ └── awaiter /path/to/app.py:110",
180 " │ │ └── awaiter2 /path/to/app.py:120",
181 " │ │ └── awaiter3 /path/to/app.py:130",
182 " │ │ └── (T) timer",
183 " │ └── (T) child2_1",
184 " │ └── awaiterB /path/to/app.py:170",
185 " │ └── awaiterB2 /path/to/app.py:180",
186 " │ └── awaiterB3 /path/to/app.py:190",
187 " │ └── (T) timer",
188 " └── (T) root2",
189 " └── bloch",
190 " └── blocho_caller",
191 " └── __aexit__",
192 " └── _aexit",
193 " ├── (T) child1_2",
194 " │ └── awaiter /path/to/app.py:110",
195 " │ └── awaiter2 /path/to/app.py:120",
196 " │ └── awaiter3 /path/to/app.py:130",
197 " │ └── (T) timer",
198 " └── (T) child2_2",
199 " └── awaiterB /path/to/app.py:170",
200 " └── awaiterB2 /path/to/app.py:180",
201 " └── awaiterB3 /path/to/app.py:190",
202 " └── (T) timer",
203 ]
204 ]
205 ),
206 ],
207 [
208 # test case containing two roots
209 (
210 AwaitedInfo(
211 thread_id=9,
212 awaited_by=[
213 TaskInfo(
214 task_id=5,
215 task_name="Task-5",
216 coroutine_stack=[],
217 awaited_by=[]
218 ),
219 TaskInfo(
220 task_id=6,
221 task_name="Task-6",
222 coroutine_stack=[],
223 awaited_by=[
224 CoroInfo(
225 call_stack=[FrameInfo("main2", "", 0)],
226 task_name=5
227 )
228 ]
229 ),
230 TaskInfo(
231 task_id=7,
232 task_name="Task-7",
233 coroutine_stack=[],
234 awaited_by=[
235 CoroInfo(
236 call_stack=[FrameInfo("main2", "", 0)],
237 task_name=5
238 )
239 ]
240 ),
241 TaskInfo(
242 task_id=8,
243 task_name="Task-8",
244 coroutine_stack=[],
245 awaited_by=[
246 CoroInfo(
247 call_stack=[FrameInfo("main2", "", 0)],
248 task_name=5
249 )
250 ]
251 )
252 ]
253 ),
254 AwaitedInfo(
255 thread_id=10,
256 awaited_by=[
257 TaskInfo(
258 task_id=1,
259 task_name="Task-1",
260 coroutine_stack=[],
261 awaited_by=[]
262 ),
263 TaskInfo(
264 task_id=2,
265 task_name="Task-2",
266 coroutine_stack=[],
267 awaited_by=[
268 CoroInfo(
269 call_stack=[FrameInfo("main", "", 0)],
270 task_name=1
271 )
272 ]
273 ),
274 TaskInfo(
275 task_id=3,
276 task_name="Task-3",
277 coroutine_stack=[],
278 awaited_by=[
279 CoroInfo(
280 call_stack=[FrameInfo("main", "", 0)],
281 task_name=1
282 )
283 ]
284 ),
285 TaskInfo(
286 task_id=4,
287 task_name="Task-4",
288 coroutine_stack=[],
289 awaited_by=[
290 CoroInfo(
291 call_stack=[FrameInfo("main", "", 0)],
292 task_name=1
293 )
294 ]
295 )
296 ]
297 ),
298 AwaitedInfo(thread_id=11, awaited_by=[]),
299 AwaitedInfo(thread_id=0, awaited_by=[])
300 ),
301 (
302 [
303 [
304 "└── (T) Task-5",
305 " └── main2",
306 " ├── (T) Task-6",
307 " ├── (T) Task-7",
308 " └── (T) Task-8",
309 ],
310 [
311 "└── (T) Task-1",
312 " └── main",
313 " ├── (T) Task-2",
314 " ├── (T) Task-3",
315 " └── (T) Task-4",
316 ],
317 ]
318 ),
319 ],
320 [
321 # test case containing two roots, one of them without subtasks
322 (
323 [
324 AwaitedInfo(
325 thread_id=1,
326 awaited_by=[
327 TaskInfo(
328 task_id=2,
329 task_name="Task-5",
330 coroutine_stack=[],
331 awaited_by=[]
332 )
333 ]
334 ),
335 AwaitedInfo(
336 thread_id=3,
337 awaited_by=[
338 TaskInfo(
339 task_id=4,
340 task_name="Task-1",
341 coroutine_stack=[],
342 awaited_by=[]
343 ),
344 TaskInfo(
345 task_id=5,
346 task_name="Task-2",
347 coroutine_stack=[],
348 awaited_by=[
349 CoroInfo(
350 call_stack=[FrameInfo("main", "", 0)],
351 task_name=4
352 )
353 ]
354 ),
355 TaskInfo(
356 task_id=6,
357 task_name="Task-3",
358 coroutine_stack=[],
359 awaited_by=[
360 CoroInfo(
361 call_stack=[FrameInfo("main", "", 0)],
362 task_name=4
363 )
364 ]
365 ),
366 TaskInfo(
367 task_id=7,
368 task_name="Task-4",
369 coroutine_stack=[],
370 awaited_by=[
371 CoroInfo(
372 call_stack=[FrameInfo("main", "", 0)],
373 task_name=4
374 )
375 ]
376 )
377 ]
378 ),
379 AwaitedInfo(thread_id=8, awaited_by=[]),
380 AwaitedInfo(thread_id=0, awaited_by=[])
381 ]
382 ),
383 (
384 [
385 ["└── (T) Task-5"],
386 [
387 "└── (T) Task-1",
388 " └── main",
389 " ├── (T) Task-2",
390 " ├── (T) Task-3",
391 " └── (T) Task-4",
392 ],
393 ]
394 ),
395 ],
396 ]
397
398 TEST_INPUTS_CYCLES_TREE = [
399 [
400 # this test case contains a cycle: two tasks awaiting each other.
401 (
402 [
403 AwaitedInfo(
404 thread_id=1,
405 awaited_by=[
406 TaskInfo(
407 task_id=2,
408 task_name="Task-1",
409 coroutine_stack=[],
410 awaited_by=[]
411 ),
412 TaskInfo(
413 task_id=3,
414 task_name="a",
415 coroutine_stack=[],
416 awaited_by=[
417 CoroInfo(
418 call_stack=[FrameInfo("awaiter2", "", 0)],
419 task_name=4
420 ),
421 CoroInfo(
422 call_stack=[FrameInfo("main", "", 0)],
423 task_name=2
424 )
425 ]
426 ),
427 TaskInfo(
428 task_id=4,
429 task_name="b",
430 coroutine_stack=[],
431 awaited_by=[
432 CoroInfo(
433 call_stack=[FrameInfo("awaiter", "", 0)],
434 task_name=3
435 )
436 ]
437 )
438 ]
439 ),
440 AwaitedInfo(thread_id=0, awaited_by=[])
441 ]
442 ),
443 ([[4, 3, 4]]),
444 ],
445 [
446 # this test case contains two cycles
447 (
448 [
449 AwaitedInfo(
450 thread_id=1,
451 awaited_by=[
452 TaskInfo(
453 task_id=2,
454 task_name="Task-1",
455 coroutine_stack=[],
456 awaited_by=[]
457 ),
458 TaskInfo(
459 task_id=3,
460 task_name="A",
461 coroutine_stack=[],
462 awaited_by=[
463 CoroInfo(
464 call_stack=[
465 FrameInfo("nested", "", 0),
466 FrameInfo("nested", "", 0),
467 FrameInfo("task_b", "", 0)
468 ],
469 task_name=4
470 )
471 ]
472 ),
473 TaskInfo(
474 task_id=4,
475 task_name="B",
476 coroutine_stack=[],
477 awaited_by=[
478 CoroInfo(
479 call_stack=[
480 FrameInfo("nested", "", 0),
481 FrameInfo("nested", "", 0),
482 FrameInfo("task_c", "", 0)
483 ],
484 task_name=5
485 ),
486 CoroInfo(
487 call_stack=[
488 FrameInfo("nested", "", 0),
489 FrameInfo("nested", "", 0),
490 FrameInfo("task_a", "", 0)
491 ],
492 task_name=3
493 )
494 ]
495 ),
496 TaskInfo(
497 task_id=5,
498 task_name="C",
499 coroutine_stack=[],
500 awaited_by=[
501 CoroInfo(
502 call_stack=[
503 FrameInfo("nested", "", 0),
504 FrameInfo("nested", "", 0)
505 ],
506 task_name=6
507 )
508 ]
509 ),
510 TaskInfo(
511 task_id=6,
512 task_name="Task-2",
513 coroutine_stack=[],
514 awaited_by=[
515 CoroInfo(
516 call_stack=[
517 FrameInfo("nested", "", 0),
518 FrameInfo("nested", "", 0),
519 FrameInfo("task_b", "", 0)
520 ],
521 task_name=4
522 )
523 ]
524 )
525 ]
526 ),
527 AwaitedInfo(thread_id=0, awaited_by=[])
528 ]
529 ),
530 ([[4, 3, 4], [4, 6, 5, 4]]),
531 ],
532 ]
533
534 TEST_INPUTS_TABLE = [
535 [
536 # test case containing a task called timer being awaited in two
537 # different subtasks part of a TaskGroup (root1 and root2) which call
538 # awaiter functions.
539 (
540 AwaitedInfo(
541 thread_id=1,
542 awaited_by=[
543 TaskInfo(
544 task_id=2,
545 task_name="Task-1",
546 coroutine_stack=[],
547 awaited_by=[]
548 ),
549 TaskInfo(
550 task_id=3,
551 task_name="timer",
552 coroutine_stack=[],
553 awaited_by=[
554 CoroInfo(
555 call_stack=[
556 FrameInfo("awaiter3", "", 0),
557 FrameInfo("awaiter2", "", 0),
558 FrameInfo("awaiter", "", 0)
559 ],
560 task_name=4
561 ),
562 CoroInfo(
563 call_stack=[
564 FrameInfo("awaiter1_3", "", 0),
565 FrameInfo("awaiter1_2", "", 0),
566 FrameInfo("awaiter1", "", 0)
567 ],
568 task_name=5
569 ),
570 CoroInfo(
571 call_stack=[
572 FrameInfo("awaiter1_3", "", 0),
573 FrameInfo("awaiter1_2", "", 0),
574 FrameInfo("awaiter1", "", 0)
575 ],
576 task_name=6
577 ),
578 CoroInfo(
579 call_stack=[
580 FrameInfo("awaiter3", "", 0),
581 FrameInfo("awaiter2", "", 0),
582 FrameInfo("awaiter", "", 0)
583 ],
584 task_name=7
585 )
586 ]
587 ),
588 TaskInfo(
589 task_id=8,
590 task_name="root1",
591 coroutine_stack=[],
592 awaited_by=[
593 CoroInfo(
594 call_stack=[
595 FrameInfo("_aexit", "", 0),
596 FrameInfo("__aexit__", "", 0),
597 FrameInfo("main", "", 0)
598 ],
599 task_name=2
600 )
601 ]
602 ),
603 TaskInfo(
604 task_id=9,
605 task_name="root2",
606 coroutine_stack=[],
607 awaited_by=[
608 CoroInfo(
609 call_stack=[
610 FrameInfo("_aexit", "", 0),
611 FrameInfo("__aexit__", "", 0),
612 FrameInfo("main", "", 0)
613 ],
614 task_name=2
615 )
616 ]
617 ),
618 TaskInfo(
619 task_id=4,
620 task_name="child1_1",
621 coroutine_stack=[],
622 awaited_by=[
623 CoroInfo(
624 call_stack=[
625 FrameInfo("_aexit", "", 0),
626 FrameInfo("__aexit__", "", 0),
627 FrameInfo("blocho_caller", "", 0),
628 FrameInfo("bloch", "", 0)
629 ],
630 task_name=8
631 )
632 ]
633 ),
634 TaskInfo(
635 task_id=6,
636 task_name="child2_1",
637 coroutine_stack=[],
638 awaited_by=[
639 CoroInfo(
640 call_stack=[
641 FrameInfo("_aexit", "", 0),
642 FrameInfo("__aexit__", "", 0),
643 FrameInfo("blocho_caller", "", 0),
644 FrameInfo("bloch", "", 0)
645 ],
646 task_name=8
647 )
648 ]
649 ),
650 TaskInfo(
651 task_id=7,
652 task_name="child1_2",
653 coroutine_stack=[],
654 awaited_by=[
655 CoroInfo(
656 call_stack=[
657 FrameInfo("_aexit", "", 0),
658 FrameInfo("__aexit__", "", 0),
659 FrameInfo("blocho_caller", "", 0),
660 FrameInfo("bloch", "", 0)
661 ],
662 task_name=9
663 )
664 ]
665 ),
666 TaskInfo(
667 task_id=5,
668 task_name="child2_2",
669 coroutine_stack=[],
670 awaited_by=[
671 CoroInfo(
672 call_stack=[
673 FrameInfo("_aexit", "", 0),
674 FrameInfo("__aexit__", "", 0),
675 FrameInfo("blocho_caller", "", 0),
676 FrameInfo("bloch", "", 0)
677 ],
678 task_name=9
679 )
680 ]
681 )
682 ]
683 ),
684 AwaitedInfo(thread_id=0, awaited_by=[])
685 ),
686 (
687 [
688 [1, "0x2", "Task-1", "", "", "", "0x0"],
689 [
690 1,
691 "0x3",
692 "timer",
693 "",
694 "awaiter3 -> awaiter2 -> awaiter",
695 "child1_1",
696 "0x4",
697 ],
698 [
699 1,
700 "0x3",
701 "timer",
702 "",
703 "awaiter1_3 -> awaiter1_2 -> awaiter1",
704 "child2_2",
705 "0x5",
706 ],
707 [
708 1,
709 "0x3",
710 "timer",
711 "",
712 "awaiter1_3 -> awaiter1_2 -> awaiter1",
713 "child2_1",
714 "0x6",
715 ],
716 [
717 1,
718 "0x3",
719 "timer",
720 "",
721 "awaiter3 -> awaiter2 -> awaiter",
722 "child1_2",
723 "0x7",
724 ],
725 [
726 1,
727 "0x8",
728 "root1",
729 "",
730 "_aexit -> __aexit__ -> main",
731 "Task-1",
732 "0x2",
733 ],
734 [
735 1,
736 "0x9",
737 "root2",
738 "",
739 "_aexit -> __aexit__ -> main",
740 "Task-1",
741 "0x2",
742 ],
743 [
744 1,
745 "0x4",
746 "child1_1",
747 "",
748 "_aexit -> __aexit__ -> blocho_caller -> bloch",
749 "root1",
750 "0x8",
751 ],
752 [
753 1,
754 "0x6",
755 "child2_1",
756 "",
757 "_aexit -> __aexit__ -> blocho_caller -> bloch",
758 "root1",
759 "0x8",
760 ],
761 [
762 1,
763 "0x7",
764 "child1_2",
765 "",
766 "_aexit -> __aexit__ -> blocho_caller -> bloch",
767 "root2",
768 "0x9",
769 ],
770 [
771 1,
772 "0x5",
773 "child2_2",
774 "",
775 "_aexit -> __aexit__ -> blocho_caller -> bloch",
776 "root2",
777 "0x9",
778 ],
779 ]
780 ),
781 ],
782 [
783 # test case containing two roots
784 (
785 AwaitedInfo(
786 thread_id=9,
787 awaited_by=[
788 TaskInfo(
789 task_id=5,
790 task_name="Task-5",
791 coroutine_stack=[],
792 awaited_by=[]
793 ),
794 TaskInfo(
795 task_id=6,
796 task_name="Task-6",
797 coroutine_stack=[],
798 awaited_by=[
799 CoroInfo(
800 call_stack=[FrameInfo("main2", "", 0)],
801 task_name=5
802 )
803 ]
804 ),
805 TaskInfo(
806 task_id=7,
807 task_name="Task-7",
808 coroutine_stack=[],
809 awaited_by=[
810 CoroInfo(
811 call_stack=[FrameInfo("main2", "", 0)],
812 task_name=5
813 )
814 ]
815 ),
816 TaskInfo(
817 task_id=8,
818 task_name="Task-8",
819 coroutine_stack=[],
820 awaited_by=[
821 CoroInfo(
822 call_stack=[FrameInfo("main2", "", 0)],
823 task_name=5
824 )
825 ]
826 )
827 ]
828 ),
829 AwaitedInfo(
830 thread_id=10,
831 awaited_by=[
832 TaskInfo(
833 task_id=1,
834 task_name="Task-1",
835 coroutine_stack=[],
836 awaited_by=[]
837 ),
838 TaskInfo(
839 task_id=2,
840 task_name="Task-2",
841 coroutine_stack=[],
842 awaited_by=[
843 CoroInfo(
844 call_stack=[FrameInfo("main", "", 0)],
845 task_name=1
846 )
847 ]
848 ),
849 TaskInfo(
850 task_id=3,
851 task_name="Task-3",
852 coroutine_stack=[],
853 awaited_by=[
854 CoroInfo(
855 call_stack=[FrameInfo("main", "", 0)],
856 task_name=1
857 )
858 ]
859 ),
860 TaskInfo(
861 task_id=4,
862 task_name="Task-4",
863 coroutine_stack=[],
864 awaited_by=[
865 CoroInfo(
866 call_stack=[FrameInfo("main", "", 0)],
867 task_name=1
868 )
869 ]
870 )
871 ]
872 ),
873 AwaitedInfo(thread_id=11, awaited_by=[]),
874 AwaitedInfo(thread_id=0, awaited_by=[])
875 ),
876 (
877 [
878 [9, "0x5", "Task-5", "", "", "", "0x0"],
879 [9, "0x6", "Task-6", "", "main2", "Task-5", "0x5"],
880 [9, "0x7", "Task-7", "", "main2", "Task-5", "0x5"],
881 [9, "0x8", "Task-8", "", "main2", "Task-5", "0x5"],
882 [10, "0x1", "Task-1", "", "", "", "0x0"],
883 [10, "0x2", "Task-2", "", "main", "Task-1", "0x1"],
884 [10, "0x3", "Task-3", "", "main", "Task-1", "0x1"],
885 [10, "0x4", "Task-4", "", "main", "Task-1", "0x1"],
886 ]
887 ),
888 ],
889 [
890 # test case containing two roots, one of them without subtasks
891 (
892 [
893 AwaitedInfo(
894 thread_id=1,
895 awaited_by=[
896 TaskInfo(
897 task_id=2,
898 task_name="Task-5",
899 coroutine_stack=[],
900 awaited_by=[]
901 )
902 ]
903 ),
904 AwaitedInfo(
905 thread_id=3,
906 awaited_by=[
907 TaskInfo(
908 task_id=4,
909 task_name="Task-1",
910 coroutine_stack=[],
911 awaited_by=[]
912 ),
913 TaskInfo(
914 task_id=5,
915 task_name="Task-2",
916 coroutine_stack=[],
917 awaited_by=[
918 CoroInfo(
919 call_stack=[FrameInfo("main", "", 0)],
920 task_name=4
921 )
922 ]
923 ),
924 TaskInfo(
925 task_id=6,
926 task_name="Task-3",
927 coroutine_stack=[],
928 awaited_by=[
929 CoroInfo(
930 call_stack=[FrameInfo("main", "", 0)],
931 task_name=4
932 )
933 ]
934 ),
935 TaskInfo(
936 task_id=7,
937 task_name="Task-4",
938 coroutine_stack=[],
939 awaited_by=[
940 CoroInfo(
941 call_stack=[FrameInfo("main", "", 0)],
942 task_name=4
943 )
944 ]
945 )
946 ]
947 ),
948 AwaitedInfo(thread_id=8, awaited_by=[]),
949 AwaitedInfo(thread_id=0, awaited_by=[])
950 ]
951 ),
952 (
953 [
954 [1, "0x2", "Task-5", "", "", "", "0x0"],
955 [3, "0x4", "Task-1", "", "", "", "0x0"],
956 [3, "0x5", "Task-2", "", "main", "Task-1", "0x4"],
957 [3, "0x6", "Task-3", "", "main", "Task-1", "0x4"],
958 [3, "0x7", "Task-4", "", "main", "Task-1", "0x4"],
959 ]
960 ),
961 ],
962 # CASES WITH CYCLES
963 [
964 # this test case contains a cycle: two tasks awaiting each other.
965 (
966 [
967 AwaitedInfo(
968 thread_id=1,
969 awaited_by=[
970 TaskInfo(
971 task_id=2,
972 task_name="Task-1",
973 coroutine_stack=[],
974 awaited_by=[]
975 ),
976 TaskInfo(
977 task_id=3,
978 task_name="a",
979 coroutine_stack=[],
980 awaited_by=[
981 CoroInfo(
982 call_stack=[FrameInfo("awaiter2", "", 0)],
983 task_name=4
984 ),
985 CoroInfo(
986 call_stack=[FrameInfo("main", "", 0)],
987 task_name=2
988 )
989 ]
990 ),
991 TaskInfo(
992 task_id=4,
993 task_name="b",
994 coroutine_stack=[],
995 awaited_by=[
996 CoroInfo(
997 call_stack=[FrameInfo("awaiter", "", 0)],
998 task_name=3
999 )
1000 ]
1001 )
1002 ]
1003 ),
1004 AwaitedInfo(thread_id=0, awaited_by=[])
1005 ]
1006 ),
1007 (
1008 [
1009 [1, "0x2", "Task-1", "", "", "", "0x0"],
1010 [1, "0x3", "a", "", "awaiter2", "b", "0x4"],
1011 [1, "0x3", "a", "", "main", "Task-1", "0x2"],
1012 [1, "0x4", "b", "", "awaiter", "a", "0x3"],
1013 ]
1014 ),
1015 ],
1016 [
1017 # this test case contains two cycles
1018 (
1019 [
1020 AwaitedInfo(
1021 thread_id=1,
1022 awaited_by=[
1023 TaskInfo(
1024 task_id=2,
1025 task_name="Task-1",
1026 coroutine_stack=[],
1027 awaited_by=[]
1028 ),
1029 TaskInfo(
1030 task_id=3,
1031 task_name="A",
1032 coroutine_stack=[],
1033 awaited_by=[
1034 CoroInfo(
1035 call_stack=[
1036 FrameInfo("nested", "", 0),
1037 FrameInfo("nested", "", 0),
1038 FrameInfo("task_b", "", 0)
1039 ],
1040 task_name=4
1041 )
1042 ]
1043 ),
1044 TaskInfo(
1045 task_id=4,
1046 task_name="B",
1047 coroutine_stack=[],
1048 awaited_by=[
1049 CoroInfo(
1050 call_stack=[
1051 FrameInfo("nested", "", 0),
1052 FrameInfo("nested", "", 0),
1053 FrameInfo("task_c", "", 0)
1054 ],
1055 task_name=5
1056 ),
1057 CoroInfo(
1058 call_stack=[
1059 FrameInfo("nested", "", 0),
1060 FrameInfo("nested", "", 0),
1061 FrameInfo("task_a", "", 0)
1062 ],
1063 task_name=3
1064 )
1065 ]
1066 ),
1067 TaskInfo(
1068 task_id=5,
1069 task_name="C",
1070 coroutine_stack=[],
1071 awaited_by=[
1072 CoroInfo(
1073 call_stack=[
1074 FrameInfo("nested", "", 0),
1075 FrameInfo("nested", "", 0)
1076 ],
1077 task_name=6
1078 )
1079 ]
1080 ),
1081 TaskInfo(
1082 task_id=6,
1083 task_name="Task-2",
1084 coroutine_stack=[],
1085 awaited_by=[
1086 CoroInfo(
1087 call_stack=[
1088 FrameInfo("nested", "", 0),
1089 FrameInfo("nested", "", 0),
1090 FrameInfo("task_b", "", 0)
1091 ],
1092 task_name=4
1093 )
1094 ]
1095 )
1096 ]
1097 ),
1098 AwaitedInfo(thread_id=0, awaited_by=[])
1099 ]
1100 ),
1101 (
1102 [
1103 [1, "0x2", "Task-1", "", "", "", "0x0"],
1104 [
1105 1,
1106 "0x3",
1107 "A",
1108 "",
1109 "nested -> nested -> task_b",
1110 "B",
1111 "0x4",
1112 ],
1113 [
1114 1,
1115 "0x4",
1116 "B",
1117 "",
1118 "nested -> nested -> task_c",
1119 "C",
1120 "0x5",
1121 ],
1122 [
1123 1,
1124 "0x4",
1125 "B",
1126 "",
1127 "nested -> nested -> task_a",
1128 "A",
1129 "0x3",
1130 ],
1131 [
1132 1,
1133 "0x5",
1134 "C",
1135 "",
1136 "nested -> nested",
1137 "Task-2",
1138 "0x6",
1139 ],
1140 [
1141 1,
1142 "0x6",
1143 "Task-2",
1144 "",
1145 "nested -> nested -> task_b",
1146 "B",
1147 "0x4",
1148 ],
1149 ]
1150 ),
1151 ],
1152 ]
1153
1154
1155 class TestAsyncioToolsTree(unittest.TestCase):
1156 def test_asyncio_utils(self):
1157 for input_, tree in TEST_INPUTS_TREE:
1158 with self.subTest(input_):
1159 result = tools.build_async_tree(input_)
1160 self.assertEqual(result, tree)
1161
1162 def test_asyncio_utils_cycles(self):
1163 for input_, cycles in TEST_INPUTS_CYCLES_TREE:
1164 with self.subTest(input_):
1165 try:
1166 tools.build_async_tree(input_)
1167 except tools.CycleFoundException as e:
1168 self.assertEqual(e.cycles, cycles)
1169
1170
1171 class TestAsyncioToolsTable(unittest.TestCase):
1172 def test_asyncio_utils(self):
1173 for input_, table in TEST_INPUTS_TABLE:
1174 with self.subTest(input_):
1175 result = tools.build_task_table(input_)
1176 self.assertEqual(result, table)
1177
1178
1179 class TestAsyncioToolsBasic(unittest.TestCase):
1180 def test_empty_input_tree(self):
1181 """Test build_async_tree with empty input."""
1182 result = []
1183 expected_output = []
1184 self.assertEqual(tools.build_async_tree(result), expected_output)
1185
1186 def test_empty_input_table(self):
1187 """Test build_task_table with empty input."""
1188 result = []
1189 expected_output = []
1190 self.assertEqual(tools.build_task_table(result), expected_output)
1191
1192 def test_only_independent_tasks_tree(self):
1193 input_ = [
1194 AwaitedInfo(
1195 thread_id=1,
1196 awaited_by=[
1197 TaskInfo(
1198 task_id=10,
1199 task_name="taskA",
1200 coroutine_stack=[],
1201 awaited_by=[]
1202 ),
1203 TaskInfo(
1204 task_id=11,
1205 task_name="taskB",
1206 coroutine_stack=[],
1207 awaited_by=[]
1208 )
1209 ]
1210 )
1211 ]
1212 expected = [["└── (T) taskA"], ["└── (T) taskB"]]
1213 result = tools.build_async_tree(input_)
1214 self.assertEqual(sorted(result), sorted(expected))
1215
1216 def test_only_independent_tasks_table(self):
1217 input_ = [
1218 AwaitedInfo(
1219 thread_id=1,
1220 awaited_by=[
1221 TaskInfo(
1222 task_id=10,
1223 task_name="taskA",
1224 coroutine_stack=[],
1225 awaited_by=[]
1226 ),
1227 TaskInfo(
1228 task_id=11,
1229 task_name="taskB",
1230 coroutine_stack=[],
1231 awaited_by=[]
1232 )
1233 ]
1234 )
1235 ]
1236 self.assertEqual(
1237 tools.build_task_table(input_),
1238 [[1, '0xa', 'taskA', '', '', '', '0x0'], [1, '0xb', 'taskB', '', '', '', '0x0']]
1239 )
1240
1241 def test_single_task_tree(self):
1242 """Test build_async_tree with a single task and no awaits."""
1243 result = [
1244 AwaitedInfo(
1245 thread_id=1,
1246 awaited_by=[
1247 TaskInfo(
1248 task_id=2,
1249 task_name="Task-1",
1250 coroutine_stack=[],
1251 awaited_by=[]
1252 )
1253 ]
1254 )
1255 ]
1256 expected_output = [
1257 [
1258 "└── (T) Task-1",
1259 ]
1260 ]
1261 self.assertEqual(tools.build_async_tree(result), expected_output)
1262
1263 def test_single_task_table(self):
1264 """Test build_task_table with a single task and no awaits."""
1265 result = [
1266 AwaitedInfo(
1267 thread_id=1,
1268 awaited_by=[
1269 TaskInfo(
1270 task_id=2,
1271 task_name="Task-1",
1272 coroutine_stack=[],
1273 awaited_by=[]
1274 )
1275 ]
1276 )
1277 ]
1278 expected_output = [[1, '0x2', 'Task-1', '', '', '', '0x0']]
1279 self.assertEqual(tools.build_task_table(result), expected_output)
1280
1281 def test_cycle_detection(self):
1282 """Test build_async_tree raises CycleFoundException for cyclic input."""
1283 result = [
1284 AwaitedInfo(
1285 thread_id=1,
1286 awaited_by=[
1287 TaskInfo(
1288 task_id=2,
1289 task_name="Task-1",
1290 coroutine_stack=[],
1291 awaited_by=[
1292 CoroInfo(
1293 call_stack=[FrameInfo("main", "", 0)],
1294 task_name=3
1295 )
1296 ]
1297 ),
1298 TaskInfo(
1299 task_id=3,
1300 task_name="Task-2",
1301 coroutine_stack=[],
1302 awaited_by=[
1303 CoroInfo(
1304 call_stack=[FrameInfo("main", "", 0)],
1305 task_name=2
1306 )
1307 ]
1308 )
1309 ]
1310 )
1311 ]
1312 with self.assertRaises(tools.CycleFoundException) as context:
1313 tools.build_async_tree(result)
1314 self.assertEqual(context.exception.cycles, [[3, 2, 3]])
1315
1316 def test_complex_tree(self):
1317 """Test build_async_tree with a more complex tree structure."""
1318 result = [
1319 AwaitedInfo(
1320 thread_id=1,
1321 awaited_by=[
1322 TaskInfo(
1323 task_id=2,
1324 task_name="Task-1",
1325 coroutine_stack=[],
1326 awaited_by=[]
1327 ),
1328 TaskInfo(
1329 task_id=3,
1330 task_name="Task-2",
1331 coroutine_stack=[],
1332 awaited_by=[
1333 CoroInfo(
1334 call_stack=[FrameInfo("main", "", 0)],
1335 task_name=2
1336 )
1337 ]
1338 ),
1339 TaskInfo(
1340 task_id=4,
1341 task_name="Task-3",
1342 coroutine_stack=[],
1343 awaited_by=[
1344 CoroInfo(
1345 call_stack=[FrameInfo("main", "", 0)],
1346 task_name=3
1347 )
1348 ]
1349 )
1350 ]
1351 )
1352 ]
1353 expected_output = [
1354 [
1355 "└── (T) Task-1",
1356 " └── main",
1357 " └── (T) Task-2",
1358 " └── main",
1359 " └── (T) Task-3",
1360 ]
1361 ]
1362 self.assertEqual(tools.build_async_tree(result), expected_output)
1363
1364 def test_complex_table(self):
1365 """Test build_task_table with a more complex tree structure."""
1366 result = [
1367 AwaitedInfo(
1368 thread_id=1,
1369 awaited_by=[
1370 TaskInfo(
1371 task_id=2,
1372 task_name="Task-1",
1373 coroutine_stack=[],
1374 awaited_by=[]
1375 ),
1376 TaskInfo(
1377 task_id=3,
1378 task_name="Task-2",
1379 coroutine_stack=[],
1380 awaited_by=[
1381 CoroInfo(
1382 call_stack=[FrameInfo("main", "", 0)],
1383 task_name=2
1384 )
1385 ]
1386 ),
1387 TaskInfo(
1388 task_id=4,
1389 task_name="Task-3",
1390 coroutine_stack=[],
1391 awaited_by=[
1392 CoroInfo(
1393 call_stack=[FrameInfo("main", "", 0)],
1394 task_name=3
1395 )
1396 ]
1397 )
1398 ]
1399 )
1400 ]
1401 expected_output = [
1402 [1, '0x2', 'Task-1', '', '', '', '0x0'],
1403 [1, '0x3', 'Task-2', '', 'main', 'Task-1', '0x2'],
1404 [1, '0x4', 'Task-3', '', 'main', 'Task-2', '0x3']
1405 ]
1406 self.assertEqual(tools.build_task_table(result), expected_output)
1407
1408 def test_deep_coroutine_chain(self):
1409 input_ = [
1410 AwaitedInfo(
1411 thread_id=1,
1412 awaited_by=[
1413 TaskInfo(
1414 task_id=10,
1415 task_name="leaf",
1416 coroutine_stack=[],
1417 awaited_by=[
1418 CoroInfo(
1419 call_stack=[
1420 FrameInfo("c1", "", 0),
1421 FrameInfo("c2", "", 0),
1422 FrameInfo("c3", "", 0),
1423 FrameInfo("c4", "", 0),
1424 FrameInfo("c5", "", 0)
1425 ],
1426 task_name=11
1427 )
1428 ]
1429 ),
1430 TaskInfo(
1431 task_id=11,
1432 task_name="root",
1433 coroutine_stack=[],
1434 awaited_by=[]
1435 )
1436 ]
1437 )
1438 ]
1439 expected = [
1440 [
1441 "└── (T) root",
1442 " └── c5",
1443 " └── c4",
1444 " └── c3",
1445 " └── c2",
1446 " └── c1",
1447 " └── (T) leaf",
1448 ]
1449 ]
1450 result = tools.build_async_tree(input_)
1451 self.assertEqual(result, expected)
1452
1453 def test_multiple_cycles_same_node(self):
1454 input_ = [
1455 AwaitedInfo(
1456 thread_id=1,
1457 awaited_by=[
1458 TaskInfo(
1459 task_id=1,
1460 task_name="Task-A",
1461 coroutine_stack=[],
1462 awaited_by=[
1463 CoroInfo(
1464 call_stack=[FrameInfo("call1", "", 0)],
1465 task_name=2
1466 )
1467 ]
1468 ),
1469 TaskInfo(
1470 task_id=2,
1471 task_name="Task-B",
1472 coroutine_stack=[],
1473 awaited_by=[
1474 CoroInfo(
1475 call_stack=[FrameInfo("call2", "", 0)],
1476 task_name=3
1477 )
1478 ]
1479 ),
1480 TaskInfo(
1481 task_id=3,
1482 task_name="Task-C",
1483 coroutine_stack=[],
1484 awaited_by=[
1485 CoroInfo(
1486 call_stack=[FrameInfo("call3", "", 0)],
1487 task_name=1
1488 ),
1489 CoroInfo(
1490 call_stack=[FrameInfo("call4", "", 0)],
1491 task_name=2
1492 )
1493 ]
1494 )
1495 ]
1496 )
1497 ]
1498 with self.assertRaises(tools.CycleFoundException) as ctx:
1499 tools.build_async_tree(input_)
1500 cycles = ctx.exception.cycles
1501 self.assertTrue(any(set(c) == {1, 2, 3} for c in cycles))
1502
1503 def test_table_output_format(self):
1504 input_ = [
1505 AwaitedInfo(
1506 thread_id=1,
1507 awaited_by=[
1508 TaskInfo(
1509 task_id=1,
1510 task_name="Task-A",
1511 coroutine_stack=[],
1512 awaited_by=[
1513 CoroInfo(
1514 call_stack=[FrameInfo("foo", "", 0)],
1515 task_name=2
1516 )
1517 ]
1518 ),
1519 TaskInfo(
1520 task_id=2,
1521 task_name="Task-B",
1522 coroutine_stack=[],
1523 awaited_by=[]
1524 )
1525 ]
1526 )
1527 ]
1528 table = tools.build_task_table(input_)
1529 for row in table:
1530 self.assertEqual(len(row), 7)
1531 self.assertIsInstance(row[0], int) # thread ID
1532 self.assertTrue(
1533 isinstance(row[1], str) and row[1].startswith("0x")
1534 ) # hex task ID
1535 self.assertIsInstance(row[2], str) # task name
1536 self.assertIsInstance(row[3], str) # coroutine stack
1537 self.assertIsInstance(row[4], str) # coroutine chain
1538 self.assertIsInstance(row[5], str) # awaiter name
1539 self.assertTrue(
1540 isinstance(row[6], str) and row[6].startswith("0x")
1541 ) # hex awaiter ID
1542
1543
1544 class TestAsyncioToolsEdgeCases(unittest.TestCase):
1545
1546 def test_task_awaits_self(self):
1547 """A task directly awaits itself - should raise a cycle."""
1548 input_ = [
1549 AwaitedInfo(
1550 thread_id=1,
1551 awaited_by=[
1552 TaskInfo(
1553 task_id=1,
1554 task_name="Self-Awaiter",
1555 coroutine_stack=[],
1556 awaited_by=[
1557 CoroInfo(
1558 call_stack=[FrameInfo("loopback", "", 0)],
1559 task_name=1
1560 )
1561 ]
1562 )
1563 ]
1564 )
1565 ]
1566 with self.assertRaises(tools.CycleFoundException) as ctx:
1567 tools.build_async_tree(input_)
1568 self.assertIn([1, 1], ctx.exception.cycles)
1569
1570 def test_task_with_missing_awaiter_id(self):
1571 """Awaiter ID not in task list - should not crash, just show 'Unknown'."""
1572 input_ = [
1573 AwaitedInfo(
1574 thread_id=1,
1575 awaited_by=[
1576 TaskInfo(
1577 task_id=1,
1578 task_name="Task-A",
1579 coroutine_stack=[],
1580 awaited_by=[
1581 CoroInfo(
1582 call_stack=[FrameInfo("coro", "", 0)],
1583 task_name=999
1584 )
1585 ]
1586 )
1587 ]
1588 )
1589 ]
1590 table = tools.build_task_table(input_)
1591 self.assertEqual(len(table), 1)
1592 self.assertEqual(table[0][5], "Unknown")
1593
1594 def test_duplicate_coroutine_frames(self):
1595 """Same coroutine frame repeated under a parent - should deduplicate."""
1596 input_ = [
1597 AwaitedInfo(
1598 thread_id=1,
1599 awaited_by=[
1600 TaskInfo(
1601 task_id=1,
1602 task_name="Task-1",
1603 coroutine_stack=[],
1604 awaited_by=[
1605 CoroInfo(
1606 call_stack=[FrameInfo("frameA", "", 0)],
1607 task_name=2
1608 ),
1609 CoroInfo(
1610 call_stack=[FrameInfo("frameA", "", 0)],
1611 task_name=3
1612 )
1613 ]
1614 ),
1615 TaskInfo(
1616 task_id=2,
1617 task_name="Task-2",
1618 coroutine_stack=[],
1619 awaited_by=[]
1620 ),
1621 TaskInfo(
1622 task_id=3,
1623 task_name="Task-3",
1624 coroutine_stack=[],
1625 awaited_by=[]
1626 )
1627 ]
1628 )
1629 ]
1630 tree = tools.build_async_tree(input_)
1631 # Both children should be under the same coroutine node
1632 flat = "\n".join(tree[0])
1633 self.assertIn("frameA", flat)
1634 self.assertIn("Task-2", flat)
1635 self.assertIn("Task-1", flat)
1636
1637 flat = "\n".join(tree[1])
1638 self.assertIn("frameA", flat)
1639 self.assertIn("Task-3", flat)
1640 self.assertIn("Task-1", flat)
1641
1642 def test_task_with_no_name(self):
1643 """Task with no name in id2name - should still render with fallback."""
1644 input_ = [
1645 AwaitedInfo(
1646 thread_id=1,
1647 awaited_by=[
1648 TaskInfo(
1649 task_id=1,
1650 task_name="root",
1651 coroutine_stack=[],
1652 awaited_by=[
1653 CoroInfo(
1654 call_stack=[FrameInfo("f1", "", 0)],
1655 task_name=2
1656 )
1657 ]
1658 ),
1659 TaskInfo(
1660 task_id=2,
1661 task_name=None,
1662 coroutine_stack=[],
1663 awaited_by=[]
1664 )
1665 ]
1666 )
1667 ]
1668 # If name is None, fallback to string should not crash
1669 tree = tools.build_async_tree(input_)
1670 self.assertIn("(T) None", "\n".join(tree[0]))
1671
1672 def test_tree_rendering_with_custom_emojis(self):
1673 """Pass custom emojis to the tree renderer."""
1674 input_ = [
1675 AwaitedInfo(
1676 thread_id=1,
1677 awaited_by=[
1678 TaskInfo(
1679 task_id=1,
1680 task_name="MainTask",
1681 coroutine_stack=[],
1682 awaited_by=[
1683 CoroInfo(
1684 call_stack=[
1685 FrameInfo("f1", "", 0),
1686 FrameInfo("f2", "", 0)
1687 ],
1688 task_name=2
1689 )
1690 ]
1691 ),
1692 TaskInfo(
1693 task_id=2,
1694 task_name="SubTask",
1695 coroutine_stack=[],
1696 awaited_by=[]
1697 )
1698 ]
1699 )
1700 ]
1701 tree = tools.build_async_tree(input_, task_emoji="🧵", cor_emoji="🔁")
1702 flat = "\n".join(tree[0])
1703 self.assertIn("🧵 MainTask", flat)
1704 self.assertIn("🔁 f1", flat)
1705 self.assertIn("🔁 f2", flat)
1706 self.assertIn("🧵 SubTask", flat)