Debian Codegraph @

Lib/test/test_json/test_recursion.py

raw
1 from test import support
2 from test.test_json import PyTest, CTest
3
4
5 class JSONTestObject:
6 pass
7
8
9 class TestRecursion:
10 def test_listrecursion(self):
11 x = []
12 x.append(x)
13 try:
14 self.dumps(x)
15 except ValueError as exc:
16 self.assertEqual(exc.__notes__, ["when serializing list item 0"])
17 else:
18 self.fail("didn't raise ValueError on list recursion")
19 x = []
20 y = [x]
21 x.append(y)
22 try:
23 self.dumps(x)
24 except ValueError as exc:
25 self.assertEqual(exc.__notes__, ["when serializing list item 0"]*2)
26 else:
27 self.fail("didn't raise ValueError on alternating list recursion")
28 y = []
29 x = [y, y]
30 # ensure that the marker is cleared
31 self.dumps(x)
32
33 def test_dictrecursion(self):
34 x = {}
35 x["test"] = x
36 try:
37 self.dumps(x)
38 except ValueError as exc:
39 self.assertEqual(exc.__notes__, ["when serializing dict item 'test'"])
40 else:
41 self.fail("didn't raise ValueError on dict recursion")
42 x = {}
43 y = {"a": x, "b": x}
44 # ensure that the marker is cleared
45 self.dumps(x)
46
47 def test_defaultrecursion(self):
48 class RecursiveJSONEncoder(self.json.JSONEncoder):
49 recurse = False
50 def default(self, o):
51 if o is JSONTestObject:
52 if self.recurse:
53 return [JSONTestObject]
54 else:
55 return 'JSONTestObject'
56 return self.json.JSONEncoder.default(o)
57
58 enc = RecursiveJSONEncoder()
59 self.assertEqual(enc.encode(JSONTestObject), '"JSONTestObject"')
60 enc.recurse = True
61 try:
62 enc.encode(JSONTestObject)
63 except ValueError as exc:
64 self.assertEqual(exc.__notes__,
65 ["when serializing list item 0",
66 "when serializing type object"])
67 else:
68 self.fail("didn't raise ValueError on default recursion")
69
70
71 @support.skip_if_unlimited_stack_size
72 @support.skip_emscripten_stack_overflow()
73 @support.skip_wasi_stack_overflow()
74 def test_highly_nested_objects_decoding(self):
75 very_deep = 500_000
76 # test that loading highly-nested objects doesn't segfault when C
77 # accelerations are used. See #12017
78 with self.assertRaises(RecursionError):
79 with support.infinite_recursion():
80 self.loads('{"a":' * very_deep + '1' + '}' * very_deep)
81 with self.assertRaises(RecursionError):
82 with support.infinite_recursion():
83 self.loads('{"a":' * very_deep + '[1]' + '}' * very_deep)
84 with self.assertRaises(RecursionError):
85 with support.infinite_recursion():
86 self.loads('[' * very_deep + '1' + ']' * very_deep)
87
88 @support.skip_if_unlimited_stack_size
89 @support.skip_wasi_stack_overflow()
90 @support.skip_emscripten_stack_overflow()
91 @support.requires_resource('cpu')
92 def test_highly_nested_objects_encoding(self):
93 # See #12051
94 l, d = [], {}
95 for x in range(500_000):
96 l, d = [l], {'k':d}
97 with self.assertRaises(RecursionError):
98 with support.infinite_recursion(5000):
99 self.dumps(l)
100 with self.assertRaises(RecursionError):
101 with support.infinite_recursion(5000):
102 self.dumps(d)
103
104 @support.skip_if_unlimited_stack_size
105 @support.skip_emscripten_stack_overflow()
106 @support.skip_wasi_stack_overflow()
107 def test_endless_recursion(self):
108 # See #12051
109 class EndlessJSONEncoder(self.json.JSONEncoder):
110 def default(self, o):
111 """If check_circular is False, this will keep adding another list."""
112 return [o]
113
114 with self.assertRaises(RecursionError):
115 with support.infinite_recursion(1000):
116 EndlessJSONEncoder(check_circular=False).encode(5j)
117
118
119 class TestPyRecursion(TestRecursion, PyTest): pass
120 class TestCRecursion(TestRecursion, CTest): pass