feat: Add basic setup for direct testing of rust code using cargo test

.github/workflows/wheels.yml

@@ -50,8 +50,26 @@ jobs:
       - name: run test
         run: uv run --group test pytest
 
+  cargo-test:
+    name: Run cargo tests
+    needs: pre-commit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: run tests
+        run: cargo test --all-features --workspace
+
   build_wheels:
-    needs: test
+    needs: [test, cargo-test]
     name: Build wheels on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
     strategy:

Cargo.toml

@@ -14,6 +14,7 @@ repository = "https://github.com/napari/bermuda.git"
 triangulation = { path = "crates/triangulation" }
 pyo3 = { version = "0.23.3", features = ["extension-module"] }
 numpy = "0.23"
+rstest = "0.24.0"
 
 
 [workspace.lints.rust]

crates/bermuda/Cargo.toml

@@ -13,6 +13,9 @@ pyo3 = { workspace = true }
 numpy = { workspace = true }
 triangulation = { workspace = true }
 
+[dev-dependencies]
+rstest = { workspace = true}
+
 [lib]
 name = "_bermuda"
 crate-type = ["cdylib"]

crates/bermuda/tests/test_point.rs

@@ -0,0 +1,28 @@
+use rstest::rstest;
+use triangulation::point::{Point, Segment, Vector};
+
+#[rstest]
+fn test_segment_order() {
+    let s1 = Segment::new(Point::new(0.0, 0.0), Point::new(1.0, 1.0));
+    let s2 = Segment::new(Point::new(1.0, 1.0), Point::new(0.0, 0.0));
+    assert_eq!(s1, s2);
+}
+
+#[rstest]
+#[case::base(1.0, 0.0, 1.0, 1.0, 2.0, 1.0)]
+#[case::zero_vector(0.0, 0.0, 1.0, 1.0, 1.0, 1.0)] // zero vector
+#[case::negative_vector(1.0, 1.0, -1.0, -1.0, 0.0, 0.0)] // negative vector
+#[case::larger_components(10.0, 20.0, 30.0, 40.0, 40.0, 60.0)] // larger components
+fn test_vector_add(
+    #[case] x1: f32,
+    #[case] y1: f32,
+    #[case] x2: f32,
+    #[case] y2: f32,
+    #[case] expected_x: f32,
+    #[case] expected_y: f32,
+) {
+    assert_eq!(
+        Point::new(x1, y1) + Vector::new(x2, y2),
+        Point::new(expected_x, expected_y)
+    );
+}

crates/triangulation/src/path_triangulation.rs

@@ -1,5 +1,4 @@
 use crate::point;
-use crate::point::Vector;
 
 #[derive(Debug)]
 pub struct PathTriangulation {
@@ -46,7 +45,7 @@ fn add_triangles_for_join(
     bevel: bool,
 ) -> f32 {
     let idx = triangles.offsets.len();
-    let mitter: Vector;
+    let mitter: point::Vector;
     let length = point::vector_length(p2, p3);
     let p1_p2_diff_norm = (p2 - p1) / prev_length;
     let p2_p3_diff_norm = (p3 - p2) / length;

crates/triangulation/src/point.rs

@@ -283,6 +283,27 @@ impl Triangle {
     }
 }
 
+/// Calculates the Euclidean distance between two points.
+///
+/// # Arguments
+/// * `p1` - The first point.
+/// * `p2` - The second point.
+///
+/// # Returns
+/// Returns the distance between `p1` and `p2` as a `Coord`.
+///
+/// # Examples
+/// ```
+/// use triangulation::point::{Point, vector_length};
+///
+/// let point1 = Point { x: 3.0, y: 0.0 };
+/// let point2 = Point { x: 0.0, y: 4.0 };
+///
+/// let distance = vector_length(point1, point2);
+/// assert_eq!(distance, 5.0);
+/// ```
 pub fn vector_length(p1: Point, p2: Point) -> Coord {
-    ((p1.x - p2.x).powi(2) + (p1.y - p2.y).powi(2)).sqrt()
+    let dx = p1.x - p2.x;
+    let dy = p1.y - p2.y;
+    (dx * dx + dy * dy).sqrt()
 }