Debian Codegraph @

Lib/test/test_turtle.py

raw
1 import os
2 import pickle
3 import re
4 import tempfile
5 import unittest
6 import unittest.mock
7 from test import support
8 from test.support import import_helper
9 from test.support import os_helper
10
11
12 turtle = import_helper.import_module('turtle')
13 Vec2D = turtle.Vec2D
14
15 test_config = """\
16 width = 0.75
17 height = 0.8
18 canvwidth = 500
19 canvheight = 200
20 leftright = 100
21 topbottom = 100
22 mode = world
23 colormode = 255
24 delay = 100
25 undobuffersize = 10000
26 shape = circle
27 pencolor = red
28 fillcolor = blue
29 resizemode = auto
30 visible = None
31 language = english
32 exampleturtle = turtle
33 examplescreen = screen
34 title = Python Turtle Graphics
35 using_IDLE = ''
36 """
37
38 test_config_two = """\
39 # Comments!
40 # Testing comments!
41 pencolor = red
42 fillcolor = blue
43 visible = False
44 language = english
45 # Some more
46 # comments
47 using_IDLE = False
48 """
49
50 invalid_test_config = """
51 pencolor = red
52 fillcolor: blue
53 visible = False
54 """
55
56
57 def patch_screen():
58 """Patch turtle._Screen for testing without a display.
59
60 We must patch the _Screen class itself instead of the _Screen
61 instance because instantiating it requires a display.
62 """
63 # Create a mock screen that delegates color validation to the real TurtleScreen methods
64 mock_screen = unittest.mock.MagicMock()
65 mock_screen.__class__ = turtle._Screen
66 mock_screen.mode.return_value = "standard"
67 mock_screen._colormode = 1.0
68
69 def mock_iscolorstring(color):
70 valid_colors = {'red', 'green', 'blue', 'black', 'white', 'yellow',
71 'orange', 'purple', 'pink', 'brown', 'gray', 'grey',
72 'cyan', 'magenta'}
73
74 return color in valid_colors or (isinstance(color, str) and color.startswith('#'))
75
76 mock_screen._iscolorstring = mock_iscolorstring
77 mock_screen._colorstr = turtle._Screen._colorstr.__get__(mock_screen)
78
79 return unittest.mock.patch(
80 "turtle._Screen.__new__",
81 return_value=mock_screen
82 )
83
84
85 class TurtleConfigTest(unittest.TestCase):
86
87 def get_cfg_file(self, cfg_str):
88 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
89 with open(os_helper.TESTFN, 'w') as f:
90 f.write(cfg_str)
91 return os_helper.TESTFN
92
93 def test_config_dict(self):
94
95 cfg_name = self.get_cfg_file(test_config)
96 parsed_cfg = turtle.config_dict(cfg_name)
97
98 expected = {
99 'width' : 0.75,
100 'height' : 0.8,
101 'canvwidth' : 500,
102 'canvheight': 200,
103 'leftright': 100,
104 'topbottom': 100,
105 'mode': 'world',
106 'colormode': 255,
107 'delay': 100,
108 'undobuffersize': 10000,
109 'shape': 'circle',
110 'pencolor' : 'red',
111 'fillcolor' : 'blue',
112 'resizemode' : 'auto',
113 'visible' : None,
114 'language': 'english',
115 'exampleturtle': 'turtle',
116 'examplescreen': 'screen',
117 'title': 'Python Turtle Graphics',
118 'using_IDLE': '',
119 }
120
121 self.assertEqual(parsed_cfg, expected)
122
123 def test_partial_config_dict_with_comments(self):
124
125 cfg_name = self.get_cfg_file(test_config_two)
126 parsed_cfg = turtle.config_dict(cfg_name)
127
128 expected = {
129 'pencolor': 'red',
130 'fillcolor': 'blue',
131 'visible': False,
132 'language': 'english',
133 'using_IDLE': False,
134 }
135
136 self.assertEqual(parsed_cfg, expected)
137
138 def test_config_dict_invalid(self):
139
140 cfg_name = self.get_cfg_file(invalid_test_config)
141
142 with support.captured_stdout() as stdout:
143 parsed_cfg = turtle.config_dict(cfg_name)
144
145 err_msg = stdout.getvalue()
146
147 self.assertIn('Bad line in config-file ', err_msg)
148 self.assertIn('fillcolor: blue', err_msg)
149
150 self.assertEqual(parsed_cfg, {
151 'pencolor': 'red',
152 'visible': False,
153 })
154
155
156 class VectorComparisonMixin:
157
158 def assertVectorsAlmostEqual(self, vec1, vec2):
159 if len(vec1) != len(vec2):
160 self.fail("Tuples are not of equal size")
161 for idx, (i, j) in enumerate(zip(vec1, vec2)):
162 self.assertAlmostEqual(
163 i, j, msg='values at index {} do not match'.format(idx))
164
165
166 class Multiplier:
167
168 def __mul__(self, other):
169 return f'M*{other}'
170
171 def __rmul__(self, other):
172 return f'{other}*M'
173
174
175 class TestVec2D(VectorComparisonMixin, unittest.TestCase):
176
177 def test_constructor(self):
178 vec = Vec2D(0.5, 2)
179 self.assertEqual(vec[0], 0.5)
180 self.assertEqual(vec[1], 2)
181 self.assertIsInstance(vec, Vec2D)
182
183 self.assertRaises(TypeError, Vec2D)
184 self.assertRaises(TypeError, Vec2D, 0)
185 self.assertRaises(TypeError, Vec2D, (0, 1))
186 self.assertRaises(TypeError, Vec2D, vec)
187 self.assertRaises(TypeError, Vec2D, 0, 1, 2)
188
189 def test_repr(self):
190 vec = Vec2D(0.567, 1.234)
191 self.assertEqual(repr(vec), '(0.57,1.23)')
192
193 def test_equality(self):
194 vec1 = Vec2D(0, 1)
195 vec2 = Vec2D(0.0, 1)
196 vec3 = Vec2D(42, 1)
197 self.assertEqual(vec1, vec2)
198 self.assertEqual(vec1, tuple(vec1))
199 self.assertEqual(tuple(vec1), vec1)
200 self.assertNotEqual(vec1, vec3)
201 self.assertNotEqual(vec2, vec3)
202
203 def test_pickling(self):
204 vec = Vec2D(0.5, 2)
205 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
206 with self.subTest(proto=proto):
207 pickled = pickle.dumps(vec, protocol=proto)
208 unpickled = pickle.loads(pickled)
209 self.assertEqual(unpickled, vec)
210 self.assertIsInstance(unpickled, Vec2D)
211
212 def _assert_arithmetic_cases(self, test_cases, lambda_operator):
213 for test_case in test_cases:
214 with self.subTest(case=test_case):
215
216 ((first, second), expected) = test_case
217
218 op1 = Vec2D(*first)
219 op2 = Vec2D(*second)
220
221 result = lambda_operator(op1, op2)
222
223 expected = Vec2D(*expected)
224
225 self.assertVectorsAlmostEqual(result, expected)
226
227 def test_vector_addition(self):
228
229 test_cases = [
230 (((0, 0), (1, 1)), (1.0, 1.0)),
231 (((-1, 0), (2, 2)), (1, 2)),
232 (((1.5, 0), (1, 1)), (2.5, 1)),
233 ]
234
235 self._assert_arithmetic_cases(test_cases, lambda x, y: x + y)
236
237 def test_vector_subtraction(self):
238
239 test_cases = [
240 (((0, 0), (1, 1)), (-1, -1)),
241 (((10.625, 0.125), (10, 0)), (0.625, 0.125)),
242 ]
243
244 self._assert_arithmetic_cases(test_cases, lambda x, y: x - y)
245
246 def test_vector_multiply(self):
247
248 vec1 = Vec2D(10, 10)
249 vec2 = Vec2D(0.5, 3)
250 answer = vec1 * vec2
251 expected = 35
252 self.assertAlmostEqual(answer, expected)
253
254 vec = Vec2D(0.5, 3)
255 expected = Vec2D(5, 30)
256 self.assertVectorsAlmostEqual(vec * 10, expected)
257 self.assertVectorsAlmostEqual(10 * vec, expected)
258 self.assertVectorsAlmostEqual(vec * 10.0, expected)
259 self.assertVectorsAlmostEqual(10.0 * vec, expected)
260
261 M = Multiplier()
262 self.assertEqual(vec * M, Vec2D(f"{vec[0]}*M", f"{vec[1]}*M"))
263 self.assertEqual(M * vec, f'M*{vec}')
264
265 def test_vector_negative(self):
266 vec = Vec2D(10, -10)
267 expected = (-10, 10)
268 self.assertVectorsAlmostEqual(-vec, expected)
269
270 def test_distance(self):
271 self.assertAlmostEqual(abs(Vec2D(6, 8)), 10)
272 self.assertEqual(abs(Vec2D(0, 0)), 0)
273 self.assertAlmostEqual(abs(Vec2D(2.5, 6)), 6.5)
274
275 def test_rotate(self):
276
277 cases = [
278 (((0, 0), 0), (0, 0)),
279 (((0, 1), 90), (-1, 0)),
280 (((0, 1), -90), (1, 0)),
281 (((1, 0), 180), (-1, 0)),
282 (((1, 0), 360), (1, 0)),
283 ]
284
285 for case in cases:
286 with self.subTest(case=case):
287 (vec, rot), expected = case
288 vec = Vec2D(*vec)
289 got = vec.rotate(rot)
290 self.assertVectorsAlmostEqual(got, expected)
291
292
293 class TestTNavigator(VectorComparisonMixin, unittest.TestCase):
294
295 def setUp(self):
296 self.nav = turtle.TNavigator()
297
298 def test_goto(self):
299 self.nav.goto(100, -100)
300 self.assertAlmostEqual(self.nav.xcor(), 100)
301 self.assertAlmostEqual(self.nav.ycor(), -100)
302
303 def test_teleport(self):
304 self.nav.teleport(20, -30, fill_gap=True)
305 self.assertAlmostEqual(self.nav.xcor(), 20)
306 self.assertAlmostEqual(self.nav.ycor(), -30)
307 self.nav.teleport(-20, 30, fill_gap=False)
308 self.assertAlmostEqual(self.nav.xcor(), -20)
309 self.assertAlmostEqual(self.nav.ycor(), 30)
310
311 def test_pos(self):
312 self.assertEqual(self.nav.pos(), self.nav._position)
313 self.nav.goto(100, -100)
314 self.assertEqual(self.nav.pos(), self.nav._position)
315
316 def test_left(self):
317 self.assertEqual(self.nav._orient, (1.0, 0))
318 self.nav.left(90)
319 self.assertVectorsAlmostEqual(self.nav._orient, (0.0, 1.0))
320
321 def test_right(self):
322 self.assertEqual(self.nav._orient, (1.0, 0))
323 self.nav.right(90)
324 self.assertVectorsAlmostEqual(self.nav._orient, (0, -1.0))
325
326 def test_reset(self):
327 self.nav.goto(100, -100)
328 self.assertAlmostEqual(self.nav.xcor(), 100)
329 self.assertAlmostEqual(self.nav.ycor(), -100)
330 self.nav.reset()
331 self.assertAlmostEqual(self.nav.xcor(), 0)
332 self.assertAlmostEqual(self.nav.ycor(), 0)
333
334 def test_forward(self):
335 self.nav.forward(150)
336 expected = Vec2D(150, 0)
337 self.assertVectorsAlmostEqual(self.nav.position(), expected)
338
339 self.nav.reset()
340 self.nav.left(90)
341 self.nav.forward(150)
342 expected = Vec2D(0, 150)
343 self.assertVectorsAlmostEqual(self.nav.position(), expected)
344
345 self.assertRaises(TypeError, self.nav.forward, 'skldjfldsk')
346
347 def test_backwards(self):
348 self.nav.back(200)
349 expected = Vec2D(-200, 0)
350 self.assertVectorsAlmostEqual(self.nav.position(), expected)
351
352 self.nav.reset()
353 self.nav.right(90)
354 self.nav.back(200)
355 expected = Vec2D(0, 200)
356 self.assertVectorsAlmostEqual(self.nav.position(), expected)
357
358 def test_distance(self):
359 self.nav.forward(100)
360 expected = 100
361 self.assertAlmostEqual(self.nav.distance(Vec2D(0,0)), expected)
362
363 def test_radians_and_degrees(self):
364 self.nav.left(90)
365 self.assertAlmostEqual(self.nav.heading(), 90)
366 self.nav.radians()
367 self.assertAlmostEqual(self.nav.heading(), 1.57079633)
368 self.nav.degrees()
369 self.assertAlmostEqual(self.nav.heading(), 90)
370
371 def test_towards(self):
372
373 coordinates = [
374 # coordinates, expected
375 ((100, 0), 0.0),
376 ((100, 100), 45.0),
377 ((0, 100), 90.0),
378 ((-100, 100), 135.0),
379 ((-100, 0), 180.0),
380 ((-100, -100), 225.0),
381 ((0, -100), 270.0),
382 ((100, -100), 315.0),
383 ]
384
385 for (x, y), expected in coordinates:
386 self.assertEqual(self.nav.towards(x, y), expected)
387 self.assertEqual(self.nav.towards((x, y)), expected)
388 self.assertEqual(self.nav.towards(Vec2D(x, y)), expected)
389
390 def test_heading(self):
391
392 self.nav.left(90)
393 self.assertAlmostEqual(self.nav.heading(), 90)
394 self.nav.left(45)
395 self.assertAlmostEqual(self.nav.heading(), 135)
396 self.nav.right(1.6)
397 self.assertAlmostEqual(self.nav.heading(), 133.4)
398 self.assertRaises(TypeError, self.nav.right, 'sdkfjdsf')
399 self.nav.reset()
400
401 rotations = [10, 20, 170, 300]
402 result = sum(rotations) % 360
403 for num in rotations:
404 self.nav.left(num)
405 self.assertEqual(self.nav.heading(), result)
406 self.nav.reset()
407
408 result = (360-sum(rotations)) % 360
409 for num in rotations:
410 self.nav.right(num)
411 self.assertEqual(self.nav.heading(), result)
412 self.nav.reset()
413
414 rotations = [10, 20, -170, 300, -210, 34.3, -50.2, -10, -29.98, 500]
415 sum_so_far = 0
416 for num in rotations:
417 if num < 0:
418 self.nav.right(abs(num))
419 else:
420 self.nav.left(num)
421 sum_so_far += num
422 self.assertAlmostEqual(self.nav.heading(), sum_so_far % 360)
423
424 def test_setheading(self):
425 self.nav.setheading(102.32)
426 self.assertAlmostEqual(self.nav.heading(), 102.32)
427 self.nav.setheading(-123.23)
428 self.assertAlmostEqual(self.nav.heading(), (-123.23) % 360)
429 self.nav.setheading(-1000.34)
430 self.assertAlmostEqual(self.nav.heading(), (-1000.34) % 360)
431 self.nav.setheading(300000)
432 self.assertAlmostEqual(self.nav.heading(), 300000%360)
433
434 def test_positions(self):
435 self.nav.forward(100)
436 self.nav.left(90)
437 self.nav.forward(-200)
438 self.assertVectorsAlmostEqual(self.nav.pos(), (100.0, -200.0))
439
440 def test_setx_and_sety(self):
441 self.nav.setx(-1023.2334)
442 self.nav.sety(193323.234)
443 self.assertVectorsAlmostEqual(self.nav.pos(), (-1023.2334, 193323.234))
444
445 def test_home(self):
446 self.nav.left(30)
447 self.nav.forward(-100000)
448 self.nav.home()
449 self.assertVectorsAlmostEqual(self.nav.pos(), (0,0))
450 self.assertAlmostEqual(self.nav.heading(), 0)
451
452 def test_distance_method(self):
453 self.assertAlmostEqual(self.nav.distance(30, 40), 50)
454 vec = Vec2D(0.22, .001)
455 self.assertAlmostEqual(self.nav.distance(vec), 0.22000227271553355)
456 another_turtle = turtle.TNavigator()
457 another_turtle.left(90)
458 another_turtle.forward(10000)
459 self.assertAlmostEqual(self.nav.distance(another_turtle), 10000)
460
461
462 class TestTPen(unittest.TestCase):
463
464 def test_pendown_and_penup(self):
465
466 tpen = turtle.TPen()
467
468 self.assertTrue(tpen.isdown())
469 tpen.penup()
470 self.assertFalse(tpen.isdown())
471 tpen.pendown()
472 self.assertTrue(tpen.isdown())
473
474 def test_showturtle_hideturtle_and_isvisible(self):
475
476 tpen = turtle.TPen()
477
478 self.assertTrue(tpen.isvisible())
479 tpen.hideturtle()
480 self.assertFalse(tpen.isvisible())
481 tpen.showturtle()
482 self.assertTrue(tpen.isvisible())
483
484 def test_teleport(self):
485
486 tpen = turtle.TPen()
487
488 for fill_gap_value in [True, False]:
489 tpen.penup()
490 tpen.teleport(100, 100, fill_gap=fill_gap_value)
491 self.assertFalse(tpen.isdown())
492 tpen.pendown()
493 tpen.teleport(-100, -100, fill_gap=fill_gap_value)
494 self.assertTrue(tpen.isdown())
495
496
497 class TestTurtleScreen(unittest.TestCase):
498 def test_save_raises_if_wrong_extension(self) -> None:
499 screen = unittest.mock.Mock()
500
501 msg = "Unknown file extension: '.png', must be one of {'.ps', '.eps'}"
502 with (
503 tempfile.TemporaryDirectory() as tmpdir,
504 self.assertRaisesRegex(ValueError, re.escape(msg))
505 ):
506 turtle.TurtleScreen.save(screen, os.path.join(tmpdir, "file.png"))
507
508 def test_save_raises_if_parent_not_found(self) -> None:
509 screen = unittest.mock.Mock()
510
511 with tempfile.TemporaryDirectory() as tmpdir:
512 parent = os.path.join(tmpdir, "unknown_parent")
513 msg = f"The directory '{parent}' does not exist. Cannot save to it"
514
515 with self.assertRaisesRegex(FileNotFoundError, re.escape(msg)):
516 turtle.TurtleScreen.save(screen, os.path.join(parent, "a.ps"))
517
518 def test_save_raises_if_file_found(self) -> None:
519 screen = unittest.mock.Mock()
520
521 with tempfile.TemporaryDirectory() as tmpdir:
522 file_path = os.path.join(tmpdir, "some_file.ps")
523 with open(file_path, "w") as f:
524 f.write("some text")
525
526 msg = (
527 f"The file '{file_path}' already exists. To overwrite it use"
528 " the 'overwrite=True' argument of the save function."
529 )
530 with self.assertRaisesRegex(FileExistsError, re.escape(msg)):
531 turtle.TurtleScreen.save(screen, file_path)
532
533 def test_save_overwrites_if_specified(self) -> None:
534 screen = unittest.mock.Mock()
535 screen.cv.postscript.return_value = "postscript"
536
537 with tempfile.TemporaryDirectory() as tmpdir:
538 file_path = os.path.join(tmpdir, "some_file.ps")
539 with open(file_path, "w") as f:
540 f.write("some text")
541
542 turtle.TurtleScreen.save(screen, file_path, overwrite=True)
543 with open(file_path) as f:
544 self.assertEqual(f.read(), "postscript")
545
546 def test_save(self) -> None:
547 screen = unittest.mock.Mock()
548 screen.cv.postscript.return_value = "postscript"
549
550 with tempfile.TemporaryDirectory() as tmpdir:
551 file_path = os.path.join(tmpdir, "some_file.ps")
552
553 turtle.TurtleScreen.save(screen, file_path)
554 with open(file_path) as f:
555 self.assertEqual(f.read(), "postscript")
556
557 def test_no_animation_sets_tracer_0(self):
558 s = turtle.TurtleScreen(cv=unittest.mock.MagicMock())
559
560 with s.no_animation():
561 self.assertEqual(s.tracer(), 0)
562
563 def test_no_animation_resets_tracer_to_old_value(self):
564 s = turtle.TurtleScreen(cv=unittest.mock.MagicMock())
565
566 for tracer in [0, 1, 5]:
567 s.tracer(tracer)
568 with s.no_animation():
569 pass
570 self.assertEqual(s.tracer(), tracer)
571
572 def test_no_animation_calls_update_at_exit(self):
573 s = turtle.TurtleScreen(cv=unittest.mock.MagicMock())
574 s.update = unittest.mock.MagicMock()
575
576 with s.no_animation():
577 s.update.assert_not_called()
578 s.update.assert_called_once()
579
580
581 class TestTurtle(unittest.TestCase):
582 def setUp(self):
583 with patch_screen():
584 self.turtle = turtle.Turtle()
585
586 # Reset the Screen singleton to avoid reference leaks
587 self.addCleanup(setattr, turtle.Turtle, '_screen', None)
588
589 def test_begin_end_fill(self):
590 self.assertFalse(self.turtle.filling())
591 self.turtle.begin_fill()
592 self.assertTrue(self.turtle.filling())
593 self.turtle.end_fill()
594 self.assertFalse(self.turtle.filling())
595
596 def test_fill(self):
597 # The context manager behaves like begin_fill and end_fill.
598 self.assertFalse(self.turtle.filling())
599 with self.turtle.fill():
600 self.assertTrue(self.turtle.filling())
601 self.assertFalse(self.turtle.filling())
602
603 def test_fill_resets_after_exception(self):
604 # The context manager cleans up correctly after exceptions.
605 try:
606 with self.turtle.fill():
607 self.assertTrue(self.turtle.filling())
608 raise ValueError
609 except ValueError:
610 self.assertFalse(self.turtle.filling())
611
612 def test_fill_context_when_filling(self):
613 # The context manager works even when the turtle is already filling.
614 self.turtle.begin_fill()
615 self.assertTrue(self.turtle.filling())
616 with self.turtle.fill():
617 self.assertTrue(self.turtle.filling())
618 self.assertFalse(self.turtle.filling())
619
620 def test_begin_end_poly(self):
621 self.assertFalse(self.turtle._creatingPoly)
622 self.turtle.begin_poly()
623 self.assertTrue(self.turtle._creatingPoly)
624 self.turtle.end_poly()
625 self.assertFalse(self.turtle._creatingPoly)
626
627 def test_poly(self):
628 # The context manager behaves like begin_poly and end_poly.
629 self.assertFalse(self.turtle._creatingPoly)
630 with self.turtle.poly():
631 self.assertTrue(self.turtle._creatingPoly)
632 self.assertFalse(self.turtle._creatingPoly)
633
634 def test_poly_resets_after_exception(self):
635 # The context manager cleans up correctly after exceptions.
636 try:
637 with self.turtle.poly():
638 self.assertTrue(self.turtle._creatingPoly)
639 raise ValueError
640 except ValueError:
641 self.assertFalse(self.turtle._creatingPoly)
642
643 def test_poly_context_when_creating_poly(self):
644 # The context manager works when the turtle is already creating poly.
645 self.turtle.begin_poly()
646 self.assertTrue(self.turtle._creatingPoly)
647 with self.turtle.poly():
648 self.assertTrue(self.turtle._creatingPoly)
649 self.assertFalse(self.turtle._creatingPoly)
650
651 def test_dot_signature(self):
652 self.turtle.dot()
653 self.turtle.dot(10)
654 self.turtle.dot(size=10)
655 self.turtle.dot((0, 0, 0))
656 self.turtle.dot(size=(0, 0, 0))
657 self.turtle.dot("blue")
658 self.turtle.dot("")
659 self.turtle.dot(size="blue")
660 self.turtle.dot(20, "blue")
661 self.turtle.dot(20, "blue")
662 self.turtle.dot(20, (0, 0, 0))
663 self.turtle.dot(20, 0, 0, 0)
664 with self.assertRaises(TypeError):
665 self.turtle.dot(color="blue")
666 self.assertRaises(turtle.TurtleGraphicsError, self.turtle.dot, "_not_a_color_")
667 self.assertRaises(turtle.TurtleGraphicsError, self.turtle.dot, 0, (0, 0, 0, 0))
668 self.assertRaises(turtle.TurtleGraphicsError, self.turtle.dot, 0, 0, 0, 0, 0)
669 self.assertRaises(turtle.TurtleGraphicsError, self.turtle.dot, 0, (-1, 0, 0))
670 self.assertRaises(turtle.TurtleGraphicsError, self.turtle.dot, 0, -1, 0, 0)
671 self.assertRaises(turtle.TurtleGraphicsError, self.turtle.dot, 0, (0, 257, 0))
672 self.assertRaises(turtle.TurtleGraphicsError, self.turtle.dot, 0, 0, 257, 0)
673
674 class TestModuleLevel(unittest.TestCase):
675 def test_all_signatures(self):
676 import inspect
677
678 known_signatures = {
679 'teleport':
680 '(x=None, y=None, *, fill_gap: bool = False) -> None',
681 'undo': '()',
682 'goto': '(x, y=None)',
683 'bgcolor': '(*args)',
684 'pen': '(pen=None, **pendict)',
685 }
686
687 for name in known_signatures:
688 with self.subTest(name=name):
689 obj = getattr(turtle, name)
690 sig = inspect.signature(obj)
691 self.assertEqual(str(sig), known_signatures[name])
692
693
694 if __name__ == '__main__':
695 unittest.main()