def test_set_centroid1(self): """ Test with rectangles of zero width or height. Test tag: <tc>#tests#Rectangle.set_centroid</tc> """ r = Rectangle(5, 5, 5, 10) # Zero width r.set_centroid(Point((0, 0))) self.assertEquals(r.left, 0) self.assertEquals(r.lower, -2.5) self.assertEquals(r.right, 0) self.assertEquals(r.upper, 2.5) r = Rectangle(10, 5, 20, 5) # Zero height r.set_centroid(Point((40, 40))) self.assertEquals(r.left, 35) self.assertEquals(r.lower, 40) self.assertEquals(r.right, 45) self.assertEquals(r.upper, 40) r = Rectangle(0, 0, 0, 0) # Zero width and height r.set_centroid(Point((-4, -4))) self.assertEquals(r.left, -4) self.assertEquals(r.lower, -4) self.assertEquals(r.right, -4) self.assertEquals(r.upper, -4)
def test_contains_point(self): p = Polygon([Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [Point((1, 2)), Point((2, 2)), Point((2, 1)), Point((1, 1))]) self.assertEquals(p.contains_point((0, 0)), 1) self.assertEquals(p.contains_point((1, 1)), 0) self.assertEquals(p.contains_point((2, 2)), 1) self.assertEquals(p.contains_point((5, 5)), 1) self.assertEquals(p.contains_point((10, 10)), 0)
def test___init__1(self): """ Tests generic cases. <tc>#tests#Ray.__init__</tc> """ r = Ray(Point((0, 0)), Point((1, 1))) r = Ray(Point((8, -3)), Point((-5, 9)))
def test___init__1(self): """ Generic testing that no exception is thrown. Test tag: <tc>#tests#Chain.__init__</tc> """ c = Chain([Point((0, 0))]) c = Chain([[Point((0, 0)), Point((1, 1))], [Point((2, 5))]])
def test_len1(self): """ Tests corner cases. Test tag: <tc>#tests#LineSegment.len</tc> """ ls = LineSegment(Point((0, 0)), Point((0, 0))) self.assertEquals(ls.len, 0) ls = LineSegment(Point((0, 0)), Point((-3, 0))) self.assertEquals(ls.len, 3)
def test_get_swap1(self): """ Tests corner cases. Test tag: <tc>#tests#LineSegment.get_swap</tc> """ ls = LineSegment(Point((0, 0)), Point((10, 0))) swap = ls.get_swap() self.assertEquals(ls.p1, swap.p2) self.assertEquals(ls.p2, swap.p1) ls = LineSegment(Point((-5, 0)), Point((5, 0))) swap = ls.get_swap() self.assertEquals(ls.p1, swap.p2) self.assertEquals(ls.p2, swap.p1) ls = LineSegment(Point((0, 0)), Point((0, 0))) swap = ls.get_swap() self.assertEquals(ls.p1, swap.p2) self.assertEquals(ls.p2, swap.p1) ls = LineSegment(Point((5, 5)), Point((5, 5))) swap = ls.get_swap() self.assertEquals(ls.p1, swap.p2) self.assertEquals(ls.p2, swap.p1)
def test___init__1(self): """ Tests whether points are created without issue. Test tag: <tc>#tests#Point.__init__</tc> """ for l in [(-5.0, 10.0), (0.0, -6.0), (float(1e300), float(-1e300))]: p = Point(l)
def test_vertices2(self): """ Test for multiple parts. Test tag: <tc>#tests#Polygon.vertices</tc> """ p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [Point((30, 30)), Point((40, 30)), Point((40, 40)), Point((30, 40))]]) self.assertEquals(len(p.vertices), 8)
def test_perimeter1(self): """ Test with multiple parts. Test tag: <tc>#tests#Polygon.perimeter</tc> """ p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [Point((30, 30)), Point((40, 30)), Point((40, 40)), Point((30, 40))]]) self.assertEquals(p.perimeter, 80)
def test_area1(self): """ Test multiple parts. Test tag: <tc>#tests#Polygon.area</tc> """ p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [Point((30, 30)), Point((40, 30)), Point((40, 40)), Point((30, 40))]]) self.assertEquals(p.area, 200)
def test_centroid2(self): """ Test polygons with multiple parts of different size. Test tag: <tc>#tests#Polygon.centroid</tc> """ p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [Point((30, 30)), Point((35, 30)), Point((35, 35)), Point((30, 35))]]) c = p.centroid self.assertEquals(c[0], 10.5) self.assertEquals(c[1], 10.5)
def test_centroid1(self): """ Test polygons with multiple parts of the same size. Test tag: <tc>#tests#Polygon.centroid</tc> """ p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [Point((30, 30)), Point((40, 30)), Point((40, 40)), Point((30, 40))]]) c = p.centroid self.assertEquals(c[0], 20) self.assertEquals(c[1], 20)
def test___str__1(self): """ Tests whether the string produced is valid for corner cases. Test tag: <tc>#tests#Point__str__</tc> """ for l in [(-5, 10), (0, -6.0), (float(1e300), -1e300)]: p = Point(l) self.assertEquals(str(p), str((float(l[0]), float( l[1])))) # Recast to floats like point does
def test_len1(self): """ Test correctness with multiple parts and zero-length point-to-point distances. Test tag: <tc>#tests#Chain.len</tc> """ vertices = [[Point((0, 0)), Point((1, 0)), Point((1, 5))], [Point((-5, -5)), Point((-5, 0)), Point((0, 0)), Point((0, 0))]] self.assertEquals(Chain(vertices).len, 6 + 10)
def test_area4(self): """ Test polygons with vertices in both orders (cw, ccw). Test tag: <tc>#tests#Polygon.area</tc> """ p = Polygon([Point( (0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))]) self.assertEquals(p.area, 100) p = Polygon([Point( (0, 0)), Point((0, 10)), Point((10, 10)), Point((10, 0))]) self.assertEquals(p.area, 100)
def test_vertices1(self): """ Test for correct values/order of vertices. Test tag: <tc>#tests#Polygon.vertices</tc> """ p = Polygon([Point( (0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))]) self.assertEquals(len(p.vertices), 4) e_verts = [Point( (0, 0)), Point((0, 10)), Point((10, 10)), Point((10, 0))] self.assertTrue(p.vertices in [e_verts, e_verts[-1:] + e_verts[:3], e_verts[-2:] + e_verts[:2], e_verts[-3:] + e_verts[:1]])
def test_bounding_box1(self): """ Test polygons with multiple parts. Test tag: <tc>#tests#Polygon.bounding_box</tc> """ p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [Point((30, 30)), Point((40, 30)), Point((40, 40)), Point((30, 40))]]) bb = p.bounding_box self.assertEquals(bb.left, 0) self.assertEquals(bb.lower, 0) self.assertEquals(bb.right, 40) self.assertEquals(bb.upper, 40)
def test_is_cw2(self): """ Test corner cases for vertical segment ending at origin. Test tag: <tc>#tests#LineSegment.is_cw</tc> """ ls = LineSegment(Point((0, -5)), Point((0, 0))) self.assertFalse(ls.is_cw(Point( (0, 10)))) # At positive boundary beyond segment self.assertFalse(ls.is_cw(Point((0, -3)))) # On segment self.assertFalse(ls.is_cw(Point( (0, -10)))) # At negative boundary beyond segment self.assertFalse(ls.is_cw(Point((0, -5)))) # Endpoint of segment self.assertFalse(ls.is_cw(Point((0, 0)))) # Endpoint of segment
def test_is_ccw3(self): """ Test corner cases for non-axis-aligned segment not through origin. Test tag: <tc>#tests#LineSegment.is_ccw</tc> """ ls = LineSegment(Point((0, 1)), Point((5, 6))) self.assertFalse(ls.is_ccw(Point( (10, 11)))) # At positive boundary beyond segment self.assertFalse(ls.is_ccw(Point((3, 4)))) # On segment self.assertFalse(ls.is_ccw(Point( (-10, -9)))) # At negative boundary beyond segment self.assertFalse(ls.is_ccw(Point((0, 1)))) # Endpoint of segment self.assertFalse(ls.is_ccw(Point((5, 6)))) # Endpoint of segment
def test_is_cw1(self): """ Test corner cases for horizontal segment starting at origin. Test tag: <tc>#tests#LineSegment.is_cw</tc> """ ls = LineSegment(Point((0, 0)), Point((5, 0))) self.assertFalse(ls.is_cw(Point( (10, 0)))) # At positive boundary beyond segment self.assertFalse(ls.is_cw(Point((3, 0)))) # On segment self.assertFalse(ls.is_cw(Point( (-10, 0)))) # At negative boundary beyond segment self.assertFalse(ls.is_cw(Point((0, 0)))) # Endpoint of segment self.assertFalse(ls.is_cw(Point((5, 0)))) # Endpoint of segment
def test_bounding_box1(self): """ Test correctness with multiple parts. Test tag: <tc>#tests#Chain.bounding_box</tc> """ vertices = [[Point((0, 0)), Point((1, 1)), Point((2, 6))], [Point((-5, -5)), Point((0, 0)), Point((2, 5))]] bb = Chain(vertices).bounding_box self.assertEquals(bb.left, -5) self.assertEquals(bb.lower, -5) self.assertEquals(bb.right, 2) self.assertEquals(bb.upper, 6)
def test_line1(self): """ Tests corner cases. Test tag: <tc>#tests#LineSegment.line</tc> """ import math ls = LineSegment(Point((0, 0)), Point((1, 0))) self.assertEquals(ls.line.m, 0) self.assertEquals(ls.line.b, 0) ls = LineSegment(Point((0, 0)), Point((0, 1))) self.assertEquals(ls.line.m, float('inf')) self.assertTrue(math.isnan(ls.line.b)) ls = LineSegment(Point((0, 0)), Point((0, -1))) self.assertEquals(ls.line.m, float('inf')) self.assertTrue(math.isnan(ls.line.b)) ls = LineSegment(Point((0, 0)), Point((0, 0))) self.assertEquals(ls.line, None)
def test_bounding_box(self): """ Tests corner cases. Test tag: <tc>#tests#LineSegment.bounding_box</tc> """ ls = LineSegment(Point((0, 0)), Point((0, 10))) self.assertEquals(ls.bounding_box.left, 0) self.assertEquals(ls.bounding_box.lower, 0) self.assertEquals(ls.bounding_box.right, 0) self.assertEquals(ls.bounding_box.upper, 10) ls = LineSegment(Point((0, 0)), Point((-3, -4))) self.assertEquals(ls.bounding_box.left, -3) self.assertEquals(ls.bounding_box.lower, -4) self.assertEquals(ls.bounding_box.right, 0) self.assertEquals(ls.bounding_box.upper, 0) ls = LineSegment(Point((-5, 0)), Point((3, 0))) self.assertEquals(ls.bounding_box.left, -5) self.assertEquals(ls.bounding_box.lower, 0) self.assertEquals(ls.bounding_box.right, 3) self.assertEquals(ls.bounding_box.upper, 0)
def test_perimeter2(self): """ Test with holes. Test tag: <tc>#tests#Polygon.perimeter</tc> """ p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [ Point((30, 30)), Point((40, 30)), Point((40, 40)), Point((30, 40)) ]], holes=[[ Point((2, 2)), Point((4, 2)), Point((4, 4)), Point((2, 4)) ], [Point((6, 6)), Point((6, 8)), Point((8, 8)), Point((8, 6))]]) self.assertEquals(p.perimeter, 80 + 16)
def test_parts1(self): """ Test for correct vertex values/order. Test tag: <tc>#tests#Polygon.parts</tc> """ p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [Point((30, 30)), Point((40, 30)), Point((30, 40))]]) self.assertEquals(len(p.parts), 2) part1 = [ Point((0, 0)), Point((0, 10)), Point((10, 10)), Point((10, 0)) ] part2 = [Point((30, 30)), Point((30, 40)), Point((40, 30))] if len(p.parts[0]) == 4: self.assertTrue(p.parts[0] in [ part1, part1[-1:] + part1[:3], part1[-2:] + part1[:2], part1[-3:] + part1[:1] ]) self.assertTrue( p.parts[1] in [part2, part2[-1:] + part2[:2], part2[-2:] + part2[:1]]) elif len(p.parts[0]) == 3: self.assertTrue( p.parts[0] in [part2, part2[-1:] + part2[:2], part2[-2:] + part2[:1]]) self.assertTrue(p.parts[1] in [ part1, part1[-1:] + part1[:3], part1[-2:] + part1[:2], part1[-3:] + part1[:1] ]) else: self.fail()
def test_holes2(self): """ Test for multiple holes. Test tag: <tc>#tests#Polygon.holes</tc> """ p = Polygon( [Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], holes=[[ Point((2, 2)), Point((4, 2)), Point((4, 4)), Point((2, 4)) ], [Point((6, 6)), Point((6, 8)), Point((8, 8)), Point((8, 6))]]) holes = p.holes self.assertEquals(len(holes), 2)
def test_holes1(self): """ Test for correct vertex values/order. Test tag: <tc>#tests#Polygon.holes</tc> """ p = Polygon( [Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], holes=[Point((2, 2)), Point((4, 2)), Point((4, 4)), Point((2, 4))]) self.assertEquals(len(p.holes), 1) e_holes = [Point((2, 2)), Point((2, 4)), Point((4, 4)), Point((4, 2))] self.assertTrue(p.holes[0] in [ e_holes, [e_holes[-1]] + e_holes[:3], e_holes[-2:] + e_holes[:2], e_holes[-3:] + [e_holes[0]] ])
def test_area2(self): """ Test holes. Test tag: <tc>#tests#Polygon.area</tc> """ p = Polygon( [Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], holes=[Point((2, 2)), Point((4, 2)), Point((4, 4)), Point((2, 4))]) self.assertEquals(p.area, 100 - 4) p = Polygon( [Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], holes=[[ Point((2, 2)), Point((4, 2)), Point((4, 4)), Point((2, 4)) ], [Point((6, 6)), Point((6, 8)), Point((8, 8)), Point((8, 6))]]) self.assertEquals(p.area, 100 - (4 + 4)) p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [ Point((30, 30)), Point((40, 30)), Point((40, 40)), Point((30, 40)) ]], holes=[[ Point((2, 2)), Point((4, 2)), Point((4, 4)), Point((2, 4)) ], [ Point((36, 36)), Point((36, 38)), Point((38, 38)), Point((38, 36)) ]]) self.assertEquals(p.area, 200 - (4 + 4))
def test___init__1(self): """ Test various input configurations (list vs. lists of lists, holes) <tc>#tests#Polygon.__init__</tc> """ # Input configurations tested (in order of test): # one part, no holes # multi parts, no holes # one part, one hole # multi part, one hole # one part, multi holes # multi part, multi holes p = Polygon( [Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))]) p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [ Point((30, 30)), Point((40, 30)), Point((40, 40)), Point((30, 40)) ]]) p = Polygon( [Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], holes=[Point((2, 2)), Point((4, 2)), Point((4, 4)), Point((2, 4))]) p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [ Point((30, 30)), Point((40, 30)), Point((40, 40)), Point((30, 40)) ]], holes=[Point((2, 2)), Point((4, 2)), Point((4, 4)), Point((2, 4))]) p = Polygon( [Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], holes=[[ Point((2, 2)), Point((4, 2)), Point((4, 4)), Point((2, 4)) ], [Point((6, 6)), Point((6, 8)), Point((8, 8)), Point((8, 6))]]) p = Polygon( [[Point((0, 0)), Point((10, 0)), Point((10, 10)), Point((0, 10))], [ Point((30, 30)), Point((40, 30)), Point((40, 40)), Point((30, 40)) ]], holes=[[ Point((2, 2)), Point((4, 2)), Point((4, 4)), Point((2, 4)) ], [Point((6, 6)), Point((6, 8)), Point((8, 8)), Point((8, 6))]])
def test_parts1(self): """ Generic testing of parts functionality. Test tag: <tc>#tests#Chain.parts</tc> """ vertices = [ Point((0, 0)), Point((1, 1)), Point((2, 5)), Point((0, 0)), Point((1, 1)), Point((2, 5)) ] self.assertEquals(Chain(vertices).parts, [vertices]) vertices = [[Point((0, 0)), Point((1, 1)), Point((2, 5))], [Point((0, 0)), Point((1, 1)), Point((2, 5))]] self.assertEquals(Chain(vertices).parts, vertices)