Add Rust tests

.github/workflows/rust.yml

@@ -13,4 +13,4 @@ jobs:
       - name: compile
         run: |
           cd rust
-          cargo build
+          cargo test

rust/Cargo.toml

@@ -2,7 +2,7 @@
 name = "codelibrary"
 version = "0.1.0"
 
-edition = "2018"
+edition = "2021"
 
 [[bin]]
 name = "topological_sort"

rust/graphs/dfs/topological_sort.rs

@@ -1,4 +1,4 @@
-fn dfs(graph: &Vec<Vec<usize>>, used: &mut Vec<bool>, order: &mut Vec<usize>, u: usize) {
+fn dfs(graph: &[Vec<usize>], used: &mut [bool], order: &mut Vec<usize>, u: usize) {
     used[u] = true;
     for v in &graph[u] {
         if !used[*v] {
@@ -8,7 +8,7 @@ fn dfs(graph: &Vec<Vec<usize>>, used: &mut Vec<bool>, order: &mut Vec<usize>, u:
     order.push(u);
 }
 
-pub fn topological_sort(graph: &Vec<Vec<usize>>) -> Vec<usize> {
+pub fn topological_sort(graph: &[Vec<usize>]) -> Vec<usize> {
     let n = graph.len();
     let mut used = vec![false; n];
     let mut order = Vec::<usize>::new();
@@ -21,8 +21,14 @@ pub fn topological_sort(graph: &Vec<Vec<usize>>) -> Vec<usize> {
     return order;
 }
 
-fn main() {
-    let g = vec![vec![0], vec![], vec![0, 1]];
-    let order = topological_sort(&g);
-    assert_eq!(order, vec![2, 1, 0]);
+#[cfg(test)]
+mod tests {
+    use crate::topological_sort;
+
+    #[test]
+    fn basic_test() {
+        let g = vec![vec![0], vec![], vec![0, 1]];
+        let order = topological_sort(&g);
+        assert_eq!(order, [2, 1, 0]);
+    }
 }

rust/graphs/matchings/max_bipartite_matching_EV.rs

@@ -1,4 +1,7 @@
-fn find_path(graph: &Vec<Vec<usize>>, u1: usize, matching: &mut Vec<usize>, vis: &mut Vec<bool>) -> bool {
+#![feature(test)]
+extern crate test;
+
+fn find_path(graph: &[Vec<usize>], u1: usize, matching: &mut [usize], vis: &mut [bool]) -> bool {
     vis[u1] = true;
     for v in &graph[u1] {
         let u2 = matching[*v];
@@ -10,7 +13,7 @@ fn find_path(graph: &Vec<Vec<usize>>, u1: usize, matching: &mut Vec<usize>, vis:
     return false;
 }
 
-pub fn max_matching(graph: &Vec<Vec<usize>>, n2: usize) -> (usize, Vec<usize>) {
+pub fn max_matching(graph: &[Vec<usize>], n2: usize) -> (usize, Vec<usize>) {
     let n1 = graph.len();
     let mut matching = vec![usize::MAX; n2];
     let mut matches = 0;
@@ -23,9 +26,25 @@ pub fn max_matching(graph: &Vec<Vec<usize>>, n2: usize) -> (usize, Vec<usize>) {
     return (matches, matching);
 }
 
-fn main() {
-    let g = vec![vec![0, 1], vec![0]];
-    let (cardinality, matching) = max_matching(&g, 2);
-    assert_eq!(cardinality, 2);
-    assert_eq!(matching, vec![1, 0]);
+#[cfg(test)]
+mod tests {
+    use crate::max_matching;
+    use test::Bencher;
+
+    #[test]
+    fn basic_test() {
+        let g = vec![vec![0, 1], vec![0]];
+        let (cardinality, matching) = max_matching(&g, 2);
+        assert_eq!(cardinality, 2);
+        assert_eq!(matching, vec![1, 0]);
+    }
+
+    #[bench]
+    fn bench_complete_bipartite_graph(b: &mut Bencher) {
+        let n = 100;
+        let g = vec![(0..n).collect(); n];
+        b.iter(|| {
+            let (_cardinality, _matching) = max_matching(&g, n);
+        });
+    }
 }

rust/graphs/shortestpaths/dijkstra.rs

@@ -2,7 +2,7 @@ use std::collections::BinaryHeap;
 
 // https://cp-algorithms.com/graph/dijkstra_sparse.html
 // O(E*log(V)) time and O(E) memory
-pub fn dijkstra_heap(graph: &Vec<Vec<(usize, i32)>>, s: usize) -> (Vec<i32>, Vec<usize>) {
+pub fn dijkstra_heap(graph: &[Vec<(usize, i32)>], s: usize) -> (Vec<i32>, Vec<usize>) {
     let n = graph.len();
     let mut prio = vec![i32::MAX; n];
     let mut pred = vec![usize::MAX; n];
@@ -23,9 +23,15 @@ pub fn dijkstra_heap(graph: &Vec<Vec<(usize, i32)>>, s: usize) -> (Vec<i32>, Vec
     return (prio, pred);
 }
 
-fn main() {
-    let g = vec![vec![(1, 10), (2, 8)], vec![(2, -5)], vec![]];
-    let (prio, pred) = dijkstra_heap(&g, 0);
-    assert_eq!(prio, vec![0, 10, 5]);
-    assert_eq!(pred, vec![usize::MAX, 0, 1]);
+#[cfg(test)]
+mod tests {
+    use crate::dijkstra_heap;
+
+    #[test]
+    fn basic_test() {
+        let g = vec![vec![(1, 10), (2, 8)], vec![(2, -5)], vec![]];
+        let (prio, pred) = dijkstra_heap(&g, 0);
+        assert_eq!(prio, [0, 10, 5]);
+        assert_eq!(pred, [usize::MAX, 0, 1]);
+    }
 }

rust/numbertheory/euclid.rs

@@ -24,7 +24,13 @@ fn euclid(mut a: i64, mut b: i64) -> [i64; 3] {
     return if a > 0 { [a, x, y] } else { [-a, -x, -y] };
 }
 
-fn main() {
-    assert_eq!(gcd(15, 20), 5);
-    assert_eq!(euclid(6, 9), [3, -1, 1]);
+#[cfg(test)]
+mod tests {
+    use crate::{euclid, gcd};
+
+    #[test]
+    fn basic_test() {
+        assert_eq!(gcd(15, 20), 5);
+        assert_eq!(euclid(6, 9), [3, -1, 1]);
+    }
 }

rust/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"

rust/structures/disjoint_sets.rs

@@ -21,10 +21,16 @@ impl DisjointSets {
     }
 }
 
-fn main() {
-    let mut ds = DisjointSets::new(3);
-    ds.unite(0, 2);
-    assert_eq!(ds.root(0), 0);
-    assert_eq!(ds.root(1), 1);
-    assert_eq!(ds.root(2), 0);
+#[cfg(test)]
+mod tests {
+    use crate::DisjointSets;
+
+    #[test]
+    fn basic_test() {
+        let mut ds = DisjointSets::new(3);
+        ds.unite(0, 2);
+        assert_eq!(ds.root(0), 0);
+        assert_eq!(ds.root(1), 1);
+        assert_eq!(ds.root(2), 0);
+    }
 }

rust/structures/fenwick_tree.rs

@@ -27,12 +27,18 @@ impl<T: AddAssign + Copy + From<i32>> Fenwick<T> {
     }
 }
 
-fn main() {
-    let mut t = Fenwick::<i32>::new(3);
-    t.add(0, 4);
-    t.add(1, 5);
-    t.add(2, 5);
-    t.add(2, 5);
-    assert_eq!(t.sum(0), 4);
-    assert_eq!(t.sum(2), 19);
+#[cfg(test)]
+mod tests {
+    use crate::Fenwick;
+
+    #[test]
+    fn basic_test() {
+        let mut t = Fenwick::<i32>::new(3);
+        t.add(0, 4);
+        t.add(1, 5);
+        t.add(2, 5);
+        t.add(2, 5);
+        assert_eq!(t.sum(0), 4);
+        assert_eq!(t.sum(2), 19);
+    }
 }