Fix cargo clippy not covering rustworkx-core tests (#1417)

* First batch of fixes

* Second batch of fixes

* Third batch of fixes

* Fourth batch of fixes

* Last batch of fixes

Author: IvanIsCoding

.github/workflows/main.yml

@@ -35,17 +35,17 @@ jobs:
       - name: Rust Format
         run: cargo fmt --all -- --check
       - name: Clippy
-        run: cargo clippy --all-targets -- -D warnings
+        run: cargo clippy --workspace --all-targets -- -D warnings
       - name: Black Codestyle Format
         run: black --check --diff retworkx rustworkx retworkx tests
       - name: Python Lint
         run: ruff check rustworkx retworkx setup.py tests
       - name: Check stray release notes
         run: python tools/find_stray_release_notes.py
       - name: rustworkx-core Rust Tests
-        run: pushd rustworkx-core && cargo test && popd
+        run: cargo test --workspace
       - name: rustworkx-core Docs
-        run: pushd rustworkx-core && cargo doc && popd
+        run: cargo doc -p rustworkx-core
         env:
           RUSTDOCFLAGS: '-D warnings'
       - uses: actions/upload-artifact@v4

CONTRIBUTING.md

@@ -203,11 +203,9 @@ https://doc.rust-lang.org/book/ch11-01-writing-tests.html
 
 The rustworkx-core tests can be run with:
 ```
-cargo test
+cargo test --workspace
 ```
 
-from the `rustworkx-core` directory.
-
 ### Fuzz Testing in rustworkx
 
 We use cargo-fuzz to test rustworkx for unexpected crashes or undefined behavior. Follow these steps to run fuzzing locally.
@@ -271,12 +269,18 @@ what CI is checking.
 ##### Lint
 
 An additional step is to run [clippy](https://github.com/rust-lang/rust-clippy)
-on your changes. You can run it by running:
+on your changes. You can execute it by running:
 
 ```bash
 cargo clippy
 ```
 
+If you want a more detailed feedback identical to CI, run instead:
+
+```bash
+cargo clippy --workspace --all-targets -- -D warnings
+```
+
 #### Python
 
 Python is used primarily for tests and some small pieces of packaging
@@ -310,18 +314,17 @@ you can view locally in a web browser.
 To build the rustworkx-core documentation you will use rust-doc. You can do this
 by running:
 ```
-cargo doc
+cargo doc -p rustworkx-core
 ```
-from the `rustworkx-core` directory (which is the root of the `rustworkx-core`
-crate. After it's built the compiled documentation will be located in
+After it's built the compiled documentation will be located in
 `target/doc/rustworkx_core` (which is off the repo root not the `rustworkx-core`
 dir)
 
 You can build and open the documentation directly in your configured default
 web browser by running:
 
 ```
-cargo doc --open
+cargo doc -p rustworkx-core --open
 ```
 
 ### Type Annotations

rustworkx-core/src/bipartite_coloring.rs

@@ -969,9 +969,8 @@ mod test_bipartite_coloring {
                 if n > 2 * k {
                     let graph: petgraph::graph::UnGraph<(), ()> =
                         petersen_graph(n, k, || (), || ()).unwrap();
-                    match bipartite_edge_color(&graph) {
-                        Ok(_) => panic!("This should error"),
-                        Err(_) => (),
+                    if bipartite_edge_color(&graph).is_ok() {
+                        panic!("This should error")
                     }
                 }
             }
@@ -980,9 +979,9 @@ mod test_bipartite_coloring {
 
     #[test]
     fn test_bipartite_random_graphs_undirected() {
-        for num_l_nodes in vec![5, 10, 15, 20] {
-            for num_r_nodes in vec![5, 10, 15, 20] {
-                for probability in vec![0.1, 0.3, 0.5, 0.7, 0.9] {
+        for num_l_nodes in [5, 10, 15, 20] {
+            for num_r_nodes in [5, 10, 15, 20] {
+                for probability in [0.1, 0.3, 0.5, 0.7, 0.9] {
                     let graph: petgraph::graph::UnGraph<(), ()> = random_bipartite_graph(
                         num_l_nodes,
                         num_r_nodes,
@@ -1014,9 +1013,9 @@ mod test_bipartite_coloring {
 
     #[test]
     fn test_bipartite_random_graphs_directed() {
-        for num_l_nodes in vec![5, 10, 15, 20] {
-            for num_r_nodes in vec![5, 10, 15, 20] {
-                for probability in vec![0.1, 0.3, 0.5, 0.7, 0.9] {
+        for num_l_nodes in [5, 10, 15, 20] {
+            for num_r_nodes in [5, 10, 15, 20] {
+                for probability in [0.1, 0.3, 0.5, 0.7, 0.9] {
                     let graph: petgraph::graph::DiGraph<(), ()> = random_bipartite_graph(
                         num_l_nodes,
                         num_r_nodes,

rustworkx-core/src/coloring.rs

@@ -1017,7 +1017,7 @@ mod test_node_coloring {
         let graph = Graph::<(), (), Undirected>::new_undirected();
         let preset_color_fn = |_| Ok::<Option<usize>, Infallible>(None);
 
-        for strategy in vec![
+        for strategy in [
             ColoringStrategy::Degree,
             ColoringStrategy::Saturation,
             ColoringStrategy::IndependentSet,
@@ -1308,7 +1308,7 @@ mod test_node_coloring {
             path_graph(Some(7), None, || (), || (), false).unwrap();
         let preset_color_fn = |_| Ok::<Option<usize>, Infallible>(None);
 
-        for strategy in vec![
+        for strategy in [
             ColoringStrategy::Degree,
             ColoringStrategy::Saturation,
             ColoringStrategy::IndependentSet,
@@ -1326,7 +1326,7 @@ mod test_node_coloring {
             cycle_graph(Some(15), None, || (), || (), false).unwrap();
         let preset_color_fn = |_| Ok::<Option<usize>, Infallible>(None);
 
-        for strategy in vec![
+        for strategy in [
             ColoringStrategy::Degree,
             ColoringStrategy::Saturation,
             ColoringStrategy::IndependentSet,
@@ -1344,7 +1344,7 @@ mod test_node_coloring {
             heavy_hex_graph(7, || (), || (), false).unwrap();
         let preset_color_fn = |_| Ok::<Option<usize>, Infallible>(None);
 
-        for strategy in vec![
+        for strategy in [
             ColoringStrategy::Degree,
             ColoringStrategy::Saturation,
             ColoringStrategy::IndependentSet,
@@ -1362,7 +1362,7 @@ mod test_node_coloring {
             complete_graph(Some(10), None, || (), || ()).unwrap();
         let preset_color_fn = |_| Ok::<Option<usize>, Infallible>(None);
 
-        for strategy in vec![
+        for strategy in [
             ColoringStrategy::Degree,
             ColoringStrategy::Saturation,
             ColoringStrategy::IndependentSet,

rustworkx-core/src/connectivity/johnson_simple_cycles.rs

@@ -489,7 +489,7 @@ mod test_longest_path {
             );
             let mut cycles_iter = johnson_simple_cycles(&graph, None);
             let mut res = 0;
-            while let Some(_) = cycles_iter.next(&graph) {
+            while cycles_iter.next(&graph).is_some() {
                 res += 1;
             }
             assert_eq!(res, 3 * k);
@@ -523,7 +523,7 @@ mod test_longest_path {
             );
             let mut cycles_iter = johnson_simple_cycles(&graph, None);
             let mut res = 0;
-            while let Some(_) = cycles_iter.next(&graph) {
+            while cycles_iter.next(&graph).is_some() {
                 res += 1;
             }
             assert_eq!(res, 3 * k);

rustworkx-core/src/dag_algo.rs

@@ -1418,7 +1418,7 @@ mod test_collect_runs {
         let mut runs = collect_runs(&graph, |_| -> Result<bool, ()> { Ok(true) }).expect("Some");
 
         let run = runs.next();
-        assert!(run == None);
+        assert!(run.is_none());
 
         let runs = collect_runs(&graph, |_| -> Result<bool, ()> { Ok(true) }).expect("Some");
 

rustworkx-core/src/generators/hexagonal_lattice_graph.rs

@@ -380,21 +380,21 @@ mod tests {
 
     fn check_expected_edges_directed<T>(
         graph: &petgraph::graph::DiGraph<T, ()>,
-        expected_edges: &Vec<(usize, usize)>,
+        expected_edges: &[(usize, usize)],
     ) {
         assert_eq!(graph.edge_count(), expected_edges.len());
 
         let edge_set: HashSet<(usize, usize)> = graph
             .edge_references()
             .map(|edge| (edge.source().index(), edge.target().index()))
             .collect();
-        let expected_set: HashSet<(usize, usize)> = expected_edges.iter().map(|&e| e).collect();
+        let expected_set: HashSet<(usize, usize)> = expected_edges.iter().copied().collect();
         assert_eq!(edge_set, expected_set);
     }
 
     fn check_expected_edges_undirected(
         graph: &petgraph::graph::UnGraph<(), ()>,
-        expected_edges: &Vec<(usize, usize)>,
+        expected_edges: &[(usize, usize)],
     ) {
         assert_eq!(graph.edge_count(), expected_edges.len());
 
@@ -409,13 +409,10 @@ mod tests {
         let edge_set: HashSet<(usize, usize)> = graph
             .edge_references()
             .map(|edge| (edge.source().index(), edge.target().index()))
-            .map(|e| sorted_pair(e))
-            .collect();
-        let expected_set: HashSet<(usize, usize)> = expected_edges
-            .iter()
-            .map(|&e| e)
-            .map(|e| sorted_pair(e))
+            .map(&sorted_pair)
             .collect();
+        let expected_set: HashSet<(usize, usize)> =
+            expected_edges.iter().copied().map(&sorted_pair).collect();
         assert_eq!(edge_set, expected_set);
     }
 

rustworkx-core/src/generators/random_graph.rs

@@ -334,7 +334,7 @@ where
 /// use rustworkx_core::generators::sbm_random_graph;
 ///
 /// let g = sbm_random_graph::<petgraph::graph::DiGraph<(), ()>, (), _, _, ()>(
-///     &vec![1, 2],
+///     &[1, 2],
 ///     &ndarray::arr2(&[[0., 1.], [0., 1.]]).view(),
 ///     true,
 ///     Some(10),
@@ -1018,7 +1018,7 @@ mod tests {
     #[test]
     fn test_sbm_directed_complete_blocks_loops() {
         let g = sbm_random_graph::<petgraph::graph::DiGraph<(), ()>, (), _, _, ()>(
-            &vec![1, 2],
+            &[1, 2],
             &ndarray::arr2(&[[0., 1.], [0., 1.]]).view(),
             true,
             Some(10),
@@ -1029,16 +1029,16 @@ mod tests {
         assert_eq!(g.node_count(), 3);
         assert_eq!(g.edge_count(), 6);
         for (u, v) in [(1, 1), (1, 2), (2, 1), (2, 2), (0, 1), (0, 2)] {
-            assert_eq!(g.contains_edge(u.into(), v.into()), true);
+            assert!(g.contains_edge(u.into(), v.into()));
         }
-        assert_eq!(g.contains_edge(1.into(), 0.into()), false);
-        assert_eq!(g.contains_edge(2.into(), 0.into()), false);
+        assert!(!g.contains_edge(1.into(), 0.into()));
+        assert!(!g.contains_edge(2.into(), 0.into()));
     }
 
     #[test]
     fn test_sbm_undirected_complete_blocks_loops() {
         let g = sbm_random_graph::<petgraph::graph::UnGraph<(), ()>, (), _, _, ()>(
-            &vec![1, 2],
+            &[1, 2],
             &ndarray::arr2(&[[0., 1.], [1., 1.]]).view(),
             true,
             Some(10),
@@ -1049,15 +1049,15 @@ mod tests {
         assert_eq!(g.node_count(), 3);
         assert_eq!(g.edge_count(), 5);
         for (u, v) in [(1, 1), (1, 2), (2, 2), (0, 1), (0, 2)] {
-            assert_eq!(g.contains_edge(u.into(), v.into()), true);
+            assert!(g.contains_edge(u.into(), v.into()));
         }
-        assert_eq!(g.contains_edge(0.into(), 0.into()), false);
+        assert!(!g.contains_edge(0.into(), 0.into()));
     }
 
     #[test]
     fn test_sbm_directed_complete_blocks_noloops() {
         let g = sbm_random_graph::<petgraph::graph::DiGraph<(), ()>, (), _, _, ()>(
-            &vec![1, 2],
+            &[1, 2],
             &ndarray::arr2(&[[0., 1.], [0., 1.]]).view(),
             false,
             Some(10),
@@ -1068,19 +1068,19 @@ mod tests {
         assert_eq!(g.node_count(), 3);
         assert_eq!(g.edge_count(), 4);
         for (u, v) in [(1, 2), (2, 1), (0, 1), (0, 2)] {
-            assert_eq!(g.contains_edge(u.into(), v.into()), true);
+            assert!(g.contains_edge(u.into(), v.into()));
         }
-        assert_eq!(g.contains_edge(1.into(), 0.into()), false);
-        assert_eq!(g.contains_edge(2.into(), 0.into()), false);
+        assert!(!g.contains_edge(1.into(), 0.into()));
+        assert!(!g.contains_edge(2.into(), 0.into()));
         for u in 0..2 {
-            assert_eq!(g.contains_edge(u.into(), u.into()), false);
+            assert!(!g.contains_edge(u.into(), u.into()));
         }
     }
 
     #[test]
     fn test_sbm_undirected_complete_blocks_noloops() {
         let g = sbm_random_graph::<petgraph::graph::UnGraph<(), ()>, (), _, _, ()>(
-            &vec![1, 2],
+            &[1, 2],
             &ndarray::arr2(&[[0., 1.], [1., 1.]]).view(),
             false,
             Some(10),
@@ -1091,17 +1091,17 @@ mod tests {
         assert_eq!(g.node_count(), 3);
         assert_eq!(g.edge_count(), 3);
         for (u, v) in [(1, 2), (0, 1), (0, 2)] {
-            assert_eq!(g.contains_edge(u.into(), v.into()), true);
+            assert!(g.contains_edge(u.into(), v.into()));
         }
         for u in 0..2 {
-            assert_eq!(g.contains_edge(u.into(), u.into()), false);
+            assert!(!g.contains_edge(u.into(), u.into()));
         }
     }
 
     #[test]
     fn test_sbm_bad_array_rows_error() {
         match sbm_random_graph::<petgraph::graph::DiGraph<(), ()>, (), _, _, ()>(
-            &vec![1, 2],
+            &[1, 2],
             &ndarray::arr2(&[[0., 1.], [1., 1.], [1., 1.]]).view(),
             true,
             Some(10),
@@ -1116,7 +1116,7 @@ mod tests {
 
     fn test_sbm_bad_array_cols_error() {
         match sbm_random_graph::<petgraph::graph::DiGraph<(), ()>, (), _, _, ()>(
-            &vec![1, 2],
+            &[1, 2],
             &ndarray::arr2(&[[0., 1., 1.], [1., 1., 1.]]).view(),
             true,
             Some(10),
@@ -1131,7 +1131,7 @@ mod tests {
     #[test]
     fn test_sbm_asymmetric_array_error() {
         match sbm_random_graph::<petgraph::graph::UnGraph<(), ()>, (), _, _, ()>(
-            &vec![1, 2],
+            &[1, 2],
             &ndarray::arr2(&[[0., 1.], [0., 1.]]).view(),
             true,
             Some(10),
@@ -1146,7 +1146,7 @@ mod tests {
     #[test]
     fn test_sbm_invalid_probability_error() {
         match sbm_random_graph::<petgraph::graph::UnGraph<(), ()>, (), _, _, ()>(
-            &vec![1, 2],
+            &[1, 2],
             &ndarray::arr2(&[[0., 1.], [0., -1.]]).view(),
             true,
             Some(10),
@@ -1161,7 +1161,7 @@ mod tests {
     #[test]
     fn test_sbm_empty_error() {
         match sbm_random_graph::<petgraph::graph::DiGraph<(), ()>, (), _, _, ()>(
-            &vec![],
+            &[],
             &ndarray::arr2(&[[]]).view(),
             true,
             Some(10),
@@ -1355,10 +1355,7 @@ mod tests {
     }
     #[test]
     fn test_hyperbolic_dist_inf() {
-        assert_eq!(
-            hyperbolic_distance(&[f64::INFINITY, 0.], &[0., 0.]).is_nan(),
-            true
-        );
+        assert!(hyperbolic_distance(&[f64::INFINITY, 0.], &[0., 0.]).is_nan());
     }
 
     #[test]

rustworkx-core/src/line_graph.rs

@@ -104,7 +104,6 @@ where
 }
 
 #[cfg(test)]
-
 mod test_line_graph {
     use crate::line_graph::line_graph;
     use crate::petgraph::visit::EdgeRef;