From 2e80646d2cf17d700c2b6a94235cd36ca683afa1 Mon Sep 17 00:00:00 2001 From: Dogukan Karatas Date: Tue, 14 Jan 2025 14:38:48 +0100 Subject: [PATCH] splitting tests --- src/specklepy/objects/tests/test_arc.py | 89 +++++ src/specklepy/objects/tests/test_geometry.py | 379 ------------------- src/specklepy/objects/tests/test_line.py | 63 +++ src/specklepy/objects/tests/test_mesh.py | 136 +++++++ src/specklepy/objects/tests/test_plane.py | 71 ++++ src/specklepy/objects/tests/test_point.py | 53 +++ src/specklepy/objects/tests/test_polyline.py | 130 +++++++ src/specklepy/objects/tests/test_vector.py | 70 ++++ 8 files changed, 612 insertions(+), 379 deletions(-) create mode 100644 src/specklepy/objects/tests/test_arc.py delete mode 100644 src/specklepy/objects/tests/test_geometry.py create mode 100644 src/specklepy/objects/tests/test_line.py create mode 100644 src/specklepy/objects/tests/test_mesh.py create mode 100644 src/specklepy/objects/tests/test_plane.py create mode 100644 src/specklepy/objects/tests/test_point.py create mode 100644 src/specklepy/objects/tests/test_polyline.py create mode 100644 src/specklepy/objects/tests/test_vector.py diff --git a/src/specklepy/objects/tests/test_arc.py b/src/specklepy/objects/tests/test_arc.py new file mode 100644 index 0000000..f94dffc --- /dev/null +++ b/src/specklepy/objects/tests/test_arc.py @@ -0,0 +1,89 @@ +import pytest +from specklepy.objects.geometry.arc import Arc +from specklepy.objects.geometry.plane import Plane +from specklepy.objects.geometry.point import Point +from specklepy.objects.geometry.vector import Vector +from specklepy.objects.other import Transform +from specklepy.objects.primitive import Interval +from specklepy.core.api.operations import serialize, deserialize + + +@pytest.fixture +def sample_arc(): + plane = Plane( + origin=Point(x=0, y=0, z=0, units="m"), + normal=Vector(x=0, y=0, z=1, units="m"), + xdir=Vector(x=1, y=0, z=0, units="m"), + ydir=Vector(x=0, y=1, z=0, units="m"), + units="m" + ) + + return Arc( + plane=plane, + startPoint=Point(x=1, y=0, z=0, units="m"), + midPoint=Point(x=0.7071, y=0.7071, z=0, units="m"), + endPoint=Point(x=0, y=1, z=0, units="m"), + domain=Interval.unit_interval(), + units="m" + ) + + +def test_arc_basic_properties(sample_arc): + assert pytest.approx(sample_arc.radius, 0.001) == 1.0 + assert sample_arc.units == "m" + + +def test_arc_transform(sample_arc): + transform = Transform(matrix=[ + 2, 0, 0, 1, + 0, 2, 0, 1, + 0, 0, 2, 1, + 0, 0, 0, 1 + ], units="m") + + success, transformed = sample_arc.transform_to(transform) + assert success is True + assert pytest.approx(transformed.radius, 0.001) == 2.0 + + +def test_arc_serialization(sample_arc): + serialized = serialize(sample_arc) + deserialized = deserialize(serialized) + + assert deserialized.units == sample_arc.units + assert pytest.approx(deserialized.radius, 0.001) == sample_arc.radius + + assert pytest.approx(deserialized.startPoint.x, + 0.001) == sample_arc.startPoint.x + assert pytest.approx(deserialized.startPoint.y, + 0.001) == sample_arc.startPoint.y + assert pytest.approx(deserialized.startPoint.z, + 0.001) == sample_arc.startPoint.z + + assert pytest.approx(deserialized.midPoint.x, + 0.001) == sample_arc.midPoint.x + assert pytest.approx(deserialized.midPoint.y, + 0.001) == sample_arc.midPoint.y + assert pytest.approx(deserialized.midPoint.z, + 0.001) == sample_arc.midPoint.z + + assert pytest.approx(deserialized.endPoint.x, + 0.001) == sample_arc.endPoint.x + assert pytest.approx(deserialized.endPoint.y, + 0.001) == sample_arc.endPoint.y + assert pytest.approx(deserialized.endPoint.z, + 0.001) == sample_arc.endPoint.z + + +def test_arc_measure(sample_arc): + assert pytest.approx(sample_arc.measure, 0.001) == 1.5708 + + +def test_arc_length(sample_arc): + assert pytest.approx(sample_arc.length, 0.001) == 1.5708 + + +def test_arc_domain(sample_arc): + assert sample_arc.domain.start == 0.0 + assert sample_arc.domain.end == 1.0 + assert sample_arc._domain == sample_arc.domain diff --git a/src/specklepy/objects/tests/test_geometry.py b/src/specklepy/objects/tests/test_geometry.py deleted file mode 100644 index 74df5ff..0000000 --- a/src/specklepy/objects/tests/test_geometry.py +++ /dev/null @@ -1,379 +0,0 @@ -import unittest -from specklepy.objects.geometry.point import Point -from specklepy.objects.geometry.vector import Vector -from specklepy.objects.geometry.line import Line -from specklepy.objects.geometry.plane import Plane -from specklepy.objects.geometry.arc import Arc -from specklepy.objects.geometry.mesh import Mesh -from specklepy.objects.geometry.polyline import Polyline -from specklepy.objects.models.units import Units -from specklepy.objects.other import Transform -from specklepy.objects.primitive import Interval -from specklepy.core.api.operations import serialize, deserialize - - -class TestPoint(unittest.TestCase): - def setUp(self): - self.p1 = Point(x=1.0, y=2.0, z=3.0, units=Units.m) - self.p2 = Point(x=4.0, y=6.0, z=8.0, units=Units.m) - self.p3 = Point(x=1000.0, y=2000.0, z=3000.0, units=Units.mm) - - def test_creation(self): - self.assertEqual(self.p1.x, 1.0) - self.assertEqual(self.p1.y, 2.0) - self.assertEqual(self.p1.z, 3.0) - self.assertEqual(self.p1.units, Units.m.value) - - def test_distance_to(self): - distance = self.p1.distance_to(self.p2) - expected = ((3.0**2 + 4.0**2 + 5.0**2) ** 0.5) - self.assertAlmostEqual(distance, expected) - - distance = self.p1.distance_to(self.p3) - self.assertAlmostEqual(distance, 0.0) - - def test_transformation(self): - transform = Transform(matrix=[ - 2.0, 0.0, 0.0, 1.0, - 0.0, 2.0, 0.0, 1.0, - 0.0, 0.0, 2.0, 1.0, - 0.0, 0.0, 0.0, 1.0 - ], units=Units.m) - - success, transformed = self.p1.transform_to(transform) - self.assertTrue(success) - self.assertEqual(transformed.x, 3.0) - self.assertEqual(transformed.y, 5.0) - self.assertEqual(transformed.z, 7.0) - - def test_serialization(self): - serialized = serialize(self.p1) - deserialized = deserialize(serialized) - - self.assertEqual(deserialized.x, self.p1.x) - self.assertEqual(deserialized.y, self.p1.y) - self.assertEqual(deserialized.z, self.p1.z) - self.assertEqual(deserialized.units, self.p1.units) - - -class TestVector(unittest.TestCase): - def setUp(self): - self.v1 = Vector(x=1.0, y=2.0, z=3.0, units=Units.m) - self.v2 = Vector(x=4.0, y=5.0, z=6.0, units=Units.m) - - def test_creation(self): - self.assertEqual(self.v1.x, 1.0) - self.assertEqual(self.v1.y, 2.0) - self.assertEqual(self.v1.z, 3.0) - self.assertEqual(self.v1.units, Units.m.value) - - def test_length(self): - length = self.v1.length - expected = (1.0**2 + 2.0**2 + 3.0**2) ** 0.5 - self.assertAlmostEqual(length, expected) - - def test_transformation(self): - transform = Transform(matrix=[ - 2.0, 0.0, 0.0, 1.0, - 0.0, 2.0, 0.0, 1.0, - 0.0, 0.0, 2.0, 1.0, - 0.0, 0.0, 0.0, 1.0 - ], units=Units.m) - - success, transformed = self.v1.transform_to(transform) - self.assertTrue(success) - self.assertEqual(transformed.x, 2.0) - self.assertEqual(transformed.y, 4.0) - self.assertEqual(transformed.z, 6.0) - - def test_serialization(self): - serialized = serialize(self.v1) - deserialized = deserialize(serialized) - - self.assertEqual(deserialized.x, self.v1.x) - self.assertEqual(deserialized.y, self.v1.y) - self.assertEqual(deserialized.z, self.v1.z) - self.assertEqual(deserialized.units, self.v1.units) - - -class TestLine(unittest.TestCase): - def setUp(self): - self.p1 = Point(x=0.0, y=0.0, z=0.0, units=Units.m) - self.p2 = Point(x=3.0, y=4.0, z=0.0, units=Units.m) - self.line = Line(start=self.p1, end=self.p2, units=Units.m) - - def test_creation(self): - self.assertEqual(self.line.start.x, 0.0) - self.assertEqual(self.line.end.x, 3.0) - self.assertEqual(self.line.units, Units.m.value) - - def test_length(self): - self.assertEqual(self.line.length, 5.0) - - def test_transformation(self): - transform = Transform(matrix=[ - 2.0, 0.0, 0.0, 1.0, - 0.0, 2.0, 0.0, 1.0, - 0.0, 0.0, 2.0, 1.0, - 0.0, 0.0, 0.0, 1.0 - ], units=Units.m) - - success, transformed = self.line.transform_to(transform) - self.assertTrue(success) - self.assertEqual(transformed.start.x, 1.0) - self.assertEqual(transformed.end.x, 7.0) - - def test_serialization(self): - serialized = serialize(self.line) - deserialized = deserialize(serialized) - - self.assertEqual(deserialized.start.x, self.line.start.x) - self.assertEqual(deserialized.end.x, self.line.end.x) - self.assertEqual(deserialized.units, self.line.units) - - -class TestPolyline(unittest.TestCase): - def setUp(self): - self.vertices = [0.0, 0.0, 0.0, - 1.0, 0.0, 0.0, - 1.0, 1.0, 0.0, - 0.0, 1.0, 0.0] - self.polyline = Polyline( - value=self.vertices, - closed=True, - units=Units.m, - domain=Interval(start=0.0, end=1.0) - ) - - def test_creation(self): - self.assertEqual(len(self.polyline.value), 12) - self.assertTrue(self.polyline.closed) - self.assertEqual(self.polyline.units, Units.m.value) - - def test_length(self): - expected_length = 4.0 - self.assertAlmostEqual(self.polyline.length, expected_length) - - def test_get_points(self): - points = self.polyline.get_points() - self.assertEqual(len(points), 4) - self.assertEqual(points[0].x, 0.0) - self.assertEqual(points[1].x, 1.0) - - def test_transformation(self): - transform = Transform(matrix=[ - 2.0, 0.0, 0.0, 1.0, - 0.0, 2.0, 0.0, 1.0, - 0.0, 0.0, 2.0, 1.0, - 0.0, 0.0, 0.0, 1.0 - ], units=Units.m) - - success, transformed = self.polyline.transform_to(transform) - self.assertTrue(success) - points = transformed.get_points() - self.assertEqual(points[0].x, 1.0) - self.assertEqual(points[1].x, 3.0) - - def test_serialization(self): - serialized = serialize(self.polyline) - deserialized = deserialize(serialized) - - self.assertEqual(deserialized.value, self.polyline.value) - self.assertEqual(deserialized.closed, self.polyline.closed) - self.assertEqual(deserialized.units, self.polyline.units) - - -class TestMesh(unittest.TestCase): - def setUp(self): - self.vertices = [ - 0.0, 0.0, 0.0, - 1.0, 0.0, 0.0, - 1.0, 1.0, 0.0, - 0.0, 1.0, 0.0 - ] - self.faces = [3, 0, 1, 2, 3, 0, 2, 3] - self.colors = [255, 0, 0, 255] * 4 - self.area = 1.0 - self.volume = 0.0 - - self.mesh = Mesh( - vertices=self.vertices.copy(), - faces=self.faces.copy(), - colors=self.colors.copy(), - units=Units.m, - area=self.area, - volume=self.volume - ) - - def test_creation(self): - self.assertEqual(self.mesh.vertices_count, 4) - self.assertEqual(self.mesh.faces_count, 2) - self.assertEqual(self.mesh.units, Units.m.value) - self.assertEqual(self.mesh.area, self.area) - self.assertEqual(self.mesh.volume, self.volume) - - def test_get_point(self): - point = self.mesh.get_point(1) - self.assertEqual(point.x, 1.0) - self.assertEqual(point.y, 0.0) - self.assertEqual(point.z, 0.0) - self.assertEqual(point.units, Units.m.value) - - def test_get_face_vertices(self): - face_vertices = self.mesh.get_face_vertices(0) - self.assertEqual(len(face_vertices), 3) - self.assertEqual(face_vertices[0].x, 0.0) - self.assertEqual(face_vertices[1].x, 1.0) - self.assertEqual(face_vertices[0].units, Units.m.value) - - def test_transformation(self): - transform = Transform(matrix=[ - 2.0, 0.0, 0.0, 1.0, - 0.0, 2.0, 0.0, 1.0, - 0.0, 0.0, 2.0, 1.0, - 0.0, 0.0, 0.0, 1.0 - ], units=Units.m) - - test_mesh = Mesh( - vertices=self.vertices.copy(), - faces=self.faces.copy(), - colors=self.colors.copy(), - units=Units.m, - area=1.0, - volume=0.0 - ) - - success, transformed = test_mesh.transform_to(transform) - - self.assertTrue(success) - point = transformed.get_point(0) - self.assertEqual(point.x, 1.0) - self.assertEqual(point.y, 1.0) - self.assertEqual(transformed.area, test_mesh.area) - self.assertEqual(transformed.volume, test_mesh.volume) - - def test_is_closed(self): - self.assertFalse(self.mesh.is_closed()) - - def test_serialization(self): - serialized = serialize(self.mesh) - deserialized = deserialize(serialized) - - self.assertEqual(deserialized.vertices, self.mesh.vertices) - self.assertEqual(deserialized.faces, self.mesh.faces) - self.assertEqual(deserialized.colors, self.mesh.colors) - self.assertEqual(deserialized.units, self.mesh.units) - self.assertEqual(deserialized.area, self.mesh.area) - self.assertEqual(deserialized.volume, self.mesh.volume) - - -class TestPlane(unittest.TestCase): - def setUp(self): - self.origin = Point(x=0.0, y=0.0, z=0.0, units=Units.m) - self.normal = Vector(x=0.0, y=0.0, z=1.0, units=Units.m) - self.xdir = Vector(x=1.0, y=0.0, z=0.0, units=Units.m) - self.ydir = Vector(x=0.0, y=1.0, z=0.0, units=Units.m) - self.plane = Plane( - origin=self.origin, - normal=self.normal, - xdir=self.xdir, - ydir=self.ydir, - units=Units.m - ) - - def test_creation(self): - self.assertEqual(self.plane.origin.x, 0.0) - self.assertEqual(self.plane.normal.z, 1.0) - self.assertEqual(self.plane.units, Units.m.value) - - def test_transformation(self): - transform = Transform(matrix=[ - 2.0, 0.0, 0.0, 1.0, - 0.0, 2.0, 0.0, 1.0, - 0.0, 0.0, 2.0, 1.0, - 0.0, 0.0, 0.0, 1.0 - ], units=Units.m) - - success, transformed = self.plane.transform_to(transform) - self.assertTrue(success) - self.assertEqual(transformed.origin.x, 1.0) - self.assertEqual(transformed.xdir.x, 2.0) - - def test_serialization(self): - serialized = serialize(self.plane) - deserialized = deserialize(serialized) - - self.assertEqual(deserialized.origin.x, self.plane.origin.x) - self.assertEqual(deserialized.normal.z, self.plane.normal.z) - self.assertEqual(deserialized.units, self.plane.units) - - -class TestArc(unittest.TestCase): - def setUp(self): - plane = Plane( - origin=Point(x=0, y=0, z=0, units="m"), - normal=Vector(x=0, y=0, z=1, units="m"), - xdir=Vector(x=1, y=0, z=0, units="m"), - ydir=Vector(x=0, y=1, z=0, units="m"), - units="m" - ) - - self.arc = Arc( - plane=plane, - startPoint=Point(x=1, y=0, z=0, units="m"), - midPoint=Point(x=0.7071, y=0.7071, z=0, units="m"), - endPoint=Point(x=0, y=1, z=0, units="m"), - units="m" - ) - - def test_basic_properties(self): - self.assertAlmostEqual(self.arc.radius, 1.0, places=3) - self.assertEqual(self.arc.units, "m") - - def test_transform(self): - transform = Transform(matrix=[ - 2, 0, 0, 1, - 0, 2, 0, 1, - 0, 0, 2, 1, - 0, 0, 0, 1 - ], units="m") - - success, transformed = self.arc.transform_to(transform) - self.assertTrue(success) - self.assertAlmostEqual(transformed.radius, 2.0, places=3) - - def test_serialization(self): - - serialized = serialize(self.arc) - deserialized = deserialize(serialized) - - self.assertEqual(deserialized.units, self.arc.units) - self.assertAlmostEqual(deserialized.radius, self.arc.radius, places=3) - - self.assertAlmostEqual(deserialized.startPoint.x, - self.arc.startPoint.x, places=3) - self.assertAlmostEqual(deserialized.startPoint.y, - self.arc.startPoint.y, places=3) - self.assertAlmostEqual(deserialized.startPoint.z, - self.arc.startPoint.z, places=3) - - self.assertAlmostEqual(deserialized.midPoint.x, - self.arc.midPoint.x, places=3) - self.assertAlmostEqual(deserialized.midPoint.y, - self.arc.midPoint.y, places=3) - self.assertAlmostEqual(deserialized.midPoint.z, - self.arc.midPoint.z, places=3) - - self.assertAlmostEqual(deserialized.endPoint.x, - self.arc.endPoint.x, places=3) - self.assertAlmostEqual(deserialized.endPoint.y, - self.arc.endPoint.y, places=3) - self.assertAlmostEqual(deserialized.endPoint.z, - self.arc.endPoint.z, places=3) - - self.assertAlmostEqual(deserialized.plane.origin.x, - self.arc.plane.origin.x, places=3) - self.assertAlmostEqual(deserialized.plane.origin.y, - self.arc.plane.origin.y, places=3) - self.assertAlmostEqual(deserialized.plane.origin.z, - self.arc.plane.origin.z, places=3) diff --git a/src/specklepy/objects/tests/test_line.py b/src/specklepy/objects/tests/test_line.py new file mode 100644 index 0000000..a3deefe --- /dev/null +++ b/src/specklepy/objects/tests/test_line.py @@ -0,0 +1,63 @@ +import pytest +from specklepy.objects.geometry.line import Line +from specklepy.objects.geometry.point import Point +from specklepy.objects.models.units import Units +from specklepy.objects.other import Transform +from specklepy.objects.primitive import Interval +from specklepy.core.api.operations import serialize, deserialize + + +@pytest.fixture +def sample_line(): + p1 = Point(x=0.0, y=0.0, z=0.0, units=Units.m) + p2 = Point(x=3.0, y=4.0, z=0.0, units=Units.m) + return Line(start=p1, end=p2, units=Units.m, domain=Interval(start=0.0, end=1.0)) + + +def test_line_creation(sample_line): + assert sample_line.start.x == 0.0 + assert sample_line.end.x == 3.0 + assert sample_line.units == Units.m.value + + +def test_line_length(sample_line): + assert sample_line.length == 5.0 + + +def test_line_transformation(sample_line): + transform = Transform(matrix=[ + 2.0, 0.0, 0.0, 1.0, + 0.0, 2.0, 0.0, 1.0, + 0.0, 0.0, 2.0, 1.0, + 0.0, 0.0, 0.0, 1.0 + ], units=Units.m) + + success, transformed = sample_line.transform_to(transform) + assert success is True + assert transformed.start.x == 1.0 + assert transformed.end.x == 7.0 + assert transformed.units == sample_line.units + + +def test_line_serialization(sample_line): + serialized = serialize(sample_line) + deserialized = deserialize(serialized) + + assert deserialized.start.x == sample_line.start.x + assert deserialized.end.x == sample_line.end.x + assert deserialized.units == sample_line.units + + +def test_line_from_list(): + coords = [0.0, 0.0, 0.0, 3.0, 4.0, 0.0] + line = Line.from_list(coords, Units.m) + assert line.start.x == 0.0 + assert line.end.x == 3.0 + assert line.units == Units.m.value + + +def test_line_from_coords(): + line = Line.from_coords(0.0, 0.0, 0.0, 3.0, 4.0, 0.0, Units.m.value) + assert line.start.x == 0.0 + assert line.end.x == 3.0 + assert line.units == Units.m.value diff --git a/src/specklepy/objects/tests/test_mesh.py b/src/specklepy/objects/tests/test_mesh.py new file mode 100644 index 0000000..ad30119 --- /dev/null +++ b/src/specklepy/objects/tests/test_mesh.py @@ -0,0 +1,136 @@ +import pytest +from specklepy.objects.geometry.mesh import Mesh +from specklepy.objects.geometry.point import Point +from specklepy.objects.models.units import Units +from specklepy.objects.other import Transform +from specklepy.core.api.operations import serialize, deserialize + + +@pytest.fixture +def sample_mesh(): + vertices = [ + 0.0, 0.0, 0.0, + 1.0, 0.0, 0.0, + 1.0, 1.0, 0.0, + 0.0, 1.0, 0.0 + ] + faces = [3, 0, 1, 2, 3, 0, 2, 3] + colors = [255, 0, 0, 255] * 4 + area = 1.0 + volume = 0.0 + + return Mesh( + vertices=vertices, + faces=faces, + colors=colors, + units=Units.m, + area=area, + volume=volume + ) + + +def test_mesh_creation(sample_mesh): + assert sample_mesh.vertices_count == 4 + assert sample_mesh.faces_count == 2 + assert sample_mesh.units == Units.m.value + assert sample_mesh.area == 1.0 + assert sample_mesh.volume == 0.0 + + +def test_mesh_get_point(sample_mesh): + point = sample_mesh.get_point(1) + assert point.x == 1.0 + assert point.y == 0.0 + assert point.z == 0.0 + assert point.units == Units.m.value + + +def test_mesh_get_points(sample_mesh): + points = sample_mesh.get_points() + assert len(points) == 4 + assert all(isinstance(p, Point) for p in points) + assert points[0].x == 0.0 + assert points[1].x == 1.0 + + +def test_mesh_get_face_vertices(sample_mesh): + face_vertices = sample_mesh.get_face_vertices(0) + assert len(face_vertices) == 3 + assert face_vertices[0].x == 0.0 + assert face_vertices[1].x == 1.0 + assert face_vertices[0].units == Units.m.value + + +def test_mesh_transform(sample_mesh): + transform = Transform(matrix=[ + 2.0, 0.0, 0.0, 1.0, + 0.0, 2.0, 0.0, 1.0, + 0.0, 0.0, 2.0, 1.0, + 0.0, 0.0, 0.0, 1.0 + ], units=Units.m) + + success, transformed = sample_mesh.transform_to(transform) + assert success is True + + point = transformed.get_point(0) + assert point.x == 1.0 + assert point.y == 1.0 + assert transformed.area == sample_mesh.area + assert transformed.volume == sample_mesh.volume + + +def test_mesh_is_closed(sample_mesh): + assert sample_mesh.is_closed() is False + + vertices = [ + 0.0, 0.0, 0.0, # 0 + 1.0, 0.0, 0.0, # 1 + 1.0, 1.0, 0.0, # 2 + 0.0, 1.0, 0.0, # 3 + 0.0, 0.0, 1.0, # 4 + 1.0, 0.0, 1.0, # 5 + 1.0, 1.0, 1.0, # 6 + 0.0, 1.0, 1.0 # 7 + ] + faces = [ + 3, 0, 1, 2, # front + 3, 0, 2, 3, + 3, 4, 5, 6, # back + 3, 4, 6, 7, + 3, 0, 4, 7, # left + 3, 0, 7, 3, + 3, 1, 5, 6, # right + 3, 1, 6, 2, + 3, 3, 2, 6, # top + 3, 3, 6, 7, + 3, 0, 1, 5, # bottom + 3, 0, 5, 4 + ] + closed_mesh = Mesh(vertices=vertices, faces=faces, + units=Units.m, area=6.0, volume=1.0) + assert closed_mesh.is_closed() is True + + +def test_mesh_serialization(sample_mesh): + serialized = serialize(sample_mesh) + deserialized = deserialize(serialized) + + assert deserialized.vertices == sample_mesh.vertices + assert deserialized.faces == sample_mesh.faces + assert deserialized.colors == sample_mesh.colors + assert deserialized.units == sample_mesh.units + assert deserialized.area == sample_mesh.area + assert deserialized.volume == sample_mesh.volume + + +def test_mesh_convert_units(sample_mesh): + sample_mesh.convert_units(Units.mm) + assert sample_mesh.units == Units.mm.value + + point = sample_mesh.get_point(1) + assert point.x == 1000.0 + assert point.units == Units.mm.value + + assert sample_mesh.area == 1.0 * (1000 ** 2) + + assert sample_mesh.volume == 0.0 diff --git a/src/specklepy/objects/tests/test_plane.py b/src/specklepy/objects/tests/test_plane.py new file mode 100644 index 0000000..eb1689f --- /dev/null +++ b/src/specklepy/objects/tests/test_plane.py @@ -0,0 +1,71 @@ +import pytest +from specklepy.objects.geometry.plane import Plane +from specklepy.objects.geometry.point import Point +from specklepy.objects.geometry.vector import Vector +from specklepy.objects.models.units import Units +from specklepy.objects.other import Transform +from specklepy.core.api.operations import serialize, deserialize + + +@pytest.fixture +def sample_plane(): + return Plane( + origin=Point(x=0.0, y=0.0, z=0.0, units=Units.m), + normal=Vector(x=0.0, y=0.0, z=1.0, units=Units.m), + xdir=Vector(x=1.0, y=0.0, z=0.0, units=Units.m), + ydir=Vector(x=0.0, y=1.0, z=0.0, units=Units.m), + units=Units.m + ) + + +def test_plane_creation(sample_plane): + assert sample_plane.origin.x == 0.0 + assert sample_plane.normal.z == 1.0 + assert sample_plane.xdir.x == 1.0 + assert sample_plane.ydir.y == 1.0 + assert sample_plane.units == Units.m.value + + +def test_plane_transformation(sample_plane): + transform = Transform(matrix=[ + 2.0, 0.0, 0.0, 1.0, + 0.0, 2.0, 0.0, 1.0, + 0.0, 0.0, 2.0, 1.0, + 0.0, 0.0, 0.0, 1.0 + ], units=Units.m) + + success, transformed = sample_plane.transform_to(transform) + assert success is True + assert transformed.origin.x == 1.0 + assert transformed.xdir.x == 2.0 + assert transformed.units == sample_plane.units + + +def test_plane_serialization(sample_plane): + serialized = serialize(sample_plane) + deserialized = deserialize(serialized) + + assert deserialized.origin.x == sample_plane.origin.x + assert deserialized.normal.z == sample_plane.normal.z + assert deserialized.units == sample_plane.units + + +def test_plane_to_list(sample_plane): + coords = sample_plane.to_list() + assert len(coords) == 13 + + +def test_plane_from_list(): + coords = [ + 0.0, 0.0, 0.0, # origin + 0.0, 0.0, 1.0, # normal + 1.0, 0.0, 0.0, # xdir + 0.0, 1.0, 0.0, # ydir + 1 # units encoding (1 = mm) + ] + plane = Plane.from_list(coords) + assert plane.origin.x == 0.0 + assert plane.normal.z == 1.0 + assert plane.xdir.x == 1.0 + assert plane.ydir.y == 1.0 + assert plane.units == "mm" diff --git a/src/specklepy/objects/tests/test_point.py b/src/specklepy/objects/tests/test_point.py new file mode 100644 index 0000000..cb054df --- /dev/null +++ b/src/specklepy/objects/tests/test_point.py @@ -0,0 +1,53 @@ +import pytest +from specklepy.objects.geometry.point import Point +from specklepy.objects.models.units import Units +from specklepy.objects.other import Transform +from specklepy.core.api.operations import serialize, deserialize + + +def test_point_creation(): + p1 = Point(x=1.0, y=2.0, z=3.0, units=Units.m) + assert p1.x == 1.0 + assert p1.y == 2.0 + assert p1.z == 3.0 + assert p1.units == Units.m.value + + +def test_point_distance_calculation(): + p1 = Point(x=1.0, y=2.0, z=3.0, units=Units.m) + p2 = Point(x=4.0, y=6.0, z=8.0, units=Units.m) + p3 = Point(x=1000.0, y=2000.0, z=3000.0, units=Units.mm) + + distance = p1.distance_to(p2) + expected = ((3.0**2 + 4.0**2 + 5.0**2) ** 0.5) + assert distance == pytest.approx(expected) + + distance = p1.distance_to(p3) + assert distance == pytest.approx(0.0) + + +def test_point_transformation(): + p1 = Point(x=1.0, y=2.0, z=3.0, units=Units.m) + transform = Transform(matrix=[ + 2.0, 0.0, 0.0, 1.0, + 0.0, 2.0, 0.0, 1.0, + 0.0, 0.0, 2.0, 1.0, + 0.0, 0.0, 0.0, 1.0 + ], units=Units.m) + + success, transformed = p1.transform_to(transform) + assert success is True + assert transformed.x == 3.0 + assert transformed.y == 5.0 + assert transformed.z == 7.0 + + +def test_point_serialization(): + p1 = Point(x=1.0, y=2.0, z=3.0, units=Units.m) + serialized = serialize(p1) + deserialized = deserialize(serialized) + + assert deserialized.x == p1.x + assert deserialized.y == p1.y + assert deserialized.z == p1.z + assert deserialized.units == p1.units diff --git a/src/specklepy/objects/tests/test_polyline.py b/src/specklepy/objects/tests/test_polyline.py new file mode 100644 index 0000000..8f849b0 --- /dev/null +++ b/src/specklepy/objects/tests/test_polyline.py @@ -0,0 +1,130 @@ +import pytest +from specklepy.objects.geometry.polyline import Polyline +from specklepy.objects.geometry.point import Point +from specklepy.objects.models.units import Units +from specklepy.objects.other import Transform +from specklepy.objects.primitive import Interval +from specklepy.core.api.operations import serialize, deserialize + + +@pytest.fixture +def square_vertices(): + return [ + 0.0, 0.0, 0.0, + 1.0, 0.0, 0.0, + 1.0, 1.0, 0.0, + 0.0, 1.0, 0.0 + ] + + +@pytest.fixture +def sample_polyline(square_vertices): + return Polyline( + value=square_vertices, + closed=True, + units=Units.m, + domain=Interval(start=0.0, end=1.0) + ) + + +def test_polyline_creation(square_vertices): + polyline = Polyline( + value=square_vertices, + closed=True, + units=Units.m, + domain=Interval(start=0.0, end=1.0) + ) + + assert len(polyline.value) == 12 + assert polyline.closed is True + assert polyline.units == Units.m.value + assert isinstance(polyline.domain, Interval) + assert polyline.domain.start == 0.0 + assert polyline.domain.end == 1.0 + + +def test_polyline_get_points(sample_polyline): + points = sample_polyline.get_points() + + assert len(points) == 4 + + assert all(isinstance(p, Point) for p in points) + + assert points[0].x == 0.0 and points[0].y == 0.0 and points[0].z == 0.0 + assert points[1].x == 1.0 and points[1].y == 0.0 and points[1].z == 0.0 + + assert all(p.units == Units.m.value for p in points) + + +def test_polyline_length(sample_polyline): + + assert pytest.approx(sample_polyline.length) == 4.0 + + sample_polyline.closed = False + assert pytest.approx(sample_polyline.length) == 3.0 + + +def test_polyline_transformation(sample_polyline): + transform = Transform(matrix=[ + 2.0, 0.0, 0.0, 1.0, + 0.0, 2.0, 0.0, 1.0, + 0.0, 0.0, 2.0, 1.0, + 0.0, 0.0, 0.0, 1.0 + ], units=Units.m) + + success, transformed = sample_polyline.transform_to(transform) + assert success is True + + points = transformed.get_points() + + assert points[0].x == 1.0 + assert points[0].y == 1.0 + assert points[0].z == 1.0 + + assert points[1].x == 3.0 + assert points[1].y == 1.0 + assert points[1].z == 1.0 + + assert transformed.units == sample_polyline.units + + +def test_polyline_serialization(sample_polyline): + serialized = serialize(sample_polyline) + deserialized = deserialize(serialized) + + assert deserialized.value == sample_polyline.value + assert deserialized.closed == sample_polyline.closed + assert deserialized.units == sample_polyline.units + assert deserialized.domain.start == sample_polyline.domain.start + assert deserialized.domain.end == sample_polyline.domain.end + + +def test_polyline_to_list(sample_polyline): + result = sample_polyline.to_list() + + assert isinstance(result, list) + assert result[2] == 1 + assert result[3] == 0.0 + assert result[4] == 1.0 + assert result[5] == len(sample_polyline.value) + + +def test_polyline_from_list(): + input_list = [ + 18, "Objects.Geometry.Polyline", + 1, + 0.0, 1.0, + 12, + 0.0, 0.0, 0.0, + 1.0, 0.0, 0.0, + 1.0, 1.0, 0.0, + 0.0, 1.0, 0.0 + ] + + polyline = Polyline.from_list(input_list, Units.m) + + assert polyline.closed is True + assert len(polyline.value) == 12 + assert polyline.units == Units.m.value + assert polyline.domain.start == 0.0 + assert polyline.domain.end == 1.0 diff --git a/src/specklepy/objects/tests/test_vector.py b/src/specklepy/objects/tests/test_vector.py new file mode 100644 index 0000000..066390d --- /dev/null +++ b/src/specklepy/objects/tests/test_vector.py @@ -0,0 +1,70 @@ +import pytest +from specklepy.objects.geometry.vector import Vector +from specklepy.objects.models.units import Units +from specklepy.objects.other import Transform +from specklepy.core.api.operations import serialize, deserialize + + +@pytest.fixture +def sample_vectors(): + return ( + Vector(x=1.0, y=2.0, z=3.0, units=Units.m), + Vector(x=4.0, y=5.0, z=6.0, units=Units.m) + ) + + +def test_vector_creation(sample_vectors): + v1, _ = sample_vectors + assert v1.x == 1.0 + assert v1.y == 2.0 + assert v1.z == 3.0 + assert v1.units == Units.m.value + + +def test_vector_length(sample_vectors): + v1, _ = sample_vectors + expected = (1.0**2 + 2.0**2 + 3.0**2) ** 0.5 + assert v1.length == pytest.approx(expected) + + +def test_vector_transformation(sample_vectors): + v1, _ = sample_vectors + transform = Transform(matrix=[ + 2.0, 0.0, 0.0, 1.0, + 0.0, 2.0, 0.0, 1.0, + 0.0, 0.0, 2.0, 1.0, + 0.0, 0.0, 0.0, 1.0 + ], units=Units.m) + + success, transformed = v1.transform_to(transform) + assert success is True + assert transformed.x == 2.0 + assert transformed.y == 4.0 + assert transformed.z == 6.0 + assert transformed.units == v1.units + + +def test_vector_serialization(sample_vectors): + v1, _ = sample_vectors + serialized = serialize(v1) + deserialized = deserialize(serialized) + + assert deserialized.x == v1.x + assert deserialized.y == v1.y + assert deserialized.z == v1.z + assert deserialized.units == v1.units + + +def test_vector_from_list(): + coords = [1.0, 2.0, 3.0] + v = Vector.from_list(coords, Units.m) + assert v.x == 1.0 + assert v.y == 2.0 + assert v.z == 3.0 + assert v.units == Units.m.value + + +def test_vector_to_list(sample_vectors): + v1, _ = sample_vectors + coords = v1.to_list() + assert coords == [1.0, 2.0, 3.0]