Complete test for 'find_intersections' function

tests/core_tests/linear_tests/test_find_intersections.py

@@ -2,18 +2,23 @@
 
 from hypothesis import given
 
-from bentley_ottmann.core.linear import find_intersections
+from bentley_ottmann.core.linear import (find_intersections,
+                                         is_real_segment,
+                                         segments_relationship,
+                                         to_real_segment)
 from bentley_ottmann.hints import Segment
 from tests.utils import (is_point,
-                         reverse_segment)
+                         reverse_point_coordinates,
+                         reverse_segment,
+                         reverse_segment_coordinates)
 from . import strategies
 
 
 @given(strategies.segments_pairs)
 def test_basic(segments_pair: Tuple[Segment, Segment]) -> None:
-    first_segment, second_segment = segments_pair
+    left_segment, right_segment = segments_pair
 
-    result = find_intersections(first_segment, second_segment)
+    result = find_intersections(left_segment, right_segment)
 
     assert isinstance(result, tuple)
     assert all(is_point(element) for element in result)
@@ -22,11 +27,11 @@ def test_basic(segments_pair: Tuple[Segment, Segment]) -> None:
 
 @given(strategies.segments_pairs)
 def test_commutativity(segments_pair: Tuple[Segment, Segment]) -> None:
-    first_segment, second_segment = segments_pair
+    left_segment, right_segment = segments_pair
 
-    result = find_intersections(first_segment, second_segment)
+    result = find_intersections(left_segment, right_segment)
 
-    assert result == find_intersections(second_segment, first_segment)
+    assert result == find_intersections(right_segment, left_segment)
 
 
 @given(strategies.segments)
@@ -36,8 +41,36 @@ def test_self(segment: Segment) -> None:
     assert result == tuple(sorted(segment))
 
 
+@given(strategies.segments_pairs)
+def test_connection_with_segments_relationship(
+        segments_pair: Tuple[Segment, Segment]) -> None:
+    left_segment, right_segment = segments_pair
+
+    result = find_intersections(left_segment, right_segment)
+
+    are_real_segments = is_real_segment(left_segment)
+    assert (len(result)
+            == segments_relationship(left_segment
+                                     if are_real_segments
+                                     else to_real_segment(left_segment),
+                                     right_segment
+                                     if are_real_segments
+                                     else to_real_segment(right_segment)))
+
+
 @given(strategies.segments)
 def test_reversed(segment: Segment) -> None:
     result = find_intersections(segment, reverse_segment(segment))
 
     assert result == tuple(sorted(segment))
+
+
+@given(strategies.segments_pairs)
+def test_reversed_coordinates(segments_pair: Tuple[Segment, Segment]) -> None:
+    left_segment, right_segment = segments_pair
+
+    result = find_intersections(left_segment, right_segment)
+
+    assert (tuple(sorted(map(reverse_point_coordinates, reversed(result))))
+            == find_intersections(reverse_segment_coordinates(left_segment),
+                                  reverse_segment_coordinates(right_segment)))

tests/utils.py

@@ -63,8 +63,7 @@ def reverse_segment(segment: Segment) -> Segment:
 
 def reverse_segment_coordinates(segment: Segment) -> Segment:
     start, end = segment
-    return (reverse_point_coordinates(start),
-            reverse_point_coordinates(end))
+    return reverse_point_coordinates(start), reverse_point_coordinates(end)
 
 
 def reverse_point_coordinates(point: Point) -> Point: