More refactoring of tests

Makefile

@@ -16,4 +16,4 @@ test:
 dtest:
 	mkdir -p "temp" && \
 	docker build -t ada/testing . && \
-	docker run --name ada-report --rm --mount type=bind,source="$(CURDIR)/temp",target=/home/tests/fem/temp ada/testing bash -c "pip install pytest && cd /home/tests/fem && pytest && python build_verification_report.py"
+	docker run --name ada-report --rm --mount type=bind,source="$(CURDIR)/temp",target=/home/tests/fem/temp ada/testing bash -c "pip install pytest && conda list && cd /home/tests/fem && pytest && python build_verification_report.py"

conda/meta.yaml

@@ -16,6 +16,7 @@ requirements:
     - python
   run:
     - python
+    - numpy
     - ifcopenshell
     - pythonocc-core 7.5.1
     - occt 7.5.1

tests/concept_objects/nodes/conftest.py

@@ -0,0 +1,25 @@
+import pytest
+
+from ada import Node
+from ada.concepts.containers import Nodes
+
+
+@pytest.fixture
+def nodes():
+    n1 = Node((1.0, 2.0, 3.0), 1)
+    n2 = Node((1.0, 1.0, 1.0), 2)
+    n3 = Node((2.0, 1.0, 8.0), 3)
+    n4 = Node((1.0, 2.0, 3.0), 4)
+    n5 = Node((1.0, 3.0, 2.0), 5)
+    n6 = Node((1.0, 1.0, 3.0), 6)
+    n7 = Node((4.0, 5.0, 1.0), 7)
+    n8 = Node((2.0, 4.0, 3.0), 8)
+    n9 = Node((1.0, 1.0, 4.0), 9)
+    n10 = Node((5.0, 2.0, 3.0), 10)
+    return n1, n2, n3, n4, n5, n6, n7, n8, n9, n10
+
+
+@pytest.fixture
+def contained3nodes(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    return Nodes([n1, n2, n3])

tests/concept_objects/nodes/test_node_iterable_protocol.py

@@ -0,0 +1,13 @@
+def test_iter(nodes, contained3nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    i = iter(contained3nodes)
+    assert next(i) == n2
+    assert next(i) == n1
+    assert next(i) == n3
+
+
+def test_for_loop(nodes, contained3nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    expected = [n2, n1, n3]
+    for i, item in enumerate(contained3nodes):
+        assert item == expected[i]

tests/concept_objects/nodes/test_node_repr.py

@@ -0,0 +1,12 @@
+from ada.concepts.containers import Nodes
+
+
+def test_repr_empty():
+    s = Nodes()
+    assert repr(s) == "Nodes(0, min_id: 0, max_id: 0)"
+
+
+def test_repr_some(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    s = Nodes([n1, n2, n3])
+    assert repr(s) == "Nodes(3, min_id: 1, max_id: 3)"

tests/concept_objects/nodes/test_node_size_protocol.py

@@ -0,0 +1,24 @@
+from ada.concepts.containers import Nodes
+
+
+def test_empty():
+    n = Nodes()
+    assert len(n) == 0
+
+
+def test_one(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    n = Nodes([n1])
+    assert len(n) == 1
+
+
+def test_ten(nodes):
+    n = Nodes(nodes)
+    assert len(n) == 10
+
+
+def test_with_duplicates(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    n = Nodes([n1, n1, n1])
+
+    assert len(n) == 1

tests/concept_objects/nodes/test_nodes_construction.py

@@ -0,0 +1,33 @@
+from ada.concepts.containers import Nodes
+
+
+def test_empty():
+    n = Nodes([])
+    assert len(n) == 0
+
+
+def test_from_sequence(nodes):
+    n = Nodes(nodes[:3])
+
+    assert len(n) == 3
+
+
+def test_with_duplicates(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    n = Nodes([n1, n2, n1])
+
+    assert len(n) == 2
+
+
+def test_from_iterables(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+
+    def geniter():
+        yield n1
+        yield n2
+        yield n3
+
+    g = geniter()
+    n = Nodes(g)
+
+    assert len(n) == 3

tests/concept_objects/nodes/test_nodes_equality_protocol.py

@@ -0,0 +1,30 @@
+from ada import Node
+from ada.concepts.containers import Nodes
+
+
+def test_positive_equal(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert Nodes([n1, n2, n3]) == Nodes([n1, n2, n3])
+
+
+def test_negative_equal(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert Nodes([n1, n2, n3]) != Nodes([n4, n5, n6])
+
+
+def test_type_mismatch(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert Nodes([n1, n2, n3]) != [n1, n2, n3]
+
+
+def test_identical(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    s = Nodes([n1, n2, n3])
+    assert s == s
+
+
+def test_random():
+    n1 = Node((1.0, 2.0, 3.0), 1)
+    n5 = Node((1.0, 3.0, 2.0), 5)
+
+    assert tuple(n1.p) < tuple(n5.p)

tests/concept_objects/nodes/test_nodes_get_by_volume.py

@@ -0,0 +1,48 @@
+from ada import Node
+from ada.concepts.containers import Nodes
+
+
+def test_get_by_volume_point(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    s = Nodes(nodes)
+    c = Nodes(s.get_by_volume(p=(4.0, 5.0, 1.0)))
+    assert c == Nodes([n7])
+
+
+def test_get_by_volume_box(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    s = Nodes(nodes)
+    c = Nodes(s.get_by_volume(p=(1.5, 0.5, 0.5), vol_box=(4.5, 5.5, 8.5)))
+    assert c == Nodes([n3, n7, n8])
+
+
+def test_get_by_volume_cylinder(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    s = Nodes(nodes)
+    c = Nodes(s.get_by_volume(p=(1.0, 1.0, 0.5), vol_cyl=(0.2, 4, 0.2)))
+    assert c == Nodes([n2, n6, n9])
+
+
+def test_in_between():
+    p1 = 284.651885, 130.233454, 553.35
+    p2 = 284.651885, 130.233454, 553.425
+    p3 = 284.651885, 130.233454, 553.5
+    p4 = 284.651885, 130.233454, 554.5
+    n1 = Node(p1, 1)
+    n2 = Node(p2, 2)
+    n3 = Node(p3, 3)
+    n4 = Node(p4, 4)
+    nodes = Nodes([n1, n2, n3, n4])
+    res = Nodes(nodes.get_by_volume(p=p1))
+    assert len(res) == 1
+
+
+def test_not_in(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+
+    s = Nodes([n1, n2, n3, n4, n5, n6, n7, n8, n9, n10])
+
+    n11 = Node((0, 0, 0), 10000)
+    assert n11 not in s
+
+    assert n10 in s

tests/concept_objects/nodes/test_nodes_protocol.py

@@ -0,0 +1,17 @@
+from ada.concepts.containers import Nodes
+
+
+def test_positive_contained(nodes, contained3nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert n1 in contained3nodes
+
+
+def test_negative_contained(nodes, contained3nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert n5 not in contained3nodes
+
+
+def test_negative_not_contained(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    n = Nodes([n1, n2, n3, n4, n5, n6, n7, n8, n9, n10])
+    assert n1 in n

tests/concept_objects/nodes/test_sequence_protocol.py

@@ -0,0 +1,108 @@
+import pytest
+
+from ada import Node
+from ada.concepts.containers import Nodes
+
+
+@pytest.fixture
+def contained_all_nodes(nodes):
+    return Nodes(nodes)
+
+
+def test_index_zero(nodes, contained_all_nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert contained_all_nodes[0] == n2
+
+
+def test_index_four(nodes, contained_all_nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert contained_all_nodes[4] == n4
+
+
+def test_index_one_beyond_the_end(contained_all_nodes):
+    with pytest.raises(IndexError):
+        contained_all_nodes[11]
+
+
+def test_index_minus_one(nodes, contained_all_nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert contained_all_nodes[-1] == n10
+
+
+def test_index_minus_five(nodes, contained_all_nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert contained_all_nodes[-10] == n2
+
+
+def test_index_one_before_the_beginning(contained_all_nodes):
+    with pytest.raises(IndexError):
+        contained_all_nodes[-11]
+
+
+def test_slice_from_start(nodes, contained_all_nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert contained_all_nodes[:3] == Nodes([n2, n6, n9])
+
+
+def test_slice_to_end(nodes, contained_all_nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert contained_all_nodes[7:] == Nodes([n8, n7, n10])
+
+
+def test_slice_empty(nodes, contained_all_nodes):
+    assert contained_all_nodes[11:] == Nodes()
+
+
+def test_slice_arbitrary(nodes, contained_all_nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    assert contained_all_nodes[2:4] == Nodes([n9, n1])
+
+
+def test_slice_full(contained_all_nodes):
+    assert contained_all_nodes[:] == contained_all_nodes
+
+
+def test_concatenate_intersect(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    s = Nodes([n1, n2, n3])
+    t = Nodes([n4, n5, n6])
+
+    assert s + t == Nodes([n1, n2, n3, n4, n5, n6])
+
+
+def test_get_by_id_positive(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    s = Nodes([n1, n2, n3])
+    assert s.from_id(1) == n1
+    assert s.from_id(2) == n2
+    assert s.from_id(3) == n3
+
+
+def test_get_by_id_negative(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    s = Nodes([n1, n2, n3])
+    with pytest.raises(ValueError):
+        s.from_id(4)
+
+
+def test_add_to_list(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    s = Nodes([n1, n2, n3])
+
+    n20 = Node((1, 1, 8), 20)
+    n21 = Node((1, 2, 4), 21)
+    n22 = Node((2, 1, 6), 22)
+    s.add(n20)
+    s.add(n21)
+    s.add(n22)
+
+    assert s == Nodes([n2, n20, n1, n21, n22, n3])
+
+
+def test_remove_from_list(nodes):
+    n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 = nodes
+    s = Nodes([n1, n2, n3])
+    s.remove(n3)
+    s.remove(n7)
+
+    assert s == Nodes([n1, n2])

tests/concept_objects/plates/conftest.py

@@ -0,0 +1,13 @@
+import pytest
+
+from ada import Placement
+
+
+@pytest.fixture
+def place1():
+    return dict(placement=Placement(origin=(0, 0, 0), xdir=(1, 0, 0), zdir=(0, 0, 1)))
+
+
+@pytest.fixture
+def place2():
+    return dict(placement=Placement(origin=(0, 0, 0), xdir=(1, 0, 0), zdir=(0, -1, 0)))