cython

1
### COPIED FROM CPython 3.12 alpha (July 2022)
2
### Original part after ############
3
# cython: language_level=3
4

5
# new code
6
import cython
7
from Cython.TestUtils import py_parse_code
8

9

10
if cython.compiled:
11
    def compile(code, name, what):
12
        assert what == 'exec'
13
        py_parse_code(code)
14

15

16
def disable(func):
17
    pass
18

19

20
############## SLIGHTLY MODIFIED ORIGINAL CODE
21
import array
22
import collections
23
import enum
24
import inspect
25
import sys
26
import unittest
27

28
if sys.version_info >= (3, 10):
29
    import dataclasses
30
    @dataclasses.dataclass
31
    class Point:
32
        x: int
33
        y: int
34
else:
35
    # predates dataclasses with match args
36
    class Point:
37
        __match_args__ = ("x", "y")
38
        x: int
39
        y: int
40

41
# TestCompiler removed - it's very CPython-specific
42
"""
43
class TestCompiler(unittest.TestCase):
44

45
    def test_refleaks(self):
46
        # Hunting for leaks using -R doesn't catch leaks in the compiler itself,
47
        # just the code under test. This test ensures that if there are leaks in
48
        # the pattern compiler, those runs will fail:
49
        with open(__file__) as file:
50
            compile(file.read(), __file__, "exec")
51
"""
52

53

54
# TestTracing also mainly removed - doesn't seem like a core test
55
#  except for one test that seems misplaced in CPython (which is below)
56
class TestTracing(unittest.TestCase):
57

58
    """
59
        @staticmethod
60
    def _trace(func, *args, **kwargs):
61
        actual_linenos = []
62

63
        def trace(frame, event, arg):
64
            if event == "line" and frame.f_code.co_name == func.__name__:
65
                assert arg is None
66
                relative_lineno = frame.f_lineno - func.__code__.co_firstlineno
67
                actual_linenos.append(relative_lineno)
68
            return trace
69

70
        old_trace = sys.gettrace()
71
        sys.settrace(trace)
72
        try:
73
            func(*args, **kwargs)
74
        finally:
75
            sys.settrace(old_trace)
76
        return actual_linenos
77

78
    def test_default_wildcard(self):
79
        def f(command):                                         # 0
80
            match command.split():                              # 1
81
                case ["go", direction] if direction in "nesw":  # 2
82
                    return f"go {direction}"                    # 3
83
                case ["go", _]:                                 # 4
84
                    return "no go"                              # 5
85
                case _:                                         # 6
86
                    return "default"                            # 7
87

88
        self.assertListEqual(self._trace(f, "go n"), [1, 2, 3])
89
        self.assertListEqual(self._trace(f, "go x"), [1, 2, 4, 5])
90
        self.assertListEqual(self._trace(f, "spam"), [1, 2, 4, 6, 7])
91

92
    def test_default_capture(self):
93
        def f(command):                                         # 0
94
            match command.split():                              # 1
95
                case ["go", direction] if direction in "nesw":  # 2
96
                    return f"go {direction}"                    # 3
97
                case ["go", _]:                                 # 4
98
                    return "no go"                              # 5
99
                case x:                                         # 6
100
                    return x                                    # 7
101

102
        self.assertListEqual(self._trace(f, "go n"), [1, 2, 3])
103
        self.assertListEqual(self._trace(f, "go x"), [1, 2, 4, 5])
104
        self.assertListEqual(self._trace(f, "spam"), [1, 2, 4, 6, 7])
105

106
    def test_no_default(self):
107
        def f(command):                                         # 0
108
            match command.split():                              # 1
109
                case ["go", direction] if direction in "nesw":  # 2
110
                    return f"go {direction}"                    # 3
111
                case ["go", _]:                                 # 4
112
                    return "no go"                              # 5
113

114
        self.assertListEqual(self._trace(f, "go n"), [1, 2, 3])
115
        self.assertListEqual(self._trace(f, "go x"), [1, 2, 4, 5])
116
        self.assertListEqual(self._trace(f, "spam"), [1, 2, 4])
117

118
    def test_only_default_wildcard(self):
119
        def f(command):               # 0
120
            match command.split():    # 1
121
                case _:               # 2
122
                    return "default"  # 3
123

124
        self.assertListEqual(self._trace(f, "go n"), [1, 2, 3])
125
        self.assertListEqual(self._trace(f, "go x"), [1, 2, 3])
126
        self.assertListEqual(self._trace(f, "spam"), [1, 2, 3])
127

128
    def test_only_default_capture(self):
129
        def f(command):             # 0
130
            match command.split():  # 1
131
                case x:             # 2
132
                    return x        # 3
133

134
        self.assertListEqual(self._trace(f, "go n"), [1, 2, 3])
135
        self.assertListEqual(self._trace(f, "go x"), [1, 2, 3])
136
        self.assertListEqual(self._trace(f, "spam"), [1, 2, 3])
137

138
    def test_unreachable_code(self):
139
        def f(command):               # 0
140
            match command:            # 1
141
                case 1:               # 2
142
                    if False:         # 3
143
                        return 1      # 4
144
                case _:               # 5
145
                    if False:         # 6
146
                        return 0      # 7
147

148
        self.assertListEqual(self._trace(f, 1), [1, 2, 3])
149
        self.assertListEqual(self._trace(f, 0), [1, 2, 5, 6])
150
    """
151

152
    def test_parser_deeply_nested_patterns(self):
153
        # Deeply nested patterns can cause exponential backtracking when parsing.
154
        # See CPython gh-93671 for more information.
155
        #
156
        # DW: Cython note - this doesn't break the parser but may cause a
157
        # RecursionError later in the code-generation. I don't believe that's
158
        # easily avoidable with the way Cython visitors currently work
159

160
        levels = 100
161

162
        patterns = [
163
            "A" + "(" * levels + ")" * levels,
164
            "{1:" * levels + "1" + "}" * levels,
165
            "[" * levels + "1" + "]" * levels,
166
        ]
167

168
        for pattern in patterns:
169
            with self.subTest(pattern):
170
                code = inspect.cleandoc("""
171
                    match None:
172
                        case {}:
173
                            pass
174
                """.format(pattern))
175
                compile(code, "<string>", "exec")
176

177

178
# FIXME - remove all the "return"s added to cause code to be dropped
179
############## ORIGINAL PART FROM CPYTHON
180

181

182
class TestInheritance(unittest.TestCase):
183

184
    @staticmethod
185
    def check_sequence_then_mapping(x):
186
        return  # disabled
187
        match x:
188
            case [*_]:
189
                return "seq"
190
            case {}:
191
                return "map"
192

193
    @staticmethod
194
    def check_mapping_then_sequence(x):
195
        return  # disabled
196
        match x:
197
            case {}:
198
                return "map"
199
            case [*_]:
200
                return "seq"
201

202
    def test_multiple_inheritance_mapping(self):
203
        return  # disabled
204
        class C:
205
            pass
206
        class M1(collections.UserDict, collections.abc.Sequence):
207
            pass
208
        class M2(C, collections.UserDict, collections.abc.Sequence):
209
            pass
210
        class M3(collections.UserDict, C, list):
211
            pass
212
        class M4(dict, collections.abc.Sequence, C):
213
            pass
214
        self.assertEqual(self.check_sequence_then_mapping(M1()), "map")
215
        self.assertEqual(self.check_sequence_then_mapping(M2()), "map")
216
        self.assertEqual(self.check_sequence_then_mapping(M3()), "map")
217
        self.assertEqual(self.check_sequence_then_mapping(M4()), "map")
218
        self.assertEqual(self.check_mapping_then_sequence(M1()), "map")
219
        self.assertEqual(self.check_mapping_then_sequence(M2()), "map")
220
        self.assertEqual(self.check_mapping_then_sequence(M3()), "map")
221
        self.assertEqual(self.check_mapping_then_sequence(M4()), "map")
222

223
    def test_multiple_inheritance_sequence(self):
224
        return  # disabled
225
        class C:
226
            pass
227
        class S1(collections.UserList, collections.abc.Mapping):
228
            pass
229
        class S2(C, collections.UserList, collections.abc.Mapping):
230
            pass
231
        class S3(list, C, collections.abc.Mapping):
232
            pass
233
        class S4(collections.UserList, dict, C):
234
            pass
235
        self.assertEqual(self.check_sequence_then_mapping(S1()), "seq")
236
        self.assertEqual(self.check_sequence_then_mapping(S2()), "seq")
237
        self.assertEqual(self.check_sequence_then_mapping(S3()), "seq")
238
        self.assertEqual(self.check_sequence_then_mapping(S4()), "seq")
239
        self.assertEqual(self.check_mapping_then_sequence(S1()), "seq")
240
        self.assertEqual(self.check_mapping_then_sequence(S2()), "seq")
241
        self.assertEqual(self.check_mapping_then_sequence(S3()), "seq")
242
        self.assertEqual(self.check_mapping_then_sequence(S4()), "seq")
243

244
    def test_late_registration_mapping(self):
245
        return  # disabled
246
        class Parent:
247
            pass
248
        class ChildPre(Parent):
249
            pass
250
        class GrandchildPre(ChildPre):
251
            pass
252
        collections.abc.Mapping.register(Parent)
253
        class ChildPost(Parent):
254
            pass
255
        class GrandchildPost(ChildPost):
256
            pass
257
        self.assertEqual(self.check_sequence_then_mapping(Parent()), "map")
258
        self.assertEqual(self.check_sequence_then_mapping(ChildPre()), "map")
259
        self.assertEqual(self.check_sequence_then_mapping(GrandchildPre()), "map")
260
        self.assertEqual(self.check_sequence_then_mapping(ChildPost()), "map")
261
        self.assertEqual(self.check_sequence_then_mapping(GrandchildPost()), "map")
262
        self.assertEqual(self.check_mapping_then_sequence(Parent()), "map")
263
        self.assertEqual(self.check_mapping_then_sequence(ChildPre()), "map")
264
        self.assertEqual(self.check_mapping_then_sequence(GrandchildPre()), "map")
265
        self.assertEqual(self.check_mapping_then_sequence(ChildPost()), "map")
266
        self.assertEqual(self.check_mapping_then_sequence(GrandchildPost()), "map")
267

268
    def test_late_registration_sequence(self):
269
        return  # disabled
270
        class Parent:
271
            pass
272
        class ChildPre(Parent):
273
            pass
274
        class GrandchildPre(ChildPre):
275
            pass
276
        collections.abc.Sequence.register(Parent)
277
        class ChildPost(Parent):
278
            pass
279
        class GrandchildPost(ChildPost):
280
            pass
281
        self.assertEqual(self.check_sequence_then_mapping(Parent()), "seq")
282
        self.assertEqual(self.check_sequence_then_mapping(ChildPre()), "seq")
283
        self.assertEqual(self.check_sequence_then_mapping(GrandchildPre()), "seq")
284
        self.assertEqual(self.check_sequence_then_mapping(ChildPost()), "seq")
285
        self.assertEqual(self.check_sequence_then_mapping(GrandchildPost()), "seq")
286
        self.assertEqual(self.check_mapping_then_sequence(Parent()), "seq")
287
        self.assertEqual(self.check_mapping_then_sequence(ChildPre()), "seq")
288
        self.assertEqual(self.check_mapping_then_sequence(GrandchildPre()), "seq")
289
        self.assertEqual(self.check_mapping_then_sequence(ChildPost()), "seq")
290
        self.assertEqual(self.check_mapping_then_sequence(GrandchildPost()), "seq")
291

292

293
class TestPatma(unittest.TestCase):
294

295
    def test_patma_000(self):
296
        return  # disabled
297
        match 0:
298
            case 0:
299
                x = True
300
        self.assertIs(x, True)
301

302
    def test_patma_001(self):
303
        return  # disabled
304
        match 0:
305
            case 0 if False:
306
                x = False
307
            case 0 if True:
308
                x = True
309
        self.assertIs(x, True)
310

311
    def test_patma_002(self):
312
        return  # disabled
313
        match 0:
314
            case 0:
315
                x = True
316
            case 0:
317
                x = False
318
        self.assertIs(x, True)
319

320
    def test_patma_003(self):
321
        return  # disabled
322
        x = False
323
        match 0:
324
            case 0 | 1 | 2 | 3:
325
                x = True
326
        self.assertIs(x, True)
327

328
    def test_patma_004(self):
329
        return  # disabled
330
        x = False
331
        match 1:
332
            case 0 | 1 | 2 | 3:
333
                x = True
334
        self.assertIs(x, True)
335

336
    def test_patma_005(self):
337
        return  # disabled
338
        x = False
339
        match 2:
340
            case 0 | 1 | 2 | 3:
341
                x = True
342
        self.assertIs(x, True)
343

344
    def test_patma_006(self):
345
        return  # disabled
346
        x = False
347
        match 3:
348
            case 0 | 1 | 2 | 3:
349
                x = True
350
        self.assertIs(x, True)
351

352
    def test_patma_007(self):
353
        return  # disabled
354
        x = False
355
        match 4:
356
            case 0 | 1 | 2 | 3:
357
                x = True
358
        self.assertIs(x, False)
359

360
    def test_patma_008(self):
361
        return  # disabled
362
        x = 0
363
        class A:
364
            y = 1
365
        match x:
366
            case A.y as z:
367
                pass
368
        self.assertEqual(x, 0)
369
        self.assertEqual(A.y, 1)
370

371
    def test_patma_009(self):
372
        return  # disabled
373
        class A:
374
            B = 0
375
        match 0:
376
            case x if x:
377
                z = 0
378
            case _ as y if y == x and y:
379
                z = 1
380
            case A.B:
381
                z = 2
382
        self.assertEqual(A.B, 0)
383
        self.assertEqual(x, 0)
384
        self.assertEqual(y, 0)
385
        self.assertEqual(z, 2)
386

387
    def test_patma_010(self):
388
        return  # disabled
389
        match ():
390
            case []:
391
                x = 0
392
        self.assertEqual(x, 0)
393

394
    def test_patma_011(self):
395
        return  # disabled
396
        match (0, 1, 2):
397
            case [*x]:
398
                y = 0
399
        self.assertEqual(x, [0, 1, 2])
400
        self.assertEqual(y, 0)
401

402
    def test_patma_012(self):
403
        return  # disabled
404
        match (0, 1, 2):
405
            case [0, *x]:
406
                y = 0
407
        self.assertEqual(x, [1, 2])
408
        self.assertEqual(y, 0)
409

410
    def test_patma_013(self):
411
        return  # disabled
412
        match (0, 1, 2):
413
            case [0, 1, *x,]:
414
                y = 0
415
        self.assertEqual(x, [2])
416
        self.assertEqual(y, 0)
417

418
    def test_patma_014(self):
419
        return  # disabled
420
        match (0, 1, 2):
421
            case [0, 1, 2, *x]:
422
                y = 0
423
        self.assertEqual(x, [])
424
        self.assertEqual(y, 0)
425

426
    def test_patma_015(self):
427
        return  # disabled
428
        match (0, 1, 2):
429
            case [*x, 2,]:
430
                y = 0
431
        self.assertEqual(x, [0, 1])
432
        self.assertEqual(y, 0)
433

434
    def test_patma_016(self):
435
        return  # disabled
436
        match (0, 1, 2):
437
            case [*x, 1, 2]:
438
                y = 0
439
        self.assertEqual(x, [0])
440
        self.assertEqual(y, 0)
441

442
    def test_patma_017(self):
443
        return  # disabled
444
        match (0, 1, 2):
445
            case [*x, 0, 1, 2,]:
446
                y = 0
447
        self.assertEqual(x, [])
448
        self.assertEqual(y, 0)
449

450
    def test_patma_018(self):
451
        return  # disabled
452
        match (0, 1, 2):
453
            case [0, *x, 2]:
454
                y = 0
455
        self.assertEqual(x, [1])
456
        self.assertEqual(y, 0)
457

458
    def test_patma_019(self):
459
        return  # disabled
460
        match (0, 1, 2):
461
            case [0, 1, *x, 2,]:
462
                y = 0
463
        self.assertEqual(x, [])
464
        self.assertEqual(y, 0)
465

466
    def test_patma_020(self):
467
        return  # disabled
468
        match (0, 1, 2):
469
            case [0, *x, 1, 2]:
470
                y = 0
471
        self.assertEqual(x, [])
472
        self.assertEqual(y, 0)
473

474
    def test_patma_021(self):
475
        return  # disabled
476
        match (0, 1, 2):
477
            case [*x,]:
478
                y = 0
479
        self.assertEqual(x, [0, 1, 2])
480
        self.assertEqual(y, 0)
481

482
    def test_patma_022(self):
483
        return  # disabled
484
        x = {}
485
        match x:
486
            case {}:
487
                y = 0
488
        self.assertEqual(x, {})
489
        self.assertEqual(y, 0)
490

491
    def test_patma_023(self):
492
        return  # disabled
493
        x = {0: 0}
494
        match x:
495
            case {}:
496
                y = 0
497
        self.assertEqual(x, {0: 0})
498
        self.assertEqual(y, 0)
499

500
    def test_patma_024(self):
501
        return  # disabled
502
        x = {}
503
        y = None
504
        match x:
505
            case {0: 0}:
506
                y = 0
507
        self.assertEqual(x, {})
508
        self.assertIs(y, None)
509

510
    def test_patma_025(self):
511
        return  # disabled
512
        x = {0: 0}
513
        match x:
514
            case {0: (0 | 1 | 2 as z)}:
515
                y = 0
516
        self.assertEqual(x, {0: 0})
517
        self.assertEqual(y, 0)
518
        self.assertEqual(z, 0)
519

520
    def test_patma_026(self):
521
        return  # disabled
522
        x = {0: 1}
523
        match x:
524
            case {0: (0 | 1 | 2 as z)}:
525
                y = 0
526
        self.assertEqual(x, {0: 1})
527
        self.assertEqual(y, 0)
528
        self.assertEqual(z, 1)
529

530
    def test_patma_027(self):
531
        return  # disabled
532
        x = {0: 2}
533
        match x:
534
            case {0: (0 | 1 | 2 as z)}:
535
                y = 0
536
        self.assertEqual(x, {0: 2})
537
        self.assertEqual(y, 0)
538
        self.assertEqual(z, 2)
539

540
    def test_patma_028(self):
541
        return  # disabled
542
        x = {0: 3}
543
        y = None
544
        match x:
545
            case {0: (0 | 1 | 2 as z)}:
546
                y = 0
547
        self.assertEqual(x, {0: 3})
548
        self.assertIs(y, None)
549

550
    def test_patma_029(self):
551
        return  # disabled
552
        x = {}
553
        y = None
554
        match x:
555
            case {0: [1, 2, {}]}:
556
                y = 0
557
            case {0: [1, 2, {}], 1: [[]]}:
558
                y = 1
559
            case []:
560
                y = 2
561
        self.assertEqual(x, {})
562
        self.assertIs(y, None)
563

564
    def test_patma_030(self):
565
        return  # disabled
566
        x = {False: (True, 2.0, {})}
567
        match x:
568
            case {0: [1, 2, {}]}:
569
                y = 0
570
            case {0: [1, 2, {}], 1: [[]]}:
571
                y = 1
572
            case []:
573
                y = 2
574
        self.assertEqual(x, {False: (True, 2.0, {})})
575
        self.assertEqual(y, 0)
576

577
    def test_patma_031(self):
578
        return  # disabled
579
        x = {False: (True, 2.0, {}), 1: [[]], 2: 0}
580
        match x:
581
            case {0: [1, 2, {}]}:
582
                y = 0
583
            case {0: [1, 2, {}], 1: [[]]}:
584
                y = 1
585
            case []:
586
                y = 2
587
        self.assertEqual(x, {False: (True, 2.0, {}), 1: [[]], 2: 0})
588
        self.assertEqual(y, 0)
589

590
    def test_patma_032(self):
591
        return  # disabled
592
        x = {False: (True, 2.0, {}), 1: [[]], 2: 0}
593
        match x:
594
            case {0: [1, 2]}:
595
                y = 0
596
            case {0: [1, 2, {}], 1: [[]]}:
597
                y = 1
598
            case []:
599
                y = 2
600
        self.assertEqual(x, {False: (True, 2.0, {}), 1: [[]], 2: 0})
601
        self.assertEqual(y, 1)
602

603
    def test_patma_033(self):
604
        return  # disabled
605
        x = []
606
        match x:
607
            case {0: [1, 2, {}]}:
608
                y = 0
609
            case {0: [1, 2, {}], 1: [[]]}:
610
                y = 1
611
            case []:
612
                y = 2
613
        self.assertEqual(x, [])
614
        self.assertEqual(y, 2)
615

616
    def test_patma_034(self):
617
        return  # disabled
618
        x = {0: 0}
619
        match x:
620
            case {0: [1, 2, {}]}:
621
                y = 0
622
            case {0: ([1, 2, {}] | False)} | {1: [[]]} | {0: [1, 2, {}]} | [] | "X" | {}:
623
                y = 1
624
            case []:
625
                y = 2
626
        self.assertEqual(x, {0: 0})
627
        self.assertEqual(y, 1)
628

629
    def test_patma_035(self):
630
        return  # disabled
631
        x = {0: 0}
632
        match x:
633
            case {0: [1, 2, {}]}:
634
                y = 0
635
            case {0: [1, 2, {}] | True} | {1: [[]]} | {0: [1, 2, {}]} | [] | "X" | {}:
636
                y = 1
637
            case []:
638
                y = 2
639
        self.assertEqual(x, {0: 0})
640
        self.assertEqual(y, 1)
641

642
    def test_patma_036(self):
643
        return  # disabled
644
        x = 0
645
        match x:
646
            case 0 | 1 | 2:
647
                y = 0
648
        self.assertEqual(x, 0)
649
        self.assertEqual(y, 0)
650

651
    def test_patma_037(self):
652
        return  # disabled
653
        x = 1
654
        match x:
655
            case 0 | 1 | 2:
656
                y = 0
657
        self.assertEqual(x, 1)
658
        self.assertEqual(y, 0)
659

660
    def test_patma_038(self):
661
        return  # disabled
662
        x = 2
663
        match x:
664
            case 0 | 1 | 2:
665
                y = 0
666
        self.assertEqual(x, 2)
667
        self.assertEqual(y, 0)
668

669
    def test_patma_039(self):
670
        return  # disabled
671
        x = 3
672
        y = None
673
        match x:
674
            case 0 | 1 | 2:
675
                y = 0
676
        self.assertEqual(x, 3)
677
        self.assertIs(y, None)
678

679
    def test_patma_040(self):
680
        return  # disabled
681
        x = 0
682
        match x:
683
            case (0 as z) | (1 as z) | (2 as z) if z == x % 2:
684
                y = 0
685
        self.assertEqual(x, 0)
686
        self.assertEqual(y, 0)
687
        self.assertEqual(z, 0)
688

689
    def test_patma_041(self):
690
        return  # disabled
691
        x = 1
692
        match x:
693
            case (0 as z) | (1 as z) | (2 as z) if z == x % 2:
694
                y = 0
695
        self.assertEqual(x, 1)
696
        self.assertEqual(y, 0)
697
        self.assertEqual(z, 1)
698

699
    def test_patma_042(self):
700
        return  # disabled
701
        x = 2
702
        y = None
703
        match x:
704
            case (0 as z) | (1 as z) | (2 as z) if z == x % 2:
705
                y = 0
706
        self.assertEqual(x, 2)
707
        self.assertIs(y, None)
708
        self.assertEqual(z, 2)
709

710
    def test_patma_043(self):
711
        return  # disabled
712
        x = 3
713
        y = None
714
        match x:
715
            case (0 as z) | (1 as z) | (2 as z) if z == x % 2:
716
                y = 0
717
        self.assertEqual(x, 3)
718
        self.assertIs(y, None)
719

720
    def test_patma_044(self):
721
        return  # disabled
722
        x = ()
723
        match x:
724
            case []:
725
                y = 0
726
        self.assertEqual(x, ())
727
        self.assertEqual(y, 0)
728

729
    def test_patma_045(self):
730
        return  # disabled
731
        x = ()
732
        match x:
733
            case ():
734
                y = 0
735
        self.assertEqual(x, ())
736
        self.assertEqual(y, 0)
737

738
    def test_patma_046(self):
739
        return  # disabled
740
        x = (0,)
741
        match x:
742
            case [0]:
743
                y = 0
744
        self.assertEqual(x, (0,))
745
        self.assertEqual(y, 0)
746

747
    def test_patma_047(self):
748
        return  # disabled
749
        x = ((),)
750
        match x:
751
            case [[]]:
752
                y = 0
753
        self.assertEqual(x, ((),))
754
        self.assertEqual(y, 0)
755

756
    def test_patma_048(self):
757
        return  # disabled
758
        x = [0, 1]
759
        match x:
760
            case [0, 1] | [1, 0]:
761
                y = 0
762
        self.assertEqual(x, [0, 1])
763
        self.assertEqual(y, 0)
764

765
    def test_patma_049(self):
766
        return  # disabled
767
        x = [1, 0]
768
        match x:
769
            case [0, 1] | [1, 0]:
770
                y = 0
771
        self.assertEqual(x, [1, 0])
772
        self.assertEqual(y, 0)
773

774
    def test_patma_050(self):
775
        return  # disabled
776
        x = [0, 0]
777
        y = None
778
        match x:
779
            case [0, 1] | [1, 0]:
780
                y = 0
781
        self.assertEqual(x, [0, 0])
782
        self.assertIs(y, None)
783

784
    def test_patma_051(self):
785
        return  # disabled
786
        w = None
787
        x = [1, 0]
788
        match x:
789
            case [(0 as w)]:
790
                y = 0
791
            case [z] | [1, (0 | 1 as z)] | [z]:
792
                y = 1
793
        self.assertIs(w, None)
794
        self.assertEqual(x, [1, 0])
795
        self.assertEqual(y, 1)
796
        self.assertEqual(z, 0)
797

798
    def test_patma_052(self):
799
        return  # disabled
800
        x = [1, 0]
801
        match x:
802
            case [0]:
803
                y = 0
804
            case [1, 0] if (x := x[:0]):
805
                y = 1
806
            case [1, 0]:
807
                y = 2
808
        self.assertEqual(x, [])
809
        self.assertEqual(y, 2)
810

811
    def test_patma_053(self):
812
        return  # disabled
813
        x = {0}
814
        y = None
815
        match x:
816
            case [0]:
817
                y = 0
818
        self.assertEqual(x, {0})
819
        self.assertIs(y, None)
820

821
    def test_patma_054(self):
822
        return  # disabled
823
        x = set()
824
        y = None
825
        match x:
826
            case []:
827
                y = 0
828
        self.assertEqual(x, set())
829
        self.assertIs(y, None)
830

831
    def test_patma_055(self):
832
        return  # disabled
833
        x = iter([1, 2, 3])
834
        y = None
835
        match x:
836
            case []:
837
                y = 0
838
        self.assertEqual([*x], [1, 2, 3])
839
        self.assertIs(y, None)
840

841
    def test_patma_056(self):
842
        return  # disabled
843
        x = {}
844
        y = None
845
        match x:
846
            case []:
847
                y = 0
848
        self.assertEqual(x, {})
849
        self.assertIs(y, None)
850

851
    def test_patma_057(self):
852
        return  # disabled
853
        x = {0: False, 1: True}
854
        y = None
855
        match x:
856
            case [0, 1]:
857
                y = 0
858
        self.assertEqual(x, {0: False, 1: True})
859
        self.assertIs(y, None)
860

861
    def test_patma_058(self):
862
        return  # disabled
863
        x = 0
864
        match x:
865
            case 0:
866
                y = 0
867
        self.assertEqual(x, 0)
868
        self.assertEqual(y, 0)
869

870
    def test_patma_059(self):
871
        return  # disabled
872
        x = 0
873
        y = None
874
        match x:
875
            case False:
876
                y = 0
877
        self.assertEqual(x, 0)
878
        self.assertEqual(y, None)
879

880
    def test_patma_060(self):
881
        return  # disabled
882
        x = 0
883
        y = None
884
        match x:
885
            case 1:
886
                y = 0
887
        self.assertEqual(x, 0)
888
        self.assertIs(y, None)
889

890
    def test_patma_061(self):
891
        return  # disabled
892
        x = 0
893
        y = None
894
        match x:
895
            case None:
896
                y = 0
897
        self.assertEqual(x, 0)
898
        self.assertIs(y, None)
899

900
    def test_patma_062(self):
901
        return  # disabled
902
        x = 0
903
        match x:
904
            case 0:
905
                y = 0
906
            case 0:
907
                y = 1
908
        self.assertEqual(x, 0)
909
        self.assertEqual(y, 0)
910

911
    def test_patma_063(self):
912
        return  # disabled
913
        x = 0
914
        y = None
915
        match x:
916
            case 1:
917
                y = 0
918
            case 1:
919
                y = 1
920
        self.assertEqual(x, 0)
921
        self.assertIs(y, None)
922

923
    def test_patma_064(self):
924
        return  # disabled
925
        x = "x"
926
        match x:
927
            case "x":
928
                y = 0
929
            case "y":
930
                y = 1
931
        self.assertEqual(x, "x")
932
        self.assertEqual(y, 0)
933

934
    def test_patma_065(self):
935
        return  # disabled
936
        x = "x"
937
        match x:
938
            case "y":
939
                y = 0
940
            case "x":
941
                y = 1
942
        self.assertEqual(x, "x")
943
        self.assertEqual(y, 1)
944

945
    def test_patma_066(self):
946
        return  # disabled
947
        x = "x"
948
        match x:
949
            case "":
950
                y = 0
951
            case "x":
952
                y = 1
953
        self.assertEqual(x, "x")
954
        self.assertEqual(y, 1)
955

956
    def test_patma_067(self):
957
        return  # disabled
958
        x = b"x"
959
        match x:
960
            case b"y":
961
                y = 0
962
            case b"x":
963
                y = 1
964
        self.assertEqual(x, b"x")
965
        self.assertEqual(y, 1)
966

967
    def test_patma_068(self):
968
        return  # disabled
969
        x = 0
970
        match x:
971
            case 0 if False:
972
                y = 0
973
            case 0:
974
                y = 1
975
        self.assertEqual(x, 0)
976
        self.assertEqual(y, 1)
977

978
    def test_patma_069(self):
979
        return  # disabled
980
        x = 0
981
        y = None
982
        match x:
983
            case 0 if 0:
984
                y = 0
985
            case 0 if 0:
986
                y = 1
987
        self.assertEqual(x, 0)
988
        self.assertIs(y, None)
989

990
    def test_patma_070(self):
991
        return  # disabled
992
        x = 0
993
        match x:
994
            case 0 if True:
995
                y = 0
996
            case 0 if True:
997
                y = 1
998
        self.assertEqual(x, 0)
999
        self.assertEqual(y, 0)
1000

1001
    def test_patma_071(self):
1002
        return  # disabled
1003
        x = 0
1004
        match x:
1005
            case 0 if 1:
1006
                y = 0
1007
            case 0 if 1:
1008
                y = 1
1009
        self.assertEqual(x, 0)
1010
        self.assertEqual(y, 0)
1011

1012
    def test_patma_072(self):
1013
        return  # disabled
1014
        x = 0
1015
        match x:
1016
            case 0 if True:
1017
                y = 0
1018
            case 0 if True:
1019
                y = 1
1020
        y = 2
1021
        self.assertEqual(x, 0)
1022
        self.assertEqual(y, 2)
1023

1024
    def test_patma_073(self):
1025
        return  # disabled
1026
        x = 0
1027
        match x:
1028
            case 0 if 0:
1029
                y = 0
1030
            case 0 if 1:
1031
                y = 1
1032
        y = 2
1033
        self.assertEqual(x, 0)
1034
        self.assertEqual(y, 2)
1035

1036
    def test_patma_074(self):
1037
        return  # disabled
1038
        x = 0
1039
        y = None
1040
        match x:
1041
            case 0 if not (x := 1):
1042
                y = 0
1043
            case 1:
1044
                y = 1
1045
        self.assertEqual(x, 1)
1046
        self.assertIs(y, None)
1047

1048
    def test_patma_075(self):
1049
        return  # disabled
1050
        x = "x"
1051
        match x:
1052
            case ["x"]:
1053
                y = 0
1054
            case "x":
1055
                y = 1
1056
        self.assertEqual(x, "x")
1057
        self.assertEqual(y, 1)
1058

1059
    def test_patma_076(self):
1060
        return  # disabled
1061
        x = b"x"
1062
        match x:
1063
            case [b"x"]:
1064
                y = 0
1065
            case ["x"]:
1066
                y = 1
1067
            case [120]:
1068
                y = 2
1069
            case b"x":
1070
                y = 4
1071
        self.assertEqual(x, b"x")
1072
        self.assertEqual(y, 4)
1073

1074
    def test_patma_077(self):
1075
        return  # disabled
1076
        x = bytearray(b"x")
1077
        y = None
1078
        match x:
1079
            case [120]:
1080
                y = 0
1081
            case 120:
1082
                y = 1
1083
        self.assertEqual(x, b"x")
1084
        self.assertIs(y, None)
1085

1086
    def test_patma_078(self):
1087
        return  # disabled
1088
        x = ""
1089
        match x:
1090
            case []:
1091
                y = 0
1092
            case [""]:
1093
                y = 1
1094
            case "":
1095
                y = 2
1096
        self.assertEqual(x, "")
1097
        self.assertEqual(y, 2)
1098

1099
    def test_patma_079(self):
1100
        return  # disabled
1101
        x = "xxx"
1102
        match x:
1103
            case ["x", "x", "x"]:
1104
                y = 0
1105
            case ["xxx"]:
1106
                y = 1
1107
            case "xxx":
1108
                y = 2
1109
        self.assertEqual(x, "xxx")
1110
        self.assertEqual(y, 2)
1111

1112
    def test_patma_080(self):
1113
        return  # disabled
1114
        x = b"xxx"
1115
        match x:
1116
            case [120, 120, 120]:
1117
                y = 0
1118
            case [b"xxx"]:
1119
                y = 1
1120
            case b"xxx":
1121
                y = 2
1122
        self.assertEqual(x, b"xxx")
1123
        self.assertEqual(y, 2)
1124

1125
    def test_patma_081(self):
1126
        return  # disabled
1127
        x = 0
1128
        match x:
1129
            case 0 if not (x := 1):
1130
                y = 0
1131
            case (0 as z):
1132
                y = 1
1133
        self.assertEqual(x, 1)
1134
        self.assertEqual(y, 1)
1135
        self.assertEqual(z, 0)
1136

1137
    def test_patma_082(self):
1138
        return  # disabled
1139
        x = 0
1140
        match x:
1141
            case (1 as z) if not (x := 1):
1142
                y = 0
1143
            case 0:
1144
                y = 1
1145
        self.assertEqual(x, 0)
1146
        self.assertEqual(y, 1)
1147

1148
    def test_patma_083(self):
1149
        return  # disabled
1150
        x = 0
1151
        match x:
1152
            case (0 as z):
1153
                y = 0
1154
        self.assertEqual(x, 0)
1155
        self.assertEqual(y, 0)
1156
        self.assertEqual(z, 0)
1157

1158
    def test_patma_084(self):
1159
        return  # disabled
1160
        x = 0
1161
        y = None
1162
        match x:
1163
            case (1 as z):
1164
                y = 0
1165
        self.assertEqual(x, 0)
1166
        self.assertIs(y, None)
1167

1168
    def test_patma_085(self):
1169
        return  # disabled
1170
        x = 0
1171
        y = None
1172
        match x:
1173
            case (0 as z) if (w := 0):
1174
                y = 0
1175
        self.assertEqual(w, 0)
1176
        self.assertEqual(x, 0)
1177
        self.assertIs(y, None)
1178
        self.assertEqual(z, 0)
1179

1180
    def test_patma_086(self):
1181
        return  # disabled
1182
        x = 0
1183
        match x:
1184
            case ((0 as w) as z):
1185
                y = 0
1186
        self.assertEqual(w, 0)
1187
        self.assertEqual(x, 0)
1188
        self.assertEqual(y, 0)
1189
        self.assertEqual(z, 0)
1190

1191
    def test_patma_087(self):
1192
        return  # disabled
1193
        x = 0
1194
        match x:
1195
            case (0 | 1) | 2:
1196
                y = 0
1197
        self.assertEqual(x, 0)
1198
        self.assertEqual(y, 0)
1199

1200
    def test_patma_088(self):
1201
        return  # disabled
1202
        x = 1
1203
        match x:
1204
            case (0 | 1) | 2:
1205
                y = 0
1206
        self.assertEqual(x, 1)
1207
        self.assertEqual(y, 0)
1208

1209
    def test_patma_089(self):
1210
        return  # disabled
1211
        x = 2
1212
        match x:
1213
            case (0 | 1) | 2:
1214
                y = 0
1215
        self.assertEqual(x, 2)
1216
        self.assertEqual(y, 0)
1217

1218
    def test_patma_090(self):
1219
        return  # disabled
1220
        x = 3
1221
        y = None
1222
        match x:
1223
            case (0 | 1) | 2:
1224
                y = 0
1225
        self.assertEqual(x, 3)
1226
        self.assertIs(y, None)
1227

1228
    def test_patma_091(self):
1229
        return  # disabled
1230
        x = 0
1231
        match x:
1232
            case 0 | (1 | 2):
1233
                y = 0
1234
        self.assertEqual(x, 0)
1235
        self.assertEqual(y, 0)
1236

1237
    def test_patma_092(self):
1238
        return  # disabled
1239
        x = 1
1240
        match x:
1241
            case 0 | (1 | 2):
1242
                y = 0
1243
        self.assertEqual(x, 1)
1244
        self.assertEqual(y, 0)
1245

1246
    def test_patma_093(self):
1247
        return  # disabled
1248
        x = 2
1249
        match x:
1250
            case 0 | (1 | 2):
1251
                y = 0
1252
        self.assertEqual(x, 2)
1253
        self.assertEqual(y, 0)
1254

1255
    def test_patma_094(self):
1256
        return  # disabled
1257
        x = 3
1258
        y = None
1259
        match x:
1260
            case 0 | (1 | 2):
1261
                y = 0
1262
        self.assertEqual(x, 3)
1263
        self.assertIs(y, None)
1264

1265
    def test_patma_095(self):
1266
        return  # disabled
1267
        x = 0
1268
        match x:
1269
            case -0:
1270
                y = 0
1271
        self.assertEqual(x, 0)
1272
        self.assertEqual(y, 0)
1273

1274
    def test_patma_096(self):
1275
        return  # disabled
1276
        x = 0
1277
        match x:
1278
            case -0.0:
1279
                y = 0
1280
        self.assertEqual(x, 0)
1281
        self.assertEqual(y, 0)
1282

1283
    def test_patma_097(self):
1284
        return  # disabled
1285
        x = 0
1286
        match x:
1287
            case -0j:
1288
                y = 0
1289
        self.assertEqual(x, 0)
1290
        self.assertEqual(y, 0)
1291

1292
    def test_patma_098(self):
1293
        return  # disabled
1294
        x = 0
1295
        match x:
1296
            case -0.0j:
1297
                y = 0
1298
        self.assertEqual(x, 0)
1299
        self.assertEqual(y, 0)
1300

1301
    def test_patma_099(self):
1302
        return  # disabled
1303
        x = -1
1304
        match x:
1305
            case -1:
1306
                y = 0
1307
        self.assertEqual(x, -1)
1308
        self.assertEqual(y, 0)
1309

1310
    def test_patma_100(self):
1311
        return  # disabled
1312
        x = -1.5
1313
        match x:
1314
            case -1.5:
1315
                y = 0
1316
        self.assertEqual(x, -1.5)
1317
        self.assertEqual(y, 0)
1318

1319
    def test_patma_101(self):
1320
        return  # disabled
1321
        x = -1j
1322
        match x:
1323
            case -1j:
1324
                y = 0
1325
        self.assertEqual(x, -1j)
1326
        self.assertEqual(y, 0)
1327

1328
    def test_patma_102(self):
1329
        return  # disabled
1330
        x = -1.5j
1331
        match x:
1332
            case -1.5j:
1333
                y = 0
1334
        self.assertEqual(x, -1.5j)
1335
        self.assertEqual(y, 0)
1336

1337
    def test_patma_103(self):
1338
        return  # disabled
1339
        x = 0
1340
        match x:
1341
            case 0 + 0j:
1342
                y = 0
1343
        self.assertEqual(x, 0)
1344
        self.assertEqual(y, 0)
1345

1346
    def test_patma_104(self):
1347
        return  # disabled
1348
        x = 0
1349
        match x:
1350
            case 0 - 0j:
1351
                y = 0
1352
        self.assertEqual(x, 0)
1353
        self.assertEqual(y, 0)
1354

1355
    def test_patma_105(self):
1356
        return  # disabled
1357
        x = 0
1358
        match x:
1359
            case -0 + 0j:
1360
                y = 0
1361
        self.assertEqual(x, 0)
1362
        self.assertEqual(y, 0)
1363

1364
    def test_patma_106(self):
1365
        return  # disabled
1366
        x = 0
1367
        match x:
1368
            case -0 - 0j:
1369
                y = 0
1370
        self.assertEqual(x, 0)
1371
        self.assertEqual(y, 0)
1372

1373
    def test_patma_107(self):
1374
        return  # disabled
1375
        x = 0.25 + 1.75j
1376
        match x:
1377
            case 0.25 + 1.75j:
1378
                y = 0
1379
        self.assertEqual(x, 0.25 + 1.75j)
1380
        self.assertEqual(y, 0)
1381

1382
    def test_patma_108(self):
1383
        return  # disabled
1384
        x = 0.25 - 1.75j
1385
        match x:
1386
            case 0.25 - 1.75j:
1387
                y = 0
1388
        self.assertEqual(x, 0.25 - 1.75j)
1389
        self.assertEqual(y, 0)
1390

1391
    def test_patma_109(self):
1392
        return  # disabled
1393
        x = -0.25 + 1.75j
1394
        match x:
1395
            case -0.25 + 1.75j:
1396
                y = 0
1397
        self.assertEqual(x, -0.25 + 1.75j)
1398
        self.assertEqual(y, 0)
1399

1400
    def test_patma_110(self):
1401
        return  # disabled
1402
        x = -0.25 - 1.75j
1403
        match x:
1404
            case -0.25 - 1.75j:
1405
                y = 0
1406
        self.assertEqual(x, -0.25 - 1.75j)
1407
        self.assertEqual(y, 0)
1408

1409
    def test_patma_111(self):
1410
        return  # disabled
1411
        class A:
1412
            B = 0
1413
        x = 0
1414
        match x:
1415
            case A.B:
1416
                y = 0
1417
        self.assertEqual(A.B, 0)
1418
        self.assertEqual(x, 0)
1419
        self.assertEqual(y, 0)
1420

1421
    def test_patma_112(self):
1422
        return  # disabled
1423
        class A:
1424
            class B:
1425
                C = 0
1426
        x = 0
1427
        match x:
1428
            case A.B.C:
1429
                y = 0
1430
        self.assertEqual(A.B.C, 0)
1431
        self.assertEqual(x, 0)
1432
        self.assertEqual(y, 0)
1433

1434
    def test_patma_113(self):
1435
        return  # disabled
1436
        class A:
1437
            class B:
1438
                C = 0
1439
                D = 1
1440
        x = 1
1441
        match x:
1442
            case A.B.C:
1443
                y = 0
1444
            case A.B.D:
1445
                y = 1
1446
        self.assertEqual(A.B.C, 0)
1447
        self.assertEqual(A.B.D, 1)
1448
        self.assertEqual(x, 1)
1449
        self.assertEqual(y, 1)
1450

1451
    def test_patma_114(self):
1452
        return  # disabled
1453
        class A:
1454
            class B:
1455
                class C:
1456
                    D = 0
1457
        x = 0
1458
        match x:
1459
            case A.B.C.D:
1460
                y = 0
1461
        self.assertEqual(A.B.C.D, 0)
1462
        self.assertEqual(x, 0)
1463
        self.assertEqual(y, 0)
1464

1465
    def test_patma_115(self):
1466
        return  # disabled
1467
        class A:
1468
            class B:
1469
                class C:
1470
                    D = 0
1471
                    E = 1
1472
        x = 1
1473
        match x:
1474
            case A.B.C.D:
1475
                y = 0
1476
            case A.B.C.E:
1477
                y = 1
1478
        self.assertEqual(A.B.C.D, 0)
1479
        self.assertEqual(A.B.C.E, 1)
1480
        self.assertEqual(x, 1)
1481
        self.assertEqual(y, 1)
1482

1483
    def test_patma_116(self):
1484
        return  # disabled
1485
        match = case = 0
1486
        match match:
1487
            case case:
1488
                x = 0
1489
        self.assertEqual(match, 0)
1490
        self.assertEqual(case, 0)
1491
        self.assertEqual(x, 0)
1492

1493
    def test_patma_117(self):
1494
        return  # disabled
1495
        match = case = 0
1496
        match case:
1497
            case match:
1498
                x = 0
1499
        self.assertEqual(match, 0)
1500
        self.assertEqual(case, 0)
1501
        self.assertEqual(x, 0)
1502

1503
    def test_patma_118(self):
1504
        return  # disabled
1505
        x = []
1506
        match x:
1507
            case [*_, _]:
1508
                y = 0
1509
            case []:
1510
                y = 1
1511
        self.assertEqual(x, [])
1512
        self.assertEqual(y, 1)
1513

1514
    def test_patma_119(self):
1515
        return  # disabled
1516
        x = collections.defaultdict(int)
1517
        match x:
1518
            case {0: 0}:
1519
                y = 0
1520
            case {}:
1521
                y = 1
1522
        self.assertEqual(x, {})
1523
        self.assertEqual(y, 1)
1524

1525
    def test_patma_120(self):
1526
        return  # disabled
1527
        x = collections.defaultdict(int)
1528
        match x:
1529
            case {0: 0}:
1530
                y = 0
1531
            case {**z}:
1532
                y = 1
1533
        self.assertEqual(x, {})
1534
        self.assertEqual(y, 1)
1535
        self.assertEqual(z, {})
1536

1537
    def test_patma_121(self):
1538
        return  # disabled
1539
        match ():
1540
            case ():
1541
                x = 0
1542
        self.assertEqual(x, 0)
1543

1544
    def test_patma_122(self):
1545
        return  # disabled
1546
        match (0, 1, 2):
1547
            case (*x,):
1548
                y = 0
1549
        self.assertEqual(x, [0, 1, 2])
1550
        self.assertEqual(y, 0)
1551

1552
    def test_patma_123(self):
1553
        return  # disabled
1554
        match (0, 1, 2):
1555
            case 0, *x:
1556
                y = 0
1557
        self.assertEqual(x, [1, 2])
1558
        self.assertEqual(y, 0)
1559

1560
    def test_patma_124(self):
1561
        return  # disabled
1562
        match (0, 1, 2):
1563
            case (0, 1, *x,):
1564
                y = 0
1565
        self.assertEqual(x, [2])
1566
        self.assertEqual(y, 0)
1567

1568
    def test_patma_125(self):
1569
        return  # disabled
1570
        match (0, 1, 2):
1571
            case 0, 1, 2, *x:
1572
                y = 0
1573
        self.assertEqual(x, [])
1574
        self.assertEqual(y, 0)
1575

1576
    def test_patma_126(self):
1577
        return  # disabled
1578
        match (0, 1, 2):
1579
            case *x, 2,:
1580
                y = 0
1581
        self.assertEqual(x, [0, 1])
1582
        self.assertEqual(y, 0)
1583

1584
    def test_patma_127(self):
1585
        return  # disabled
1586
        match (0, 1, 2):
1587
            case (*x, 1, 2):
1588
                y = 0
1589
        self.assertEqual(x, [0])
1590
        self.assertEqual(y, 0)
1591

1592
    def test_patma_128(self):
1593
        return  # disabled
1594
        match (0, 1, 2):
1595
            case *x, 0, 1, 2,:
1596
                y = 0
1597
        self.assertEqual(x, [])
1598
        self.assertEqual(y, 0)
1599

1600
    def test_patma_129(self):
1601
        return  # disabled
1602
        match (0, 1, 2):
1603
            case (0, *x, 2):
1604
                y = 0
1605
        self.assertEqual(x, [1])
1606
        self.assertEqual(y, 0)
1607

1608
    def test_patma_130(self):
1609
        return  # disabled
1610
        match (0, 1, 2):
1611
            case 0, 1, *x, 2,:
1612
                y = 0
1613
        self.assertEqual(x, [])
1614
        self.assertEqual(y, 0)
1615

1616
    def test_patma_131(self):
1617
        return  # disabled
1618
        match (0, 1, 2):
1619
            case (0, *x, 1, 2):
1620
                y = 0
1621
        self.assertEqual(x, [])
1622
        self.assertEqual(y, 0)
1623

1624
    def test_patma_132(self):
1625
        return  # disabled
1626
        match (0, 1, 2):
1627
            case *x,:
1628
                y = 0
1629
        self.assertEqual(x, [0, 1, 2])
1630
        self.assertEqual(y, 0)
1631

1632
    def test_patma_133(self):
1633
        return  # disabled
1634
        x = collections.defaultdict(int, {0: 1})
1635
        match x:
1636
            case {1: 0}:
1637
                y = 0
1638
            case {0: 0}:
1639
                y = 1
1640
            case {}:
1641
                y = 2
1642
        self.assertEqual(x, {0: 1})
1643
        self.assertEqual(y, 2)
1644

1645
    def test_patma_134(self):
1646
        return  # disabled
1647
        x = collections.defaultdict(int, {0: 1})
1648
        match x:
1649
            case {1: 0}:
1650
                y = 0
1651
            case {0: 0}:
1652
                y = 1
1653
            case {**z}:
1654
                y = 2
1655
        self.assertEqual(x, {0: 1})
1656
        self.assertEqual(y, 2)
1657
        self.assertEqual(z, {0: 1})
1658

1659
    def test_patma_135(self):
1660
        return  # disabled
1661
        x = collections.defaultdict(int, {0: 1})
1662
        match x:
1663
            case {1: 0}:
1664
                y = 0
1665
            case {0: 0}:
1666
                y = 1
1667
            case {0: _, **z}:
1668
                y = 2
1669
        self.assertEqual(x, {0: 1})
1670
        self.assertEqual(y, 2)
1671
        self.assertEqual(z, {})
1672

1673
    def test_patma_136(self):
1674
        return  # disabled
1675
        x = {0: 1}
1676
        match x:
1677
            case {1: 0}:
1678
                y = 0
1679
            case {0: 0}:
1680
                y = 0
1681
            case {}:
1682
                y = 1
1683
        self.assertEqual(x, {0: 1})
1684
        self.assertEqual(y, 1)
1685

1686
    def test_patma_137(self):
1687
        return  # disabled
1688
        x = {0: 1}
1689
        match x:
1690
            case {1: 0}:
1691
                y = 0
1692
            case {0: 0}:
1693
                y = 0
1694
            case {**z}:
1695
                y = 1
1696
        self.assertEqual(x, {0: 1})
1697
        self.assertEqual(y, 1)
1698
        self.assertEqual(z, {0: 1})
1699

1700
    def test_patma_138(self):
1701
        return  # disabled
1702
        x = {0: 1}
1703
        match x:
1704
            case {1: 0}:
1705
                y = 0
1706
            case {0: 0}:
1707
                y = 0
1708
            case {0: _, **z}:
1709
                y = 1
1710
        self.assertEqual(x, {0: 1})
1711
        self.assertEqual(y, 1)
1712
        self.assertEqual(z, {})
1713

1714
    def test_patma_139(self):
1715
        return  # disabled
1716
        x = False
1717
        match x:
1718
            case bool(z):
1719
                y = 0
1720
        self.assertIs(x, False)
1721
        self.assertEqual(y, 0)
1722
        self.assertIs(z, x)
1723

1724
    def test_patma_140(self):
1725
        return  # disabled
1726
        x = True
1727
        match x:
1728
            case bool(z):
1729
                y = 0
1730
        self.assertIs(x, True)
1731
        self.assertEqual(y, 0)
1732
        self.assertIs(z, x)
1733

1734
    def test_patma_141(self):
1735
        return  # disabled
1736
        x = bytearray()
1737
        match x:
1738
            case bytearray(z):
1739
                y = 0
1740
        self.assertEqual(x, bytearray())
1741
        self.assertEqual(y, 0)
1742
        self.assertIs(z, x)
1743

1744
    def test_patma_142(self):
1745
        return  # disabled
1746
        x = b""
1747
        match x:
1748
            case bytes(z):
1749
                y = 0
1750
        self.assertEqual(x, b"")
1751
        self.assertEqual(y, 0)
1752
        self.assertIs(z, x)
1753

1754
    def test_patma_143(self):
1755
        return  # disabled
1756
        x = {}
1757
        match x:
1758
            case dict(z):
1759
                y = 0
1760
        self.assertEqual(x, {})
1761
        self.assertEqual(y, 0)
1762
        self.assertIs(z, x)
1763

1764
    def test_patma_144(self):
1765
        return  # disabled
1766
        x = 0.0
1767
        match x:
1768
            case float(z):
1769
                y = 0
1770
        self.assertEqual(x, 0.0)
1771
        self.assertEqual(y, 0)
1772
        self.assertIs(z, x)
1773

1774
    def test_patma_145(self):
1775
        return  # disabled
1776
        x = frozenset()
1777
        match x:
1778
            case frozenset(z):
1779
                y = 0
1780
        self.assertEqual(x, frozenset())
1781
        self.assertEqual(y, 0)
1782
        self.assertIs(z, x)
1783

1784
    def test_patma_146(self):
1785
        return  # disabled
1786
        x = 0
1787
        match x:
1788
            case int(z):
1789
                y = 0
1790
        self.assertEqual(x, 0)
1791
        self.assertEqual(y, 0)
1792
        self.assertIs(z, x)
1793

1794
    def test_patma_147(self):
1795
        return  # disabled
1796
        x = []
1797
        match x:
1798
            case list(z):
1799
                y = 0
1800
        self.assertEqual(x, [])
1801
        self.assertEqual(y, 0)
1802
        self.assertIs(z, x)
1803

1804
    def test_patma_148(self):
1805
        return  # disabled
1806
        x = set()
1807
        match x:
1808
            case set(z):
1809
                y = 0
1810
        self.assertEqual(x, set())
1811
        self.assertEqual(y, 0)
1812
        self.assertIs(z, x)
1813

1814
    def test_patma_149(self):
1815
        return  # disabled
1816
        x = ""
1817
        match x:
1818
            case str(z):
1819
                y = 0
1820
        self.assertEqual(x, "")
1821
        self.assertEqual(y, 0)
1822
        self.assertIs(z, x)
1823

1824
    def test_patma_150(self):
1825
        return  # disabled
1826
        x = ()
1827
        match x:
1828
            case tuple(z):
1829
                y = 0
1830
        self.assertEqual(x, ())
1831
        self.assertEqual(y, 0)
1832
        self.assertIs(z, x)
1833

1834
    def test_patma_151(self):
1835
        return  # disabled
1836
        x = 0
1837
        match x,:
1838
            case y,:
1839
                z = 0
1840
        self.assertEqual(x, 0)
1841
        self.assertIs(y, x)
1842
        self.assertIs(z, 0)
1843

1844
    def test_patma_152(self):
1845
        return  # disabled
1846
        w = 0
1847
        x = 0
1848
        match w, x:
1849
            case y, z:
1850
                v = 0
1851
        self.assertEqual(w, 0)
1852
        self.assertEqual(x, 0)
1853
        self.assertIs(y, w)
1854
        self.assertIs(z, x)
1855
        self.assertEqual(v, 0)
1856

1857
    def test_patma_153(self):
1858
        return  # disabled
1859
        x = 0
1860
        match w := x,:
1861
            case y as v,:
1862
                z = 0
1863
        self.assertEqual(x, 0)
1864
        self.assertIs(y, x)
1865
        self.assertEqual(z, 0)
1866
        self.assertIs(w, x)
1867
        self.assertIs(v, y)
1868

1869
    def test_patma_154(self):
1870
        return  # disabled
1871
        x = 0
1872
        y = None
1873
        match x:
1874
            case 0 if x:
1875
                y = 0
1876
        self.assertEqual(x, 0)
1877
        self.assertIs(y, None)
1878

1879
    def test_patma_155(self):
1880
        return  # disabled
1881
        x = 0
1882
        y = None
1883
        match x:
1884
            case 1e1000:
1885
                y = 0
1886
        self.assertEqual(x, 0)
1887
        self.assertIs(y, None)
1888

1889
    def test_patma_156(self):
1890
        return  # disabled
1891
        x = 0
1892
        match x:
1893
            case z:
1894
                y = 0
1895
        self.assertEqual(x, 0)
1896
        self.assertEqual(y, 0)
1897
        self.assertIs(z, x)
1898

1899
    def test_patma_157(self):
1900
        return  # disabled
1901
        x = 0
1902
        y = None
1903
        match x:
1904
            case _ if x:
1905
                y = 0
1906
        self.assertEqual(x, 0)
1907
        self.assertIs(y, None)
1908

1909
    def test_patma_158(self):
1910
        return  # disabled
1911
        x = 0
1912
        match x:
1913
            case -1e1000:
1914
                y = 0
1915
            case 0:
1916
                y = 1
1917
        self.assertEqual(x, 0)
1918
        self.assertEqual(y, 1)
1919

1920
    def test_patma_159(self):
1921
        return  # disabled
1922
        x = 0
1923
        match x:
1924
            case 0 if not x:
1925
                y = 0
1926
            case 1:
1927
                y = 1
1928
        self.assertEqual(x, 0)
1929
        self.assertEqual(y, 0)
1930

1931
    def test_patma_160(self):
1932
        return  # disabled
1933
        x = 0
1934
        z = None
1935
        match x:
1936
            case 0:
1937
                y = 0
1938
            case z if x:
1939
                y = 1
1940
        self.assertEqual(x, 0)
1941
        self.assertEqual(y, 0)
1942
        self.assertIs(z, None)
1943

1944
    def test_patma_161(self):
1945
        return  # disabled
1946
        x = 0
1947
        match x:
1948
            case 0:
1949
                y = 0
1950
            case _:
1951
                y = 1
1952
        self.assertEqual(x, 0)
1953
        self.assertEqual(y, 0)
1954

1955
    def test_patma_162(self):
1956
        return  # disabled
1957
        x = 0
1958
        match x:
1959
            case 1 if x:
1960
                y = 0
1961
            case 0:
1962
                y = 1
1963
        self.assertEqual(x, 0)
1964
        self.assertEqual(y, 1)
1965

1966
    def test_patma_163(self):
1967
        return  # disabled
1968
        x = 0
1969
        y = None
1970
        match x:
1971
            case 1:
1972
                y = 0
1973
            case 1 if not x:
1974
                y = 1
1975
        self.assertEqual(x, 0)
1976
        self.assertIs(y, None)
1977

1978
    def test_patma_164(self):
1979
        return  # disabled
1980
        x = 0
1981
        match x:
1982
            case 1:
1983
                y = 0
1984
            case z:
1985
                y = 1
1986
        self.assertEqual(x, 0)
1987
        self.assertEqual(y, 1)
1988
        self.assertIs(z, x)
1989

1990
    def test_patma_165(self):
1991
        return  # disabled
1992
        x = 0
1993
        match x:
1994
            case 1 if x:
1995
                y = 0
1996
            case _:
1997
                y = 1
1998
        self.assertEqual(x, 0)
1999
        self.assertEqual(y, 1)
2000

2001
    def test_patma_166(self):
2002
        return  # disabled
2003
        x = 0
2004
        match x:
2005
            case z if not z:
2006
                y = 0
2007
            case 0 if x:
2008
                y = 1
2009
        self.assertEqual(x, 0)
2010
        self.assertEqual(y, 0)
2011
        self.assertIs(z, x)
2012

2013
    def test_patma_167(self):
2014
        return  # disabled
2015
        x = 0
2016
        match x:
2017
            case z if not z:
2018
                y = 0
2019
            case 1:
2020
                y = 1
2021
        self.assertEqual(x, 0)
2022
        self.assertEqual(y, 0)
2023
        self.assertIs(z, x)
2024

2025
    def test_patma_168(self):
2026
        return  # disabled
2027
        x = 0
2028
        match x:
2029
            case z if not x:
2030
                y = 0
2031
            case z:
2032
                y = 1
2033
        self.assertEqual(x, 0)
2034
        self.assertEqual(y, 0)
2035
        self.assertIs(z, x)
2036

2037
    def test_patma_169(self):
2038
        return  # disabled
2039
        x = 0
2040
        match x:
2041
            case z if not z:
2042
                y = 0
2043
            case _ if x:
2044
                y = 1
2045
        self.assertEqual(x, 0)
2046
        self.assertEqual(y, 0)
2047
        self.assertIs(z, x)
2048

2049
    def test_patma_170(self):
2050
        return  # disabled
2051
        x = 0
2052
        match x:
2053
            case _ if not x:
2054
                y = 0
2055
            case 0:
2056
                y = 1
2057
        self.assertEqual(x, 0)
2058
        self.assertEqual(y, 0)
2059

2060
    def test_patma_171(self):
2061
        return  # disabled
2062
        x = 0
2063
        y = None
2064
        match x:
2065
            case _ if x:
2066
                y = 0
2067
            case 1:
2068
                y = 1
2069
        self.assertEqual(x, 0)
2070
        self.assertIs(y, None)
2071

2072
    def test_patma_172(self):
2073
        return  # disabled
2074
        x = 0
2075
        z = None
2076
        match x:
2077
            case _ if not x:
2078
                y = 0
2079
            case z if not x:
2080
                y = 1
2081
        self.assertEqual(x, 0)
2082
        self.assertEqual(y, 0)
2083
        self.assertIs(z, None)
2084

2085
    def test_patma_173(self):
2086
        return  # disabled
2087
        x = 0
2088
        match x:
2089
            case _ if not x:
2090
                y = 0
2091
            case _:
2092
                y = 1
2093
        self.assertEqual(x, 0)
2094
        self.assertEqual(y, 0)
2095

2096
    def test_patma_174(self):
2097
        return  # disabled
2098
        def http_error(status):
2099
            match status:
2100
                case 400:
2101
                    return "Bad request"
2102
                case 401:
2103
                    return "Unauthorized"
2104
                case 403:
2105
                    return "Forbidden"
2106
                case 404:
2107
                    return "Not found"
2108
                case 418:
2109
                    return "I'm a teapot"
2110
                case _:
2111
                    return "Something else"
2112
        self.assertEqual(http_error(400), "Bad request")
2113
        self.assertEqual(http_error(401), "Unauthorized")
2114
        self.assertEqual(http_error(403), "Forbidden")
2115
        self.assertEqual(http_error(404), "Not found")
2116
        self.assertEqual(http_error(418), "I'm a teapot")
2117
        self.assertEqual(http_error(123), "Something else")
2118
        self.assertEqual(http_error("400"), "Something else")
2119
        self.assertEqual(http_error(401 | 403 | 404), "Something else")  # 407
2120

2121
    def test_patma_175(self):
2122
        return  # disabled
2123
        def http_error(status):
2124
            match status:
2125
                case 400:
2126
                    return "Bad request"
2127
                case 401 | 403 | 404:
2128
                    return "Not allowed"
2129
                case 418:
2130
                    return "I'm a teapot"
2131
        self.assertEqual(http_error(400), "Bad request")
2132
        self.assertEqual(http_error(401), "Not allowed")
2133
        self.assertEqual(http_error(403), "Not allowed")
2134
        self.assertEqual(http_error(404), "Not allowed")
2135
        self.assertEqual(http_error(418), "I'm a teapot")
2136
        self.assertIs(http_error(123), None)
2137
        self.assertIs(http_error("400"), None)
2138
        self.assertIs(http_error(401 | 403 | 404), None)  # 407
2139

2140
    def test_patma_176(self):
2141
        return  # disabled
2142
        def whereis(point):
2143
            match point:
2144
                case (0, 0):
2145
                    return "Origin"
2146
                case (0, y):
2147
                    return f"Y={y}"
2148
                case (x, 0):
2149
                    return f"X={x}"
2150
                case (x, y):
2151
                    return f"X={x}, Y={y}"
2152
                case _:
2153
                    return "Not a point"
2154
        self.assertEqual(whereis((0, 0)), "Origin")
2155
        self.assertEqual(whereis((0, -1.0)), "Y=-1.0")
2156
        self.assertEqual(whereis(("X", 0)), "X=X")
2157
        self.assertEqual(whereis((None, 1j)), "X=None, Y=1j")
2158
        self.assertEqual(whereis(42), "Not a point")
2159

2160
    def test_patma_177(self):
2161
        return  # disabled
2162
        def whereis(point):
2163
            match point:
2164
                case Point(0, 0):
2165
                    return "Origin"
2166
                case Point(0, y):
2167
                    return f"Y={y}"
2168
                case Point(x, 0):
2169
                    return f"X={x}"
2170
                case Point():
2171
                    return "Somewhere else"
2172
                case _:
2173
                    return "Not a point"
2174
        self.assertEqual(whereis(Point(1, 0)), "X=1")
2175
        self.assertEqual(whereis(Point(0, 0)), "Origin")
2176
        self.assertEqual(whereis(10), "Not a point")
2177
        self.assertEqual(whereis(Point(False, False)), "Origin")
2178
        self.assertEqual(whereis(Point(0, -1.0)), "Y=-1.0")
2179
        self.assertEqual(whereis(Point("X", 0)), "X=X")
2180
        self.assertEqual(whereis(Point(None, 1j)), "Somewhere else")
2181
        self.assertEqual(whereis(Point), "Not a point")
2182
        self.assertEqual(whereis(42), "Not a point")
2183

2184
    def test_patma_178(self):
2185
        return  # disabled
2186
        def whereis(point):
2187
            match point:
2188
                case Point(1, var):
2189
                    return var
2190
        self.assertEqual(whereis(Point(1, 0)), 0)
2191
        self.assertIs(whereis(Point(0, 0)), None)
2192

2193
    def test_patma_179(self):
2194
        return  # disabled
2195
        def whereis(point):
2196
            match point:
2197
                case Point(1, y=var):
2198
                    return var
2199
        self.assertEqual(whereis(Point(1, 0)), 0)
2200
        self.assertIs(whereis(Point(0, 0)), None)
2201

2202
    def test_patma_180(self):
2203
        return  # disabled
2204
        def whereis(point):
2205
            match point:
2206
                case Point(x=1, y=var):
2207
                    return var
2208
        self.assertEqual(whereis(Point(1, 0)), 0)
2209
        self.assertIs(whereis(Point(0, 0)), None)
2210

2211
    def test_patma_181(self):
2212
        return  # disabled
2213
        def whereis(point):
2214
            match point:
2215
                case Point(y=var, x=1):
2216
                    return var
2217
        self.assertEqual(whereis(Point(1, 0)), 0)
2218
        self.assertIs(whereis(Point(0, 0)), None)
2219

2220
    def test_patma_182(self):
2221
        return  # disabled
2222
        def whereis(points):
2223
            match points:
2224
                case []:
2225
                    return "No points"
2226
                case [Point(0, 0)]:
2227
                    return "The origin"
2228
                case [Point(x, y)]:
2229
                    return f"Single point {x}, {y}"
2230
                case [Point(0, y1), Point(0, y2)]:
2231
                    return f"Two on the Y axis at {y1}, {y2}"
2232
                case _:
2233
                    return "Something else"
2234
        self.assertEqual(whereis([]), "No points")
2235
        self.assertEqual(whereis([Point(0, 0)]), "The origin")
2236
        self.assertEqual(whereis([Point(0, 1)]), "Single point 0, 1")
2237
        self.assertEqual(whereis([Point(0, 0), Point(0, 0)]), "Two on the Y axis at 0, 0")
2238
        self.assertEqual(whereis([Point(0, 1), Point(0, 1)]), "Two on the Y axis at 1, 1")
2239
        self.assertEqual(whereis([Point(0, 0), Point(1, 0)]), "Something else")
2240
        self.assertEqual(whereis([Point(0, 0), Point(0, 0), Point(0, 0)]), "Something else")
2241
        self.assertEqual(whereis([Point(0, 1), Point(0, 1), Point(0, 1)]), "Something else")
2242

2243
    def test_patma_183(self):
2244
        return  # disabled
2245
        def whereis(point):
2246
            match point:
2247
                case Point(x, y) if x == y:
2248
                    return f"Y=X at {x}"
2249
                case Point(x, y):
2250
                    return "Not on the diagonal"
2251
        self.assertEqual(whereis(Point(0, 0)), "Y=X at 0")
2252
        self.assertEqual(whereis(Point(0, False)), "Y=X at 0")
2253
        self.assertEqual(whereis(Point(False, 0)), "Y=X at False")
2254
        self.assertEqual(whereis(Point(-1 - 1j, -1 - 1j)), "Y=X at (-1-1j)")
2255
        self.assertEqual(whereis(Point("X", "X")), "Y=X at X")
2256
        self.assertEqual(whereis(Point("X", "x")), "Not on the diagonal")
2257

2258
    def test_patma_184(self):
2259
        return  # disabled
2260
        class Seq(collections.abc.Sequence):
2261
            __getitem__ = None
2262
            def __len__(self):
2263
                return 0
2264
        match Seq():
2265
            case []:
2266
                y = 0
2267
        self.assertEqual(y, 0)
2268

2269
    def test_patma_185(self):
2270
        return  # disabled
2271
        class Seq(collections.abc.Sequence):
2272
            __getitem__ = None
2273
            def __len__(self):
2274
                return 42
2275
        match Seq():
2276
            case [*_]:
2277
                y = 0
2278
        self.assertEqual(y, 0)
2279

2280
    def test_patma_186(self):
2281
        return  # disabled
2282
        class Seq(collections.abc.Sequence):
2283
            def __getitem__(self, i):
2284
                return i
2285
            def __len__(self):
2286
                return 42
2287
        match Seq():
2288
            case [x, *_, y]:
2289
                z = 0
2290
        self.assertEqual(x, 0)
2291
        self.assertEqual(y, 41)
2292
        self.assertEqual(z, 0)
2293

2294
    def test_patma_187(self):
2295
        return  # disabled
2296
        w = range(10)
2297
        match w:
2298
            case [x, y, *rest]:
2299
                z = 0
2300
        self.assertEqual(w, range(10))
2301
        self.assertEqual(x, 0)
2302
        self.assertEqual(y, 1)
2303
        self.assertEqual(z, 0)
2304
        self.assertEqual(rest, list(range(2, 10)))
2305

2306
    def test_patma_188(self):
2307
        return  # disabled
2308
        w = range(100)
2309
        match w:
2310
            case (x, y, *rest):
2311
                z = 0
2312
        self.assertEqual(w, range(100))
2313
        self.assertEqual(x, 0)
2314
        self.assertEqual(y, 1)
2315
        self.assertEqual(z, 0)
2316
        self.assertEqual(rest, list(range(2, 100)))
2317

2318
    def test_patma_189(self):
2319
        return  # disabled
2320
        w = range(1000)
2321
        match w:
2322
            case x, y, *rest:
2323
                z = 0
2324
        self.assertEqual(w, range(1000))
2325
        self.assertEqual(x, 0)
2326
        self.assertEqual(y, 1)
2327
        self.assertEqual(z, 0)
2328
        self.assertEqual(rest, list(range(2, 1000)))
2329

2330
    def test_patma_190(self):
2331
        return  # disabled
2332
        w = range(1 << 10)
2333
        match w:
2334
            case [x, y, *_]:
2335
                z = 0
2336
        self.assertEqual(w, range(1 << 10))
2337
        self.assertEqual(x, 0)
2338
        self.assertEqual(y, 1)
2339
        self.assertEqual(z, 0)
2340

2341
    def test_patma_191(self):
2342
        return  # disabled
2343
        w = range(1 << 20)
2344
        match w:
2345
            case (x, y, *_):
2346
                z = 0
2347
        self.assertEqual(w, range(1 << 20))
2348
        self.assertEqual(x, 0)
2349
        self.assertEqual(y, 1)
2350
        self.assertEqual(z, 0)
2351

2352
    def test_patma_192(self):
2353
        return  # disabled
2354
        w = range(1 << 30)
2355
        match w:
2356
            case x, y, *_:
2357
                z = 0
2358
        self.assertEqual(w, range(1 << 30))
2359
        self.assertEqual(x, 0)
2360
        self.assertEqual(y, 1)
2361
        self.assertEqual(z, 0)
2362

2363
    def test_patma_193(self):
2364
        return  # disabled
2365
        x = {"bandwidth": 0, "latency": 1}
2366
        match x:
2367
            case {"bandwidth": b, "latency": l}:
2368
                y = 0
2369
        self.assertEqual(x, {"bandwidth": 0, "latency": 1})
2370
        self.assertIs(b, x["bandwidth"])
2371
        self.assertIs(l, x["latency"])
2372
        self.assertEqual(y, 0)
2373

2374
    def test_patma_194(self):
2375
        return  # disabled
2376
        x = {"bandwidth": 0, "latency": 1, "key": "value"}
2377
        match x:
2378
            case {"latency": l, "bandwidth": b}:
2379
                y = 0
2380
        self.assertEqual(x, {"bandwidth": 0, "latency": 1, "key": "value"})
2381
        self.assertIs(l, x["latency"])
2382
        self.assertIs(b, x["bandwidth"])
2383
        self.assertEqual(y, 0)
2384

2385
    def test_patma_195(self):
2386
        return  # disabled
2387
        x = {"bandwidth": 0, "latency": 1, "key": "value"}
2388
        match x:
2389
            case {"bandwidth": b, "latency": l, **rest}:
2390
                y = 0
2391
        self.assertEqual(x, {"bandwidth": 0, "latency": 1, "key": "value"})
2392
        self.assertIs(b, x["bandwidth"])
2393
        self.assertIs(l, x["latency"])
2394
        self.assertEqual(rest, {"key": "value"})
2395
        self.assertEqual(y, 0)
2396

2397
    def test_patma_196(self):
2398
        return  # disabled
2399
        x = {"bandwidth": 0, "latency": 1}
2400
        match x:
2401
            case {"latency": l, "bandwidth": b, **rest}:
2402
                y = 0
2403
        self.assertEqual(x, {"bandwidth": 0, "latency": 1})
2404
        self.assertIs(l, x["latency"])
2405
        self.assertIs(b, x["bandwidth"])
2406
        self.assertEqual(rest, {})
2407
        self.assertEqual(y, 0)
2408

2409
    def test_patma_197(self):
2410
        return  # disabled
2411
        w = [Point(-1, 0), Point(1, 2)]
2412
        match w:
2413
            case (Point(x1, y1), Point(x2, y2) as p2):
2414
                z = 0
2415
        self.assertEqual(w, [Point(-1, 0), Point(1, 2)])
2416
        self.assertIs(x1, w[0].x)
2417
        self.assertIs(y1, w[0].y)
2418
        self.assertIs(p2, w[1])
2419
        self.assertIs(x2, w[1].x)
2420
        self.assertIs(y2, w[1].y)
2421
        self.assertIs(z, 0)
2422

2423
    def test_patma_198(self):
2424
        return  # disabled
2425
        class Color(enum.Enum):
2426
            RED = 0
2427
            GREEN = 1
2428
            BLUE = 2
2429
        def f(color):
2430
            match color:
2431
                case Color.RED:
2432
                    return "I see red!"
2433
                case Color.GREEN:
2434
                    return "Grass is green"
2435
                case Color.BLUE:
2436
                    return "I'm feeling the blues :("
2437
        self.assertEqual(f(Color.RED), "I see red!")
2438
        self.assertEqual(f(Color.GREEN), "Grass is green")
2439
        self.assertEqual(f(Color.BLUE), "I'm feeling the blues :(")
2440
        self.assertIs(f(Color), None)
2441
        self.assertIs(f(0), None)
2442
        self.assertIs(f(1), None)
2443
        self.assertIs(f(2), None)
2444
        self.assertIs(f(3), None)
2445
        self.assertIs(f(False), None)
2446
        self.assertIs(f(True), None)
2447
        self.assertIs(f(2+0j), None)
2448
        self.assertIs(f(3.0), None)
2449

2450
    def test_patma_199(self):
2451
        return  # disabled
2452
        class Color(int, enum.Enum):
2453
            RED = 0
2454
            GREEN = 1
2455
            BLUE = 2
2456
        def f(color):
2457
            match color:
2458
                case Color.RED:
2459
                    return "I see red!"
2460
                case Color.GREEN:
2461
                    return "Grass is green"
2462
                case Color.BLUE:
2463
                    return "I'm feeling the blues :("
2464
        self.assertEqual(f(Color.RED), "I see red!")
2465
        self.assertEqual(f(Color.GREEN), "Grass is green")
2466
        self.assertEqual(f(Color.BLUE), "I'm feeling the blues :(")
2467
        self.assertIs(f(Color), None)
2468
        self.assertEqual(f(0), "I see red!")
2469
        self.assertEqual(f(1), "Grass is green")
2470
        self.assertEqual(f(2), "I'm feeling the blues :(")
2471
        self.assertIs(f(3), None)
2472
        self.assertEqual(f(False), "I see red!")
2473
        self.assertEqual(f(True), "Grass is green")
2474
        self.assertEqual(f(2+0j), "I'm feeling the blues :(")
2475
        self.assertIs(f(3.0), None)
2476

2477
    def test_patma_200(self):
2478
        return  # disabled
2479
        class Class:
2480
            __match_args__ = ("a", "b")
2481
        c = Class()
2482
        c.a = 0
2483
        c.b = 1
2484
        match c:
2485
            case Class(x, y):
2486
                z = 0
2487
        self.assertIs(x, c.a)
2488
        self.assertIs(y, c.b)
2489
        self.assertEqual(z, 0)
2490

2491
    def test_patma_201(self):
2492
        return  # disabled
2493
        class Class:
2494
            __match_args__ = ("a", "b")
2495
        c = Class()
2496
        c.a = 0
2497
        c.b = 1
2498
        match c:
2499
            case Class(x, b=y):
2500
                z = 0
2501
        self.assertIs(x, c.a)
2502
        self.assertIs(y, c.b)
2503
        self.assertEqual(z, 0)
2504

2505
    def test_patma_202(self):
2506
        return  # disabled
2507
        class Parent:
2508
            __match_args__ = "a", "b"
2509
        class Child(Parent):
2510
            __match_args__ = ("c", "d")
2511
        c = Child()
2512
        c.a = 0
2513
        c.b = 1
2514
        match c:
2515
            case Parent(x, y):
2516
                z = 0
2517
        self.assertIs(x, c.a)
2518
        self.assertIs(y, c.b)
2519
        self.assertEqual(z, 0)
2520

2521
    def test_patma_203(self):
2522
        return  # disabled
2523
        class Parent:
2524
            __match_args__ = ("a", "b")
2525
        class Child(Parent):
2526
            __match_args__ = "c", "d"
2527
        c = Child()
2528
        c.a = 0
2529
        c.b = 1
2530
        match c:
2531
            case Parent(x, b=y):
2532
                z = 0
2533
        self.assertIs(x, c.a)
2534
        self.assertIs(y, c.b)
2535
        self.assertEqual(z, 0)
2536

2537
    def test_patma_204(self):
2538
        return  # disabled
2539
        def f(w):
2540
            match w:
2541
                case 42:
2542
                    out = locals()
2543
                    del out["w"]
2544
                    return out
2545
        self.assertEqual(f(42), {})
2546
        self.assertIs(f(0), None)
2547
        self.assertEqual(f(42.0), {})
2548
        self.assertIs(f("42"), None)
2549

2550
    def test_patma_205(self):
2551
        return  # disabled
2552
        def f(w):
2553
            match w:
2554
                case 42.0:
2555
                    out = locals()
2556
                    del out["w"]
2557
                    return out
2558
        self.assertEqual(f(42.0), {})
2559
        self.assertEqual(f(42), {})
2560
        self.assertIs(f(0.0), None)
2561
        self.assertIs(f(0), None)
2562

2563
    def test_patma_206(self):
2564
        return  # disabled
2565
        def f(w):
2566
            match w:
2567
                case 1 | 2 | 3:
2568
                    out = locals()
2569
                    del out["w"]
2570
                    return out
2571
        self.assertEqual(f(1), {})
2572
        self.assertEqual(f(2), {})
2573
        self.assertEqual(f(3), {})
2574
        self.assertEqual(f(3.0), {})
2575
        self.assertIs(f(0), None)
2576
        self.assertIs(f(4), None)
2577
        self.assertIs(f("1"), None)
2578

2579
    def test_patma_207(self):
2580
        return  # disabled
2581
        def f(w):
2582
            match w:
2583
                case [1, 2] | [3, 4]:
2584
                    out = locals()
2585
                    del out["w"]
2586
                    return out
2587
        self.assertEqual(f([1, 2]), {})
2588
        self.assertEqual(f([3, 4]), {})
2589
        self.assertIs(f(42), None)
2590
        self.assertIs(f([2, 3]), None)
2591
        self.assertIs(f([1, 2, 3]), None)
2592
        self.assertEqual(f([1, 2.0]), {})
2593

2594
    def test_patma_208(self):
2595
        return  # disabled
2596
        def f(w):
2597
            match w:
2598
                case x:
2599
                    out = locals()
2600
                    del out["w"]
2601
                    return out
2602
        self.assertEqual(f(42), {"x": 42})
2603
        self.assertEqual(f((1, 2)), {"x": (1, 2)})
2604
        self.assertEqual(f(None), {"x": None})
2605

2606
    def test_patma_209(self):
2607
        return  # disabled
2608
        def f(w):
2609
            match w:
2610
                case _:
2611
                    out = locals()
2612
                    del out["w"]
2613
                    return out
2614
        self.assertEqual(f(42), {})
2615
        self.assertEqual(f(None), {})
2616
        self.assertEqual(f((1, 2)), {})
2617

2618
    def test_patma_210(self):
2619
        return  # disabled
2620
        def f(w):
2621
            match w:
2622
                case (x, y, z):
2623
                    out = locals()
2624
                    del out["w"]
2625
                    return out
2626
        self.assertEqual(f((1, 2, 3)), {"x": 1, "y": 2, "z": 3})
2627
        self.assertIs(f((1, 2)), None)
2628
        self.assertIs(f((1, 2, 3, 4)), None)
2629
        self.assertIs(f(123), None)
2630
        self.assertIs(f("abc"), None)
2631
        self.assertIs(f(b"abc"), None)
2632
        self.assertEqual(f(array.array("b", b"abc")), {'x': 97, 'y': 98, 'z': 99})
2633
        self.assertEqual(f(memoryview(b"abc")), {"x": 97, "y": 98, "z": 99})
2634
        self.assertIs(f(bytearray(b"abc")), None)
2635

2636
    def test_patma_211(self):
2637
        return  # disabled
2638
        def f(w):
2639
            match w:
2640
                case {"x": x, "y": "y", "z": z}:
2641
                    out = locals()
2642
                    del out["w"]
2643
                    return out
2644
        self.assertEqual(f({"x": "x", "y": "y", "z": "z"}), {"x": "x", "z": "z"})
2645
        self.assertEqual(f({"x": "x", "y": "y", "z": "z", "a": "a"}), {"x": "x", "z": "z"})
2646
        self.assertIs(f(({"x": "x", "y": "yy", "z": "z", "a": "a"})), None)
2647
        self.assertIs(f(({"x": "x", "y": "y"})), None)
2648

2649
    def test_patma_212(self):
2650
        return  # disabled
2651
        def f(w):
2652
            match w:
2653
                case Point(int(xx), y="hello"):
2654
                    out = locals()
2655
                    del out["w"]
2656
                    return out
2657
        self.assertEqual(f(Point(42, "hello")), {"xx": 42})
2658

2659
    def test_patma_213(self):
2660
        return  # disabled
2661
        def f(w):
2662
            match w:
2663
                case (p, q) as x:
2664
                    out = locals()
2665
                    del out["w"]
2666
                    return out
2667
        self.assertEqual(f((1, 2)), {"p": 1, "q": 2, "x": (1, 2)})
2668
        self.assertEqual(f([1, 2]), {"p": 1, "q": 2, "x": [1, 2]})
2669
        self.assertIs(f(12), None)
2670
        self.assertIs(f((1, 2, 3)), None)
2671

2672
    def test_patma_214(self):
2673
        return  # disabled
2674
        def f():
2675
            match 42:
2676
                case 42:
2677
                    return locals()
2678
        self.assertEqual(set(f()), set())
2679

2680
    def test_patma_215(self):
2681
        return  # disabled
2682
        def f():
2683
            match 1:
2684
                case 1 | 2 | 3:
2685
                    return locals()
2686
        self.assertEqual(set(f()), set())
2687

2688
    def test_patma_216(self):
2689
        return  # disabled
2690
        def f():
2691
            match ...:
2692
                case _:
2693
                    return locals()
2694
        self.assertEqual(set(f()), set())
2695

2696
    def test_patma_217(self):
2697
        return  # disabled
2698
        def f():
2699
            match ...:
2700
                case abc:
2701
                    return locals()
2702
        self.assertEqual(set(f()), {"abc"})
2703

2704
    def test_patma_218(self):
2705
        return  # disabled
2706
        def f():
2707
            match ..., ...:
2708
                case a, b:
2709
                    return locals()
2710
        self.assertEqual(set(f()), {"a", "b"})
2711

2712
    def test_patma_219(self):
2713
        return  # disabled
2714
        def f():
2715
            match {"k": ..., "l": ...}:
2716
                case {"k": a, "l": b}:
2717
                    return locals()
2718
        self.assertEqual(set(f()), {"a", "b"})
2719

2720
    def test_patma_220(self):
2721
        return  # disabled
2722
        def f():
2723
            match Point(..., ...):
2724
                case Point(x, y=y):
2725
                    return locals()
2726
        self.assertEqual(set(f()), {"x", "y"})
2727

2728
    def test_patma_221(self):
2729
        return  # disabled
2730
        def f():
2731
            match ...:
2732
                case b as a:
2733
                    return locals()
2734
        self.assertEqual(set(f()), {"a", "b"})
2735

2736
    def test_patma_222(self):
2737
        return  # disabled
2738
        def f(x):
2739
            match x:
2740
                case _:
2741
                    return 0
2742
        self.assertEqual(f(0), 0)
2743
        self.assertEqual(f(1), 0)
2744
        self.assertEqual(f(2), 0)
2745
        self.assertEqual(f(3), 0)
2746

2747
    def test_patma_223(self):
2748
        return  # disabled
2749
        def f(x):
2750
            match x:
2751
                case 0:
2752
                    return 0
2753
        self.assertEqual(f(0), 0)
2754
        self.assertIs(f(1), None)
2755
        self.assertIs(f(2), None)
2756
        self.assertIs(f(3), None)
2757

2758
    def test_patma_224(self):
2759
        return  # disabled
2760
        def f(x):
2761
            match x:
2762
                case 0:
2763
                    return 0
2764
                case _:
2765
                    return 1
2766
        self.assertEqual(f(0), 0)
2767
        self.assertEqual(f(1), 1)
2768
        self.assertEqual(f(2), 1)
2769
        self.assertEqual(f(3), 1)
2770

2771
    def test_patma_225(self):
2772
        return  # disabled
2773
        def f(x):
2774
            match x:
2775
                case 0:
2776
                    return 0
2777
                case 1:
2778
                    return 1
2779
        self.assertEqual(f(0), 0)
2780
        self.assertEqual(f(1), 1)
2781
        self.assertIs(f(2), None)
2782
        self.assertIs(f(3), None)
2783

2784
    def test_patma_226(self):
2785
        return  # disabled
2786
        def f(x):
2787
            match x:
2788
                case 0:
2789
                    return 0
2790
                case 1:
2791
                    return 1
2792
                case _:
2793
                    return 2
2794
        self.assertEqual(f(0), 0)
2795
        self.assertEqual(f(1), 1)
2796
        self.assertEqual(f(2), 2)
2797
        self.assertEqual(f(3), 2)
2798

2799
    def test_patma_227(self):
2800
        return  # disabled
2801
        def f(x):
2802
            match x:
2803
                case 0:
2804
                    return 0
2805
                case 1:
2806
                    return 1
2807
                case 2:
2808
                    return 2
2809
        self.assertEqual(f(0), 0)
2810
        self.assertEqual(f(1), 1)
2811
        self.assertEqual(f(2), 2)
2812
        self.assertIs(f(3), None)
2813

2814
    def test_patma_228(self):
2815
        return  # disabled
2816
        match():
2817
            case():
2818
                x = 0
2819
        self.assertEqual(x, 0)
2820

2821
    def test_patma_229(self):
2822
        return  # disabled
2823
        x = 0
2824
        match(x):
2825
            case(x):
2826
                y = 0
2827
        self.assertEqual(x, 0)
2828
        self.assertEqual(y, 0)
2829

2830
    def test_patma_230(self):
2831
        return  # disabled
2832
        x = 0
2833
        match x:
2834
            case False:
2835
                y = 0
2836
            case 0:
2837
                y = 1
2838
        self.assertEqual(x, 0)
2839
        self.assertEqual(y, 1)
2840

2841
    def test_patma_231(self):
2842
        return  # disabled
2843
        x = 1
2844
        match x:
2845
            case True:
2846
                y = 0
2847
            case 1:
2848
                y = 1
2849
        self.assertEqual(x, 1)
2850
        self.assertEqual(y, 1)
2851

2852
    def test_patma_232(self):
2853
        return  # disabled
2854
        class Eq:
2855
            def __eq__(self, other):
2856
                return True
2857
        x = eq = Eq()
2858
        y = None
2859
        match x:
2860
            case None:
2861
                y = 0
2862
        self.assertIs(x, eq)
2863
        self.assertEqual(y, None)
2864

2865
    def test_patma_233(self):
2866
        return  # disabled
2867
        x = False
2868
        match x:
2869
            case False:
2870
                y = 0
2871
        self.assertIs(x, False)
2872
        self.assertEqual(y, 0)
2873

2874
    def test_patma_234(self):
2875
        return  # disabled
2876
        x = True
2877
        match x:
2878
            case True:
2879
                y = 0
2880
        self.assertIs(x, True)
2881
        self.assertEqual(y, 0)
2882

2883
    def test_patma_235(self):
2884
        return  # disabled
2885
        x = None
2886
        match x:
2887
            case None:
2888
                y = 0
2889
        self.assertIs(x, None)
2890
        self.assertEqual(y, 0)
2891

2892
    def test_patma_236(self):
2893
        return  # disabled
2894
        x = 0
2895
        match x:
2896
            case (0 as w) as z:
2897
                y = 0
2898
        self.assertEqual(w, 0)
2899
        self.assertEqual(x, 0)
2900
        self.assertEqual(y, 0)
2901
        self.assertEqual(z, 0)
2902

2903
    def test_patma_237(self):
2904
        return  # disabled
2905
        x = 0
2906
        match x:
2907
            case (0 as w) as z:
2908
                y = 0
2909
        self.assertEqual(w, 0)
2910
        self.assertEqual(x, 0)
2911
        self.assertEqual(y, 0)
2912
        self.assertEqual(z, 0)
2913

2914
    def test_patma_238(self):
2915
        return  # disabled
2916
        x = ((0, 1), (2, 3))
2917
        match x:
2918
            case ((a as b, c as d) as e) as w, ((f as g, h) as i) as z:
2919
                y = 0
2920
        self.assertEqual(a, 0)
2921
        self.assertEqual(b, 0)
2922
        self.assertEqual(c, 1)
2923
        self.assertEqual(d, 1)
2924
        self.assertEqual(e, (0, 1))
2925
        self.assertEqual(f, 2)
2926
        self.assertEqual(g, 2)
2927
        self.assertEqual(h, 3)
2928
        self.assertEqual(i, (2, 3))
2929
        self.assertEqual(w, (0, 1))
2930
        self.assertEqual(x, ((0, 1), (2, 3)))
2931
        self.assertEqual(y, 0)
2932
        self.assertEqual(z, (2, 3))
2933

2934
    def test_patma_239(self):
2935
        return  # disabled
2936
        x = collections.UserDict({0: 1, 2: 3})
2937
        match x:
2938
            case {2: 3}:
2939
                y = 0
2940
        self.assertEqual(x, {0: 1, 2: 3})
2941
        self.assertEqual(y, 0)
2942

2943
    def test_patma_240(self):
2944
        return  # disabled
2945
        x = collections.UserDict({0: 1, 2: 3})
2946
        match x:
2947
            case {2: 3, **z}:
2948
                y = 0
2949
        self.assertEqual(x, {0: 1, 2: 3})
2950
        self.assertEqual(y, 0)
2951
        self.assertEqual(z, {0: 1})
2952

2953
    def test_patma_241(self):
2954
        return  # disabled
2955
        x = [[{0: 0}]]
2956
        match x:
2957
            case list([({-0-0j: int(real=0+0j, imag=0-0j) | (1) as z},)]):
2958
                y = 0
2959
        self.assertEqual(x, [[{0: 0}]])
2960
        self.assertEqual(y, 0)
2961
        self.assertEqual(z, 0)
2962

2963
    def test_patma_242(self):
2964
        return  # disabled
2965
        x = range(3)
2966
        match x:
2967
            case [y, *_, z]:
2968
                w = 0
2969
        self.assertEqual(w, 0)
2970
        self.assertEqual(x, range(3))
2971
        self.assertEqual(y, 0)
2972
        self.assertEqual(z, 2)
2973

2974
    def test_patma_243(self):
2975
        return  # disabled
2976
        x = range(3)
2977
        match x:
2978
            case [_, *_, y]:
2979
                z = 0
2980
        self.assertEqual(x, range(3))
2981
        self.assertEqual(y, 2)
2982
        self.assertEqual(z, 0)
2983

2984
    def test_patma_244(self):
2985
        return  # disabled
2986
        x = range(3)
2987
        match x:
2988
            case [*_, y]:
2989
                z = 0
2990
        self.assertEqual(x, range(3))
2991
        self.assertEqual(y, 2)
2992
        self.assertEqual(z, 0)
2993

2994
    def test_patma_245(self):
2995
        return  # disabled
2996
        x = {"y": 1}
2997
        match x:
2998
            case {"y": (0 as y) | (1 as y)}:
2999
                z = 0
3000
        self.assertEqual(x, {"y": 1})
3001
        self.assertEqual(y, 1)
3002
        self.assertEqual(z, 0)
3003

3004
    def test_patma_246(self):
3005
        return  # disabled
3006
        def f(x):
3007
            match x:
3008
                case ((a, b, c, d, e, f, g, h, i, 9) |
3009
                      (h, g, i, a, b, d, e, c, f, 10) |
3010
                      (g, b, a, c, d, -5, e, h, i, f) |
3011
                      (-1, d, f, b, g, e, i, a, h, c)):
3012
                    w = 0
3013
            out = locals()
3014
            del out["x"]
3015
            return out
3016
        alts = [
3017
            dict(a=0, b=1, c=2, d=3, e=4, f=5, g=6, h=7, i=8, w=0),
3018
            dict(h=1, g=2, i=3, a=4, b=5, d=6, e=7, c=8, f=9, w=0),
3019
            dict(g=0, b=-1, a=-2, c=-3, d=-4, e=-6, h=-7, i=-8, f=-9, w=0),
3020
            dict(d=-2, f=-3, b=-4, g=-5, e=-6, i=-7, a=-8, h=-9, c=-10, w=0),
3021
            dict(),
3022
        ]
3023
        self.assertEqual(f(range(10)), alts[0])
3024
        self.assertEqual(f(range(1, 11)), alts[1])
3025
        self.assertEqual(f(range(0, -10, -1)), alts[2])
3026
        self.assertEqual(f(range(-1, -11, -1)), alts[3])
3027
        self.assertEqual(f(range(10, 20)), alts[4])
3028

3029
    def test_patma_247(self):
3030
        return  # disabled
3031
        def f(x):
3032
            match x:
3033
                case [y, (a, b, c, d, e, f, g, h, i, 9) |
3034
                         (h, g, i, a, b, d, e, c, f, 10) |
3035
                         (g, b, a, c, d, -5, e, h, i, f) |
3036
                         (-1, d, f, b, g, e, i, a, h, c), z]:
3037
                    w = 0
3038
            out = locals()
3039
            del out["x"]
3040
            return out
3041
        alts = [
3042
            dict(a=0, b=1, c=2, d=3, e=4, f=5, g=6, h=7, i=8, w=0, y=False, z=True),
3043
            dict(h=1, g=2, i=3, a=4, b=5, d=6, e=7, c=8, f=9, w=0, y=False, z=True),
3044
            dict(g=0, b=-1, a=-2, c=-3, d=-4, e=-6, h=-7, i=-8, f=-9, w=0, y=False, z=True),
3045
            dict(d=-2, f=-3, b=-4, g=-5, e=-6, i=-7, a=-8, h=-9, c=-10, w=0, y=False, z=True),
3046
            dict(),
3047
        ]
3048
        self.assertEqual(f((False, range(10), True)), alts[0])
3049
        self.assertEqual(f((False, range(1, 11), True)), alts[1])
3050
        self.assertEqual(f((False, range(0, -10, -1), True)), alts[2])
3051
        self.assertEqual(f((False, range(-1, -11, -1), True)), alts[3])
3052
        self.assertEqual(f((False, range(10, 20), True)), alts[4])
3053

3054
    def test_patma_248(self):
3055
        return  # disabled
3056
        class C(dict):
3057
            @staticmethod
3058
            def get(key, default=None):
3059
                return 'bar'
3060

3061
        x = C({'foo': 'bar'})
3062
        match x:
3063
            case {'foo': bar}:
3064
                y = bar
3065

3066
        self.assertEqual(y, 'bar')
3067

3068
    def test_patma_249(self):
3069
        return  # disabled
3070
        class C:
3071
            __attr = "eggs"  # mangled to _C__attr
3072
            _Outer__attr = "bacon"
3073
        class Outer:
3074
            def f(self, x):
3075
                match x:
3076
                    # looks up __attr, not _C__attr or _Outer__attr
3077
                    case C(__attr=y):
3078
                        return y
3079
        c = C()
3080
        setattr(c, "__attr", "spam")  # setattr is needed because we're in a class scope
3081
        self.assertEqual(Outer().f(c), "spam")
3082

3083

3084
class TestSyntaxErrors(unittest.TestCase):
3085

3086
    def assert_syntax_error(self, code: str):
3087
        with self.assertRaises(SyntaxError):
3088
            compile(inspect.cleandoc(code), "<test>", "exec")
3089

3090
    def test_alternative_patterns_bind_different_names_0(self):
3091
        self.assert_syntax_error("""
3092
        match ...:
3093
            case "a" | a:
3094
                pass
3095
        """)
3096

3097
    def test_alternative_patterns_bind_different_names_1(self):
3098
        self.assert_syntax_error("""
3099
        match ...:
3100
            case [a, [b] | [c] | [d]]:
3101
                pass
3102
        """)
3103

3104

3105
    @disable  # validation will be added when class patterns are added
3106
    def test_attribute_name_repeated_in_class_pattern(self):
3107
        self.assert_syntax_error("""
3108
        match ...:
3109
            case Class(a=_, a=_):
3110
                pass
3111
        """)
3112

3113
    def test_imaginary_number_required_in_complex_literal_0(self):
3114
        self.assert_syntax_error("""
3115
        match ...:
3116
            case 0+0:
3117
                pass
3118
        """)
3119

3120
    def test_imaginary_number_required_in_complex_literal_1(self):
3121
        self.assert_syntax_error("""
3122
        match ...:
3123
            case {0+0: _}:
3124
                pass
3125
        """)
3126

3127
    def test_invalid_syntax_0(self):
3128
        self.assert_syntax_error("""
3129
        match ...:
3130
            case {**rest, "key": value}:
3131
                pass
3132
        """)
3133

3134
    def test_invalid_syntax_1(self):
3135
        self.assert_syntax_error("""
3136
        match ...:
3137
            case {"first": first, **rest, "last": last}:
3138
                pass
3139
        """)
3140

3141
    def test_invalid_syntax_2(self):
3142
        self.assert_syntax_error("""
3143
        match ...:
3144
            case {**_}:
3145
                pass
3146
        """)
3147

3148
    def test_invalid_syntax_3(self):
3149
        self.assert_syntax_error("""
3150
        match ...:
3151
            case 42 as _:
3152
                pass
3153
        """)
3154

3155
    def test_mapping_pattern_keys_may_only_match_literals_and_attribute_lookups(self):
3156
        self.assert_syntax_error("""
3157
        match ...:
3158
            case {f"": _}:
3159
                pass
3160
        """)
3161

3162
    def test_multiple_assignments_to_name_in_pattern_0(self):
3163
        self.assert_syntax_error("""
3164
        match ...:
3165
            case a, a:
3166
                pass
3167
        """)
3168

3169
    def test_multiple_assignments_to_name_in_pattern_1(self):
3170
        self.assert_syntax_error("""
3171
        match ...:
3172
            case {"k": a, "l": a}:
3173
                pass
3174
        """)
3175

3176
    def test_multiple_assignments_to_name_in_pattern_2(self):
3177
        self.assert_syntax_error("""
3178
        match ...:
3179
            case MyClass(x, x):
3180
                pass
3181
        """)
3182

3183
    def test_multiple_assignments_to_name_in_pattern_3(self):
3184
        self.assert_syntax_error("""
3185
        match ...:
3186
            case MyClass(x=x, y=x):
3187
                pass
3188
        """)
3189

3190
    def test_multiple_assignments_to_name_in_pattern_4(self):
3191
        self.assert_syntax_error("""
3192
        match ...:
3193
            case MyClass(x, y=x):
3194
                pass
3195
        """)
3196

3197
    def test_multiple_assignments_to_name_in_pattern_5(self):
3198
        self.assert_syntax_error("""
3199
        match ...:
3200
            case a as a:
3201
                pass
3202
        """)
3203

3204
    @disable  # will be implemented as part of sequence patterns
3205
    def test_multiple_starred_names_in_sequence_pattern_0(self):
3206
        self.assert_syntax_error("""
3207
        match ...:
3208
            case *a, b, *c, d, *e:
3209
                pass
3210
        """)
3211

3212
    @disable  # will be implemented as part of sequence patterns
3213
    def test_multiple_starred_names_in_sequence_pattern_1(self):
3214
        self.assert_syntax_error("""
3215
        match ...:
3216
            case a, *b, c, *d, e:
3217
                pass
3218
        """)
3219

3220
    def test_name_capture_makes_remaining_patterns_unreachable_0(self):
3221
        self.assert_syntax_error("""
3222
        match ...:
3223
            case a | "a":
3224
                pass
3225
        """)
3226

3227
    def test_name_capture_makes_remaining_patterns_unreachable_1(self):
3228
        self.assert_syntax_error("""
3229
        match 42:
3230
            case x:
3231
                pass
3232
            case y:
3233
                pass
3234
        """)
3235

3236
    def test_name_capture_makes_remaining_patterns_unreachable_2(self):
3237
        self.assert_syntax_error("""
3238
        match ...:
3239
            case x | [_ as x] if x:
3240
                pass
3241
        """)
3242

3243
    def test_name_capture_makes_remaining_patterns_unreachable_3(self):
3244
        self.assert_syntax_error("""
3245
        match ...:
3246
            case x:
3247
                pass
3248
            case [x] if x:
3249
                pass
3250
        """)
3251

3252
    def test_name_capture_makes_remaining_patterns_unreachable_4(self):
3253
        self.assert_syntax_error("""
3254
        match ...:
3255
            case x:
3256
                pass
3257
            case _:
3258
                pass
3259
        """)
3260

3261
    def test_patterns_may_only_match_literals_and_attribute_lookups_0(self):
3262
        self.assert_syntax_error("""
3263
        match ...:
3264
            case f"":
3265
                pass
3266
        """)
3267

3268
    def test_patterns_may_only_match_literals_and_attribute_lookups_1(self):
3269
        self.assert_syntax_error("""
3270
        match ...:
3271
            case f"{x}":
3272
                pass
3273
        """)
3274

3275
    def test_real_number_required_in_complex_literal_0(self):
3276
        self.assert_syntax_error("""
3277
        match ...:
3278
            case 0j+0:
3279
                pass
3280
        """)
3281

3282
    def test_real_number_required_in_complex_literal_1(self):
3283
        self.assert_syntax_error("""
3284
        match ...:
3285
            case 0j+0j:
3286
                pass
3287
        """)
3288

3289
    def test_real_number_required_in_complex_literal_2(self):
3290
        self.assert_syntax_error("""
3291
        match ...:
3292
            case {0j+0: _}:
3293
                pass
3294
        """)
3295

3296
    def test_real_number_required_in_complex_literal_3(self):
3297
        self.assert_syntax_error("""
3298
        match ...:
3299
            case {0j+0j: _}:
3300
                pass
3301
        """)
3302

3303
    def test_wildcard_makes_remaining_patterns_unreachable_0(self):
3304
        self.assert_syntax_error("""
3305
        match ...:
3306
            case _ | _:
3307
                pass
3308
        """)
3309

3310
    def test_wildcard_makes_remaining_patterns_unreachable_1(self):
3311
        self.assert_syntax_error("""
3312
        match ...:
3313
            case (_ as x) | [x]:
3314
                pass
3315
        """)
3316

3317
    def test_wildcard_makes_remaining_patterns_unreachable_2(self):
3318
        self.assert_syntax_error("""
3319
        match ...:
3320
            case _ | _ if condition():
3321
                pass
3322
        """)
3323

3324
    def test_wildcard_makes_remaining_patterns_unreachable_3(self):
3325
        self.assert_syntax_error("""
3326
        match ...:
3327
            case _:
3328
                pass
3329
            case None:
3330
                pass
3331
        """)
3332

3333
    def test_wildcard_makes_remaining_patterns_unreachable_4(self):
3334
        self.assert_syntax_error("""
3335
        match ...:
3336
            case (None | _) | _:
3337
                pass
3338
        """)
3339

3340
    def test_wildcard_makes_remaining_patterns_unreachable_5(self):
3341
        self.assert_syntax_error("""
3342
        match ...:
3343
            case _ | (True | False):
3344
                pass
3345
        """)
3346

3347
    @disable  # validation will be added when class patterns are added
3348
    def test_mapping_pattern_duplicate_key(self):
3349
        self.assert_syntax_error("""
3350
        match ...:
3351
            case {"a": _, "a": _}:
3352
                pass
3353
        """)
3354

3355
    @disable  # validation will be added when class patterns are added
3356
    def test_mapping_pattern_duplicate_key_edge_case0(self):
3357
        self.assert_syntax_error("""
3358
        match ...:
3359
            case {0: _, False: _}:
3360
                pass
3361
        """)
3362

3363
    @disable  # validation will be added when class patterns are added
3364
    def test_mapping_pattern_duplicate_key_edge_case1(self):
3365
        self.assert_syntax_error("""
3366
        match ...:
3367
            case {0: _, 0.0: _}:
3368
                pass
3369
        """)
3370

3371
    @disable  # validation will be added when class patterns are added
3372
    def test_mapping_pattern_duplicate_key_edge_case2(self):
3373
        self.assert_syntax_error("""
3374
        match ...:
3375
            case {0: _, -0: _}:
3376
                pass
3377
        """)
3378

3379
    @disable  # validation will be added when class patterns are added
3380
    def test_mapping_pattern_duplicate_key_edge_case3(self):
3381
        self.assert_syntax_error("""
3382
        match ...:
3383
            case {0: _, 0j: _}:
3384
                pass
3385
        """)
3386

3387
class TestTypeErrors(unittest.TestCase):
3388

3389
    def test_accepts_positional_subpatterns_0(self):
3390
        return  # disabled
3391
        class Class:
3392
            __match_args__ = ()
3393
        x = Class()
3394
        y = z = None
3395
        with self.assertRaises(TypeError):
3396
            match x:
3397
                case Class(y):
3398
                    z = 0
3399
        self.assertIs(y, None)
3400
        self.assertIs(z, None)
3401

3402
    def test_accepts_positional_subpatterns_1(self):
3403
        return  # disabled
3404
        x = range(10)
3405
        y = None
3406
        with self.assertRaises(TypeError):
3407
            match x:
3408
                case range(10):
3409
                    y = 0
3410
        self.assertEqual(x, range(10))
3411
        self.assertIs(y, None)
3412

3413
    def test_got_multiple_subpatterns_for_attribute_0(self):
3414
        return  # disabled
3415
        class Class:
3416
            __match_args__ = ("a", "a")
3417
            a = None
3418
        x = Class()
3419
        w = y = z = None
3420
        with self.assertRaises(TypeError):
3421
            match x:
3422
                case Class(y, z):
3423
                    w = 0
3424
        self.assertIs(w, None)
3425
        self.assertIs(y, None)
3426
        self.assertIs(z, None)
3427

3428
    def test_got_multiple_subpatterns_for_attribute_1(self):
3429
        return  # disabled
3430
        class Class:
3431
            __match_args__ = ("a",)
3432
            a = None
3433
        x = Class()
3434
        w = y = z = None
3435
        with self.assertRaises(TypeError):
3436
            match x:
3437
                case Class(y, a=z):
3438
                    w = 0
3439
        self.assertIs(w, None)
3440
        self.assertIs(y, None)
3441
        self.assertIs(z, None)
3442

3443
    def test_match_args_elements_must_be_strings(self):
3444
        return  # disabled
3445
        class Class:
3446
            __match_args__ = (None,)
3447
        x = Class()
3448
        y = z = None
3449
        with self.assertRaises(TypeError):
3450
            match x:
3451
                case Class(y):
3452
                    z = 0
3453
        self.assertIs(y, None)
3454
        self.assertIs(z, None)
3455

3456
    def test_match_args_must_be_a_tuple_0(self):
3457
        return  # disabled
3458
        class Class:
3459
            __match_args__ = None
3460
        x = Class()
3461
        y = z = None
3462
        with self.assertRaises(TypeError):
3463
            match x:
3464
                case Class(y):
3465
                    z = 0
3466
        self.assertIs(y, None)
3467
        self.assertIs(z, None)
3468

3469
    def test_match_args_must_be_a_tuple_1(self):
3470
        return  # disabled
3471
        class Class:
3472
            __match_args__ = "XYZ"
3473
        x = Class()
3474
        y = z = None
3475
        with self.assertRaises(TypeError):
3476
            match x:
3477
                case Class(y):
3478
                    z = 0
3479
        self.assertIs(y, None)
3480
        self.assertIs(z, None)
3481

3482
    def test_match_args_must_be_a_tuple_2(self):
3483
        return  # disabled
3484
        class Class:
3485
            __match_args__ = ["spam", "eggs"]
3486
            spam = 0
3487
            eggs = 1
3488
        x = Class()
3489
        w = y = z = None
3490
        with self.assertRaises(TypeError):
3491
            match x:
3492
                case Class(y, z):
3493
                    w = 0
3494
        self.assertIs(w, None)
3495
        self.assertIs(y, None)
3496
        self.assertIs(z, None)
3497

3498

3499
class TestValueErrors(unittest.TestCase):
3500

3501
    def test_mapping_pattern_checks_duplicate_key_1(self):
3502
        return  # disabled
3503
        class Keys:
3504
            KEY = "a"
3505
        x = {"a": 0, "b": 1}
3506
        w = y = z = None
3507
        with self.assertRaises(ValueError):
3508
            match x:
3509
                case {Keys.KEY: y, "a": z}:
3510
                    w = 0
3511
        self.assertIs(w, None)
3512
        self.assertIs(y, None)
3513
        self.assertIs(z, None)
3514

3515

3516
def run_pyperf():
3517
    import pyperf
3518

3519

3520
    class PerfPatma(TestPatma):
3521

3522
        def assertEqual(*_, **__):
3523
            pass
3524

3525
        def assertIs(*_, **__):
3526
            pass
3527

3528
        def assertRaises(*_, **__):
3529
            assert False, "this test should be a method of a different class!"
3530

3531
        def run_perf(self, count):
3532
            tests = []
3533
            for attr in vars(TestPatma):
3534
                if attr.startswith("test_"):
3535
                    tests.append(getattr(self, attr))
3536
            tests *= count
3537
            start = pyperf.perf_counter()
3538
            for test in tests:
3539
                test()
3540
            return pyperf.perf_counter() - start
3541

3542

3543
    runner = pyperf.Runner()
3544
    runner.bench_time_func("patma", PerfPatma().run_perf)
3545

3546

3547
if __name__ == "__main__":
3548
    """
3549
    # From inside environment using this Python, with pyperf installed:
3550
    sudo $(which pyperf) system tune && \
3551
         $(which python) -m test.test_patma --rigorous; \
3552
    sudo $(which pyperf) system reset
3553
    """
3554
    run_pyperf()
3555