import math import unittest from math import sqrt from pygame import FRect, Rect, Vector2, Vector3 from pygame.geometry import Circle, Line def float_range(a, b, step): result = [] current_value = a while current_value < b: result.append(current_value) current_value += step return result class CircleTypeTest(unittest.TestCase): def testConstruction_invalid_type(self): """Checks whether passing wrong types to the constructor raises the appropriate errors """ invalid_types = (None, [], "1", (1,), [1, 2, 3], Vector2(1, 1)) # Test x for value in invalid_types: with self.assertRaises(TypeError): c = Circle(value, 0, 1) # Test y for value in invalid_types: with self.assertRaises(TypeError): c = Circle(0, value, 1) # Test r for value in invalid_types + (-1,): with self.assertRaises(TypeError): c = Circle(0, 0, value) def test2ndConstruction_invalid_type(self): """Checks whether passing wrong types to the 2nd constructor raises the appropriate errors """ invalid_types = (None, [], "1", (1,), [1, 2, 3], Vector2(1, 1)) # Test x for value in invalid_types: with self.assertRaises(TypeError): c = Circle((value, 0), 1) # Test y for value in invalid_types: with self.assertRaises(TypeError): c = Circle((0, value), 1) # Test r for value in invalid_types + (-1,): with self.assertRaises(TypeError): c = Circle((0, 0), value) def testConstruction_invalid_arguments_number(self): """Checks whether passing the wrong number of arguments to the constructor raises the appropriate errors """ arguments = ( (1,), # one non vec3 non circle arg (1, 1, 1, 1), # four args ) for arg_seq in arguments: with self.assertRaises(TypeError): c = Circle(*arg_seq) def testConstructionXYR_float(self): c = Circle(1.0, 2.0, 3.0) self.assertEqual(1.0, c.x) self.assertEqual(2.0, c.y) self.assertEqual(3.0, c.r) def testConstructionTUP_XYR_float(self): c = Circle((1.0, 2.0, 3.0)) self.assertEqual(1.0, c.x) self.assertEqual(2.0, c.y) self.assertEqual(3.0, c.r) def testConstructionXYR_int(self): c = Circle(1, 2, 3) self.assertEqual(1.0, c.x) self.assertEqual(2.0, c.y) self.assertEqual(3.0, c.r) def testConstructionTUP_XYR_int(self): c = Circle((1, 2, 3)) self.assertEqual(1.0, c.x) self.assertEqual(2.0, c.y) self.assertEqual(3.0, c.r) def testConstruction_zero_radius(self): c = Circle(1, 2, 0) self.assertEqual(1.0, c.x) self.assertEqual(2.0, c.y) self.assertEqual(0, c.r) def test_x(self): """Ensures changing the x attribute moves the circle and does not change the circle's radius. """ expected_x = 10.0 expected_y = 2.0 expected_radius = 5.0 c = Circle(1, expected_y, expected_radius) c.x = expected_x self.assertEqual(c.x, expected_x) self.assertEqual(c.y, expected_y) self.assertEqual(c.r, expected_radius) def test_x__invalid_value(self): """Ensures the x attribute handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): c.x = value def test_x__del(self): """Ensures the x attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.x def test_y(self): """Ensures changing the y attribute moves the circle and does not change the circle's radius. """ expected_x = 10.0 expected_y = 2.0 expected_radius = 5.0 c = Circle(expected_x, 1, expected_radius) c.y = expected_y self.assertEqual(c.x, expected_x) self.assertEqual(c.y, expected_y) self.assertEqual(c.r, expected_radius) def test_y__invalid_value(self): """Ensures the y attribute handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): c.y = value def test_y__del(self): """Ensures the y attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.y def test_r(self): """Ensures changing the r attribute changes the radius without moving the circle.""" expected_x = 10.0 expected_y = 2.0 expected_radius = 5.0 c = Circle(expected_x, expected_y, 1.0) c.r = expected_radius self.assertEqual(c.x, expected_x) self.assertEqual(c.y, expected_y) self.assertEqual(c.r, expected_radius) c.radius = expected_radius self.assertEqual(c.x, expected_x) self.assertEqual(c.y, expected_y) self.assertEqual(c.radius, expected_radius) def test_r__invalid_value(self): """Ensures the r attribute handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): c.r = value with self.assertRaises(TypeError): c.radius = value for value in (-10.3234, -1): with self.assertRaises(ValueError): c.r = value with self.assertRaises(ValueError): c.radius = value def test_r__del(self): """Ensures the r attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.r with self.assertRaises(AttributeError): del c.radius def test_r_sqr(self): """Ensures setting the r_sqr attribute matches the r_sqr passed""" expected_r_sqr = 10.0 c = Circle(1.0, 1.0, 1.0) c.r_sqr = expected_r_sqr self.assertAlmostEqual(c.r_sqr, expected_r_sqr, places=14) def test_r_to_r_sqr(self): """Ensures changing the r attribute correctly changes the r_sqr attribute.""" expected_r_sqr = 1.0 expected_r_sqr2 = 100.0 c = Circle(0, 0, 23) c2 = Circle(0, 0, 4) c.r = 1 self.assertEqual(c.r_sqr, expected_r_sqr) c2.r = 10 self.assertEqual(c2.r_sqr, expected_r_sqr2) def test_r_sqr_to_r(self): """Ensures changing the r_sqr attribute correctly changes the r attribute.""" expected_r = 2.0 c = Circle(0, 0, 23) c.r_sqr = 4.0 self.assertEqual(c.r, expected_r) self.assertEqual(c.radius, expected_r) c.r_sqr = 13.33421 self.assertEqual(c.r, sqrt(13.33421)) self.assertEqual(c.radius, sqrt(13.33421)) def test_r_sqr__invalid_set(self): """Ensures the r_sqr attribute can't be set""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): c.r_sqr = value def test_r_sqr__del(self): """Ensures the r attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.r def test_center(self): """Ensures changing the center moves the circle and does not change the circle's radius. """ expected_x = 10.3 expected_y = 2.12 expected_radius = 5.0 c = Circle(1, 1, expected_radius) c.center = (expected_x, expected_y) self.assertEqual(c.x, expected_x) self.assertEqual(c.y, expected_y) self.assertEqual(c.r, expected_radius) def test_center_update(self): """Ensures changing the x or y value of the circle correctly updates the center.""" expected_x = 10.3 expected_y = 2.12 expected_radius = 5.0 c = Circle(1, 1, expected_radius) c.x = expected_x self.assertEqual(c.center, (expected_x, c.y)) c.y = expected_y self.assertEqual(c.center, (c.x, expected_y)) def test_center_invalid_value(self): """Ensures the center attribute handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): c.center = value def test_center_del(self): """Ensures the center attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.center def test_top(self): """Ensures changing the top attribute moves the circle and does not change the circle's radius.""" expected_radius = 5.0 for pos in [ (1, 0), (0, 0), (-1, 0), (0, -1), (1, 1), (-1, -1), (-1, 1), (1, -1), ]: c = Circle((0, 0), expected_radius) c.top = pos self.assertEqual(pos[0], c.x) self.assertEqual(pos[1], c.y - expected_radius) self.assertEqual(expected_radius, c.r) def test_top_update(self): """Ensures changing the x or y value of the circle correctly updates the top.""" expected_x = 10.3 expected_y = 2.12 expected_radius = 5.0 c = Circle(1, 1, expected_radius) c.x = expected_x self.assertEqual(c.top, (expected_x, c.y - expected_radius)) c.y = expected_y self.assertEqual(c.top, (c.x, expected_y - expected_radius)) def test_top_invalid_value(self): """Ensures the top attribute handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3], True, False): with self.assertRaises(TypeError): c.top = value def test_top_del(self): """Ensures the top attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.top def test_left(self): """Ensures changing the left attribute moves the circle and does not change the circle's radius.""" expected_radius = 5.0 for pos in [ (1, 0), (0, 0), (-1, 0), (0, -1), (1, 1), (-1, -1), (-1, 1), (1, -1), ]: c = Circle((0, 0), expected_radius) c.left = pos self.assertEqual(pos[0], c.x - expected_radius) self.assertEqual(pos[1], c.y) self.assertEqual(expected_radius, c.r) def test_left_update(self): """Ensures changing the x or y value of the circle correctly updates the left.""" expected_x = 10.3 expected_y = 2.12 expected_radius = 5.0 c = Circle(1, 1, expected_radius) c.x = expected_x self.assertEqual(c.left, (expected_x - expected_radius, c.y)) c.y = expected_y self.assertEqual(c.left, (c.x - expected_radius, expected_y)) def test_left_invalid_value(self): """Ensures the left attribute handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3], True, False): with self.assertRaises(TypeError): c.left = value def test_left_del(self): """Ensures the left attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.left def test_right(self): """Ensures changing the right attribute moves the circle and does not change the circle's radius.""" expected_radius = 5.0 for pos in [ (1, 0), (0, 0), (-1, 0), (0, -1), (1, 1), (-1, -1), (-1, 1), (1, -1), ]: c = Circle((0, 0), expected_radius) c.right = pos self.assertEqual(pos[0], c.x + expected_radius) self.assertEqual(pos[1], c.y) self.assertEqual(expected_radius, c.r) def test_right_update(self): """Ensures changing the x or y value of the circle correctly updates the right.""" expected_x = 10.3 expected_y = 2.12 expected_radius = 5.0 c = Circle(1, 1, expected_radius) c.x = expected_x self.assertEqual(c.right, (expected_x + expected_radius, c.y)) c.y = expected_y self.assertEqual(c.right, (c.x + expected_radius, expected_y)) def test_right_invalid_value(self): """Ensures the right attribute handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3], True, False): with self.assertRaises(TypeError): c.right = value def test_right_del(self): """Ensures the right attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.right def test_bottom(self): """Ensures changing the bottom attribute moves the circle and does not change the circle's radius.""" expected_radius = 5.0 for pos in [ (1, 0), (0, 0), (-1, 0), (0, -1), (1, 1), (-1, -1), (-1, 1), (1, -1), ]: c = Circle((0, 0), expected_radius) c.bottom = pos self.assertEqual(pos[0], c.x) self.assertEqual(pos[1], c.y + expected_radius) self.assertEqual(expected_radius, c.r) def test_bottom_update(self): """Ensures changing the x or y value of the circle correctly updates the bottom.""" expected_x = 10.3 expected_y = 2.12 expected_radius = 5.0 c = Circle(1, 1, expected_radius) c.x = expected_x self.assertEqual(c.bottom, (expected_x, c.y + expected_radius)) c.y = expected_y self.assertEqual(c.bottom, (c.x, expected_y + expected_radius)) def test_bottom_invalid_value(self): """Ensures the bottom attribute handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3], True, False): with self.assertRaises(TypeError): c.bottom = value def test_bottom_del(self): """Ensures the bottom attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.bottom def test_area(self): """Ensures the area is calculated correctly.""" c = Circle(0, 0, 1) self.assertEqual(c.area, math.pi) def test_area_update(self): """Ensures the area is updated correctly.""" c = Circle(0, 0, 1) c.r = 2 self.assertEqual(c.area, math.pi * 4) c.r_sqr = 100 self.assertEqual(c.area, math.pi * (10**2)) def test_area_invalid_value(self): """Ensures the area handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): c.area = value for value in (-10.3234, -1): with self.assertRaises(ValueError): c.area = value def test_area_del(self): """Ensures the area attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.area def test_circumference(self): """Ensures the circumference is calculated correctly.""" c = Circle(0, 0, 1) self.assertEqual(c.circumference, math.tau) def test_circumference_update(self): """Ensures the circumference is updated correctly.""" c = Circle(0, 0, 1) c.r = 2 self.assertEqual(c.circumference, math.tau * 2) c.r_sqr = 100 self.assertEqual(c.circumference, math.tau * 10) def test_circumference_invalid_value(self): """Ensures the circumference handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): c.circumference = value for value in (-10.3234, -1): with self.assertRaises(ValueError): c.circumference = value def test_circumference_del(self): """Ensures the circumference attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.circumference def test_diameter(self): """Ensures the diameter is calculated correctly.""" c = Circle(0, 0, 1) self.assertEqual(c.diameter, 2.0) self.assertEqual(c.d, 2.0) def test_diameter_update(self): """Ensures the diameter is updated correctly.""" c = Circle(0, 0, 1) c.r = 2 self.assertEqual(c.diameter, 4.0) self.assertEqual(c.d, 4.0) c.r_sqr = 100 self.assertEqual(c.diameter, 20.0) self.assertEqual(c.d, 20.0) def test_diameter_invalid_value(self): """Ensures the diameter handles invalid values correctly.""" c = Circle(0, 0, 1) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): c.diameter = value for value in (-10.3234, -1): with self.assertRaises(ValueError): c.diameter = value with self.assertRaises(ValueError): c.d = value def test_diameter_del(self): """Ensures the diameter attribute can't be deleted.""" c = Circle(0, 0, 1) with self.assertRaises(AttributeError): del c.diameter with self.assertRaises(AttributeError): del c.d def test__str__(self): """Checks whether the __str__ method works correctly.""" c_str = "Circle((10.3, 3.2), 4.3)" circle = Circle((10.3, 3.2), 4.3) self.assertEqual(str(circle), c_str) self.assertEqual(circle.__str__(), c_str) def test__repr__(self): """Checks whether the __repr__ method works correctly.""" c_repr = "Circle((10.3, 3.2), 4.3)" circle = Circle((10.3, 3.2), 4.3) self.assertEqual(repr(circle), c_repr) self.assertEqual(circle.__repr__(), c_repr) def test_copy(self): c = Circle(10, 10, 4) # check 1 arg passed with self.assertRaises(TypeError): c.copy(10) # check copied circle has the same attribute values c_2 = c.copy() self.assertEqual(c.x, c_2.x) self.assertEqual(c.y, c_2.y) self.assertEqual(c.r, c_2.r) # check c2 is not c self.assertIsNot(c_2, c) def test_collidepoint_argtype(self): """tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, [], "1", (1,), Vector3(1, 1, 1), 1) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.collidepoint(value) def test_collidepoint_argnum(self): c = Circle(10, 10, 4) args = [tuple(range(x)) for x in range(3, 13)] # no params with self.assertRaises(TypeError): c.collidepoint() # too many params for arg in args: with self.assertRaises(TypeError): c.collidepoint(*arg) def test_collidepoint(self): c = Circle(0, 0, 5) p1 = (3, 3) p2 = (10, 10) p3 = Vector2(3, 3) p4 = Vector2(10, 10) # colliding single self.assertTrue(c.collidepoint(p1), "Expected True, point should collide here") self.assertTrue(c.collidepoint(p3), "Expected True, point should collide here") # not colliding single self.assertFalse( c.collidepoint(p2), "Expected False, point should not collide here" ) self.assertFalse( c.collidepoint(p4), "Expected False, point should not collide here" ) # colliding 2 args self.assertTrue( c.collidepoint(3, 3), "Expected True, point should collide here" ) # not colliding 2 args self.assertFalse( c.collidepoint(10, 10), "Expected False, point should not collide here" ) def test_collidecircle_argtype(self): """tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, [], "1", (1,), Vector2(1, 1), 1) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.collidecircle(value) def test_collidecircle_argnum(self): c = Circle(10, 10, 4) # no params with self.assertRaises(TypeError): c.collidecircle() with self.assertRaises(TypeError): c.collidecircle(Circle(10, 10, 4), Circle(10, 10, 4)) def test_collidecircle(self): c = Circle(0, 0, 5) c_same = c.copy() c2 = Circle(10, 0, 5) c3 = Circle(100, 100, 5) c4 = Circle(10, 0, 4.999999999999) c5 = Circle(0, 0, 2) c6 = Circle(10, 0, 7) # touching self.assertTrue( c.collidecircle(c2), "Expected True, circles should collide here" ) # partly colliding self.assertTrue( c.collidecircle(c6), "Expected True, circles should collide here" ) # self colliding self.assertTrue( c.collidecircle(c), "Expected True, circles should collide with self" ) # completely colliding self.assertTrue( c.collidecircle(c_same), "Expected True, circles should collide with self" ) # not touching self.assertFalse( c.collidecircle(c3), "Expected False, circles should not collide here" ) # barely not touching self.assertFalse( c.collidecircle(c4), "Expected False, circles should not collide here" ) # small circle inside big circle self.assertTrue( c.collidecircle(c5), "Expected True, circles should collide here" ) # big circle outside small circle self.assertTrue( c5.collidecircle(c), "Expected False, circles should collide here" ) def test_colliderect_argtype(self): """tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, [], "1", (1,), Vector3(1, 1, 1), 1, True, False) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.colliderect(value) def test_colliderect_argnum(self): """tests if the function correctly handles incorrect number of parameters""" c = Circle(10, 10, 4) args = [(1), (1, 1), (1, 1, 1), (1, 1, 1, 1, 1)] # no params with self.assertRaises(TypeError): c.colliderect() # invalid num for arg in args: with self.assertRaises(TypeError): c.colliderect(*arg) def test_colliderect(self): """ensures the function correctly detects collisions with rects""" msgt = "Expected True, rect should collide here" msgf = "Expected False, rect should not collide here" # ==================================================== c = Circle(0, 0, 5) r1, r2, r3 = Rect(2, 2, 4, 4), Rect(10, 15, 43, 24), Rect(0, 5, 4, 4) fr1, fr2, fr3 = FRect(r1), FRect(r2), FRect(r3) # colliding single for r in (r1, fr1): self.assertTrue(c.colliderect(r), msgt) # not colliding single for r in (r2, fr2): self.assertFalse(c.colliderect(r), msgf) # barely colliding single for r in (r3, fr3): self.assertTrue(c.colliderect(r), msgt) # colliding 4 args self.assertTrue(c.colliderect(2, 2, 4, 4), msgt) # not colliding 4 args self.assertFalse(c.colliderect(10, 15, 43, 24), msgf) # barely colliding single self.assertTrue(c.colliderect(0, 4.9999999999999, 4, 4), msgt) # ensure FRects aren't truncated c2 = Circle(0, 0, 0.35) c3 = Circle(2, 0, 0.65) fr9 = FRect(0.4, 0.0, 1, 1) self.assertFalse(c2.colliderect(fr9), msgf) self.assertFalse(c2.colliderect(0.4, 0.0, 1, 1), msgf) self.assertFalse(c2.colliderect((0.4, 0.0), (1, 1)), msgf) self.assertTrue(c3.colliderect(fr9), msgt) self.assertTrue(c3.colliderect(0.4, 0.0, 1, 1), msgt) self.assertTrue(c3.colliderect((0.4, 0.0), (1, 1)), msgt) def test_collideswith_argtype(self): """tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, [], "1", (1,), Vector3(1, 1, 1), 1) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.collideswith(value) def test_collideswith_argnum(self): c = Circle(10, 10, 4) args = [tuple(range(x)) for x in range(2, 4)] # no params with self.assertRaises(TypeError): c.collideswith() # too many params for arg in args: with self.assertRaises(TypeError): c.collideswith(*arg) def test_collideswith(self): """Ensures the collideswith function correctly registers collisions with circles, lines, rects and points""" c = Circle(0, 0, 5) # circle c2 = Circle(0, 10, 15) c3 = Circle(100, 100, 1) self.assertTrue(c.collideswith(c2)) self.assertFalse(c.collideswith(c3)) # rect r = Rect(0, 0, 10, 10) r2 = Rect(50, 0, 10, 10) self.assertTrue(c.collideswith(r)) self.assertFalse(c.collideswith(r2)) # rect r = FRect(0, 0, 10, 10) r2 = FRect(50, 0, 10, 10) self.assertTrue(c.collideswith(r)) self.assertFalse(c.collideswith(r2)) # point p = (0, 0) p2 = (50, 0) self.assertTrue(c.collideswith(p)) self.assertFalse(c.collideswith(p2)) def test_collidelist_argtype(self): """Tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, "1", (1,), 1, (1, 2, 3), True, False) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.collidelist(value) def test_collidelist_argnum(self): """Tests if the function correctly handles incorrect number of parameters""" c = Circle(10, 10, 4) circles = [(Circle(10, 10, 4), Circle(10, 10, 4))] with self.assertRaises(TypeError): c.collidelist() with self.assertRaises(TypeError): c.collidelist(circles, 1) def test_collidelist_return_type(self): """Tests if the function returns the correct type""" c = Circle(10, 10, 4) objects = [ Circle(10, 10, 4), Rect(10, 10, 4, 4), ] for object in objects: self.assertIsInstance(c.collidelist([object]), int) def test_collidelist(self): """Ensures that the collidelist method works correctly""" c = Circle(10, 10, 4) circles = [Circle(1000, 1000, 2), Circle(5, 10, 5), Circle(16, 10, 7)] rects = [Rect(1000, 1000, 4, 4), Rect(1000, 200, 5, 5), Rect(5, 10, 7, 3)] points = [(-10, -10), Vector2(1, 1), Vector2(10, -20), (10, 10)] expected = [1, 2, 3] for objects, expected in zip([circles, rects, points], expected): self.assertEqual(c.collidelist(objects), expected) def test_collidelistall_argtype(self): """Tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, "1", (1,), 1, (1, 2, 3), True, False) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.collidelistall(value) def test_collidelistall_argnum(self): """Tests if the function correctly handles incorrect number of parameters""" c = Circle(10, 10, 4) circles = [(Circle(10, 10, 4), Circle(10, 10, 4))] with self.assertRaises(TypeError): c.collidelistall() with self.assertRaises(TypeError): c.collidelistall(circles, 1) def test_collidelistall_return_type(self): """Tests if the function returns the correct type""" c = Circle(10, 10, 4) objects = [ Circle(10, 10, 4), Rect(10, 10, 4, 4), (10, 10), Vector2(9, 9), ] for object in objects: self.assertIsInstance(c.collidelistall([object]), list) def test_collidelistall(self): """Ensures that the collidelistall method works correctly""" c = Circle(10, 10, 4) circles = [Circle(1000, 1000, 2), Circle(5, 10, 5), Circle(16, 10, 7)] rects = [Rect(1000, 1000, 4, 4), Rect(1000, 200, 5, 5), Rect(5, 10, 7, 3)] points = [Vector2(-10, -10), (8, 8), (10, -20), Vector2(10, 10)] expected = [[1, 2], [2], [1, 3]] for objects, expected in zip([circles, rects, points], expected): self.assertEqual(c.collidelistall(objects), expected) def test_update(self): """Ensures that updating the circle position and dimension correctly updates position and dimension""" c = Circle(0, 0, 10) c.update(5, 5, 3) self.assertEqual(c.x, 5.0) self.assertEqual(c.y, 5.0) self.assertEqual(c.r, 3.0) self.assertEqual(c.r_sqr, 9.0) def test_update_argtype(self): """tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, [], "1", (1,), Vector2(1, 1), 1, 0.2324) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.update(value) def test_update_argnum(self): c = Circle(10, 10, 4) # no params with self.assertRaises(TypeError): c.update() # too many params with self.assertRaises(TypeError): c.update(1, 1, 1, 1) def test_update_twice(self): """Ensures that updating the circle position and dimension correctly updates position and dimension""" c = Circle(0, 0, 10) c.update(5, 5, 3) c.update(0, 0, 10) self.assertEqual(c.x, 0.0) self.assertEqual(c.y, 0.0) self.assertEqual(c.r, 10) self.assertEqual(c.r_sqr, 100) def test_update_inplace(self): """Ensures that updating the circle to its position doesn't move the circle to another position""" c = Circle(0, 0, 10) centerx = c.x centery = c.y c_r = c.r c_r_sqr = c.r_sqr c.update(0, 0, 10) self.assertEqual(c.x, centerx) self.assertEqual(c.y, centery) self.assertEqual(c.r, c_r) self.assertEqual(c.r_sqr, c_r_sqr) c.update(c) def test_selfupdate(self): """Ensures that updating the circle to its position doesn't move the circle to another position""" c = Circle(0, 0, 10) centerx = c.x centery = c.y c_r = c.r c_r_sqr = c.r_sqr c.update(c) self.assertEqual(c.x, centerx) self.assertEqual(c.y, centery) self.assertEqual(c.r, c_r) self.assertEqual(c.r_sqr, c_r_sqr) def test_as_rect_invalid_args(self): c = Circle(0, 0, 10) invalid_args = [None, [], "1", (1,), Vector2(1, 1), 1] with self.assertRaises(TypeError): for arg in invalid_args: c.as_rect(arg) def test_as_rect(self): c = Circle(0, 0, 10) self.assertEqual(c.as_rect(), Rect(-10, -10, 20, 20)) def test_as_frect_invalid_args(self): c = Circle(0, 0, 10) invalid_args = [None, [], "1", (1,), Vector2(1, 1), 1] with self.assertRaises(TypeError): for arg in invalid_args: c.as_frect(arg) def test_as_frect(self): c = Circle(0, 0, 10) self.assertEqual(c.as_frect(), FRect(-10, -10, 20, 20)) def test_circle_richcompare(self): """Ensures that the circle correctly compares itself to other circles""" c = Circle(0, 0, 10) c2 = Circle(0, 0, 10) c3 = Circle(0, 0, 5) c4 = Circle(0, 0, 20) self.assertTrue(c == c2) self.assertFalse(c != c2) self.assertFalse(c == c3) self.assertTrue(c != c3) self.assertFalse(c == c4) self.assertTrue(c != c4) # self compare self.assertTrue(c == c) self.assertFalse(c != c) # not implemented compare with self.assertRaises(TypeError): c > c2 with self.assertRaises(TypeError): c < c2 with self.assertRaises(TypeError): c >= c2 with self.assertRaises(TypeError): c <= c2 # invalid types invalid_types = ( None, [], "1", (1,), Vector2(1, 1), 1, 0.2324, Rect(0, 0, 10, 10), True, ) for value in invalid_types: self.assertFalse(c == value) self.assertTrue(c != value) with self.assertRaises(TypeError): c > value with self.assertRaises(TypeError): c < value with self.assertRaises(TypeError): c >= value with self.assertRaises(TypeError): c <= value def test_move_invalid_args(self): """tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, [], "1", (1,), Vector3(1, 1, 3), Circle(3, 3, 1)) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.move(value) def test_move_argnum(self): c = Circle(10, 10, 4) invalid_args = [(1, 1, 1), (1, 1, 1, 1)] for arg in invalid_args: with self.assertRaises(TypeError): c.move(*arg) def test_move_return_type(self): c = Circle(10, 10, 4) class CircleSub(Circle): pass cs = CircleSub(10, 10, 4) self.assertIsInstance(c.move(1, 1), Circle) self.assertIsInstance(cs.move(1, 1), CircleSub) def test_move(self): """Ensures that moving the circle position correctly updates position""" c = Circle(0, 0, 3) new_c = c.move(5, 5) self.assertEqual(new_c.x, 5.0) self.assertEqual(new_c.y, 5.0) self.assertEqual(new_c.r, 3.0) self.assertEqual(new_c.r_sqr, 9.0) new_c = new_c.move(-5, -10) self.assertEqual(new_c.x, 0.0) self.assertEqual(new_c.y, -5.0) def test_move_inplace(self): """Ensures that moving the circle position by 0, 0 doesn't move the circle""" c = Circle(1, 1, 3) c.move(0, 0) self.assertEqual(c.x, 1.0) self.assertEqual(c.y, 1.0) self.assertEqual(c.r, 3.0) self.assertEqual(c.r_sqr, 9.0) def test_move_equality(self): """Ensures that moving the circle by 0, 0 will return a circle that's equal to the original""" c = Circle(1, 1, 3) new_c = c.move(0, 0) self.assertEqual(new_c, c) def test_move_ip_invalid_args(self): """tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, [], "1", (1,), Vector3(1, 1, 3), Circle(3, 3, 1)) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.move_ip(value) def test_move_ip_argnum(self): """tests if the function correctly handles incorrect number of args""" c = Circle(10, 10, 4) invalid_args = [(1, 1, 1), (1, 1, 1, 1)] for arg in invalid_args: with self.assertRaises(TypeError): c.move_ip(*arg) def test_move_ip(self): """Ensures that moving the circle position correctly updates position""" c = Circle(0, 0, 3) c.move_ip(5, 5) self.assertEqual(c.x, 5.0) self.assertEqual(c.y, 5.0) self.assertEqual(c.r, 3.0) self.assertEqual(c.r_sqr, 9.0) c.move_ip(-5, -10) self.assertEqual(c.x, 0.0) self.assertEqual(c.y, -5.0) def test_move_ip_inplace(self): """Ensures that moving the circle position by 0, 0 doesn't move the circle""" c = Circle(1, 1, 3) c.move_ip(0, 0) self.assertEqual(c.x, 1.0) self.assertEqual(c.y, 1.0) self.assertEqual(c.r, 3.0) self.assertEqual(c.r_sqr, 9.0) def test_move_ip_equality(self): """Ensures that moving the circle by 0, 0 will return a circle that's equal to the original""" c = Circle(1, 1, 3) c.move_ip(0, 0) self.assertEqual(c, Circle(1, 1, 3)) def test_move_ip_return_type(self): """Ensures that the move_ip method returns None""" c = Circle(10, 10, 4) class CircleSub(Circle): pass cs = CircleSub(10, 10, 4) self.assertEqual(type(c.move_ip(1, 1)), type(None)) self.assertEqual(type(cs.move_ip(1, 1)), type(None)) def test_meth_rotate_ip_invalid_argnum(self): """Ensures that the rotate_ip method correctly deals with invalid numbers of arguments.""" c = Circle(0, 0, 1) with self.assertRaises(TypeError): c.rotate_ip() invalid_args = [ (1, (2, 2), 2), (1, (2, 2), 2, 2), (1, (2, 2), 2, 2, 2), (1, (2, 2), 2, 2, 2, 2), (1, (2, 2), 2, 2, 2, 2, 2), (1, (2, 2), 2, 2, 2, 2, 2, 2), ] for args in invalid_args: with self.assertRaises(TypeError): c.rotate_ip(*args) def test_meth_rotate_ip_invalid_argtype(self): """Ensures that the rotate_ip method correctly deals with invalid argument types.""" c = Circle(0, 0, 1) invalid_args = [ ("a",), # angle str (None,), # angle str ((1, 2)), # angle tuple ([1, 2]), # angle list (1, "a"), # origin str (1, None), # origin None (1, True), # origin True (1, False), # origin False (1, (1, 2, 3)), # origin tuple (1, [1, 2, 3]), # origin list (1, (1, "a")), # origin str (1, ("a", 1)), # origin str (1, (1, None)), # origin None (1, (None, 1)), # origin None (1, (1, (1, 2))), # origin tuple (1, (1, [1, 2])), # origin list ] for value in invalid_args: with self.assertRaises(TypeError): c.rotate_ip(*value) def test_meth_rotate_ip_return(self): """Ensures that the rotate_ip method always returns None.""" c = Circle(0, 0, 1) for angle in float_range(-360, 360, 1): self.assertIsNone(c.rotate_ip(angle)) self.assertIsInstance(c.rotate_ip(angle), type(None)) def test_meth_rotate_invalid_argnum(self): """Ensures that the rotate method correctly deals with invalid numbers of arguments.""" c = Circle(0, 0, 1) with self.assertRaises(TypeError): c.rotate() invalid_args = [ (1, (2, 2), 2), (1, (2, 2), 2, 2), (1, (2, 2), 2, 2, 2), (1, (2, 2), 2, 2, 2, 2), (1, (2, 2), 2, 2, 2, 2, 2), (1, (2, 2), 2, 2, 2, 2, 2, 2), ] for args in invalid_args: with self.assertRaises(TypeError): c.rotate(*args) def test_meth_rotate_invalid_argtype(self): """Ensures that the rotate method correctly deals with invalid argument types.""" c = Circle(0, 0, 1) invalid_args = [ ("a",), # angle str (None,), # angle str ((1, 2)), # angle tuple ([1, 2]), # angle list (1, "a"), # origin str (1, None), # origin None (1, True), # origin True (1, False), # origin False (1, (1, 2, 3)), # origin tuple (1, [1, 2, 3]), # origin list (1, (1, "a")), # origin str (1, ("a", 1)), # origin str (1, (1, None)), # origin None (1, (None, 1)), # origin None (1, (1, (1, 2))), # origin tuple (1, (1, [1, 2])), # origin list ] for value in invalid_args: with self.assertRaises(TypeError): c.rotate(*value) def test_meth_rotate_return(self): """Ensures that the rotate method always returns a Circle.""" c = Circle(0, 0, 1) class CircleSubclass(Circle): pass cs = CircleSubclass(0, 0, 1) for angle in float_range(-360, 360, 1): self.assertIsInstance(c.rotate(angle), Circle) self.assertIsInstance(cs.rotate(angle), CircleSubclass) def test_meth_rotate(self): """Ensures the Circle.rotate() method rotates the Circle correctly.""" def rotate_circle(circle: Circle, angle, center): def rotate_point(x, y, rang, cx, cy): x -= cx y -= cy x_new = x * math.cos(rang) - y * math.sin(rang) y_new = x * math.sin(rang) + y * math.cos(rang) return x_new + cx, y_new + cy angle = math.radians(angle) cx, cy = center if center is not None else circle.center x, y = rotate_point(circle.x, circle.y, angle, cx, cy) return Circle(x, y, circle.r) def assert_approx_equal(circle1, circle2, eps=1e-12): self.assertAlmostEqual(circle1.x, circle2.x, delta=eps) self.assertAlmostEqual(circle1.y, circle2.y, delta=eps) self.assertAlmostEqual(circle1.r, circle2.r, delta=eps) c = Circle(0, 0, 1) angles = float_range(-360, 360, 0.5) centers = [(a, b) for a in range(-10, 10) for b in range(-10, 10)] for angle in angles: assert_approx_equal(c.rotate(angle), rotate_circle(c, angle, None)) for center in centers: assert_approx_equal( c.rotate(angle, center), rotate_circle(c, angle, center) ) def test_meth_rotate_ip(self): """Ensures the Circle.rotate_ip() method rotates the Circle correctly.""" def rotate_circle(circle: Circle, angle, center): def rotate_point(x, y, rang, cx, cy): x -= cx y -= cy x_new = x * math.cos(rang) - y * math.sin(rang) y_new = x * math.sin(rang) + y * math.cos(rang) return x_new + cx, y_new + cy angle = math.radians(angle) cx, cy = center if center is not None else circle.center x, y = rotate_point(circle.x, circle.y, angle, cx, cy) circle.x = x circle.y = y return circle def assert_approx_equal(circle1, circle2, eps=1e-12): self.assertAlmostEqual(circle1.x, circle2.x, delta=eps) self.assertAlmostEqual(circle1.y, circle2.y, delta=eps) self.assertAlmostEqual(circle1.r, circle2.r, delta=eps) c = Circle(0, 0, 1) angles = float_range(-360, 360, 0.5) centers = [(a, b) for a in range(-10, 10) for b in range(-10, 10)] for angle in angles: c.rotate_ip(angle) assert_approx_equal(c, rotate_circle(c, angle, None)) for center in centers: c.rotate_ip(angle, center) assert_approx_equal(c, rotate_circle(c, angle, center)) def test_contains_argtype(self): """Tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, [], "1", (1,), 1, (1, 2, 3)) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.contains(value) def test_contains_argnum(self): """Tests if the function correctly handles incorrect number of parameters""" c = Circle(10, 10, 4) invalid_args = [(Circle(10, 10, 4), Circle(10, 10, 4))] with self.assertRaises(TypeError): c.contains() for arg in invalid_args: with self.assertRaises(TypeError): c.contains(*arg) def test_contains_return_type(self): """Tests if the function returns the correct type""" c = Circle(10, 10, 4) items = [ Circle(3, 4, 15), (0, 0), Vector2(0, 0), Rect(0, 0, 10, 10), FRect(0, 0, 10, 10), ] for item in items: self.assertIsInstance(c.contains(item), bool) def test_contains_circle(self): """Ensures that the contains method correctly determines if a circle is contained within the circle""" c = Circle(10, 10, 4) c2 = Circle(10, 10, 2) c3 = Circle(100, 100, 5) c4 = Circle(16, 10, 7) # self self.assertTrue(c.contains(c)) # self-like c_s = Circle(c) self.assertTrue(c.contains(c_s)) # contained circle self.assertTrue(c.contains(c2)) # not contained circle self.assertFalse(c.contains(c3)) # intersecting circle self.assertFalse(c.contains(c4)) # bigger circle not contained in smaller circle self.assertFalse(c2.contains(c)) self.assertFalse(c3.contains(c4)) def test_contains_point(self): """Ensures that the contains method correctly determines if a point is contained within the circle""" c = Circle(10, 10, 4) p1 = (10, 10) p2 = (10, 15) p3 = (100, 100) p4 = (c.x + math.sin(math.pi / 4) * c.r, c.y + math.cos(math.pi / 4) * c.r) p1v = Vector2(p1) p2v = Vector2(p2) p3v = Vector2(p3) p4v = Vector2(p4) # contained point self.assertTrue(c.contains(p1)) # not contained point self.assertFalse(c.contains(p2)) self.assertFalse(c.contains(p3)) # on the edge self.assertTrue(c.contains(p4)) # contained point self.assertTrue(c.contains(p1v)) # not contained point self.assertFalse(c.contains(p2v)) self.assertFalse(c.contains(p3v)) # on the edge self.assertTrue(c.contains(p4v)) def test_contains_rect_frect(self): """Ensures that the contains method correctly determines if a rect is contained within the circle""" c = Circle(0, 0, 10) r1 = Rect(0, 0, 3, 3) r2 = Rect(10, 10, 10, 10) r3 = Rect(10, 10, 5, 5) angle = math.pi / 4 x = c.x - math.sin(angle) * c.r y = c.y - math.cos(angle) * c.r rx = c.x + math.sin(angle) * c.r ry = c.y + math.cos(angle) * c.r r_edge = Rect(x, y, rx - x, ry - y) fr1 = FRect(0, 0, 3, 3) fr2 = FRect(10, 10, 10, 10) fr3 = FRect(10, 10, 5, 5) fr_edge = FRect(x, y, rx - x, ry - y) # contained rect self.assertTrue(c.contains(r1)) # not contained rect self.assertFalse(c.contains(r2)) self.assertFalse(c.contains(r3)) # on the edge self.assertTrue(c.contains(r_edge)) # contained rect self.assertTrue(c.contains(fr1)) # not contained rect self.assertFalse(c.contains(fr2)) self.assertFalse(c.contains(fr3)) # on the edge self.assertTrue(c.contains(fr_edge)) def test_intersect_argtype(self): """Tests if the function correctly handles incorrect types as parameters""" invalid_types = (None, "1", (1,), 1, (1, 2, 3), True, False) c = Circle(10, 10, 4) for value in invalid_types: with self.assertRaises(TypeError): c.intersect(value) def test_intersect_argnum(self): """Tests if the function correctly handles incorrect number of parameters""" c = Circle(10, 10, 4) circles = [(Circle(10, 10, 4) for _ in range(100))] for size in range(len(circles)): with self.assertRaises(TypeError): c.intersect(*circles[:size]) def test_intersect_return_type(self): """Tests if the function returns the correct type""" c = Circle(10, 10, 4) objects = [ Circle(10, 10, 4), Circle(10, 10, 400), Circle(10, 10, 1), Circle(15, 10, 10), ] for object in objects: self.assertIsInstance(c.intersect(object), list) def test_intersect(self): # Circle c = Circle(10, 10, 4) c2 = Circle(10, 10, 2) c3 = Circle(100, 100, 1) c3_1 = Circle(10, 10, 400) c4 = Circle(16, 10, 7) c5 = Circle(18, 10, 4) for circle in [c, c2, c3, c3_1]: self.assertEqual(c.intersect(circle), []) # intersecting circle self.assertEqual( [(10.25, 6.007820144332172), (10.25, 13.992179855667828)], c.intersect(c4) ) # touching self.assertEqual([(14.0, 10.0)], c.intersect(c5)) class LineTypeTest(unittest.TestCase): class ClassWithLineAttrib: def __init__(self, line): self.line = line class ClassWithLineProperty: def __init__(self, line): self._line = line @property def line(self): return self._line class ClassWithLineFunction: def __init__(self, line): self._line = line def line(self): return self._line def testConstruction_invalid_type(self): """Checks whether passing wrong types to the constructor raises the appropriate errors """ invalid_types = (None, [], "1", (1,), [1, 2, 3], Vector2(1, 1)) # Test ax for value in invalid_types: with self.assertRaises(TypeError): Line(value, 0, 1, 2) # Test ay for value in invalid_types: with self.assertRaises(TypeError): Line(0, value, 1, 2) # Test bx for value in invalid_types: with self.assertRaises(TypeError): Line(0, 0, value, 2) # Test by for value in invalid_types: with self.assertRaises(TypeError): Line(0, 1, 2, value) # Test ax for value in invalid_types: with self.assertRaises(TypeError): Line((value, 0), (1, 2)) # Test ay for value in invalid_types: with self.assertRaises(TypeError): Line((0, value), (1, 2)) # Test bx for value in invalid_types: with self.assertRaises(TypeError): Line((0, 0), (value, 2)) # Test by for value in invalid_types: with self.assertRaises(TypeError): Line((0, 1), (2, value)) # Test ax for value in invalid_types: with self.assertRaises(TypeError): Line(((value, 0), (1, 2))) # Test ay for value in invalid_types: with self.assertRaises(TypeError): Line(((0, value), (1, 2))) # Test bx for value in invalid_types: with self.assertRaises(TypeError): Line(((0, 0), (value, 2))) # Test by for value in invalid_types: with self.assertRaises(TypeError): Line(((0, 1), (2, value))) def testConstruction_invalid_arguments_number(self): """Checks whether passing the wrong number of arguments to the constructor raises the appropriate errors """ arguments = ( (1,), # one non vec3 non circle arg (1, 1), # two args (1, 1, 1), # three args (1, 1, 1, 1, 1), # five args ) for arg_seq in arguments: with self.assertRaises(TypeError): Line(*arg_seq) def testConstructionaxabyxby_float(self): """Tests the construction of a line with 4 float arguments""" line = Line(1.0, 2.0, 3.0, 4.0) self.assertEqual(line.ax, 1.0) self.assertEqual(line.ay, 2.0) self.assertEqual(line.bx, 3.0) self.assertEqual(line.by, 4.0) def testConstructionTUP_axabyxby_float(self): """Tests the construction of a line with a tuple of 4 float arguments""" line = Line((1.0, 2.0, 3.0, 4.0)) self.assertEqual(line.ax, 1.0) self.assertEqual(line.ay, 2.0) self.assertEqual(line.bx, 3.0) self.assertEqual(line.by, 4.0) def testConstructionaxabyxby_int(self): """Tests the construction of a line with 4 int arguments""" line = Line(1, 2, 3, 4) self.assertEqual(line.ax, 1.0) self.assertEqual(line.ay, 2.0) self.assertEqual(line.bx, 3.0) self.assertEqual(line.by, 4.0) def testConstructionTUP_axabyxby_int(self): """Tests the construction of a line with a tuple of 4 int arguments""" line = Line((1, 2, 3, 4)) self.assertEqual(line.ax, 1.0) self.assertEqual(line.ay, 2.0) self.assertEqual(line.bx, 3.0) self.assertEqual(line.by, 4.0) def testConstruction_class_with_line_attrib(self): """Tests the construction of a line with a class that has a line attribute""" class_ = self.ClassWithLineAttrib(Line(1.1, 2.2, 3.3, 4.4)) line = Line(class_) self.assertEqual(line.ax, 1.1) self.assertEqual(line.ay, 2.2) self.assertEqual(line.bx, 3.3) self.assertEqual(line.by, 4.4) def testConstruction_class_with_line_property(self): """Tests the construction of a line with a class that has a line property""" class_ = self.ClassWithLineProperty(Line(1.1, 2.2, 3.3, 4.4)) line = Line(class_) self.assertEqual(line.ax, 1.1) self.assertEqual(line.ay, 2.2) self.assertEqual(line.bx, 3.3) self.assertEqual(line.by, 4.4) def testConstruction_class_with_line_function(self): """Tests the construction of a line with a class that has a line function""" class_ = self.ClassWithLineFunction(Line(1.1, 2.2, 3.3, 4.4)) line = Line(class_) self.assertEqual(line.ax, 1.1) self.assertEqual(line.ay, 2.2) self.assertEqual(line.bx, 3.3) self.assertEqual(line.by, 4.4) def test_attrib_x1(self): """a full test for the ax attribute""" expected_x1 = 10.0 expected_y1 = 2.0 expected_x2 = 5.0 expected_y2 = 6.0 line = Line(1, expected_y1, expected_x2, expected_y2) line.ax = expected_x1 self.assertEqual(line.ax, expected_x1) self.assertEqual(line.ay, expected_y1) self.assertEqual(line.bx, expected_x2) self.assertEqual(line.by, expected_y2) line = Line(0, 0, 1, 0) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): line.ax = value line = Line(0, 0, 1, 0) with self.assertRaises(AttributeError): del line.ax def test_attrib_y1(self): """a full test for the ay attribute""" expected_x1 = 10.0 expected_y1 = 2.0 expected_x2 = 5.0 expected_y2 = 6.0 line = Line(expected_x1, 1, expected_x2, expected_y2) line.ay = expected_y1 self.assertEqual(line.ax, expected_x1) self.assertEqual(line.ay, expected_y1) self.assertEqual(line.bx, expected_x2) self.assertEqual(line.by, expected_y2) line = Line(0, 0, 1, 0) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): line.ay = value line = Line(0, 0, 1, 0) with self.assertRaises(AttributeError): del line.ay def test_attrib_x2(self): """a full test for the ay attribute""" expected_x1 = 10.0 expected_y1 = 2.0 expected_x2 = 5.0 expected_y2 = 6.0 line = Line(expected_x1, expected_y1, 1, expected_y2) line.bx = expected_x2 self.assertEqual(line.ax, expected_x1) self.assertEqual(line.ay, expected_y1) self.assertEqual(line.bx, expected_x2) self.assertEqual(line.by, expected_y2) line = Line(0, 0, 1, 0) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): line.bx = value line = Line(0, 0, 1, 0) with self.assertRaises(AttributeError): del line.bx def test_attrib_y2(self): """a full test for the ay attribute""" expected_x1 = 10.0 expected_y1 = 2.0 expected_x2 = 5.0 expected_y2 = 6.0 line = Line(expected_x1, expected_y1, expected_x2, 1) line.by = expected_y2 self.assertEqual(line.ax, expected_x1) self.assertEqual(line.ay, expected_y1) self.assertEqual(line.bx, expected_x2) self.assertEqual(line.by, expected_y2) line = Line(0, 0, 1, 0) for value in (None, [], "1", (1,), [1, 2, 3]): with self.assertRaises(TypeError): line.by = value line = Line(0, 0, 1, 0) with self.assertRaises(AttributeError): del line.by def test_attrib_a(self): """a full test for the ay attribute""" expected_x1 = 10.0 expected_y1 = 2.0 expected_x2 = 5.0 expected_y2 = 6.0 expected_a = expected_x1, expected_y1 expected_b = expected_x2, expected_y2 line = Line((0, 1), expected_b) line.a = expected_a self.assertEqual(line.a, expected_a) self.assertEqual(line.b, expected_b) line = Line(0, 0, 1, 0) for value in (None, [], "1", (1,), [1, 2, 3], 1): with self.assertRaises(TypeError): line.a = value line = Line(0, 0, 1, 0) with self.assertRaises(AttributeError): del line.a def test_attrib_b(self): """a full test for the ay attribute""" expected_x1 = 10.0 expected_y1 = 2.0 expected_x2 = 5.0 expected_y2 = 6.0 expected_a = expected_x1, expected_y1 expected_b = expected_x2, expected_y2 line = Line(expected_a, (0, 1)) line.b = expected_b self.assertEqual(line.a, expected_a) self.assertEqual(line.b, expected_b) line = Line(0, 0, 1, 0) for value in (None, [], "1", (1,), [1, 2, 3], 1): with self.assertRaises(TypeError): line.b = value line = Line(0, 0, 1, 0) with self.assertRaises(AttributeError): del line.b def test_attrib_length(self): """a full test for the length attribute""" expected_length = 3.0 line = Line(1, 4, 4, 4) self.assertEqual(line.length, expected_length) line.ax = 2 expected_length = 2.0 self.assertEqual(line.length, expected_length) line.ax = 2.7 expected_length = 1.2999999999999998 self.assertAlmostEqual(line.length, expected_length) line.ay = 2 expected_length = 2.3853720883753127 self.assertAlmostEqual(line.length, expected_length) line.ay = 2.7 expected_length = 1.8384776310850233 self.assertAlmostEqual(line.length, expected_length) line.bx = 2 expected_length = 1.4764823060233399 self.assertAlmostEqual(line.length, expected_length) line.bx = 2.7 expected_length = 1.2999999999999998 self.assertAlmostEqual(line.length, expected_length) line.by = 2 expected_length = 0.7000000000000002 self.assertAlmostEqual(line.length, expected_length) line.by = 2.7 expected_length = 0.0 self.assertEqual(line.length, expected_length) line1 = Line(7, 3, 2, 3) line2 = Line(9, 5, 4, 5) self.assertEqual(line1.length, line2.length) line = Line(7.6, 3.2, 2.1, 3.8) expected_length = 5.532630477449222 self.assertAlmostEqual(line.length, expected_length) line = Line(-9.8, -5.2, -4.4, -5.6) expected_length = 5.414794548272353 self.assertAlmostEqual(line.length, expected_length) def test_meth_copy(self): line = Line(1, 2, 3, 4) # check 1 arg passed with self.assertRaises(TypeError): line.copy(10) line_2 = line.copy() self.assertEqual(line.ax, line_2.ax) self.assertEqual(line.by, line_2.by) self.assertEqual(line.bx, line_2.bx) self.assertEqual(line.by, line_2.by) self.assertIsNot(line, line_2) def test_meth_move(self): line = Line(1.1, 2.2, 3.3, 4.4) ret = line.move(1, 2) self.assertEqual(ret.ax, 2.1) self.assertEqual(ret.ay, 4.2) self.assertEqual(ret.bx, 4.3) self.assertEqual(ret.by, 6.4) with self.assertRaises(TypeError): line.move() with self.assertRaises(TypeError): line.move(1) with self.assertRaises(TypeError): line.move(1, 2, 3) with self.assertRaises(TypeError): line.move("1", "2") def test_meth_move_ip(self): line = Line(1.1, 2.2, 3.3, 4.4) line.move_ip(1, 2) self.assertEqual(line.ax, 2.1) self.assertEqual(line.ay, 4.2) self.assertEqual(line.bx, 4.3) self.assertEqual(line.by, 6.4) with self.assertRaises(TypeError): line.move_ip() with self.assertRaises(TypeError): line.move_ip(1) with self.assertRaises(TypeError): line.move_ip(1, 2, 3) with self.assertRaises(TypeError): line.move_ip("1", "2") def test_meth_scale(self): line = Line(0, 0, 10, 0).scale(2, 0) self.assertEqual(line.length, 20) line = Line(0, 0, 20, 0).scale(2.1, 0) self.assertEqual(line.length, 42) line = Line(0, 0, 10, 0).scale(4, 0) self.assertEqual(line.length, 40) line = Line(0, 0, 10, 0).scale(3, 0) self.assertEqual(line.length, 30) line = Line(10, 10, 20, 20).scale(2, 0) self.assertAlmostEqual(line.length, 28.284271247461902) line = Line(10, 10, 20, 20).scale(2, 0.5) self.assertAlmostEqual(line.length, 28.284271247461902) line = Line(10, 10, 20, 20).scale(2, 1) self.assertAlmostEqual(line.length, 28.284271247461902) with self.assertRaises(ValueError): line = line.scale(0, 0.5) with self.assertRaises(ValueError): line = line.scale(2, -0.1) with self.assertRaises(ValueError): line = line.scale(-2, -0.5) with self.assertRaises(ValueError): line = line.scale(17, 1.1) with self.assertRaises(ValueError): line = line.scale(17, 10.0) def test_meth_scale_ip(self): line = Line(0, 0, 10, 0) line.scale_ip(2, 0) self.assertEqual(line.length, 20) line = Line(0, 0, 20, 0) line.scale_ip(2.1, 0) self.assertEqual(line.length, 42) line = Line(0, 0, 10, 0) line.scale_ip(4, 0) self.assertEqual(line.length, 40) line = Line(0, 0, 10, 0) line.scale_ip(3, 0) self.assertEqual(line.length, 30) line = Line(10, 10, 20, 20) line.scale_ip(2, 0) self.assertAlmostEqual(line.length, 28.284271247461902) line = Line(10, 10, 20, 20) line.scale_ip(2, 0.5) self.assertAlmostEqual(line.length, 28.284271247461902) line = Line(10, 10, 20, 20) line.scale_ip(2, 1.0) self.assertAlmostEqual(line.length, 28.284271247461902) with self.assertRaises(ValueError): line.scale_ip(0, 0.5) with self.assertRaises(ValueError): line.scale_ip(2, -0.1) with self.assertRaises(ValueError): line.scale_ip(-2, -0.5) with self.assertRaises(ValueError): line.scale_ip(17, 1.1) with self.assertRaises(ValueError): line.scale_ip(17, 10.0) def test_meth_flip(self): line = Line(1.1, 2.2, 3.3, 4.4) ret = line.flip_ab() self.assertIsInstance(ret, Line) self.assertEqual(ret.ax, 3.3) self.assertEqual(ret.ay, 4.4) self.assertEqual(ret.bx, 1.1) self.assertEqual(ret.by, 2.2) with self.assertRaises(TypeError): line.flip_ab(1) def test_meth_flip_ab_ip(self): line = Line(1.1, 2.2, 3.3, 4.4) line.flip_ab_ip() self.assertEqual(line.ax, 3.3) self.assertEqual(line.ay, 4.4) self.assertEqual(line.bx, 1.1) self.assertEqual(line.by, 2.2) with self.assertRaises(TypeError): line.flip_ab_ip(1) def test_meth_update(self): line = Line(0, 0, 1, 1) line.update(1, 2, 3, 4) self.assertEqual(line.ax, 1) self.assertEqual(line.ay, 2) self.assertEqual(line.bx, 3) self.assertEqual(line.by, 4) line.update((5, 6), (7, 8)) self.assertEqual(line.ax, 5) self.assertEqual(line.ay, 6) self.assertEqual(line.bx, 7) self.assertEqual(line.by, 8) line.update((9, 10, 11, 12)) self.assertEqual(line.ax, 9) self.assertEqual(line.ay, 10) self.assertEqual(line.bx, 11) self.assertEqual(line.by, 12) with self.assertRaises(TypeError): line.update() with self.assertRaises(TypeError): line.update(1, 2, 3, 4, 5) with self.assertRaises(TypeError): line.update(1, 2, 3) def test_meth_project(self): line = Line(0, 0, 100, 100) test_point1 = (25, 75) test_clamp_point1 = (100, 300) test_clamp_point2 = (-50, -150) test_clamp_point3 = (-200, -200) bad_line = Line(0, 0, 0, 0) test_bad_line_point = (10, 10) projected_point = line.project(test_point1) self.assertEqual(math.ceil(projected_point[0]), 50) self.assertEqual(math.ceil(projected_point[1]), 50) projected_point = line.project(test_clamp_point1, clamp=True) self.assertEqual(math.ceil(projected_point[0]), 100) self.assertEqual(math.ceil(projected_point[1]), 100) projected_point = line.project(test_clamp_point2, clamp=True) self.assertEqual(math.ceil(projected_point[0]), 0) self.assertEqual(math.ceil(projected_point[1]), 0) projected_point = line.project(test_clamp_point3, clamp=True) self.assertEqual(math.ceil(projected_point[0]), 0) self.assertEqual(math.ceil(projected_point[1]), 0) projected_point = bad_line.project(test_bad_line_point, clamp=True) self.assertEqual(math.ceil(projected_point[0]), 0) self.assertEqual(math.ceil(projected_point[1]), 0) projected_point = bad_line.project(test_bad_line_point) self.assertEqual(math.ceil(projected_point[0]), 0) def test__str__(self): """Checks whether the __str__ method works correctly.""" l_str = "Line((10.1, 10.2), (4.3, 56.4))" line = Line(10.1, 10.2, 4.3, 56.4) self.assertEqual(str(line), l_str) self.assertEqual(line.__str__(), l_str) def test__repr__(self): """Checks whether the __repr__ method works correctly.""" l_repr = "Line((10.1, 10.2), (4.3, 56.4))" line = Line(10.1, 10.2, 4.3, 56.4) self.assertEqual(repr(line), l_repr) self.assertEqual(line.__repr__(), l_repr) if __name__ == "__main__": unittest.main()