Merge pull request #145 from marcostfermin/pr/modified-tests

Expand test coverage for electricpy, circle, and triangle modules

Author: engineerjoe440

test/test_circle.py

@@ -1,5 +1,9 @@
 import cmath
-from electricpy.geometry.circle import Circle
+import math
+import pytest
+
+import electricpy.geometry.circle as circle_mod
+from electricpy.geometry.circle import Circle, construct
 from electricpy.geometry import Line, Point
 
 
@@ -80,3 +84,128 @@ def test_1(self):
 
         assert compare_lines(c.normal(p0), Line(1, -1, 0))
         assert compare_lines(c.normal(p1), Line(1, 1, 0))
+
+
+def test_contains_point_and_tangent_validation():
+    c = Circle((0, 0), 2)
+    assert c.contains_point(Point(2, 0))
+    with pytest.raises(ValueError):
+        c.tangent(Point(1, 1))
+    assert c.tangent(Point(1, 1), require_on_circle=False) == Line(1, 1, -4)
+
+    assert c.power(Point(0, 0)) == -4
+    assert c.power(Point(2, 0)) == 0
+    assert c.is_tangent(Line(1, 0, -2))
+    assert not c.is_tangent(Line(1, 0, -3))
+    assert c.is_normal(Line(1, 0, 0))
+    assert not c.is_normal(Line(1, 0, -1))
+
+
+def test_equation_and_parametric_errors():
+    c = Circle((1, 2), 3)
+    eq = c.equation()
+    assert "x^2 + y^2" in eq
+    assert " - 2*x" in eq
+    assert " - 4*y" in eq
+    assert " - 4" in eq
+    assert c.radius == 3
+    
+    with pytest.raises(ValueError):
+        list(c.parametric_equation(theta_resolution=0))
+    with pytest.raises(ValueError):
+        list(c.parametric_equation(theta_resolution=-0.1))
+
+    points = list(c.parametric_equation(theta_resolution=math.pi))
+    assert points[0] == (4.0, 2.0)
+    assert points[-1][0] == pytest.approx(4.0)
+    semi = list(c.parametric_equation(theta_resolution=math.pi / 2, semi=True))
+    assert semi[0] == (4.0, 2.0)
+    assert semi[-1][0] == pytest.approx(-2.0)
+
+    eq_no_linear = Circle((0, 0), math.pi).equation()
+    assert "x^2 + y^2" in eq_no_linear
+    assert "*x" not in eq_no_linear
+    assert "*y" not in eq_no_linear
+    assert " - " in eq_no_linear
+
+    eq_float = Circle((0.3, 0), 1).equation()
+    assert " - 0.6*x" in eq_float
+
+
+def test_sector_and_intersection_cases():
+    c1 = Circle((0, 0), 1)
+    c2 = Circle((2, 0), 1)
+    assert c1.sector_length(cmath.pi) == cmath.pi
+    assert c1.sector_area(cmath.pi) == cmath.pi / 2
+    inter = c1.intersection(c2)
+    assert isinstance(inter, Point)
+    assert c1.intersetion(c2) == inter
+
+    assert c1.intersection(Circle((0, 0), 1)) == "infinite"
+    assert c1.intersection(Circle((0, 0), 2)) is None
+    assert c1.intersection(Circle((5, 0), 1)) is None
+    assert c1.intersection(Circle((0.5, 0), 5)) is None
+
+    two = c1.intersection(Circle((1, 0), 1))
+    assert isinstance(two, tuple)
+    assert len(two) == 2
+    assert c1.contains_point(two[0])
+    assert c1.contains_point(two[1])
+
+    with pytest.raises(TypeError):
+        c1.intersection("not-a-circle")
+
+    near_tangent = c1.intersection(Circle((2 + 1e-6, 0), 1), tol=1e-5)
+    assert isinstance(near_tangent, Point)
+
+    assert c1.intersection(Circle((2.5, 0), 1), tol=0.5) is None
+
+
+def test_construct_circle():
+    p0 = Point(1, 0)
+    p1 = Point(0, 1)
+    p2 = Point(-1, 0)
+    circ = construct(p0, p1, p2)
+    assert circ.contains_point(p1)
+
+    with pytest.raises(AssertionError):
+        construct(Point(0, 0), Point(1, 1), Point(2, 2))
+
+
+def test_point_coercion_and_repr():
+    pt = circle_mod._as_point((1, 2))
+    assert isinstance(pt, Point)
+    assert pt == Point(1, 2)
+    pt = circle_mod._as_point([3, 4])
+    assert pt == Point(3, 4)
+    pt = circle_mod._as_point(Point(5, 6))
+    assert pt == Point(5, 6)
+
+    with pytest.raises(ValueError):
+        circle_mod._as_point((1, 2, 3))
+    with pytest.raises(TypeError):
+        circle_mod._as_point("bad")
+
+    assert circle_mod._is_close(1.0, 1.0 + 1e-10)
+    assert not circle_mod._is_close(1.0, 1.1, rel_tol=1e-6, abs_tol=1e-6)
+
+    circle = Circle((0, 0), 1)
+    assert repr(circle) == "Circle(center=(0.0, 0.0), radius=1.0)"
+    assert str(circle) == "Circle(center=(0.0, 0.0), radius=1.0)"
+    assert circle == Circle((0, 0), 1)
+    assert circle != Circle((0, 0), 2)
+    assert circle != "not-a-circle"
+    assert hash(circle) == hash((0.0, 0.0, 1.0))
+
+
+def test_circle_init_validation_and_normal_error():
+    with pytest.raises(TypeError):
+        Circle((0, 0), "bad")
+    with pytest.raises(ValueError):
+        Circle((0, 0), -1)
+    with pytest.raises(TypeError):
+        Circle("bad", 1)
+
+    circle = Circle((1, 1), 1)
+    with pytest.raises(ValueError):
+        circle.normal(Point(1, 1))

test/test_electricpy.py

@@ -5,6 +5,8 @@
 # Electricpy Imports
 from electricpy import powerflow
 from electricpy import phasor
+from electricpy import reactance
+from electricpy import tcycle
 from electricpy.passive import air_core_inductance
 
 def test_bridge_impedance():
@@ -453,4 +455,14 @@ def test_1(self):
         self.turn = 251
 
         expected_result = 0.42755
-        self.check_result(expected_result)
+        self.check_result(expected_result)
+
+
+def test_tcycle_validation():
+    with pytest.raises(ValueError):
+        tcycle(1, freq=-60)
+
+
+def test_reactance_inductive():
+    result = reactance(5, freq=60)
+    assert result > 0

test/test_triangle.py

@@ -1,4 +1,7 @@
 import cmath
+import math
+import pytest
+
 from electricpy.geometry import triangle
 from electricpy.geometry import Point
 from test import compare_points
@@ -66,4 +69,132 @@ def test_1(self):
         p2 = Point(1, 0)
         p3 = Point(1*cmath.cos(cmath.pi/3), 1*cmath.sin(cmath.pi/3))
         t = triangle.Triangle(p1, p2, p3)
-        assert compare_points(t.circum_center(), Point(0.5, cmath.sqrt(3)/6))
+        assert compare_points(t.circum_center(), Point(0.5, cmath.sqrt(3)/6))
+
+
+def test_triangle_perimeter_and_area():
+    p1 = Point(0, 0)
+    p2 = Point(3, 0)
+    p3 = Point(0, 4)
+    t = triangle.Triangle(p1, p2, p3)
+    assert t.perimeter() == 12
+    assert t.perimeters() == 12
+    assert t.area() == 6
+
+
+def test_triangle_radii():
+    p1 = Point(0, 0)
+    p2 = Point(3, 0)
+    p3 = Point(0, 4)
+    t = triangle.Triangle(p1, p2, p3)
+    assert t.in_radius() == 1
+    assert t.circum_radius() == 2.5
+
+
+def test_triangle_invalid_points():
+    p1 = Point(0, 0)
+    p2 = Point(1, 1)
+    p3 = Point(2, 2)
+    with pytest.raises(ValueError):
+        triangle.Triangle(p1, p2, p3)
+
+
+def test_triangle_init_validation_and_helpers():
+    with pytest.raises(ValueError):
+        triangle.Triangle(Point(0, 0), Point(1, 0))
+
+    with pytest.raises(TypeError):
+        triangle.Triangle(Point(0, 0), (1, 0), Point(0, 1))
+
+    with pytest.raises(ValueError):
+        triangle.Triangle(Point(0, 0), Point(0, 0), Point(1, 1))
+
+    assert triangle._as_float(1) == 1.0
+    assert triangle._as_float(1 + 1e-13j) == 1.0
+    with pytest.raises(ValueError):
+        triangle._as_float(1 + 1e-3j)
+
+    assert triangle._is_close(1.0, 1.0 + 1e-10)
+    assert not triangle._is_close(1.0, 1.01, rel_tol=1e-6, abs_tol=1e-6)
+
+    p0 = Point(0, 0)
+    p1 = Point(2, 0)
+    p2 = Point(0, 2)
+    assert triangle._triangle_twice_area(p0, p1, p2) == 4.0
+
+
+def test_triangle_area_and_centers_errors():
+    tri = object.__new__(triangle.Triangle)
+    tri.points = (Point(0, 0), Point(1, 0), Point(0, 1))
+    tri._tol = 1e-12
+    tri.a = 0.0
+    tri.b = 0.0
+    tri.c = 0.0
+
+    with pytest.raises(ValueError):
+        tri.in_center()
+
+    with pytest.raises(ValueError):
+        tri.in_radius()
+
+    tri2 = object.__new__(triangle.Triangle)
+    tri2.points = (Point(0, 0), Point(1, 0), Point(0, 1))
+    tri2._tol = 1e-12
+    tri2.a = 1.0
+    tri2.b = 1.0
+    tri2.c = 3.0
+
+    with pytest.raises(ValueError):
+        tri2.area()
+
+    tri3 = object.__new__(triangle.Triangle)
+    tri3.points = (Point(0, 0), Point(1, 0), Point(0, 1))
+    tri3._tol = 1e-12
+    tri3.a = 1.0
+    tri3.b = 1.0
+    tri3.c = 2.0
+
+    with pytest.raises(ValueError):
+        tri3.circum_radius()
+
+    tri4 = object.__new__(triangle.Triangle)
+    tri4.points = (Point(0, 0), Point(1, 0), Point(0, 1))
+    tri4._tol = 1e-12
+    tri4.a = 1.0
+    tri4.b = 1.0
+    tri4.c = 2.0 + 1e-13
+    assert tri4.area() == 0.0
+
+
+def test_triangle_validation_helper():
+    tri = object.__new__(triangle.Triangle)
+    tri.points = (Point(0, 0), Point(1, 0), Point(2, 0))
+    tri._tol = 1e-12
+    tri.a = 1.0
+    tri.b = 1.0
+    tri.c = 2.1
+    assert not tri._Triangle__is_valid()
+
+    tri.c = 2.0
+    assert not tri._Triangle__is_valid()
+
+    tri.a = 1.0
+    tri.b = 3.0
+    tri.c = 1.0
+    assert not tri._Triangle__is_valid()
+
+    tri.a = 3.0
+    tri.b = 1.0
+    tri.c = 1.0
+    assert not tri._Triangle__is_valid()
+
+    tri.a = 1.0
+    tri.b = 1.0
+    tri.c = 1.0
+    assert not tri._Triangle__is_valid()
+
+    tri.points = (Point(0, 0), Point(1, 0), Point(0, 1))
+    tri.a = math.sqrt(2)
+    tri.b = 1.0
+    tri.c = 1.0
+    assert tri._Triangle__is_valid()