feat: test with graph from la-n-egg tests

Author: VanyaGlazunov

src/formats/mm.rs

@@ -31,7 +31,7 @@ use std::os::fd::IntoRawFd;
 use std::path::{Path, PathBuf};
 
 use crate::formats::FormatError;
-use crate::graph::{ensure_grb_init, GraphError};
+use crate::graph::{GraphError, ensure_grb_init};
 use crate::la_ok;
 use crate::lagraph_sys::{FILE, GrB_Matrix, LAGraph_MMRead};
 
@@ -40,10 +40,13 @@ pub fn load_mm_file(path: impl AsRef<Path>) -> Result<GrB_Matrix, FormatError> {
     let path = path.as_ref();
 
     ensure_grb_init().map_err(|e| match e {
-        GraphError::LAGraph(info, msg) => FormatError::MatrixMarket { code: info, message: msg },
+        GraphError::LAGraph(info, msg) => FormatError::MatrixMarket {
+            code: info,
+            message: msg,
+        },
         _ => FormatError::MatrixMarket {
             code: crate::lagraph_sys::GrB_Info::GrB_PANIC,
-            message: "Failed to initialize GraphBLAS".to_string()
+            message: "Failed to initialize GraphBLAS".to_string(),
         },
     })?;
 
@@ -62,10 +65,12 @@ pub fn load_mm_file(path: impl AsRef<Path>) -> Result<GrB_Matrix, FormatError> {
     let err = la_ok!(LAGraph_MMRead(&mut matrix, f as *mut FILE));
     unsafe { libc::fclose(f) };
 
-
     match err {
         Ok(_) => Ok(matrix),
-        Err(GraphError::LAGraph(info, msg)) => Err(FormatError::MatrixMarket { code: info, message: msg }),
+        Err(GraphError::LAGraph(info, msg)) => Err(FormatError::MatrixMarket {
+            code: info,
+            message: msg,
+        }),
         _ => unreachable!("should be either mm read error or ok"),
     }
 }

tests/mm_tests.rs

@@ -0,0 +1,204 @@
+use pathrex::formats::mm::MatrixMarket;
+use pathrex::graph::{Backend, Graph, GraphDecomposition, GraphSource, InMemory, InMemoryGraph};
+
+const GRAPH_DIR: &str = "tests/testdata/mm_graph";
+static INMEMORY_GRAPH: std::sync::LazyLock<InMemoryGraph> =
+    std::sync::LazyLock::new(|| load_graph_from_mm::<InMemory>(GRAPH_DIR));
+
+fn load_graph_from_mm<B: Backend>(dir: &str) -> B::Graph
+where
+    MatrixMarket: GraphSource<B::Builder>,
+{
+    let mm = MatrixMarket::from_dir(dir);
+    Graph::<B>::try_from(mm).expect("Failed to load graph")
+}
+
+#[test]
+fn test_load_mm_graph_basic() {
+    let graph = &INMEMORY_GRAPH;
+    let expected_nodes_number = 24225;
+
+    assert_eq!(graph.num_nodes(), expected_nodes_number);
+}
+
+#[test]
+fn test_mm_graph_node_mapping() {
+    let graph = &INMEMORY_GRAPH;
+
+    let test_nodes = vec![
+        ("<Article1>", 1),
+        ("<1940>", 2),
+        ("<Adamanta_Schlitt>", 3),
+        ("<Paul_Erdoes>", 4),
+    ];
+
+    for (name, expected_id) in test_nodes {
+        let id = graph.get_node_id(name).expect("Node should exist");
+        assert_eq!(id, expected_id);
+
+        let retrieved_name = graph
+            .get_node_name(id)
+            .expect("ID should map back to a name");
+        assert_eq!(retrieved_name, name,);
+    }
+}
+
+#[test]
+fn test_mm_graph_edge_labels() {
+    let graph = &INMEMORY_GRAPH;
+
+    let expected_labels = vec![
+        "<journal>",
+        "<creator>",
+        "<references>",
+        "<cite>",
+        "<editor>",
+        "<coauthor>",
+        "<partOf>",
+        "<record>",
+        "<predecessor>",
+    ];
+
+    for label in expected_labels {
+        let result = graph.get_graph(label);
+        assert!(result.is_ok(),);
+    }
+}
+
+#[test]
+fn test_mm_graph_nonexistent_label() {
+    let graph = &INMEMORY_GRAPH;
+
+    let result = graph.get_graph("<nonexistent_label>");
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_mm_graph_nonexistent_node() {
+    let graph = &INMEMORY_GRAPH;
+
+    assert!(graph.get_node_id("<NonexistentNode>").is_none(),);
+
+    assert!(graph.get_node_name(999999).is_none(),);
+}
+
+#[test]
+fn test_mm_graph_specific_nodes_exist() {
+    let graph = &INMEMORY_GRAPH;
+
+    let nodes_to_check = vec![
+        "<Article1>",
+        "<Article20>",
+        "<Article100>",
+        "<Paul_Erdoes>",
+        "<1940>",
+        "<1950>",
+        "<1960>",
+        "<Inproceeding1>",
+        "<Incollection1>",
+    ];
+
+    for node in nodes_to_check {
+        assert!(graph.get_node_id(node).is_some());
+    }
+}
+
+#[test]
+fn test_mm_graph_matrix_dimensions() {
+    let graph = &INMEMORY_GRAPH;
+
+    let expected_labels = vec![
+        "<journal>",
+        "<creator>",
+        "<references>",
+        "<cite>",
+        "<editor>",
+        "<coauthor>",
+        "<partOf>",
+        "<record>",
+        "<predecessor>",
+    ];
+
+    for label in expected_labels {
+        let matrix = graph
+            .get_graph(label)
+            .expect(&format!("Should have matrix for label {}", label));
+        matrix
+            .check_graph()
+            .expect(&format!("Matrix for {} should be valid", label));
+    }
+}
+
+#[test]
+fn test_mm_graph_load_from_nonexistent_dir() {
+    let mm = MatrixMarket::from_dir("tests/testdata/nonexistent_dir");
+    let result = Graph::<InMemory>::try_from(mm);
+
+    assert!(
+        result.is_err(),
+        "Loading from nonexistent directory should fail"
+    );
+}
+
+#[test]
+fn test_mm_graph_edge_label_mapping() {
+    let mm = MatrixMarket::from_dir("tests/testdata/mm_graph");
+    let graph = Graph::<InMemory>::try_from(mm).expect("Failed to load graph");
+
+    // Test that edge labels map correctly to their index files
+    // From edges.txt:
+    // <journal> 1 -> 1.txt
+    // <creator> 2 -> 2.txt
+    // <references> 3 -> 3.txt
+    // etc.
+
+    let label_to_file = vec![
+        ("<journal>", "1.txt"),
+        ("<creator>", "2.txt"),
+        ("<references>", "3.txt"),
+        ("<cite>", "4.txt"),
+        ("<editor>", "5.txt"),
+        ("<coauthor>", "6.txt"),
+        ("<partOf>", "7.txt"),
+        ("<record>", "8.txt"),
+        ("<predecessor>", "9.txt"),
+    ];
+
+    for (label, _file) in label_to_file {
+        let result = graph.get_graph(label);
+        assert!(
+            result.is_ok(),
+            "Label {} should be loaded from its corresponding matrix file",
+            label
+        );
+    }
+}
+
+#[test]
+fn test_mm_graph_handles_large_indices() {
+    let mm = MatrixMarket::from_dir("tests/testdata/mm_graph");
+    let graph = Graph::<InMemory>::try_from(mm).expect("Failed to load graph");
+
+    // Test that we can handle nodes with large indices
+    // The last node in vertices.txt should be around index 24225
+    let num_nodes = graph.num_nodes();
+
+    // Try to get a node name for a valid high index
+    let high_index = num_nodes;
+    let name = graph.get_node_name(high_index);
+    assert!(
+        name.is_some(),
+        "Should be able to retrieve node at index {}",
+        high_index
+    );
+}
+
+#[test]
+fn test_mm_graph_empty_label_handling() {
+    let mm = MatrixMarket::from_dir("tests/testdata/mm_graph");
+    let graph = Graph::<InMemory>::try_from(mm).expect("Failed to load graph");
+
+    // Test that empty string label is handled correctly
+    let result = graph.get_graph("");
+    assert!(result.is_err(), "Empty label should not exist in the graph");
+}