Add updated unit tests.

Author: AceFire6

formation.py

@@ -7,7 +7,7 @@ class Formation(object):
     """Formation that handles all units it manages. Used to handle unit
     placement and waypoint updating.
     """
-    def __init__(self, filename=None):
+    def __init__(self, file=None):
         """Create a formation. If a filename is specified, the formation
         is loaded from there, otherwise, the file has to be specified later.
         """
@@ -16,8 +16,8 @@ def __init__(self, filename=None):
         self._direction = Vec2d(0, 0)
         self.positions = []
         self.waypoints = []
-        if filename:
-            self.parse_formation_file(filename)
+        if file:
+            self.parse_formation_file(file)
 
     def parse_formation_file(self, open_file):
         """Open and parse the given formation file. Set up all the required
@@ -44,9 +44,9 @@ def set_center(self, center_pair_or_x, y=None):
         specifying the x and y coordinates as separate arguments.
         """
         if y is None:
-            self.waypoint = center_pair_or_x
+            self._center = center_pair_or_x
         else:
-            self.waypoint = Vec2d(center_pair_or_x, y)
+            self._center = Vec2d(center_pair_or_x, y)
 
     def gen_and_get_boids(self):
         """Generate all the units in the formation based on their relative

test_unit_tests.py

@@ -0,0 +1,18 @@
+import unittest
+from enemy import Enemy
+from vec2d import Vec2d
+
+
+class TestEnemy(unittest.TestCase):
+    def test___init__(self):
+        enemy = Enemy(Vec2d(0, 0), Vec2d(200, 200))
+        self.assertIsNotNone(enemy)
+
+    def test_update_and_apply_velocity(self):
+        enemy = Enemy(Vec2d(0, 0), Vec2d(200, 200))
+        enemy_pos = Vec2d(enemy.position.x, enemy.position.y)
+        enemy.update()
+        self.assertNotEquals(enemy_pos, enemy.position)
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_enemy.py

@@ -0,0 +1,8 @@
+(291, 214)
+(-1, 91)
+(-33, 1)
+(21, -2)
+(-3, 40)
+(-49, 79)
+(46, 81)
+(4, 124)

tests/test_formation.fm

@@ -0,0 +1,40 @@
+import unittest
+from vec2d import Vec2d
+from formation import Formation
+
+
+class TestFormation(unittest.TestCase):
+    def test___init__(self):
+        formation = Formation(open('test_formation.fm'))
+        self.assertIsNotNone(formation)
+
+    def test_center(self):
+        formation = Formation(open('test_formation.fm'))
+        self.assertEqual(Vec2d(291, 214), formation.center)
+
+    def test_direction(self):
+        formation = Formation(open('test_formation.fm'))
+        self.assertEqual(Vec2d(290, 305), formation.direction)
+
+    def test_facing(self):
+        formation = Formation(open('test_formation.fm'))
+        self.assertEqual(Vec2d(-1, 91), formation.facing)
+
+    def test_gen_and_get_boids(self):
+        formation = Formation(open('test_formation.fm'))
+        self.assertEqual(6, len(formation.gen_and_get_boids()))
+
+    def test_set_center(self):
+        formation = Formation(open('test_formation.fm'))
+        old_center = formation.center
+        formation.set_center(300, 300)
+        self.assertEqual(Vec2d(300, 300), formation.center)
+        self.assertNotEqual(old_center, formation.center)
+
+    def test_set_waypoint(self):
+        formation = Formation(open('test_formation.fm'))
+        formation.set_waypoint(500, 500)
+        self.assertEqual(Vec2d(500, 500), formation.waypoint)
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_formation.py

@@ -0,0 +1,60 @@
+from formation_designer import add_tuple
+import unittest
+from formation_designer import distance_to
+from formation_designer import close_to
+from formation_designer import get_closest
+from formation_designer import get_closest_and_dist
+
+
+class TestAddTuple(unittest.TestCase):
+    def test_add_tuple_returns_tuple_for_t1_equal_tuple_and_t2_equal_tuple(self):
+        self.assertEqual((3, 5), add_tuple((1, 2), (2, 3)))
+
+
+class TestDistanceTo(unittest.TestCase):
+    def test_distance_to_returns_111803398875_for_point1_equal_tuple_and_point2_equal_tuple(self):
+        self.assertEqual(111.80339887498948, distance_to((100, 50), (0, 0)))
+
+    def test_distance_to_returns_111803398875_for_point1_equal_tuple_and_point2_equal_tuple_case_2(self):
+        self.assertEqual(111.80339887498948, distance_to((200, 50), (100, 100)))
+
+    def test_distance_to_returns_1500_for_point1_equal_tuple_and_point2_equal_tuple(self):
+        self.assertEqual(150.0, distance_to((200, 50), (50, 50)))
+
+    def test_distance_to_returns_206155281281_for_point1_equal_tuple_and_point2_equal_tuple(self):
+        self.assertEqual(206.15528128088303, distance_to((200, 50), (0, 0)))
+
+    def test_distance_to_returns_20_for_point1_equal_tuple_and_point2_equal_tuple(self):
+        self.assertEqual(2.0, distance_to((0, 0), (2, 0)))
+
+    def test_distance_to_returns_269258240357_for_point1_equal_tuple_and_point2_equal_tuple(self):
+        self.assertEqual(269.2582403567252, distance_to((200, 50), (300, 300)))
+
+    def test_distance_to_returns_320156211872_for_point1_equal_tuple_and_point2_equal_tuple(self):
+        self.assertEqual(320.1562118716424, distance_to((100, 50), (300, 300)))
+
+    def test_distance_to_returns_500_for_point1_equal_tuple_and_point2_equal_tuple(self):
+        self.assertEqual(50.0, distance_to((100, 50), (100, 100)))
+
+    def test_distance_to_returns_500_for_point1_equal_tuple_and_point2_equal_tuple_case_2(self):
+        self.assertEqual(50.0, distance_to((100, 50), (50, 50)))
+
+
+class TestCloseTo(unittest.TestCase):
+    def test_close_to_returns_list_for_placed_units_equal_list_and_point_equal_tuple(self):
+        self.assertEqual([], close_to((200, 50), [(0, 0), (100, 100), (50, 50), (300, 300)]))
+
+
+class TestGetClosest(unittest.TestCase):
+    def test_get_closest_returns_tuple_for_close_units_equal_list_and_point_equal_tuple(self):
+        obj = (100, 100)
+        self.assertEqual(obj, get_closest((100, 50), [(0, 0), obj, (50, 50), (300, 300)]))
+
+
+class TestGetClosestAndDist(unittest.TestCase):
+    def test_get_closest_and_dist_returns_tuple_for_close_units_equal_list_and_point_equal_tuple(self):
+        obj = (100, 100)
+        self.assertEqual((obj, 50.0), get_closest_and_dist((100, 50), [(0, 0), obj, (50, 50), (300, 300)]))
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_formation_designer.py

@@ -0,0 +1,25 @@
+import unittest
+from unit import Unit
+from vec2d import Vec2d
+
+
+class TestUnit(unittest.TestCase):
+    def test___init__(self):
+        unit = Unit(Vec2d(0, 0), Vec2d(0, 0), None)
+        self.assertIsNotNone(unit)
+
+    def test_contains(self):
+        unit = Unit(Vec2d(0, 0), Vec2d(0, 0), None)
+        self.assertTrue(unit.contains(Vec2d(5, 0)))
+
+    def test_get_center(self):
+        unit = Unit(Vec2d(0, 0), Vec2d(0, 0), None)
+        self.assertListEqual([0, 0], unit.get_center())
+
+    def test_get_inverse_square(self):
+        unit = Unit(Vec2d(0, 0), Vec2d(0, 0), None)
+        other_unit = Unit(Vec2d(10, 0), Vec2d(10, 0), None)
+        self.assertEqual(1.0 / 100, unit.get_inverse_square(other_unit))
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_unit.py

@@ -0,0 +1,26 @@
+from waypoint import Waypoint
+from vec2d import Vec2d
+import unittest
+
+
+class TestWaypoint(unittest.TestCase):
+    def test_create_waypoint(self):
+        waypoint = Waypoint(Vec2d(0, 0), Vec2d(100, 100))
+        self.assertIsNotNone(waypoint)
+
+    def test_get_position(self):
+        waypoint = Waypoint(Vec2d(0, 0), Vec2d(100, 100))
+        self.assertEqual(Vec2d(100, 100), waypoint.get_position())
+
+    def test_update_position(self):
+        waypoint = Waypoint(Vec2d(0, 0), Vec2d(100, 100))
+        waypoint.update_position(Vec2d(50, 50))
+        self.assertEqual(Vec2d(50, 50), waypoint.get_position())
+
+    def test_rotate(self):
+        waypoint = Waypoint(Vec2d(10, 0), Vec2d(100, 0))
+        waypoint.rotate(90)
+        self.assertEqual(Vec2d(100, 10), waypoint.get_position())
+
+if __name__ == '__main__':
+    unittest.main()