Adding quickcheck for complete graph (#1471)

* Adding quickcheck for complete graph

To verify the structural integrity of complete graph, we check the number of nodes, edges and whether all expected edges exist.

* Add ignore for files temporarily

* Address lint in test target as well

---------

Co-authored-by: Ivan Carvalho <[email protected]>

Author: Krishn1412

rustworkx-core/fuzz/fuzz_targets/test_fuzz_contraction.rs

@@ -1,4 +1,5 @@
 #![no_main]
+#![allow(clippy::uninlined_format_args)]
 
 use arbitrary::{Arbitrary, Unstructured};
 use libfuzzer_sys::fuzz_target;

rustworkx-core/src/lib.rs

@@ -82,6 +82,8 @@
 //!
 //! <https://www.rustworkx.org/release_notes.html>
 
+#![allow(clippy::uninlined_format_args)]
+
 use std::convert::Infallible;
 
 /// A convenient type alias that by default assumes no error can happen.

rustworkx-core/tests/graph_ext/contraction.rs

@@ -253,7 +253,7 @@ where
                 assert_eq!(*seen.entry('e').or_insert(e), e);
                 assert_eq!(*seen.entry('m').or_insert(m), m);
             }
-            (_, _, w) => panic!("Unexpected edge weight: {}", w),
+            (_, _, w) => panic!("Unexpected edge weight: {w}"),
         }
     }
 

rustworkx-core/tests/quickcheck/complete_graph.rs

@@ -0,0 +1,75 @@
+use petgraph::graph::{DiGraph, UnGraph};
+use petgraph::visit::EdgeRef;
+use quickcheck::{quickcheck, TestResult};
+use rustworkx_core::generators::complete_graph;
+use std::collections::HashSet;
+
+#[test]
+fn prop_complete_graph_structure_directed() {
+    fn prop(n: usize) -> TestResult {
+        let n = n % 100; // limit for runtime issues
+        if n == 0 {
+            return TestResult::discard();
+        }
+
+        let g = match complete_graph::<DiGraph<(), ()>, (), _, _, ()>(Some(n), None, || (), || ()) {
+            Ok(g) => g,
+            Err(_) => return TestResult::error("Unexpected error in directed complete graph"),
+        };
+
+        if g.node_count() != n || g.edge_count() != n * (n - 1) {
+            return TestResult::failed();
+        }
+
+        // Ensure that for every pair (i, j) with i != j, an edge exists exists
+        let expected_edges: HashSet<_> = (0..n)
+            .flat_map(|i| (0..n).filter(move |&j| j != i).map(move |j| (i, j)))
+            .collect();
+
+        let actual_edges: HashSet<_> = g
+            .edge_references()
+            .map(|e| (e.source().index(), e.target().index()))
+            .collect();
+
+        TestResult::from_bool(expected_edges == actual_edges)
+    }
+
+    quickcheck(prop as fn(usize) -> TestResult);
+}
+
+#[test]
+fn prop_complete_graph_structure_undirected() {
+    fn prop(n: usize) -> TestResult {
+        let n = n % 100;
+        if n == 0 {
+            return TestResult::discard();
+        }
+
+        let g = match complete_graph::<UnGraph<(), ()>, (), _, _, ()>(Some(n), None, || (), || ()) {
+            Ok(g) => g,
+            Err(_) => return TestResult::error("Unexpected error in undirected complete graph"),
+        };
+
+        if g.node_count() != n || g.edge_count() != n * (n - 1) / 2 {
+            return TestResult::failed();
+        }
+
+        // in undirected graphs, (i, j) and (j, i) are the same edge, so we only include one of them.
+        let expected_edges: HashSet<_> = (0..n)
+            .flat_map(|i| (i + 1..n).map(move |j| (i, j)))
+            .collect();
+
+        let actual_edges: HashSet<_> = g
+            .edge_references()
+            .map(|e| {
+                let u = e.source().index();
+                let v = e.target().index();
+                (u.min(v), u.max(v))
+            })
+            .collect();
+
+        TestResult::from_bool(expected_edges == actual_edges)
+    }
+
+    quickcheck(prop as fn(usize) -> TestResult);
+}

rustworkx-core/tests/quickcheck/main.rs

@@ -1,5 +1,6 @@
 mod barbell_graph;
 mod binomial_tree_graph;
+mod complete_graph;
 mod full_rary_tree_graph;
 mod grid_graph;
 mod heavy_hex_graph;

src/lib.rs

@@ -10,6 +10,8 @@
 // License for the specific language governing permissions and limitations
 // under the License.
 
+#![allow(clippy::uninlined_format_args)]
+
 mod bisimulation;
 mod cartesian_product;
 mod centrality;