def test_polygon_specific_value():
# specific value unit test
poly9 = Pp.Poly(6, 2)
poly10 = Pp.Poly(4, 1)
poly11 = Pp.Poly(4, 1)
poly12 = Pp.Poly(4, 1)
poly13 = Pp.Poly(1000, 1)
for i in range(9, 14):
eval("poly{0}.calcproperties()".format(i))
assert math.isclose(poly9.apothem, 1.732, rel_tol=.001, abs_tol=.001)
assert math.isclose(poly9.area, 10.392, rel_tol=.001, abs_tol=.001)
assert math.isclose(poly9.perimeter, 12, rel_tol=.001, abs_tol=.001)
assert math.isclose(poly9.interior_angle, 120, rel_tol=.001, abs_tol=.001)
assert math.isclose(poly9.edge_length, 2, rel_tol=.001, abs_tol=.001)
assert math.isclose(poly10.area, 2, rel_tol=.001, abs_tol=.001)
assert math.isclose(poly12.edge_length, math.sqrt(2), rel_tol=.001, abs_tol=.001)
assert math.isclose(poly13.area, math.pi, rel_tol=.001, abs_tol=.001)
# test equality
assert poly10.equal_area(poly11)
assert poly10.equal_perimeter(poly11)
# test equality exceptions
with raises(Exception):
assert poly13.equal_area(poly9)
with raises(Exception):
assert poly13.equal_perimeter(poly9)
def test_polygon_float_radius_repr():
# unit test: Polygon radius float/int repr
poly100 = Pp.Poly(3, 3)
assert poly100.__repr__() == "Poly(3,3)"
poly100 = Pp.Poly(3, 3.1)
assert poly100.__repr__() == "Poly(3,3.1)"
poly100 = Pp.Poly(3, 3.0)
assert poly100.__repr__() == "Poly(3,3)"
def test_polygon_perimeter_cache():
poly = Pp.Poly(5, 5)
if poly.perimeter:
assert poly.perimeter
poly.side_count = 8
assert poly._perimeter is None
poly.circumradius = 1
assert poly._perimeter is None
poly.side_count = 3
assert poly._perimeter is None
def test_polygon_area_cache():
poly = Pp.Poly(5, 5)
if poly.area:
assert poly.area
poly.side_count = 9
assert poly._area is None
poly.circumradius = 1
assert poly._area is None
poly.side_count = 3
assert poly._area is None
def test_polygon_apothem_cache():
poly = Pp.Poly(5, 5)
if poly.apothem:
assert poly.apothem
poly.side_count = 9
assert poly._apothem is None
poly.circumradius = 1
assert poly._apothem is None
poly.side_count = 3
assert poly._apothem is None
def test_polygon_edge_length_cache():
poly = Pp.Poly(5, 5)
if poly.edge_length:
assert poly.edge_length
poly.side_count = 9
assert poly._edge_length is None
poly.circumradius = 1
assert poly._edge_length is None
poly.side_count = 3
assert poly._edge_length is None
def test_polygon_interior_angle_cache():
poly = Pp.Poly(5, 5)
if poly.interior_angle:
assert poly.interior_angle
poly.side_count = 9
assert poly._interior_angle is None
poly.circumradius = 1
assert poly._interior_angle is None
poly.side_count = 3
assert poly._interior_angle is None
def test_poly():
n = [i for i in range(3, 13)]
r = [i for i in range(13, 23)]
nr = tuple(zip(n, r))
name = tuple(('poly{0}'.format(n)) for n in range(100, 100 + len(n)))
polylist = [p.Poly(n, r) for n, r in nr]
polydict = OrderedDict(zip(name, polylist))
polydict['poly111'] = 'dummy_obj'
polydict['poly112'] = p.Poly(3, 13)
# for k, v in polydict.items():
# print(k, v,
# 'perimeter =', v.perimeter,"\n",
# 'apothem =', v.apothem,"\n",
# 'interior angle =', v.interior_angle,"\n",
# 'edge_length =', v.edge_length,"\n",
# 'area =', v.area
# )
return polydict
def nrfinal(self):
""" nrfinal generates instances of Poly(n,r) objects from specified parameters"""
# Unique n list + Unique r list of length icount
# lists are mutable data structures
# so use deepcopy (copy is a shallow copy and thus is a pass by reference)
# deep copy is a pass by value instantiating a new list
nrvalslist = list(zip(sorted(self.sample_ints, reverse=True),
sorted(self.sample_floats, reverse=True)))
# print('Initial Unique Values:', len(nrvalslist), nrvalslist)
nrdups = deepcopy(nrvalslist[0:self._clones] * self._cloneamount)
# print('Clones To Append:', len(nrdups), nrdups)
nrremainder = deepcopy(nrvalslist[self._clones:])
# print('Remaining Unique Values:', len(nrremainder) , nrremainder)
finallist = deepcopy(nrdups + nrremainder)
# print(finallist)
# print('Final Values of (n,r) for Poly Generation:', len(finallist), finallist)
# print('POLYGON CLASS TESTING:')
name = tuple(('poly{0}'.format(n)) for n in range(101, 101+self._finalcount))
# print('Newly Created Object Names:', len(name), name)
# polylist instantiates Poly objects
polylist = [pp.Poly(n, r) for n, r in finallist]
polydict = OrderedDict(zip(name, polylist))
self.polydict = polydict
globals().update(polydict)
self.finallist = len(finallist)
""" self.polynames = list of names for newly created Poly(n,r) objects """
self.polynames = name
return """Process Complete"""
def test_polygon_interior_angle_value_calculates_without_radius():
poly = Pp.Poly(3, None)
return poly.interior_angle
def test_polygon_polycheck_n_type():
with raises(Exception):
Pp.Poly('string', 4)
def test_polygon_set_item():
# set item and recalculate of poly1
poly1 = Pp.Poly(4, 5)
poly1.__setitem__(10, 13.1)
assert str(poly1) == 'Poly(10,13.1)'
def test_polygon_interior_angle_value_error():
poly = Pp.Poly(None, None)
with raises(ValueError):
return poly.interior_angle
def test_polygons_max_efficencey_method(test_polygons):
# test the max efficencey formula
# assert max([p.area/p.perimeter for p in test_polygons[1]]) == test_polygons[1].max_efficiency
assert test_polygons[1].max_efficiency == Pp.Poly(500, 1)
def test_polygon_perimeter_value_error():
with raises(ValueError):
poly1 = Pp.Poly()
return poly1.perimeter
def test_polygon_nrskey_valid():
poly100 = Pp.Poly(4, 4)
assert poly100.nrkey == (4, 4)
def test_polygon_nrkey_returns_none():
# with raises(Exception):
poly100 = Pp.Poly()
return poly100.nrkey
def test_polygon_polycheck_r_positive_type():
with raises(Exception):
Pp.Poly(4, -4)
def test_polygon_polycheck_n_positive():
with raises(Exception):
Pp.Poly(-4, 4)
def test_polygon_edge_length_value_error():
poly = Pp.Poly(None, None)
with raises(ValueError):
return poly.edge_length
def test_polygon_calculate_properties_method():
# poly1 list properties
poly1 = Pp.Poly(4, 5)
assert poly1.calcproperties()
def test_polygon_area_value_error():
poly = Pp.Poly(None, None)
with raises(ValueError):
return poly.area
