| import pickle | |
| import unittest | |
| from test import test_support as support | |
| turtle = support.import_module('turtle') | |
| Vec2D = turtle.Vec2D | |
| test_config = """\ | |
| width = 0.75 | |
| height = 0.8 | |
| canvwidth = 500 | |
| canvheight = 200 | |
| leftright = 100 | |
| topbottom = 100 | |
| mode = world | |
| colormode = 255 | |
| delay = 100 | |
| undobuffersize = 10000 | |
| shape = circle | |
| pencolor = red | |
| fillcolor = blue | |
| resizemode = auto | |
| visible = None | |
| language = english | |
| exampleturtle = turtle | |
| examplescreen = screen | |
| title = Python Turtle Graphics | |
| using_IDLE = '' | |
| """ | |
| test_config_two = """\ | |
| # Comments! | |
| # Testing comments! | |
| pencolor = red | |
| fillcolor = blue | |
| visible = False | |
| language = english | |
| # Some more | |
| # comments | |
| using_IDLE = False | |
| """ | |
| invalid_test_config = """ | |
| pencolor = red | |
| fillcolor: blue | |
| visible = False | |
| """ | |
| class TurtleConfigTest(unittest.TestCase): | |
| def get_cfg_file(self, cfg_str): | |
| self.addCleanup(support.unlink, support.TESTFN) | |
| with open(support.TESTFN, 'w') as f: | |
| f.write(cfg_str) | |
| return support.TESTFN | |
| def test_config_dict(self): | |
| cfg_name = self.get_cfg_file(test_config) | |
| parsed_cfg = turtle.config_dict(cfg_name) | |
| expected = { | |
| 'width' : 0.75, | |
| 'height' : 0.8, | |
| 'canvwidth' : 500, | |
| 'canvheight': 200, | |
| 'leftright': 100, | |
| 'topbottom': 100, | |
| 'mode': 'world', | |
| 'colormode': 255, | |
| 'delay': 100, | |
| 'undobuffersize': 10000, | |
| 'shape': 'circle', | |
| 'pencolor' : 'red', | |
| 'fillcolor' : 'blue', | |
| 'resizemode' : 'auto', | |
| 'visible' : None, | |
| 'language': 'english', | |
| 'exampleturtle': 'turtle', | |
| 'examplescreen': 'screen', | |
| 'title': 'Python Turtle Graphics', | |
| 'using_IDLE': '', | |
| } | |
| self.assertEqual(parsed_cfg, expected) | |
| def test_partial_config_dict_with_commments(self): | |
| cfg_name = self.get_cfg_file(test_config_two) | |
| parsed_cfg = turtle.config_dict(cfg_name) | |
| expected = { | |
| 'pencolor': 'red', | |
| 'fillcolor': 'blue', | |
| 'visible': False, | |
| 'language': 'english', | |
| 'using_IDLE': False, | |
| } | |
| self.assertEqual(parsed_cfg, expected) | |
| def test_config_dict_invalid(self): | |
| cfg_name = self.get_cfg_file(invalid_test_config) | |
| with support.captured_stdout() as stdout: | |
| parsed_cfg = turtle.config_dict(cfg_name) | |
| err_msg = stdout.getvalue() | |
| self.assertIn('Bad line in config-file ', err_msg) | |
| self.assertIn('fillcolor: blue', err_msg) | |
| self.assertEqual(parsed_cfg, { | |
| 'pencolor': 'red', | |
| 'visible': False, | |
| }) | |
| class VectorComparisonMixin: | |
| def assertVectorsAlmostEqual(self, vec1, vec2): | |
| if len(vec1) != len(vec2): | |
| self.fail("Tuples are not of equal size") | |
| for idx, (i, j) in enumerate(zip(vec1, vec2)): | |
| self.assertAlmostEqual( | |
| i, j, msg='values at index {} do not match'.format(idx)) | |
| class TestVec2D(VectorComparisonMixin, unittest.TestCase): | |
| def test_constructor(self): | |
| vec = Vec2D(0.5, 2) | |
| self.assertEqual(vec[0], 0.5) | |
| self.assertEqual(vec[1], 2) | |
| self.assertIsInstance(vec, Vec2D) | |
| self.assertRaises(TypeError, Vec2D) | |
| self.assertRaises(TypeError, Vec2D, 0) | |
| self.assertRaises(TypeError, Vec2D, (0, 1)) | |
| self.assertRaises(TypeError, Vec2D, vec) | |
| self.assertRaises(TypeError, Vec2D, 0, 1, 2) | |
| def test_repr(self): | |
| vec = Vec2D(0.567, 1.234) | |
| self.assertEqual(repr(vec), '(0.57,1.23)') | |
| def test_equality(self): | |
| vec1 = Vec2D(0, 1) | |
| vec2 = Vec2D(0.0, 1) | |
| vec3 = Vec2D(42, 1) | |
| self.assertEqual(vec1, vec2) | |
| self.assertEqual(vec1, tuple(vec1)) | |
| self.assertEqual(tuple(vec1), vec1) | |
| self.assertNotEqual(vec1, vec3) | |
| self.assertNotEqual(vec2, vec3) | |
| def test_pickling(self): | |
| vec = Vec2D(0.5, 2) | |
| for proto in range(pickle.HIGHEST_PROTOCOL + 1): | |
| pickled = pickle.dumps(vec, protocol=proto) | |
| unpickled = pickle.loads(pickled) | |
| self.assertEqual(unpickled, vec) | |
| self.assertIsInstance(unpickled, Vec2D) | |
| def _assert_arithmetic_cases(self, test_cases, lambda_operator): | |
| for test_case in test_cases: | |
| ((first, second), expected) = test_case | |
| op1 = Vec2D(*first) | |
| op2 = Vec2D(*second) | |
| result = lambda_operator(op1, op2) | |
| expected = Vec2D(*expected) | |
| self.assertVectorsAlmostEqual(result, expected) | |
| def test_vector_addition(self): | |
| test_cases = [ | |
| (((0, 0), (1, 1)), (1.0, 1.0)), | |
| (((-1, 0), (2, 2)), (1, 2)), | |
| (((1.5, 0), (1, 1)), (2.5, 1)), | |
| ] | |
| self._assert_arithmetic_cases(test_cases, lambda x, y: x + y) | |
| def test_vector_subtraction(self): | |
| test_cases = [ | |
| (((0, 0), (1, 1)), (-1, -1)), | |
| (((10.625, 0.125), (10, 0)), (0.625, 0.125)), | |
| ] | |
| self._assert_arithmetic_cases(test_cases, lambda x, y: x - y) | |
| def test_vector_multiply(self): | |
| vec1 = Vec2D(10, 10) | |
| vec2 = Vec2D(0.5, 3) | |
| answer = vec1 * vec2 | |
| expected = 35 | |
| self.assertAlmostEqual(answer, expected) | |
| vec = Vec2D(0.5, 3) | |
| answer = vec * 10 | |
| expected = Vec2D(5, 30) | |
| self.assertVectorsAlmostEqual(answer, expected) | |
| def test_vector_negative(self): | |
| vec = Vec2D(10, -10) | |
| expected = (-10, 10) | |
| self.assertVectorsAlmostEqual(-vec, expected) | |
| def test_distance(self): | |
| vec = Vec2D(6, 8) | |
| expected = 10 | |
| self.assertEqual(abs(vec), expected) | |
| vec = Vec2D(0, 0) | |
| expected = 0 | |
| self.assertEqual(abs(vec), expected) | |
| vec = Vec2D(2.5, 6) | |
| expected = 6.5 | |
| self.assertEqual(abs(vec), expected) | |
| def test_rotate(self): | |
| cases = [ | |
| (((0, 0), 0), (0, 0)), | |
| (((0, 1), 90), (-1, 0)), | |
| (((0, 1), -90), (1, 0)), | |
| (((1, 0), 180), (-1, 0)), | |
| (((1, 0), 360), (1, 0)), | |
| ] | |
| for case in cases: | |
| (vec, rot), expected = case | |
| vec = Vec2D(*vec) | |
| got = vec.rotate(rot) | |
| self.assertVectorsAlmostEqual(got, expected) | |
| class TestTNavigator(VectorComparisonMixin, unittest.TestCase): | |
| def setUp(self): | |
| self.nav = turtle.TNavigator() | |
| def test_goto(self): | |
| self.nav.goto(100, -100) | |
| self.assertAlmostEqual(self.nav.xcor(), 100) | |
| self.assertAlmostEqual(self.nav.ycor(), -100) | |
| def test_pos(self): | |
| self.assertEqual(self.nav.pos(), self.nav._position) | |
| self.nav.goto(100, -100) | |
| self.assertEqual(self.nav.pos(), self.nav._position) | |
| def test_left(self): | |
| self.assertEqual(self.nav._orient, (1.0, 0)) | |
| self.nav.left(90) | |
| self.assertVectorsAlmostEqual(self.nav._orient, (0.0, 1.0)) | |
| def test_right(self): | |
| self.assertEqual(self.nav._orient, (1.0, 0)) | |
| self.nav.right(90) | |
| self.assertVectorsAlmostEqual(self.nav._orient, (0, -1.0)) | |
| def test_reset(self): | |
| self.nav.goto(100, -100) | |
| self.assertAlmostEqual(self.nav.xcor(), 100) | |
| self.assertAlmostEqual(self.nav.ycor(), -100) | |
| self.nav.reset() | |
| self.assertAlmostEqual(self.nav.xcor(), 0) | |
| self.assertAlmostEqual(self.nav.ycor(), 0) | |
| def test_forward(self): | |
| self.nav.forward(150) | |
| expected = Vec2D(150, 0) | |
| self.assertVectorsAlmostEqual(self.nav.position(), expected) | |
| self.nav.reset() | |
| self.nav.left(90) | |
| self.nav.forward(150) | |
| expected = Vec2D(0, 150) | |
| self.assertVectorsAlmostEqual(self.nav.position(), expected) | |
| self.assertRaises(TypeError, self.nav.forward, 'skldjfldsk') | |
| def test_backwards(self): | |
| self.nav.back(200) | |
| expected = Vec2D(-200, 0) | |
| self.assertVectorsAlmostEqual(self.nav.position(), expected) | |
| self.nav.reset() | |
| self.nav.right(90) | |
| self.nav.back(200) | |
| expected = Vec2D(0, 200) | |
| self.assertVectorsAlmostEqual(self.nav.position(), expected) | |
| def test_distance(self): | |
| self.nav.forward(100) | |
| expected = 100 | |
| self.assertAlmostEqual(self.nav.distance(Vec2D(0,0)), expected) | |
| def test_radians_and_degrees(self): | |
| self.nav.left(90) | |
| self.assertAlmostEqual(self.nav.heading(), 90) | |
| self.nav.radians() | |
| self.assertAlmostEqual(self.nav.heading(), 1.57079633) | |
| self.nav.degrees() | |
| self.assertAlmostEqual(self.nav.heading(), 90) | |
| def test_towards(self): | |
| coordinates = [ | |
| # coordinates, expected | |
| ((100, 0), 0.0), | |
| ((100, 100), 45.0), | |
| ((0, 100), 90.0), | |
| ((-100, 100), 135.0), | |
| ((-100, 0), 180.0), | |
| ((-100, -100), 225.0), | |
| ((0, -100), 270.0), | |
| ((100, -100), 315.0), | |
| ] | |
| for (x, y), expected in coordinates: | |
| self.assertEqual(self.nav.towards(x, y), expected) | |
| self.assertEqual(self.nav.towards((x, y)), expected) | |
| self.assertEqual(self.nav.towards(Vec2D(x, y)), expected) | |
| def test_heading(self): | |
| self.nav.left(90) | |
| self.assertAlmostEqual(self.nav.heading(), 90) | |
| self.nav.left(45) | |
| self.assertAlmostEqual(self.nav.heading(), 135) | |
| self.nav.right(1.6) | |
| self.assertAlmostEqual(self.nav.heading(), 133.4) | |
| self.assertRaises(TypeError, self.nav.right, 'sdkfjdsf') | |
| self.nav.reset() | |
| rotations = [10, 20, 170, 300] | |
| result = sum(rotations) % 360 | |
| for num in rotations: | |
| self.nav.left(num) | |
| self.assertEqual(self.nav.heading(), result) | |
| self.nav.reset() | |
| result = (360-sum(rotations)) % 360 | |
| for num in rotations: | |
| self.nav.right(num) | |
| self.assertEqual(self.nav.heading(), result) | |
| self.nav.reset() | |
| rotations = [10, 20, -170, 300, -210, 34.3, -50.2, -10, -29.98, 500] | |
| sum_so_far = 0 | |
| for num in rotations: | |
| if num < 0: | |
| self.nav.right(abs(num)) | |
| else: | |
| self.nav.left(num) | |
| sum_so_far += num | |
| self.assertAlmostEqual(self.nav.heading(), sum_so_far % 360) | |
| def test_setheading(self): | |
| self.nav.setheading(102.32) | |
| self.assertAlmostEqual(self.nav.heading(), 102.32) | |
| self.nav.setheading(-123.23) | |
| self.assertAlmostEqual(self.nav.heading(), (-123.23) % 360) | |
| self.nav.setheading(-1000.34) | |
| self.assertAlmostEqual(self.nav.heading(), (-1000.34) % 360) | |
| self.nav.setheading(300000) | |
| self.assertAlmostEqual(self.nav.heading(), 300000%360) | |
| def test_positions(self): | |
| self.nav.forward(100) | |
| self.nav.left(90) | |
| self.nav.forward(-200) | |
| self.assertVectorsAlmostEqual(self.nav.pos(), (100.0, -200.0)) | |
| def test_setx_and_sety(self): | |
| self.nav.setx(-1023.2334) | |
| self.nav.sety(193323.234) | |
| self.assertVectorsAlmostEqual(self.nav.pos(), (-1023.2334, 193323.234)) | |
| def test_home(self): | |
| self.nav.left(30) | |
| self.nav.forward(-100000) | |
| self.nav.home() | |
| self.assertVectorsAlmostEqual(self.nav.pos(), (0,0)) | |
| self.assertAlmostEqual(self.nav.heading(), 0) | |
| def test_distance_method(self): | |
| self.assertAlmostEqual(self.nav.distance(30, 40), 50) | |
| vec = Vec2D(0.22, .001) | |
| self.assertAlmostEqual(self.nav.distance(vec), 0.22000227271553355) | |
| another_turtle = turtle.TNavigator() | |
| another_turtle.left(90) | |
| another_turtle.forward(10000) | |
| self.assertAlmostEqual(self.nav.distance(another_turtle), 10000) | |
| class TestTPen(unittest.TestCase): | |
| def test_pendown_and_penup(self): | |
| tpen = turtle.TPen() | |
| self.assertTrue(tpen.isdown()) | |
| tpen.penup() | |
| self.assertFalse(tpen.isdown()) | |
| tpen.pendown() | |
| self.assertTrue(tpen.isdown()) | |
| def test_showturtle_hideturtle_and_isvisible(self): | |
| tpen = turtle.TPen() | |
| self.assertTrue(tpen.isvisible()) | |
| tpen.hideturtle() | |
| self.assertFalse(tpen.isvisible()) | |
| tpen.showturtle() | |
| self.assertTrue(tpen.isvisible()) | |
| def test_main(): | |
| support.run_unittest(TurtleConfigTest, TestVec2D, TestTNavigator, TestTPen) | |
| if __name__ == '__main__': | |
| test_main() |