Simplified tests

Author: vigna

webgraph/src/traits/graph.rs

@@ -56,6 +56,9 @@ struct this_method_cannot_be_called_use_successors_instead;
 /// ascending order, or the successors of a node will be returned in ascending
 /// order. The marker traits [`SortedLender`] and [`SortedIterator`] can be used
 /// to force these properties.
+///
+/// The function [`eq`](eq) can be used to check whether two
+/// graphs are equal.
 #[autoimpl(for<S: trait + ?Sized> &S, &mut S, Rc<S>)]
 pub trait SequentialGraph: SequentialLabeling<Label = usize> {}
 
@@ -146,6 +149,9 @@ pub trait RandomAccessGraph: RandomAccessLabeling<Label = usize> + SequentialGra
 /// A labeled sequential graph is a sequential labeling whose labels are pairs
 /// `(usize, L)`. The first coordinate is the successor, the second is the
 /// label.
+///
+/// The function [`eq_labeled`](eq_labeled) can be used to check whether two
+/// labeled graphs are equal.
 #[autoimpl(for<S: trait + ?Sized> &S, &mut S, Rc<S>)]
 pub trait LabeledSequentialGraph<L>: SequentialLabeling<Label = (usize, L)> {}
 

webgraph/src/traits/labels.rs

@@ -56,6 +56,9 @@ use sux::{traits::Succ, utils::FairChunks};
 /// [`par_apply`](SequentialLabeling::par_apply) and
 /// [`par_node_apply`](SequentialLabeling::par_node_apply), that make it easy to
 /// process in parallel the nodes of the labeling.
+///
+/// The function [`eq_sorted`](eq_sorted) can be used to check whether two
+/// sorted labelings are equal.
 #[autoimpl(for<S: trait + ?Sized> &S, &mut S, Rc<S>)]
 pub trait SequentialLabeling {
     type Label;
@@ -327,6 +330,9 @@ impl<I: ExactSizeIterator> ExactSizeIterator for SortedIter<I> {
 
 /// A [`SequentialLabeling`] providing, additionally, random access to
 /// the list of labels associated with a node.
+///
+/// The function [`check_impl`](check_impl) can be used to check whether the
+/// sequential and random-access implementations of a labeling are consistent.
 #[autoimpl(for<S: trait + ?Sized> &S, &mut S, Rc<S>)]
 pub trait RandomAccessLabeling: SequentialLabeling {
     /// The type of the iterator over the labels of a node

webgraph/tests/test_par_bvcomp.rs

@@ -12,6 +12,7 @@ use anyhow::Result;
 use dsi_bitstream::prelude::*;
 use dsi_progress_logger::prelude::*;
 use lender::*;
+use log::info;
 use webgraph::prelude::*;
 
 #[test]
@@ -72,25 +73,9 @@ fn _test_par_bvcomp(basename: &str) -> Result<()> {
             webgraph::graphs::bvgraph::sequential::BvGraphSeq::with_basename(&tmp_basename)
                 .endianness::<BE>()
                 .load()?;
-        let mut iter = comp_graph.iter();
 
-        let mut pr = ProgressLogger::default();
-        pr.display_memory(true)
-            .item_name("node")
-            .expected_updates(Some(graph.num_nodes()));
-        pr.start("Checking that the newly compressed graph is equivalent to the original one...");
-
-        let mut iter_nodes = graph.iter();
-        while let Some((node, succ_iter)) = iter_nodes.next() {
-            let (new_node, new_succ_iter) = iter.next().unwrap();
-            assert_eq!(node, new_node);
-            let succ = succ_iter.collect::<Vec<_>>();
-            let new_succ = new_succ_iter.collect::<Vec<_>>();
-            assert_eq!(succ, new_succ, "Node {} differs", node);
-            pr.light_update();
-        }
-
-        pr.done();
+        info!("Checking that the newly compressed graph is equivalent to the original one...");
+        assert!(graph::eq(&graph, &comp_graph));
 
         let offsets_path = tmp_basename.with_extension(OFFSETS_EXTENSION);
         let mut offsets_reader =