8000 Updated unit tests to reflect the latest PEP 695 spec. · python/cpython@830b36a · GitHub
[go: up one dir, main page]
Skip to content

Commit 830b36a

Browse files
msfterictrautmsfterictraut
committed
Updated unit tests to reflect the latest PEP 695 spec.
1 parent 9c8cd71 commit 830b36a

File tree

2 files changed

+27
-71
lines changed

2 files changed

+27
-71
lines changed

‎Lib/test/test_type_aliases.py

Lines changed: 5 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -5,26 +5,22 @@
55

66
class TypeParamsInvalidTest(unittest.TestCase):
77
def test_name_collision_01(self):
8-
code = """type TA1[A, A] = None"""
8+
code = """type TA1[A, **A] = None"""
99

1010
with self.assertRaisesRegex(SyntaxError, "duplicate type parameter 'A'"):
1111
exec(code, {}, {})
1212

13-
def test_name_collision_02(self):
13+
def test_name_non_collision_02(self):
1414
code = """type TA1[A] = lambda A: None"""
15+
exec(code, {}, {})
1516

16-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter 'A'"):
17-
exec(code, {}, {})
18-
19-
def test_name_collision_03(self):
17+
def test_name_non_collision_03(self):
2018
code = textwrap.dedent("""\
2119
class Outer[A]:
2220
type TA1[A] = None
2321
"""
2422
)
25-
26-
with self.assertRaisesRegex(SyntaxError, "duplicate type parameter 'A'"):
27-
exec(code, {}, {})
23+
exec(code, {}, {})
2824

2925

3026
class TypeParamsAccessTest(unittest.TestCase):
@@ -33,15 +29,13 @@ def test_alias_access_01(self):
3329
type TA1[A, B] = dict[A, B]
3430
"""
3531
)
36-
3732
exec(code, {}, {})
3833

3934
def test_alias_access_02(self):
4035
code = textwrap.dedent("""\
4136
type TA1[A, B] = TA1[A, B] | int
4237
"""
4338
)
44-
4539
exec(code, {}, {})
4640

4741
def test_alias_access_03(self):
@@ -51,7 +45,6 @@ def inner[B](self):
5145
type TA1[C] = TA1[A, B] | int
5246
"""
5347
)
54-
5548
exec(code, {}, {})
5649

5750

‎Lib/test/test_type_params.py

Lines changed: 22 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -6,130 +6,97 @@
66

77
class TypeParamsInvalidTest(unittest.TestCase):
88
def test_name_collision_01(self):
9-
code = """def func[A, A](): ..."""
10-
9+
code = """def func[**A, A](): ..."""
1110
with self.assertRaisesRegex(SyntaxError, "duplicate type parameter 'A'"):
1211
exec(code, {}, {})
1312

14-
def test_name_collision_02(self):
13+
def test_name_non_collision_02(self):
1514
code = """def func[A](A): ..."""
15+
exec(code, {}, {})
1616

17-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter 'A'"):
18-
exec(code, {}, {})
19-
20-
def test_name_collision_03(self):
17+
def test_name_non_collision_03(self):
2118
code = """def func[A](*A): ..."""
19+
exec(code, {}, {})
2220

23-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter 'A'"):
24-
exec(code, {}, {})
25-
26-
def test_name_collision_04(self):
21+
def test_name_non_collision_04(self):
2722
# Mangled names should not cause a conflict.
2823
code = textwrap.dedent("""\
2924
class ClassA:
3025
def func[__A](self, __A): ...
3126
"""
3227
)
33-
3428
exec(code, {}, {})
3529

36-
def test_name_collision_05(self):
30+
def test_name_non_collision_05(self):
3731
code = textwrap.dedent("""\
3832
class ClassA:
3933
def func[_ClassA__A](self, __A): ...
4034
"""
4135
)
36+
exec(code, {}, {})
4237

43-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter '__A'"):
44-
exec(code, {}, {})
45-
46-
def test_name_collision_06(self):
38+
def test_name_non_collision_06(self):
4739
code = textwrap.dedent("""\
4840
class ClassA[X]:
4941
def func(self, X): ...
5042
"""
5143
)
44+
exec(code, {}, {})
5245

53-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter 'X'"):
54-
exec(code, {}, {})
55-
56-
def test_name_collision_07(self):
46+
def test_name_non_collision_07(self):
5747
code = textwrap.dedent("""\
5848
class ClassA[X]:
5949
def func(self):
6050
X = 1
6151
"""
6252
)
53+
exec(code, {}, {})
6354

64-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter 'X'"):
65-
exec(code, {}, {})
66-
67-
def test_name_collision_08(self):
55+
def test_name_non_collision_08(self):
6856
code = textwrap.dedent("""\
6957
class ClassA[X]:
7058
def func(self):
7159
a = [X for X in []]
7260
"""
7361
)
62+
exec(code, {}, {})
7463

75-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter 'X'"):
76-
exec(code, {}, {})
77-
78-
def test_name_collision_09(self):
79-
code = textwrap.dedent("""\
80-
class ClassA[X]:
81-
def func(self):
82-
a = lambda X: None
83-
"""
84-
)
85-
86-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter 'X'"):
87-
exec(code, {}, {})
88-
89-
def test_name_collision_10(self):
64+
def test_name_non_collision_9(self):
9065
code = textwrap.dedent("""\
9166
class ClassA[X]:
9267
def func[X](self):
9368
...
9469
"""
9570
)
71+
exec(code, {}, {})
9672

97-
with self.assertRaisesRegex(SyntaxError, "duplicate type parameter 'X'"):
98-
exec(code, {}, {})
99-
100-
def test_name_collision_11(self):
73+
def test_name_non_collision_10(self):
10174
code = textwrap.dedent("""\
10275
class ClassA[X]:
10376
X: int
10477
"""
10578
)
79+
exec(code, {}, {})
10680

107-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter 'X'"):
108-
exec(code, {}, {})
109-
110-
def test_name_collision_12(self):
81+
def test_name_non_collision_11(self):
11182
code = textwrap.dedent("""\
11283
def outer():
11384
X = 1
11485
def inner[X]():
11586
nonlocal X
11687
"""
11788
)
89+
exec(code, {}, {})
11890

119-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter 'X'"):
120-
exec(code, {}, {})
121-
122-
def test_name_collision_13(self):
91+
def test_name_non_collision_13(self):
12392
code = textwrap.dedent("""\
12493
X = 1
12594
def outer():
12695
def inner[X]():
12796
global X
12897
"""
12998
)
130-
131-
with self.assertRaisesRegex(SyntaxError, "cannot overwrite type parameter 'X'"):
132-
exec(code, {}, {})
99+
exec(code, {}, {})
133100

134101

135102
class TypeParamsAccessTest(unittest.TestCase):
@@ -139,7 +106,6 @@ class ClassA[A, B](dict[A, B]):
139106
...
140107
"""
141108
)
142-
143109
exec(code, {}, {})
144110

145111
def test_class_access_02(self):
@@ -149,7 +115,6 @@ class ClassA[A, B](metaclass=MyMeta[A, B]):
149115
...
150116
"""
151117
)
152-
153118
exec(code, {}, {})
154119

155120
def test_class_access_03(self):
@@ -171,7 +136,6 @@ def func[A, B](a: dict[A, B]):
171136
...
172137
"""
173138
)
174-
175139
exec(code, {}, {})
176140

177141
def test_function_access_02(self):
@@ -206,7 +170,6 @@ def funcD[D](self):
206170
lambda : (A, B, C, D)
207171
"""
208172
)
209-
210173
exec(code, {}, {})
211174

212175
def test_out_of_scope_01(self):

0 commit comments

Comments
 (0)
0