test(rust): add fast unit tests for broadcast/error and i256 helpers; add rlib crate-type; run cargo test in CI

Author: elyase

.github/workflows/ci.yml

@@ -82,6 +82,15 @@ jobs:
       - name: Clippy
         run: cargo clippy --all-features -- -D warnings
 
+  rust-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Rust
+        run: rustup show
+      - name: Run cargo tests
+        run: cargo test --all-features --quiet
+
   linux:
     runs-on: ${{ matrix.platform.runner }}
     strategy:
@@ -182,7 +191,7 @@ jobs:
     name: Release
     runs-on: ubuntu-latest
     if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
-    needs: [linux-just-test, linux-min-versions-just-test, clippy, linux, windows, macos, sdist]
+    needs: [linux-just-test, linux-min-versions-just-test, clippy, rust-tests, linux, windows, macos, sdist]
     environment: pypi
     permissions:
       # Use to sign the release artifacts

Cargo.toml

@@ -4,7 +4,7 @@ version = "0.2.2"
 edition = "2021"
 
 [lib]
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 polars = { version = "0.49.1", default-features = false }

src/expressions.rs

@@ -834,3 +834,5 @@ pub fn i256_mean(inputs: &[Series]) -> PolarsResult<Series> {
     let q = if neg && q_abs != U256::from(0u8) { (!q_abs).overflowing_add(U256::from(1u8)).0 } else { q_abs };
     Ok(Series::new(s0.name().clone(), [Some(q.to_be_bytes::<32>().to_vec())]))
 }
+
+// (unit tests moved to src/lib.rs to ensure visibility of module items)

src/lib.rs

@@ -185,3 +185,85 @@ fn i256_to_i64_opt(bytes: &[u8]) -> Option<i64> {
         }
     }
 }
+
+// -------------------- Unit tests (Rust) --------------------
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ruint::aliases::U256;
+
+    fn be32_from_u64(v: u64) -> [u8; 32] {
+        let mut out = [0u8; 32];
+        out[24..].copy_from_slice(&v.to_be_bytes());
+        out
+    }
+
+    fn be32_from_i64(v: i64) -> [u8; 32] {
+        if v >= 0 {
+            be32_from_u64(v as u64)
+        } else {
+            let mag = (-v) as u64;
+            let inv = U256::from(0u8).overflowing_sub(U256::from(mag)).0;
+            inv.to_be_bytes()
+        }
+    }
+
+    fn series_from_be32(name: &str, vals: Vec<Option<[u8; 32]>>) -> Series {
+        BinaryChunked::from_iter_options(name.into(), vals.into_iter()).into_series()
+    }
+
+    #[test]
+    fn test_broadcast_mismatch_err() {
+        let a = series_from_be32(
+            "a",
+            vec![Some(be32_from_u64(1)), Some(be32_from_u64(2))],
+        );
+        let b = series_from_be32(
+            "b",
+            vec![Some(be32_from_u64(3)), Some(be32_from_u64(4)), Some(be32_from_u64(5))],
+        );
+        let a_bin = a.binary().unwrap();
+        let b_bin = b.binary().unwrap();
+        let err = broadcast_binary_pair(a_bin, b_bin).unwrap_err();
+        let msg = format!("{err}");
+        assert!(msg.contains("cannot do a binary operation on columns of different lengths"));
+    }
+
+    #[test]
+    fn test_map_pair_add_overflow_to_null() {
+        let a = series_from_be32("a", vec![Some(U256::MAX.to_be_bytes())]);
+        let b = series_from_be32("b", vec![Some(be32_from_u64(1))]);
+        let out = map_pair_binary_to_binary_series(
+            &PlSmallStr::from_static("out"),
+            a.binary().unwrap(),
+            b.binary().unwrap(),
+            |la, rb| {
+                let ua = u256_from_be32(la).ok()?;
+                let ub = u256_from_be32(rb).ok()?;
+                let (sum, overflow) = ua.overflowing_add(ub);
+                if overflow { None } else { Some(u256_to_be32(&sum)) }
+            },
+        )
+        .unwrap();
+        let first = out.binary().unwrap().into_iter().next().unwrap();
+        assert!(first.is_none());
+    }
+
+    #[test]
+    fn test_i256_twos_complement_roundtrip_small() {
+        // For a small magnitude negative, tc(tc(x)) = x
+        let x = be32_from_i64(-123);
+        let tc = i256_twos_complement(&x);
+        let back = i256_twos_complement(&tc);
+        assert_eq!(back, x);
+    }
+
+    #[test]
+    fn test_i256_cmp_bytes_sign_ordering() {
+        let neg = be32_from_i64(-1);
+        let pos = be32_from_i64(1);
+        assert!(i256_cmp_bytes(&neg, &pos).unwrap().is_lt());
+        assert!(i256_cmp_bytes(&pos, &neg).unwrap().is_gt());
+        assert!(i256_cmp_bytes(&neg, &neg).unwrap().is_eq());
+    }
+}