8000 Switch other tests to use @all_pickle_protocols too · mrahtz/cpython@de68232 · GitHub
[go: up one dir, main page]
Skip to content

Commit de68232

Browse files
mrahtzmrahtz
committed
Switch other tests to use @all_pickle_protocols too
1 parent f234214 commit de68232

File tree

1 file changed

+97
-97
lines changed

1 file changed

+97
-97
lines changed

‎Lib/test/test_typing.py

Lines changed: 97 additions & 97 deletions
Original file line numberDiff line numberDiff line change
@@ -1235,15 +1235,15 @@ def test_weakref(self):
12351235
alias = Callable[[int, str], float]
12361236
self.assertEqual(weakref.ref(alias)(), alias)
12371237

1238-
def test_pickle(self):
1238+
@all_pickle_protocols
1239+
def test_pickle(self, proto):
12391240
Callable = self.Callable
12401241
alias = Callable[[int, str], float]
1241-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1242-
s = pickle.dumps(alias, proto)
1243-
loaded = pickle.loads(s)
1244-
self.assertEqual(alias.__origin__, loaded.__origin__)
1245-
self.assertEqual(alias.__args__, loaded.__args__)
1246-
self.assertEqual(alias.__parameters__, loaded.__parameters__)
1242+
s = pickle.dumps(alias, proto)
1243+
loaded = pickle.loads(s)
1244+
self.assertEqual(alias.__origin__, loaded.__origin__)
1245+
self.assertEqual(alias.__args__, loaded.__args__)
1246+
self.assertEqual(alias.__parameters__, loaded.__parameters__)
12471247

12481248
def test_var_substitution(self):
12491249
Callable = self.Callable
@@ -2218,7 +2218,8 @@ class P(Protocol):
22182218
Alias2 = typing.Union[P, typing.Iterable]
22192219
self.assertEqual(Alias, Alias2)
22202220

2221-
def test_protocols_pickleable(self):
2221+
@all_pickle_protocols
2222+
def test_protocols_pickleable(self, proto):
22222223
global P, CP # pickle wants to reference the class by name
22232224
T = TypeVar('T')
22242225

@@ -2232,20 +2233,20 @@ class CP(P[int]):
22322233
c = CP()
22332234
c.foo = 42
22342235
c.bar = 'abc'
2235-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
2236-
z = pickle.dumps(c, proto)
2237-
x = pickle.loads(z)
2238-
self.assertEqual(x.foo, 42)
2239-
self.assertEqual(x.bar, 'abc')
2240-
self.assertEqual(x.x, 1)
2241-
self.assertEqual(x.__dict__, {'foo': 42, 'bar': 'abc'})
2242-
s = pickle.dumps(P)
2243-
D = pickle.loads(s)
22442236

2245-
class E:
2246-
x = 1
2237+
z = pickle.dumps(c, proto)
2238+
x = pickle.loads(z)
2239+
self.assertEqual(x.foo, 42)
2240+
self.assertEqual(x.bar, 'abc')
2241+
self.assertEqual(x.x, 1)
2242+
self.assertEqual(x.__dict__, {'foo': 42, 'bar': 'abc'})
2243+
s = pickle.dumps(P)
2244+
D = pickle.loads(s)
22472245

2248-
self.assertIsInstance(E(), D)
2246+
class E:
2247+
x = 1
2248+
2249+
self.assertIsInstance(E(), D)
22492250

22502251
def test_supports_int(self):
22512252
self.assertIsSubclass(int, typing.SupportsInt)
@@ -2844,7 +2845,8 @@ def test_all_repr_eq_any(self):
28442845
self.assertNotEqual(repr(base), '')
28452846
self.assertEqual(base, base)
28462847

2847-
def test_pickle(self):
2848+
@all_pickle_protocols
2849+
def test_pickle(self, proto):
28482850
global C # pickle wants to reference the class by name
28492851
T = TypeVar('T')
28502852

@@ -2857,27 +2859,26 @@ class C(B[int]):
28572859
c = C()
28582860
c.foo = 42
28592861
c.bar = 'abc'
2860-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
2861-
z = pickle.dumps(c, proto)
2862-
x = pickle.loads(z)
2863-
self.assertEqual(x.foo, 42)
2864-
self.assertEqual(x.bar, 'abc')
2865-
self.assertEqual(x.__dict__, {'foo': 42, 'bar': 'abc'})
2862+
2863+
z = pickle.dumps(c, proto)
2864+
x = pickle.loads(z)
2865+
self.assertEqual(x.foo, 42)
2866+
self.assertEqual(x.bar, 'abc')
2867+
self.assertEqual(x.__dict__, {'foo': 42, 'bar': 'abc'})
2868+
28662869
samples = [Any, Union, Tuple, Callable, ClassVar,
28672870
Union[int, str], ClassVar[List], Tuple[int, ...], Callable[[str], bytes],
28682871
typing.DefaultDict, typing.FrozenSet[int]]
28692872
for s in samples:
2870-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
2871-
z = pickle.dumps(s, proto)
2872-
x = pickle.loads(z)
2873-
self.assertEqual(s, x)
2873+
z = pickle.dumps(s, proto)
2874+
x = pickle.loads(z)
2875+
self.assertEqual(s, x)
28742876
more_samples = [List, typing.Iterable, typing.Type, List[int],
28752877
typing.Type[typing.Mapping], typing.AbstractSet[Tuple[int, str]]]
28762878
for s in more_samples:
2877-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
2878-
z = pickle.dumps(s, proto)
2879-
x = pickle.loads(z)
2880-
self.assertEqual(s, x)
2879+
z = pickle.dumps(s, proto)
2880+
x = pickle.loads(z)
2881+
self.assertEqual(s, x)
28812882

28822883
def test_copy_and_deepcopy(self):
28832884
T = TypeVar('T')
@@ -2891,7 +2892,8 @@ class Node(Generic[T]): ...
28912892
self.assertEqual(t, copy(t))
28922893
self.assertEqual(t, deepcopy(t))
28932894

2894-
def test_immutability_by_copy_and_pickle(self):
2895+
@all_pickle_protocols
2896+
def test_immutability_by_copy_and_pickle(self, proto):
28952897
# Special forms like Union, Any, etc., generic aliases to containers like List,
28962898
# Mapping, etc., and type variabcles are considered immutable by copy and pickle.
28972899
global TP, TPB, TPV, PP # for pickle
@@ -2905,8 +2907,7 @@ def test_immutability_by_copy_and_pickle(self):
29052907
with self.subTest(thing=X):
29062908
self.assertIs(copy(X), X)
29072909
self.assertIs(deepcopy(X), X)
2908-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
2909-
self.assertIs(pickle.loads(pickle.dumps(X, proto)), X)
2910+
self.assertIs(pickle.loads(pickle.dumps(X, proto)), X)
29102911
del TP, TPB, TPV, PP
29112912

29122913
# Check that local type variables are copyable.
@@ -4977,20 +4978,20 @@ def test_repr(self):
49774978
self.assertEqual(repr(self.UserName),
49784979
f'{__name__}.{self.__class__.__qualname__}.UserName')
49794980

4980-
def test_pickle(self):
4981+
@all_pickle_protocols
4982+
def test_pickle(self, proto):
49814983
UserAge = self.module.NewType('UserAge', float)
4982-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
4983-
with self.subTest(proto=proto):
4984-
pickled = pickle.dumps(UserId, proto)
4985-
loaded = pickle.loads(pickled)
4986-
self.assertIs(loaded, UserId)
49874984

4988-
pickled = pickle.dumps(self.UserName, proto)
4989-
loaded = pickle.loads(pickled)
4990-
self.assertIs(loaded, self.UserName)
4985+
pickled = pickle.dumps(UserId, proto)
4986+
loaded = pickle.loads(pickled)
4987+
self.assertIs(loaded, UserId)
4988+
4989+
pickled = pickle.dumps(self.UserName, proto)
4990+
loaded = pickle.loads(pickled)
4991+
self.assertIs(loaded, self.UserName)
49914992

4992-
with self.assertRaises(pickle.PicklingError):
4993-
pickle.dumps(UserAge, proto)
4993+
with self.assertRaises(pickle.PicklingError):
4994+
pickle.dumps(UserAge, proto)
49944995

49954996
def test_missing__name__(self):
49964997
code = ("import typing\n"
@@ -5142,17 +5143,18 @@ def test_namedtuple_errors(self):
51425143
with self.assertRaises(TypeError):
51435144
NamedTuple(typename='Emp', name=str, id=int)
51445145

5145-
def test_copy_and_pickle(self):
5146+
@all_pickle_protocols
5147+
def test_copy_and_pickle(self, proto):
51465148
global Emp # pickle wants to reference the class by name
51475149
Emp = NamedTuple('Emp', [('name', str), ('cool', int)])
51485150
for cls in Emp, CoolEmployee, self.NestedEmployee:
51495151
with self.subTest(cls=cls):
51505152
jane = cls('jane', 37)
5151-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
5152-
z = pickle.dumps(jane, proto)
5153-
jane2 = pickle.loads(z)
5154-
self.assertEqual(jane2, jane)
5155-
self.assertIsInstance(jane2, cls)
5153+
5154+
z = pickle.dumps(jane, proto)
5155+
jane2 = pickle.loads(z)
5156+
self.assertEqual(jane2, jane)
5157+
self.assertIsInstance(jane2, cls)
51565158

51575159
jane2 = copy(jane)
51585160
self.assertEqual(jane2, jane)
@@ -5244,18 +5246,19 @@ def test_py36_class_syntax_usage(self):
52445246
other = LabelPoint2D(x=0, y=1, label='hi')
52455247
self.assertEqual(other['label'], 'hi')
52465248

5247-
def test_pickle(self):
5249+
@all_pickle_protocols
5250+
def test_pickle(self, proto):
52485251
global EmpD # pickle wants to reference the class by name
52495252
EmpD = TypedDict('EmpD', {'name': str, 'id': int})
52505253
jane = EmpD({'name': 'jane', 'id': 37})
5251-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
5252-
z = pickle.dumps(jane, proto)
5253-
jane2 = pickle.loads(z)
5254-
self.assertEqual(jane2, jane)
5255-
self.assertEqual(jane2, {'name': 'jane', 'id': 37})
5256-
ZZ = pickle.dumps(EmpD, proto)
5257-
EmpDnew = pickle.loads(ZZ)
5258-
self.assertEqual(EmpDnew({'name': 'jane', 'id': 37}), jane)
5254+
5255+
z = pickle.dumps(jane, proto)
5256+
jane2 = pickle.loads(z)
5257+
self.assertEqual(jane2, jane)
5258+
self.assertEqual(jane2, {'name': 'jane', 'id': 37})
5259+
ZZ = pickle.dumps(EmpD, proto)
5260+
EmpDnew = pickle.loads(ZZ)
5261+
self.assertEqual(EmpDnew({'name': 'jane', 'id': 37}), jane)
52595262

52605263
def test_optional(self):
52615264
EmpD = TypedDict('EmpD', {'name': str, 'id': int})
@@ -5645,19 +5648,19 @@ def test_too_few_type_args(self):
56455648
with self.assertRaisesRegex(TypeError, 'at least two arguments'):
56465649
Annotated[int]
56475650

5648-
def test_pickle(self):
5651+
@all_pickle_protocols
5652+
def test_pickle(self, proto):
56495653
samples = [typing.Any, typing.Union[int, str],
56505654
typing.Optional[str], Tuple[int, ...],
56515655
typing.Callable[[str], bytes]]
56525656

56535657
for t in samples:
56545658
x = Annotated[t, "a"]
56555659

5656-
for prot in range(pickle.HIGHEST_PROTOCOL + 1):
5657-
with self.subTest(protocol=prot, type=t):
5658-
pickled = pickle.dumps(x, prot)
5659-
restored = pickle.loads(pickled)
5660-
self.assertEqual(x, restored)
5660+
with self.subTest(type=t):
5661+
pickled = pickle.dumps(x, proto)
5662+
restored = pickle.loads(pickled)
5663+
self.assertEqual(x, restored)
56615664

56625665
global _Annotated_test_G
56635666

@@ -5668,12 +5671,11 @@ class _Annotated_test_G(Generic[T]):
56685671
G.foo = 42
56695672
G.bar = 'abc'
56705673

5671-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
5672-
z = pickle.dumps(G, proto)
5673-
x = pickle.loads(z)
5674-
self.assertEqual(x.foo, 42)
5675-
self.assertEqual(x.bar, 'abc')
5676-
self.assertEqual(x.x, 1)
5674+
z = pickle.dumps(G, proto)
5675+
x = pickle.loads(z)
5676+
self.assertEqual(x.foo, 42)
5677+
self.assertEqual(x.bar, 'abc')
5678+
self.assertEqual(x.x, 1)
56775679

56785680
def test_subst(self):
56795681
dec = "a decoration"
@@ -6040,7 +6042,8 @@ def test_no_isinstance(self):
60406042

60416043
class SpecialAttrsTests(BaseTestCase):
60426044

6043-
def test_special_attrs(self):
6045+
@all_pickle_protocols
6046+
def test_special_attrs(self, proto):
60446047
cls_to_check = {
60456048
# ABC classes
60466049
typing.AbstractSet: 'AbstractSet',
@@ -6160,14 +6163,15 @@ def test_special_attrs(self):
61606163
self.assertEqual(cls.__name__, name, str(cls))
61616164
self.assertEqual(cls.__qualname__, name, str(cls))
61626165
self.assertEqual(cls.__module__, 'typing', str(cls))
6163-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
6164-
s = pickle.dumps(cls, proto)
6165-
loaded = pickle.loads(s)
6166-
self.assertIs(cls, loaded)
6166+
6167+
s = pickle.dumps(cls, proto)
6168+
loaded = pickle.loads(s)
6169+
self.assertIs(cls, loaded)
61676170

61686171
TypeName = typing.NewType('SpecialAttrsTests.TypeName', Any)
61696172

6170-
def test_special_attrs2(self):
6173+
@all_pickle_protocols
6174+
def test_special_attrs2(self, proto):
61716175
# Forward refs provide a different introspection API. __name__ and
61726176
# __qualname__ make little sense for forward refs as they can store
61736177
# complex typing expressions.
@@ -6176,9 +6180,8 @@ def test_special_attrs2(self):
61766180
self.assertFalse(hasattr(fr, '__qualname__'))
61776181
self.assertEqual(fr.__module__, 'typing')
61786182
# Forward refs are currently unpicklable.
6179-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
6180-
with self.assertRaises(TypeError) as exc:
6181-
pickle.dumps(fr, proto)
6183+
with self.assertRaises(TypeError) as exc:
6184+
pickle.dumps(fr, proto)
61826185

61836186
self.assertEqual(SpecialAttrsTests.TypeName.__name__, 'TypeName')
61846187
self.assertEqual(
@@ -6190,10 +6193,9 @@ def test_special_attrs2(self):
61906193
__name__,
61916194
)
61926195
# NewTypes are picklable assuming correct qualname information.
6193-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
6194-
s = pickle.dumps(SpecialAttrsTests.TypeName, proto)
6195-
loaded = pickle.loads(s)
6196-
self.assertIs(SpecialAttrsTests.TypeName, loaded)
6196+
s = pickle.dumps(SpecialAttrsTests.TypeName)
6197+
loaded = pickle.loads(s)
6198+
self.assertIs(SpecialAttrsTests.TypeName, loaded)
61976199

61986200
# Type variables don't support non-global instantiation per PEP 484
61996201
# restriction that "The argument to TypeVar() must be a string equal
@@ -6203,19 +6205,17 @@ def test_special_attrs2(self):
62036205
self.assertFalse(hasattr(SpecialAttrsT, '__qualname__'))
62046206
self.assertEqual(SpecialAttrsT.__module__, __name__)
62056207
# Module-level type variables are picklable.
6206-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
6207-
s = pickle.dumps(SpecialAttrsT, proto)
6208-
loaded = pickle.loads(s)
6209-
self.assertIs(SpecialAttrsT, loaded)
6208+
s = pickle.dumps(SpecialAttrsT, proto)
6209+
loaded = pickle.loads(s)
6210+
self.assertIs(SpecialAttrsT, loaded)
62106211

62116212
self.assertEqual(SpecialAttrsP.__name__, 'SpecialAttrsP')
62126213
self.assertFalse(hasattr(SpecialAttrsP, '__qualname__'))
62136214
self.assertEqual(SpecialAttrsP.__module__, __name__)
62146215
# Module-level ParamSpecs are picklable.
6215-
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
6216-
s = pickle.dumps(SpecialAttrsP, proto)
6217-
loaded = pickle.loads(s)
6218-
self.assertIs(SpecialAttrsP, loaded)
6216+
s = pickle.dumps(SpecialAttrsP, proto)
6217+
loaded = pickle.loads(s)
6218+
self.assertIs(SpecialAttrsP, loaded)
62196219

62206220
def test_genericalias_dir(self):
62216221
class Foo(Generic[T]):

0 commit comments

Comments
 (0)
0