| 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() |