diff -r 89eb5d9f7541 Lib/test/test_turtle_textonly.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Lib/test/test_turtle_textonly.py Mon Apr 13 16:00:18 2015 -0400 @@ -0,0 +1,393 @@ +from unittest.mock import patch +import unittest +import os +import io +import sys +from test import support + +turtle = support.import_module('turtle') + +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 = ''""" + +commented_test_config = """# Comments! + # Testing comments! + pencolor = red + fillcolor = blue + visible = False + language = english + # Some more + # comments + using_IDLE = False""" + +invalid_test_config = """pencolor: red""" + +boolean_test_config = """visible = None + using_IDLE = ''""" + +def get_stringio_config(config_string): + s = io.StringIO() + s.write(config_string) + s.seek(0) + return s + + +class TurtleConfigTestCase(unittest.TestCase): + @patch('builtins.open') + def test_config_dict(self, mock_open): + mock_open.return_value = get_stringio_config(test_config) + + results = turtle.config_dict('turtle.cfg') + + self.assertTrue(results['width'] == 0.75) + self.assertTrue(results['canvwidth'] == 500) + + self.assertTrue(results['shape'] == 'circle') + self.assertTrue(results['pencolor'] == 'red') + + self.assertTrue(results['visible'] == None) + self.assertTrue(results['using_IDLE'] == '') + + @patch('builtins.open') + def test_config_dict_comments(self, mock_open): + mock_open.return_value = get_stringio_config(commented_test_config) + + results = turtle.config_dict('turtle.cfg') + + self.assertTrue(results['pencolor'] == 'red') + + @patch('builtins.open') + def test_config_dict_invalid_cfg(self, mock_open): + mock_open.return_value = get_stringio_config(invalid_test_config) + + old_stdout = sys.stdout + + test_stdout = io.StringIO() + sys.stdout = test_stdout + + results = turtle.config_dict('turtle.cfg') + + output = test_stdout.getvalue().strip() + sys.stdout = old_stdout + + self.assertTrue(output == "Bad line in config-file turtle.cfg:\npencolor: red") + self.assertTrue(results == {}) + + @patch('turtle.isfile') + @patch('builtins.open') + def test_read_config(self, mock_open, mock_isfile): + mock_open.side_effect = lambda n, m: get_stringio_config(test_config) + mock_isfile.return_value = True + + turtle.readconfig(turtle._CFG) + + self.assertTrue(turtle._CFG['pencolor'] == 'red') + + +class TestVec2D(unittest.TestCase): + def assertVecAlmostEqual(self, value1, value2): + if len(value1) != len(value2): + self.fail("Tuples are not of equal size") + for i, j in zip(value1, value2): + self.assertAlmostEqual(i, j) + + def test_vector_addition(self): + vec1 = turtle.Vec2D(0,0) + vec2 = turtle.Vec2D(1,1) + answer = vec1 + vec2 + expected = (1.0,1.0) + self.assertVecAlmostEqual(answer, expected) + + vec1 = turtle.Vec2D(-1, 0) + vec2 = turtle.Vec2D(2, 2) + answer = vec1 + vec2 + expected = (1, 2) + self.assertVecAlmostEqual(answer, expected) + + vec1 = turtle.Vec2D(1.5, 0) + vec2 = turtle.Vec2D(1, 1) + answer = vec1 + vec2 + expected = (2.5, 1) + self.assertVecAlmostEqual(answer, expected) + + def test_vector_subtraction(self): + vec1 = turtle.Vec2D(0, 0) + vec2 = turtle.Vec2D(1, 1) + answer = vec1 - vec2 + expected = turtle.Vec2D(-1, -1) + self.assertVecAlmostEqual(answer, expected) + + vec1 = turtle.Vec2D(10.6, 0.1) + vec2 = turtle.Vec2D(10, 0) + answer = vec1 - vec2 + expected = turtle.Vec2D(0.6, 0.1) + self.assertVecAlmostEqual(answer, expected) + + def test_vector_multiply(self): + vec1 = turtle.Vec2D(10, 10) + vec2 = turtle.Vec2D(0.5, 3) + answer = vec1 * vec2 + expected = 35 + self.assertAlmostEqual(answer, expected) + + vec = turtle.Vec2D(0.5, 3) + answer = vec * 10 + expected = turtle.Vec2D(5, 30) + self.assertVecAlmostEqual(answer, expected) + + def test_vector_negative(self): + vec = turtle.Vec2D(10, -10) + expected = (-10, 10) + self.assertVecAlmostEqual(-vec, expected) + + def test_distance(self): + vec = turtle.Vec2D(6, 8) + expected = 10 + self.assertEqual(abs(vec), expected) + + vec = turtle.Vec2D(0, 0) + expected = 0 + self.assertEqual(abs(vec), expected) + + vec = turtle.Vec2D(2.5, 6) + expected = 6.5 + self.assertEqual(abs(vec), expected) + + def test_rotate(self): + vec = turtle.Vec2D(0, 1) + rotated_vec = vec.rotate(90) + expected = turtle.Vec2D(-1, 0) + self.assertVecAlmostEqual(rotated_vec, expected) + + rotated_vec = vec.rotate(-90) + expected = turtle.Vec2D(1, 0) + self.assertVecAlmostEqual(rotated_vec, expected) + + rotated_vec = vec.rotate(180) + expected = turtle.Vec2D(0, -1) + self.assertVecAlmostEqual(rotated_vec, expected) + + rotated_vec = vec.rotate(45) + expected = turtle.Vec2D(-(1/(2**0.5)), 1/(2**0.5)) + self.assertVecAlmostEqual(rotated_vec, expected) + + rotated_vec = vec.rotate(360) + self.assertAlmostEqual(rotated_vec, vec) + + +class TestTNavigator(unittest.TestCase): + def assertVecAlmostEqual(self, value1, value2): + if len(value1) != len(value2): + self.fail("Tuples are not of equal size") + for i, j in zip(value1, value2): + self.assertAlmostEqual(i, j) + + 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.assertVecAlmostEqual(self.nav._orient, (0.0, 1.0)) + + def test_right(self): + self.assertEqual(self.nav._orient, (1.0, 0)) + self.nav.right(90) + self.assertVecAlmostEqual(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 = turtle.Vec2D(150, 0) + self.assertVecAlmostEqual(self.nav.position(), expected) + + self.nav.reset() + self.nav.left(90) + self.nav.forward(150) + expected = turtle.Vec2D(0, 150) + self.assertVecAlmostEqual(self.nav.position(), expected) + + self.assertRaises(TypeError, self.nav.forward, 'skldjfldsk') + + def test_backwards(self): + self.nav.back(200) + expected = turtle.Vec2D(-200, 0) + self.assertVecAlmostEqual(self.nav.position(), expected) + + self.nav.reset() + self.nav.right(90) + self.nav.back(200) + expected = turtle.Vec2D(0, 200) + self.assertVecAlmostEqual(self.nav.position(), expected) + + def test_distance(self): + self.nav.forward(100) + expected = 100 + self.assertAlmostEqual(self.nav.distance(turtle.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 = { + # name: coordinates, expected + 'east': ((100, 0), 0.0), + 'north_east': ((100, 100), 45.0), + 'north': ((0, 100), 90.0), + 'north_west': ((-100, 100), 135.0), + 'west': ((-100, 0), 180.0), + 'south_west': ((-100, -100), 225.0), + 'south': ((0, -100), 270.0), + 'south_east': ((100, -100), 315.0), + } + + for orientation, (coordinates, expected) in coordinates.items(): + + angle = self.nav.towards(*coordinates) + self.assertEqual( + angle, expected, 'Failed for {}'.format(orientation) + ) + angle = self.nav.towards(turtle.Vec2D(*coordinates)) + self.assertEqual( + angle, expected, 'Failed for {} as Vec2D'.format(orientation) + ) + angle = self.nav.towards(tuple(coordinates)) + self.assertEqual( + angle, expected, 'Failed for {} as tuple'.format(orientation) + ) + + 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)) + sum_so_far = 360 + num + sum_so_far + 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(), 360-123.23) + self.nav.setheading(-1000.34) + self.assertAlmostEqual(self.nav.heading(), (360-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.assertVecAlmostEqual(self.nav.pos(), (100.0, -200.0)) + + def test_setx_and_sety(self): + self.nav.setx(-1023.2334) + self.nav.sety(193323.234) + self.assertVecAlmostEqual(self.nav.pos(), (-1023.2334, 193323.234)) + + def test_home(self): + self.nav.left(30) + self.nav.forward(-100000) + self.nav.home() + self.assertVecAlmostEqual(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 = turtle.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._drawing) + tpen.penup() + self.assertFalse(tpen._drawing) + tpen.pendown() + self.assertTrue(tpen._drawing) + + 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())