Debian Codegraph @

Lib/test/test_structseq.py

raw
1 import copy
2 import gc
3 import os
4 import pickle
5 import re
6 import textwrap
7 import time
8 import unittest
9 from test.support import script_helper
10
11
12 class StructSeqTest(unittest.TestCase):
13
14 def test_tuple(self):
15 t = time.gmtime()
16 self.assertIsInstance(t, tuple)
17 astuple = tuple(t)
18 self.assertEqual(len(t), len(astuple))
19 self.assertEqual(t, astuple)
20
21 # Check that slicing works the same way; at one point, slicing t[i:j] with
22 # 0 < i < j could produce NULLs in the result.
23 for i in range(-len(t), len(t)):
24 self.assertEqual(t[i:], astuple[i:])
25 for j in range(-len(t), len(t)):
26 self.assertEqual(t[i:j], astuple[i:j])
27
28 for j in range(-len(t), len(t)):
29 self.assertEqual(t[:j], astuple[:j])
30
31 self.assertRaises(IndexError, t.__getitem__, -len(t)-1)
32 self.assertRaises(IndexError, t.__getitem__, len(t))
33 for i in range(-len(t), len(t)-1):
34 self.assertEqual(t[i], astuple[i])
35
36 def test_repr(self):
37 t = time.gmtime()
38 self.assertTrue(repr(t))
39 t = time.gmtime(0)
40 self.assertEqual(repr(t),
41 "time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, "
42 "tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)")
43 # os.stat() gives a complicated struct sequence.
44 st = os.stat(__file__)
45 rep = repr(st)
46 self.assertStartsWith(rep, "os.stat_result")
47 self.assertIn("st_mode=", rep)
48 self.assertIn("st_ino=", rep)
49 self.assertIn("st_dev=", rep)
50
51 def test_concat(self):
52 t1 = time.gmtime()
53 t2 = t1 + tuple(t1)
54 for i in range(len(t1)):
55 self.assertEqual(t2[i], t2[i+len(t1)])
56
57 def test_repeat(self):
58 t1 = time.gmtime()
59 t2 = 3 * t1
60 for i in range(len(t1)):
61 self.assertEqual(t2[i], t2[i+len(t1)])
62 self.assertEqual(t2[i], t2[i+2*len(t1)])
63
64 def test_contains(self):
65 t1 = time.gmtime()
66 for item in t1:
67 self.assertIn(item, t1)
68 self.assertNotIn(-42, t1)
69
70 def test_hash(self):
71 t1 = time.gmtime()
72 self.assertEqual(hash(t1), hash(tuple(t1)))
73
74 def test_cmp(self):
75 t1 = time.gmtime()
76 t2 = type(t1)(t1)
77 self.assertEqual(t1, t2)
78 self.assertTrue(not (t1 < t2))
79 self.assertTrue(t1 <= t2)
80 self.assertTrue(not (t1 > t2))
81 self.assertTrue(t1 >= t2)
82 self.assertTrue(not (t1 != t2))
83
84 def test_fields(self):
85 t = time.gmtime()
86 self.assertEqual(len(t), t.n_sequence_fields)
87 self.assertEqual(t.n_unnamed_fields, 0)
88 self.assertEqual(t.n_fields, time._STRUCT_TM_ITEMS)
89
90 def test_constructor(self):
91 t = time.struct_time
92
93 self.assertRaises(TypeError, t)
94 self.assertRaises(TypeError, t, None)
95 self.assertRaises(TypeError, t, "123")
96 self.assertRaises(TypeError, t, "123", dict={})
97 self.assertRaises(TypeError, t, "123456789", dict=None)
98 self.assertRaises(TypeError, t, seq="123456789", dict={})
99
100 self.assertEqual(t("123456789"), tuple("123456789"))
101 self.assertEqual(t("123456789", {}), tuple("123456789"))
102 self.assertEqual(t("123456789", dict={}), tuple("123456789"))
103 self.assertEqual(t(sequence="123456789", dict={}), tuple("123456789"))
104
105 self.assertEqual(t("1234567890"), tuple("123456789"))
106 self.assertEqual(t("1234567890").tm_zone, "0")
107 self.assertEqual(t("123456789", {"tm_zone": "some zone"}), tuple("123456789"))
108 self.assertEqual(t("123456789", {"tm_zone": "some zone"}).tm_zone, "some zone")
109
110 s = "123456789"
111 self.assertEqual("".join(t(s)), s)
112
113 def test_constructor_with_duplicate_fields(self):
114 t = time.struct_time
115
116 error_message = re.escape("got duplicate or unexpected field name(s)")
117 with self.assertRaisesRegex(TypeError, error_message):
118 t("1234567890", dict={"tm_zone": "some zone"})
119 with self.assertRaisesRegex(TypeError, error_message):
120 t("1234567890", dict={"tm_zone": "some zone", "tm_mon": 1})
121 with self.assertRaisesRegex(TypeError, error_message):
122 t("1234567890", dict={"error": 0, "tm_zone": "some zone"})
123 with self.assertRaisesRegex(TypeError, error_message):
124 t("1234567890", dict={"error": 0, "tm_zone": "some zone", "tm_mon": 1})
125
126 def test_constructor_with_duplicate_unnamed_fields(self):
127 assert os.stat_result.n_unnamed_fields > 0
128 n_visible_fields = os.stat_result.n_sequence_fields
129
130 r = os.stat_result(range(n_visible_fields), {'st_atime': -1.0})
131 self.assertEqual(r.st_atime, -1.0)
132 self.assertEqual(r, tuple(range(n_visible_fields)))
133
134 r = os.stat_result((*range(n_visible_fields), -1.0))
135 self.assertEqual(r.st_atime, -1.0)
136 self.assertEqual(r, tuple(range(n_visible_fields)))
137
138 with self.assertRaisesRegex(TypeError,
139 re.escape("got duplicate or unexpected field name(s)")):
140 os.stat_result((*range(n_visible_fields), -1.0), {'st_atime': -1.0})
141
142 def test_constructor_with_unknown_fields(self):
143 t = time.struct_time
144
145 error_message = re.escape("got duplicate or unexpected field name(s)")
146 with self.assertRaisesRegex(TypeError, error_message):
147 t("123456789", dict={"tm_year": 0})
148 with self.assertRaisesRegex(TypeError, error_message):
149 t("123456789", dict={"tm_year": 0, "tm_mon": 1})
150 with self.assertRaisesRegex(TypeError, error_message):
151 t("123456789", dict={"tm_zone": "some zone", "tm_mon": 1})
152 with self.assertRaisesRegex(TypeError, error_message):
153 t("123456789", dict={"tm_zone": "some zone", "error": 0})
154 with self.assertRaisesRegex(TypeError, error_message):
155 t("123456789", dict={"error": 0, "tm_zone": "some zone", "tm_mon": 1})
156 with self.assertRaisesRegex(TypeError, error_message):
157 t("123456789", dict={"error": 0})
158 with self.assertRaisesRegex(TypeError, error_message):
159 t("123456789", dict={"tm_zone": "some zone", "error": 0})
160
161 def test_eviltuple(self):
162 class Exc(Exception):
163 pass
164
165 # Devious code could crash structseqs' constructors
166 class C:
167 def __getitem__(self, i):
168 raise Exc
169 def __len__(self):
170 return 9
171
172 self.assertRaises(Exc, time.struct_time, C())
173
174 def test_pickling(self):
175 t = time.gmtime()
176 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
177 p = pickle.dumps(t, proto)
178 t2 = pickle.loads(p)
179 self.assertEqual(t2.__class__, t.__class__)
180 self.assertEqual(t2, t)
181 self.assertEqual(t2.tm_year, t.tm_year)
182 self.assertEqual(t2.tm_zone, t.tm_zone)
183
184 def test_pickling_with_unnamed_fields(self):
185 assert os.stat_result.n_unnamed_fields > 0
186
187 r = os.stat_result(range(os.stat_result.n_sequence_fields),
188 {'st_atime': 1.0, 'st_atime_ns': 2.0})
189 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
190 p = pickle.dumps(r, proto)
191 r2 = pickle.loads(p)
192 self.assertEqual(r2.__class__, r.__class__)
193 self.assertEqual(r2, r)
194 self.assertEqual(r2.st_mode, r.st_mode)
195 self.assertEqual(r2.st_atime, r.st_atime)
196 self.assertEqual(r2.st_atime_ns, r.st_atime_ns)
197
198 def test_copying(self):
199 n_fields = time.struct_time.n_fields
200 t = time.struct_time([[i] for i in range(n_fields)])
201
202 t2 = copy.copy(t)
203 self.assertEqual(t2.__class__, t.__class__)
204 self.assertEqual(t2, t)
205 self.assertEqual(t2.tm_year, t.tm_year)
206 self.assertEqual(t2.tm_zone, t.tm_zone)
207 self.assertIs(t2[0], t[0])
208 self.assertIs(t2.tm_year, t.tm_year)
209
210 t3 = copy.deepcopy(t)
211 self.assertEqual(t3.__class__, t.__class__)
212 self.assertEqual(t3, t)
213 self.assertEqual(t3.tm_year, t.tm_year)
214 self.assertEqual(t3.tm_zone, t.tm_zone)
215 self.assertIsNot(t3[0], t[0])
216 self.assertIsNot(t3.tm_year, t.tm_year)
217
218 def test_copying_with_unnamed_fields(self):
219 assert os.stat_result.n_unnamed_fields > 0
220
221 n_sequence_fields = os.stat_result.n_sequence_fields
222 r = os.stat_result([[i] for i in range(n_sequence_fields)],
223 {'st_atime': [1.0], 'st_atime_ns': [2.0]})
224
225 r2 = copy.copy(r)
226 self.assertEqual(r2.__class__, r.__class__)
227 self.assertEqual(r2, r)
228 self.assertEqual(r2.st_mode, r.st_mode)
229 self.assertEqual(r2.st_atime, r.st_atime)
230 self.assertEqual(r2.st_atime_ns, r.st_atime_ns)
231 self.assertIs(r2[0], r[0])
232 self.assertIs(r2.st_mode, r.st_mode)
233 self.assertIs(r2.st_atime, r.st_atime)
234 self.assertIs(r2.st_atime_ns, r.st_atime_ns)
235
236 r3 = copy.deepcopy(r)
237 self.assertEqual(r3.__class__, r.__class__)
238 self.assertEqual(r3, r)
239 self.assertEqual(r3.st_mode, r.st_mode)
240 self.assertEqual(r3.st_atime, r.st_atime)
241 self.assertEqual(r3.st_atime_ns, r.st_atime_ns)
242 self.assertIsNot(r3[0], r[0])
243 self.assertIsNot(r3.st_mode, r.st_mode)
244 self.assertIsNot(r3.st_atime, r.st_atime)
245 self.assertIsNot(r3.st_atime_ns, r.st_atime_ns)
246
247 def test_extended_getslice(self):
248 # Test extended slicing by comparing with list slicing.
249 t = time.gmtime()
250 L = list(t)
251 indices = (0, None, 1, 3, 19, 300, -1, -2, -31, -300)
252 for start in indices:
253 for stop in indices:
254 # Skip step 0 (invalid)
255 for step in indices[1:]:
256 self.assertEqual(list(t[start:stop:step]),
257 L[start:stop:step])
258
259 def test_match_args(self):
260 expected_args = ('tm_year', 'tm_mon', 'tm_mday', 'tm_hour', 'tm_min',
261 'tm_sec', 'tm_wday', 'tm_yday', 'tm_isdst')
262 self.assertEqual(time.struct_time.__match_args__, expected_args)
263
264 def test_match_args_with_unnamed_fields(self):
265 expected_args = ('st_mode', 'st_ino', 'st_dev', 'st_nlink', 'st_uid',
266 'st_gid', 'st_size')
267 self.assertEqual(os.stat_result.n_unnamed_fields, 3)
268 self.assertEqual(os.stat_result.__match_args__, expected_args)
269
270 def test_copy_replace_all_fields_visible(self):
271 assert os.times_result.n_unnamed_fields == 0
272 assert os.times_result.n_sequence_fields == os.times_result.n_fields
273
274 t = os.times()
275
276 # visible fields
277 self.assertEqual(copy.replace(t), t)
278 self.assertIsInstance(copy.replace(t), os.times_result)
279 self.assertEqual(copy.replace(t, user=1.5), (1.5, *t[1:]))
280 self.assertEqual(copy.replace(t, system=2.5), (t[0], 2.5, *t[2:]))
281 self.assertEqual(copy.replace(t, user=1.5, system=2.5), (1.5, 2.5, *t[2:]))
282
283 # unknown fields
284 with self.assertRaisesRegex(TypeError, 'unexpected field name'):
285 copy.replace(t, error=-1)
286 with self.assertRaisesRegex(TypeError, 'unexpected field name'):
287 copy.replace(t, user=1, error=-1)
288
289 def test_copy_replace_with_invisible_fields(self):
290 assert time.struct_time.n_unnamed_fields == 0
291 assert time.struct_time.n_sequence_fields < time.struct_time.n_fields
292
293 t = time.gmtime(0)
294
295 # visible fields
296 t2 = copy.replace(t)
297 self.assertEqual(t2, (1970, 1, 1, 0, 0, 0, 3, 1, 0))
298 self.assertIsInstance(t2, time.struct_time)
299 t3 = copy.replace(t, tm_year=2000)
300 self.assertEqual(t3, (2000, 1, 1, 0, 0, 0, 3, 1, 0))
301 self.assertEqual(t3.tm_year, 2000)
302 t4 = copy.replace(t, tm_mon=2)
303 self.assertEqual(t4, (1970, 2, 1, 0, 0, 0, 3, 1, 0))
304 self.assertEqual(t4.tm_mon, 2)
305 t5 = copy.replace(t, tm_year=2000, tm_mon=2)
306 self.assertEqual(t5, (2000, 2, 1, 0, 0, 0, 3, 1, 0))
307 self.assertEqual(t5.tm_year, 2000)
308 self.assertEqual(t5.tm_mon, 2)
309
310 # named invisible fields
311 self.assertHasAttr(t, 'tm_zone')
312 with self.assertRaisesRegex(AttributeError, 'readonly attribute'):
313 t.tm_zone = 'some other zone'
314 self.assertEqual(t2.tm_zone, t.tm_zone)
315 self.assertEqual(t3.tm_zone, t.tm_zone)
316 self.assertEqual(t4.tm_zone, t.tm_zone)
317 t6 = copy.replace(t, tm_zone='some other zone')
318 self.assertEqual(t, t6)
319 self.assertEqual(t6.tm_zone, 'some other zone')
320 t7 = copy.replace(t, tm_year=2000, tm_zone='some other zone')
321 self.assertEqual(t7, (2000, 1, 1, 0, 0, 0, 3, 1, 0))
322 self.assertEqual(t7.tm_year, 2000)
323 self.assertEqual(t7.tm_zone, 'some other zone')
324
325 # unknown fields
326 with self.assertRaisesRegex(TypeError, 'unexpected field name'):
327 copy.replace(t, error=2)
328 with self.assertRaisesRegex(TypeError, 'unexpected field name'):
329 copy.replace(t, tm_year=2000, error=2)
330 with self.assertRaisesRegex(TypeError, 'unexpected field name'):
331 copy.replace(t, tm_zone='some other zone', error=2)
332
333 def test_copy_replace_with_unnamed_fields(self):
334 assert os.stat_result.n_unnamed_fields > 0
335
336 r = os.stat_result(range(os.stat_result.n_sequence_fields))
337
338 error_message = re.escape('__replace__() is not supported')
339 with self.assertRaisesRegex(TypeError, error_message):
340 copy.replace(r)
341 with self.assertRaisesRegex(TypeError, error_message):
342 copy.replace(r, st_mode=1)
343 with self.assertRaisesRegex(TypeError, error_message):
344 copy.replace(r, error=2)
345 with self.assertRaisesRegex(TypeError, error_message):
346 copy.replace(r, st_mode=1, error=2)
347
348 def test_reference_cycle(self):
349 # gh-122527: Check that a structseq that's part of a reference cycle
350 # with its own type doesn't crash. Previously, if the type's dictionary
351 # was cleared first, the structseq instance would crash in the
352 # destructor.
353 script_helper.assert_python_ok("-c", textwrap.dedent(r"""
354 import time
355 t = time.gmtime()
356 type(t).refcyle = t
357 """))
358
359 def test_replace_gc_tracked(self):
360 # Verify that __replace__ results are properly GC-tracked
361 time_struct = time.gmtime(0)
362 lst = []
363 replaced_struct = time_struct.__replace__(tm_year=lst)
364 lst.append(replaced_struct)
365
366 self.assertTrue(gc.is_tracked(replaced_struct))
367
368 if __name__ == "__main__":
369 unittest.main()