|
6 | 6 |
|
7 | 7 |
|
8 | 8 | # mock output of get_all_awaited_by function. |
9 | | -TEST_INPUTS = [ |
| 9 | +TEST_INPUTS_TREE = [ |
10 | 10 | [ |
11 | 11 | # test case containing a task called timer being awaited in two |
12 | 12 | # different subtasks part of a TaskGroup (root1 and root2) which call |
|
80 | 80 | ), |
81 | 81 | (0, []), |
82 | 82 | ), |
83 | | - ([]), |
84 | 83 | ( |
85 | 84 | [ |
86 | 85 | [ |
|
121 | 120 | ] |
122 | 121 | ] |
123 | 122 | ), |
| 123 | + ], |
| 124 | + [ |
| 125 | + # test case containing two roots |
| 126 | + ( |
| 127 | + ( |
| 128 | + 9, |
| 129 | + [ |
| 130 | + (5, "Task-5", []), |
| 131 | + (6, "Task-6", [[["main2"], 5]]), |
| 132 | + (7, "Task-7", [[["main2"], 5]]), |
| 133 | + (8, "Task-8", [[["main2"], 5]]), |
| 134 | + ], |
| 135 | + ), |
| 136 | + ( |
| 137 | + 10, |
| 138 | + [ |
| 139 | + (1, "Task-1", []), |
| 140 | + (2, "Task-2", [[["main"], 1]]), |
| 141 | + (3, "Task-3", [[["main"], 1]]), |
| 142 | + (4, "Task-4", [[["main"], 1]]), |
| 143 | + ], |
| 144 | + ), |
| 145 | + (11, []), |
| 146 | + (0, []), |
| 147 | + ), |
| 148 | + ( |
| 149 | + [ |
| 150 | + [ |
| 151 | + "└── (T) Task-5", |
| 152 | + " └── main2", |
| 153 | + " ├── (T) Task-6", |
| 154 | + " ├── (T) Task-7", |
| 155 | + " └── (T) Task-8", |
| 156 | + ], |
| 157 | + [ |
| 158 | + "└── (T) Task-1", |
| 159 | + " └── main", |
| 160 | + " ├── (T) Task-2", |
| 161 | + " ├── (T) Task-3", |
| 162 | + " └── (T) Task-4", |
| 163 | + ], |
| 164 | + ] |
| 165 | + ), |
| 166 | + ], |
| 167 | +] |
| 168 | + |
| 169 | +TEST_INPUTS_CYCLES_TREE = [ |
| 170 | + [ |
| 171 | + # this test case contains a cycle: two tasks awaiting each other. |
| 172 | + ( |
| 173 | + [ |
| 174 | + ( |
| 175 | + 1, |
| 176 | + [ |
| 177 | + (2, "Task-1", []), |
| 178 | + ( |
| 179 | + 3, |
| 180 | + "a", |
| 181 | + [[["awaiter2"], 4], [["main"], 2]], |
| 182 | + ), |
| 183 | + (4, "b", [[["awaiter"], 3]]), |
| 184 | + ], |
| 185 | + ), |
| 186 | + (0, []), |
| 187 | + ] |
| 188 | + ), |
| 189 | + ([[4, 3, 4]]), |
| 190 | + ], |
| 191 | + [ |
| 192 | + # this test case contains two cycles |
| 193 | + ( |
| 194 | + [ |
| 195 | + ( |
| 196 | + 1, |
| 197 | + [ |
| 198 | + (2, "Task-1", []), |
| 199 | + ( |
| 200 | + 3, |
| 201 | + "A", |
| 202 | + [[["nested", "nested", "task_b"], 4]], |
| 203 | + ), |
| 204 | + ( |
| 205 | + 4, |
| 206 | + "B", |
| 207 | + [ |
| 208 | + [["nested", "nested", "task_c"], 5], |
| 209 | + [["nested", "nested", "task_a"], 3], |
| 210 | + ], |
| 211 | + ), |
| 212 | + (5, "C", [[["nested", "nested"], 6]]), |
| 213 | + ( |
| 214 | + 6, |
| 215 | + "Task-2", |
| 216 | + [[["nested", "nested", "task_b"], 4]], |
| 217 | + ), |
| 218 | + ], |
| 219 | + ), |
| 220 | + (0, []), |
| 221 | + ] |
| 222 | + ), |
| 223 | + ([[4, 3, 4], [4, 6, 5, 4]]), |
| 224 | + ], |
| 225 | +] |
| 226 | + |
| 227 | +TEST_INPUTS_TABLE = [ |
| 228 | + [ |
| 229 | + # test case containing a task called timer being awaited in two |
| 230 | + # different subtasks part of a TaskGroup (root1 and root2) which call |
| 231 | + # awaiter functions. |
| 232 | + ( |
| 233 | + ( |
| 234 | + 1, |
| 235 | + [ |
| 236 | + (2, "Task-1", []), |
| 237 | + ( |
| 238 | + 3, |
| 239 | + "timer", |
| 240 | + [ |
| 241 | + [["awaiter3", "awaiter2", "awaiter"], 4], |
| 242 | + [["awaiter1_3", "awaiter1_2", "awaiter1"], 5], |
| 243 | + [["awaiter1_3", "awaiter1_2", "awaiter1"], 6], |
| 244 | + [["awaiter3", "awaiter2", "awaiter"], 7], |
| 245 | + ], |
| 246 | + ), |
| 247 | + ( |
| 248 | + 8, |
| 249 | + "root1", |
| 250 | + [[["_aexit", "__aexit__", "main"], 2]], |
| 251 | + ), |
| 252 | + ( |
| 253 | + 9, |
| 254 | + "root2", |
| 255 | + [[["_aexit", "__aexit__", "main"], 2]], |
| 256 | + ), |
| 257 | + ( |
| 258 | + 4, |
| 259 | + "child1_1", |
| 260 | + [ |
| 261 | + [ |
| 262 | + ["_aexit", "__aexit__", "blocho_caller", "bloch"], |
| 263 | + 8, |
| 264 | + ] |
| 265 | + ], |
| 266 | + ), |
| 267 | + ( |
| 268 | + 6, |
| 269 | + "child2_1", |
| 270 | + [ |
| 271 | + [ |
| 272 | + ["_aexit", "__aexit__", "blocho_caller", "bloch"], |
| 273 | + 8, |
| 274 | + ] |
| 275 | + ], |
| 276 | + ), |
| 277 | + ( |
| 278 | + 7, |
| 279 | + "child1_2", |
| 280 | + [ |
| 281 | + [ |
| 282 | + ["_aexit", "__aexit__", "blocho_caller", "bloch"], |
| 283 | + 9, |
| 284 | + ] |
| 285 | + ], |
| 286 | + ), |
| 287 | + ( |
| 288 | + 5, |
| 289 | + "child2_2", |
| 290 | + [ |
| 291 | + [ |
| 292 | + ["_aexit", "__aexit__", "blocho_caller", "bloch"], |
| 293 | + 9, |
| 294 | + ] |
| 295 | + ], |
| 296 | + ), |
| 297 | + ], |
| 298 | + ), |
| 299 | + (0, []), |
| 300 | + ), |
124 | 301 | ( |
125 | 302 | [ |
126 | 303 | [ |
|
230 | 407 | (11, []), |
231 | 408 | (0, []), |
232 | 409 | ), |
233 | | - ([]), |
234 | | - ( |
235 | | - [ |
236 | | - [ |
237 | | - "└── (T) Task-5", |
238 | | - " └── main2", |
239 | | - " ├── (T) Task-6", |
240 | | - " ├── (T) Task-7", |
241 | | - " └── (T) Task-8", |
242 | | - ], |
243 | | - [ |
244 | | - "└── (T) Task-1", |
245 | | - " └── main", |
246 | | - " ├── (T) Task-2", |
247 | | - " ├── (T) Task-3", |
248 | | - " └── (T) Task-4", |
249 | | - ], |
250 | | - ] |
251 | | - ), |
252 | 410 | ( |
253 | 411 | [ |
254 | 412 | [9, "0x6", "Task-6", "main2", "Task-5", "0x5"], |
|
260 | 418 | ] |
261 | 419 | ), |
262 | 420 | ], |
263 | | - # Tests cycle detection. |
| 421 | + # CASES WITH CYCLES |
264 | 422 | [ |
265 | 423 | # this test case contains a cycle: two tasks awaiting each other. |
266 | 424 | ( |
|
280 | 438 | (0, []), |
281 | 439 | ] |
282 | 440 | ), |
283 | | - ([[4, 3, 4]]), |
284 | | - ([]), |
285 | 441 | ( |
286 | 442 | [ |
287 | 443 | [1, "0x3", "a", "awaiter2", "b", "0x4"], |
|
322 | 478 | (0, []), |
323 | 479 | ] |
324 | 480 | ), |
325 | | - ([[4, 3, 4], [4, 6, 5, 4]]), |
326 | | - ([]), |
327 | 481 | ( |
328 | 482 | [ |
329 | 483 | [ |
|
372 | 526 | ] |
373 | 527 |
|
374 | 528 |
|
375 | | -class TestAsyncioTools(unittest.TestCase): |
| 529 | +class TestAsyncioToolsTree(unittest.TestCase): |
376 | 530 |
|
377 | 531 | def test_asyncio_utils(self): |
378 | | - for input_, cycles, tree, table in TEST_INPUTS: |
379 | | - if cycles: |
| 532 | + for input_, tree in TEST_INPUTS_TREE: |
| 533 | + with self.subTest(input_): |
| 534 | + self.assertEqual(tools.print_async_tree(input_), tree) |
| 535 | + |
| 536 | + def test_asyncio_utils_cycles(self): |
| 537 | + for input_, cycles in TEST_INPUTS_CYCLES_TREE: |
| 538 | + with self.subTest(input_): |
380 | 539 | try: |
381 | 540 | tools.print_async_tree(input_) |
382 | 541 | except tools.CycleFoundException as e: |
383 | 542 | self.assertEqual(e.cycles, cycles) |
384 | | - else: |
385 | | - self.assertEqual(tools.print_async_tree(input_), tree) |
386 | | - self.assertEqual(tools.build_task_table(input_), table) |
| 543 | + |
| 544 | + |
| 545 | +class TestAsyncioToolsTable(unittest.TestCase): |
| 546 | + def test_asyncio_utils(self): |
| 547 | + for input_, table in TEST_INPUTS_TABLE: |
| 548 | + with self.subTest(input_): |
| 549 | + self.assertEqual(tools.build_task_table(input_), table) |
0 commit comments