Esempio n. 1
0
 def test_new_line_horizontal(self):
     line = Line(Point(3, 5), Point(8, 5))
     self.assertEqual(line.direction, 'HORIZONTAL')
     self.assertEqual(line.min_x, 3)
     self.assertEqual(line.max_x, 8)
     self.assertEqual(line.min_y, 5)
     self.assertEqual(line.max_y, 5)
Esempio n. 2
0
 def test_new_line_vertical(self):
     line = Line(Point(10, 3), Point(10, 10))
     self.assertEqual(line.direction, 'VERTICAL')
     self.assertEqual(line.min_x, 10)
     self.assertEqual(line.max_x, 10)
     self.assertEqual(line.min_y, 3)
     self.assertEqual(line.max_y, 10)
Esempio n. 3
0
 def test_cut_lines(self):
     hor = Line(Point(3, 5), Point(8, 5))
     ver = Line(Point(6, 3), Point(6, 10))
     cut_point = hor.intersected_by(ver)
     self.assertEqual(cut_point.isExist(), True)
     self.assertEqual(cut_point.x, 6)
     self.assertEqual(cut_point.y, 5)
def getSize():  #Возвращает значимые параметры bmp из файла с его размерами.
    with open("size.txt", 'r') as f:
        arr = np.asfarray(f.readlines(), float)
    f.close()
    listOfObjects = Point()
    listOfObjects.i = arr[0]
    listOfObjects.j = arr[1]
    return listOfObjects
Esempio n. 5
0
    def test_long_path(self):
        start_time = datetime.datetime.now()
        shortest_path = self.cavern.path_length(Point(2, 2), Point(53, 3))
        end_time = datetime.datetime.now()

        expected_result = PathStep(51, Point(3, 2))
        self.assertEqual(shortest_path, expected_result)

        running_time = (end_time - start_time).total_seconds()
        time_threshold_seconds = 1
        self.assertTrue(
            running_time <= time_threshold_seconds,
            msg=
            "Test did not complete in a reasonable time ({threshold} seconds). {elapsed} seconds elapsed."
            .format(threshold=time_threshold_seconds, elapsed=running_time))
 def setUp(self):
     app.config.from_pyfile('test_config.py')
     self.test_point = Point(pointName="test",
                             pointLatitude=0.,
                             pointLongitude=0.)
     db.create_all()
     self.client = app.test_client()
Esempio n. 7
0
    def test_full_round_equal_distance(self):
        self.cavern_2.step(1)

        # Check all the units moved correctly
        self.assertIsNone(self.cavern_2.unit_at(Point(4, 1)))
        self.assertTrue(type(self.cavern_2.unit_at(Point(4, 2))) == Goblin)
        self.assertIsNone(self.cavern_2.unit_at(Point(1, 4)))
        self.assertTrue(type(self.cavern_2.unit_at(Point(2, 4))) == Goblin)
        self.assertIsNone(self.cavern_2.unit_at(Point(4, 4)))
        self.assertTrue(type(self.cavern_2.unit_at(Point(4, 3))) == Elf)

        # Now check that all the units (apart from the first Goblin) have 200 HP
        self.assertTrue(self.cavern_2.unit_at(Point(4, 2)).hp == 197)
        self.assertTrue(self.cavern_2.unit_at(Point(2, 4)).hp == 200)
        self.assertTrue(self.cavern_2.unit_at(Point(4, 3)).hp == 200)
Esempio n. 8
0
 def test_is_Between_horizontal(self):
     pointA = Point(3, 5)
     pointB = Point(5, 5)
     pointC = Point(8, 5)
     bIsBetween = pointB.isBetween(pointA, pointC)
     self.assertEqual(bIsBetween, True)
     aIsBetween = pointA.isBetween(pointB, pointC)
     self.assertEqual(aIsBetween, False)
Esempio n. 9
0
 def test_is_Between_vertical(self):
     pointA = Point(10, 3)
     pointB = Point(10, 7)
     pointC = Point(10, 10)
     bIsBetween = pointB.isBetween(pointA, pointC)
     self.assertEqual(bIsBetween, True)
     aIsBetween = pointA.isBetween(pointB, pointC)
     self.assertEqual(aIsBetween, False)
Esempio n. 10
0
 def test_part_two(self):
     TestData = namedtuple("TestData", "wire_one,wire_two,expected")
     inputs = [
         TestData(
             ["R75", "D30", "R83", "U83", "L12", "D49", "R71", "U7", "L72"],
             ["U62", "R66", "U55", "R34", "D71", "R55", "D58", "R83"],
             610,
         ),
         TestData(
             [
                 "R98",
                 "U47",
                 "R26",
                 "D63",
                 "R33",
                 "U87",
                 "L62",
                 "D20",
                 "R33",
                 "U53",
                 "R51",
             ],
             [
                 "U98", "R91", "D20", "R16", "D67", "R40", "U7", "R15",
                 "U6", "R7"
             ],
             410,
         ),
         TestData(["R8", "U5", "L5", "D3"], ["U7", "R6", "D4", "L4"], 30),
     ]
     for data in inputs:
         with self.subTest(data=data):
             points1 = generate_points(Point(0, 0), data.wire_one)
             points2 = generate_points(Point(0, 0), data.wire_two)
             intersections = get_intersections(points1, points2)
             assert data.expected == part_two(intersections, points1,
                                              points2)
Esempio n. 11
0
    def test_path_with_overlapping_paths(self):
        shortest_path_forward = self.cavern.path_length(
            Point(1, 6), Point(4, 8))
        expected_result_forward = PathStep(4, Point(2, 6))
        shortest_path_backward = self.cavern.path_length(
            Point(4, 8), Point(1, 6))
        expected_result_backward = PathStep(4, Point(3, 8))

        self.assertEqual(shortest_path_forward, expected_result_forward)
        self.assertEqual(shortest_path_backward, expected_result_backward)
Esempio n. 12
0
def test_4th_5th_lines():
    points = [
        Point(10, 1),
        Point(10, 2),
        Point(10, 3),
        Point(11, 4),
        Point(11, 5),
        Point(11, 6)
    ]
    manager = Manager(points)
    manager.process()
    assert 2 == manager.count_line()
Esempio n. 13
0
def test_2nd_3rd_lines():
    points = [
        Point(7, 1),
        Point(7, 2),
        Point(8, 3),
        Point(8, 4),
        Point(9, 5),
        Point(9, 6)
    ]
    manager = Manager(points)
    manager.process()
    assert 2 == manager.count_line()
Esempio n. 14
0
def test_first_line():
    points = [
        Point(1, 1),
        Point(2, 2),
        Point(3, 3),
        Point(4, 4),
        Point(5, 5),
        Point(6, 6)
    ]
    manager = Manager(points)
    manager.process()
    assert 1 == manager.count_line()
Esempio n. 15
0
    def test_nextPoint_with_0_0(self):
        centralPoint = Point(0, 0)
        nxPoint = centralPoint.nextPoint('R8')
        self.assertEqual(nxPoint.x, 8)
        self.assertEqual(nxPoint.y, 0)

        nxPoint = centralPoint.nextPoint('U5')
        self.assertEqual(nxPoint.x, 0)
        self.assertEqual(nxPoint.y, 5)

        nxPoint = centralPoint.nextPoint('L8')
        self.assertEqual(nxPoint.x, -8)
        self.assertEqual(nxPoint.y, 0)

        nxPoint = centralPoint.nextPoint('D5')
        self.assertEqual(nxPoint.x, 0)
        self.assertEqual(nxPoint.y, -5)
Esempio n. 16
0
    def test_number_of_steps(self):
        point = Point(3, 3)
        points1 = generate_points(Point(0, 0), ["R8", "U5", "L5", "D3"])
        expected = 20
        actual = steps_taken(point, points1)
        assert expected == actual
        points2 = generate_points(Point(0, 0), ["U7", "R6", "D4", "L4"])
        actual = steps_taken(point, points2)
        assert expected == actual

        point = Point(6, 5)
        points1 = generate_points(Point(0, 0), ["R8", "U5", "L5", "D3"])
        expected = 15
        actual = steps_taken(point, points1)
        assert expected == actual
        points2 = generate_points(Point(0, 0), ["U7", "R6", "D4", "L4"])
        actual = steps_taken(point, points2)
        assert expected == actual
Esempio n. 17
0
 def test_periphery_of_larger_room(self):
     x = Room(Point(0,0), 3, 3)
     p = list(x.periphery())
     expected = 8 # should be 3 at top, 3 at bottom, and 2 at middle (center point isn't peripheral)
     self.assertEqual(expected, len(p), "Too many points counted as periphery")
Esempio n. 18
0
 def test_periphery(self):
     x = Room(Point(0, 0), 2, 5)
     expected = {
         Point(0,0), Point(1,0),
         Point(0,1), Point(1,1),
         Point(0,2), Point(1,2),
         Point(0,3), Point(1,3),
         Point(0,4), Point(1,4)
     }
     self.assertSetEqual(expected, set(x.periphery()))
Esempio n. 19
0
 def test_clear(self):
     point = Point(3, 56, '6')
     point.clear()
     self.assertEqual(point.symbol, ' ')
Esempio n. 20
0
 def test_move(self):
     self.assertRaises(ValueError, Point(1, 0, 'd').move, 1, Directions.top)
     
     point  = Point(1, 0, 'd')
     point.move(1, Directions.bottom)
     self.assertEqual(point, Point(1, 1, 'd'))
Esempio n. 21
0
 def test_path_with_unit_obstruction(self):
     shortest_path = self.cavern.path_length(Point(6, 2), Point(6, 4))
     expected_result = PathStep(5, Point(7, 2))
     self.assertEqual(shortest_path, expected_result)
Esempio n. 22
0
 def test_valid_route_with_two_paths(self):
     shortest_path = self.cavern.path_length(Point(1, 1), Point(4, 1))
     expected_result = PathStep(6, Point(2, 1))
     self.assertEqual(shortest_path, expected_result)
Esempio n. 23
0
 def test_empty_path(self):
     shortest_path = self.cavern.path_length(Point(2, 3), Point(4, 2))
     expected_result = PathStep(2, Point(3, 3))
     self.assertEqual(shortest_path, expected_result)
Esempio n. 24
0
    def test_is_rb(self):
        tr = Triangle(Point(0, 0), Point(3, 0), Point(0, 3))
        self.assertTrue(tr.is_rb())

        tr = Triangle(Point(4.5, 4.5), Point(3, 0), Point(0, 3))
        self.assertTrue(tr.is_rb())

        tr = Triangle(Point(0, 0), Point(0, 0), Point(0, 0))
        self.assertFalse(tr.is_rb())

        tr = Triangle(Point(0, 1.23), Point(0, 1.23), Point(0, 6))
        self.assertFalse(tr.is_rb())

        tr = Triangle(Point(0, 1), Point(0, 3), Point(0, 6))
        self.assertFalse(tr.is_rb())
Esempio n. 25
0
 def test_periphery_of_ten_by_ten_room(self):
     x = Room(Point(0,0), 10, 10)
     p = set(x.periphery())
     expected = 10 + (2*8) + 10
     self.assertEqual(expected, len(p), "Unexpected number of periphery points")
     self.assertIn((0,1), p)
Esempio n. 26
0
 def test_add(self):
     self.assertEqual(Point(2, 3) + Point(3, 3), (5, 6))
     self.assertEqual(Point(2.5, 3.0) + Point(1.2, 3.2), (3.7, 6.2))
     self.assertEqual(Point(-2, -3) + Point(2, 3), (0, 0))
Esempio n. 27
0
    def test_is_triangle(self):
        tr = Triangle(Point(0, 0), Point(0, 3), Point(4, 0))
        self.assertTrue(tr.is_triangle())

        tr = Triangle(Point(0, 0), Point(0, 3), Point(10, 0))
        self.assertTrue(tr.is_triangle())

        tr = Triangle(Point(0, 1.5), Point(3, 0), Point(1.5, 1))
        self.assertTrue(tr.is_triangle())

        tr = Triangle(Point(0, 1), Point(0, 3), Point(0, 6))
        self.assertFalse(tr.is_triangle())

        tr = Triangle(Point(0, 1.23), Point(0, 1.23), Point(0, 6))
        self.assertFalse(tr.is_triangle())

        tr = Triangle(Point(0, 0), Point(0, 0), Point(0, 0))
        self.assertFalse(tr.is_triangle())
Esempio n. 28
0
 def test_path_unreachable_because_unit(self):
     shortest_path = self.cavern.path_length(Point(10, 3), Point(12, 3))
     expected_result = None
     self.assertEqual(shortest_path, expected_result)
Esempio n. 29
0
    def test_square(self):
        tr = Triangle(Point(0, 1), Point(0, 3), Point(0, 6))
        self.assertEqual(tr.square(), -1)

        tr = Triangle(Point(0, 0), Point(3, 0), Point(0, 3))
        self.assertEqual(tr.square(), 4.5)

        tr = Triangle(Point(0, 0), Point(10.1, 0), Point(0, 10.1))
        self.assertEqual(tr.square(), 51.005)

        tr = Triangle(Point(0, 0), Point(0, 0), Point(0, 0))
        self.assertEqual(tr.square(), -1)

        tr = Triangle(Point(0, 1.23), Point(0, 1.23), Point(0, 6))
        self.assertEqual(tr.square(), -1)

        tr = Triangle(Point(0, 1), Point(0, 3), Point(0, 6))
        self.assertEqual(tr.square(), -1)
Esempio n. 30
0
 def test_path_ends_on_wall(self):
     shortest_path = self.cavern.path_length(Point(2, 1), Point(2, 0))
     expected_result = None
     self.assertEqual(shortest_path, expected_result)
Esempio n. 31
0
 def test_str(self):
     tr = Triangle(Point(0, 0), Point(3, 0), Point(0, 3))
     self.assertEqual(str(tr), "0 0 3 0 0 3")
Esempio n. 32
0
 def test_path_ends_on_unit(self):
     shortest_path = self.cavern.path_length(Point(1, 2), Point(1, 1))
     expected_result = PathStep(0, Point(1, 1))
     self.assertEqual(shortest_path, expected_result)