15791628916

Committed 21 Jun 2025 03:28AM UTC coverage: 94.579% (-0.1%) from 94.725%

Build # 15791628916

Build Type

Pull #12

github

Committed by

web-flow

Commit Message

Merge af3ccbf83 into ce0622484

Pull Request Pull Request #12: Rework node add/remove

Run Details

194 of 263 new or added lines in 5 files covered. (73.76%)

6 existing lines in 1 file now uncovered.

6543 of 6918 relevant lines covered (94.58%)

38.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.55

/src/matrix/map_matrix.rs

use crate::{
    containers::maps::MapTrait,
    graph::{Graph, GraphError, GraphWithMutableNodes, NodeIndex},
};

/// A matrix-based graph representation that maps arbitrary node indices to matrix positions
///
/// This struct wraps a [`Matrix`](super::simple_matrix::Matrix) and provides a mapping
/// from arbitrary node indices to matrix row/column positions, allowing graphs with
/// non-contiguous or non-zero-based node indices.
pub struct MapMatrix<const N: usize, NI, EDGEVALUE, M, COLUMNS, ROW>
where
    NI: NodeIndex,
    ROW: AsRef<[Option<EDGEVALUE>]>,
    COLUMNS: AsRef<[ROW]>,
    M: MapTrait<NI, usize>,
{
    inner: super::simple_matrix::Matrix<N, EDGEVALUE, COLUMNS, ROW>,
    index_map: M,
    _phantom: core::marker::PhantomData<NI>,
}

impl<const N: usize, NI, EDGEVALUE, M, COLUMNS, ROW> MapMatrix<N, NI, EDGEVALUE, M, COLUMNS, ROW>
where
    NI: NodeIndex,
    ROW: AsRef<[Option<EDGEVALUE>]>,
    COLUMNS: AsRef<[ROW]>,
    M: MapTrait<NI, usize>,
{
    /// Creates a new MapMatrix with the given matrix data and index mapping
    ///
    /// The `matrix` parameter provides the adjacency matrix data, and `index_map`
    /// maps from the actual node indices to matrix indices (0..N).
    pub fn new(matrix: COLUMNS, index_map: M) -> Result<Self, GraphError<NI>> {
        for (node, idx) in index_map.iter() {
            if *idx >= N {
                return Err(GraphError::IndexOutOfBounds(*idx, *node));
            }
        }
        Ok(Self::new_unchecked(matrix, index_map))
    }

    /// Creates a new MapMatrix with the given matrix data and index mapping
    ///
    /// The `matrix` parameter provides the adjacency matrix data, and `index_map`
    /// maps from the actual node indices to matrix indices (0..N).
    pub fn new_unchecked(matrix: COLUMNS, index_map: M) -> Self {
        Self {
            inner: super::simple_matrix::Matrix::new(matrix),
            index_map,
            _phantom: Default::default(),
        }
    }
}

impl<const N: usize, NI, EDGEVALUE, M, COLUMNS, ROW> Graph<NI>
    for MapMatrix<N, NI, EDGEVALUE, M, COLUMNS, ROW>
where
    NI: NodeIndex,
    ROW: AsRef<[Option<EDGEVALUE>]>,
    COLUMNS: AsRef<[ROW]>,
    M: MapTrait<NI, usize>,
{
    type Error = GraphError<NI>;

    fn iter_nodes(&self) -> Result<impl Iterator<Item = NI>, Self::Error> {
        Ok(self.index_map.iter().map(|(&k, _)| k))
    }

    fn contains_node(&self, node: NI) -> Result<bool, Self::Error> {
        Ok(self.index_map.contains_key(&node))
    }

    /// Note: Uses linear search for backindexing matrix indices to NI, this is slow.
    ///
    /// TODO: Store back-index ?
    fn iter_edges(&self) -> Result<impl Iterator<Item = (NI, NI)>, Self::Error> {
        Ok(self
            .index_map
            .iter()
            .flat_map(move |(&from_node, &from_idx)| {
                self.index_map
                    .iter()
                    .filter_map(move |(&to_node, &to_idx)| {
                        if self.inner.get_edge_value(from_idx, to_idx).is_some() {
                            Some((from_node, to_node))
                        } else {
                            None
                        }
                    })
            }))
    }

    /// Note: Uses linear search for backindexing matrix indices to NI, this is slow.
    ///
    /// TODO: Store back-index ?
    fn outgoing_edges(&self, node: NI) -> Result<impl Iterator<Item = NI>, Self::Error> {
        // Fast direct lookup of matrix index for this node
        let matrix_idx = self.index_map.get(&node).copied();

        Ok(self
            .inner
            .outgoing_edges(matrix_idx.unwrap_or(usize::MAX))
            .map_err(|_| GraphError::Unexpected)?
            .filter(move |_| matrix_idx.is_some()) // Filter out everything if node doesn't exist
            .filter_map(move |target_idx| {
                self.index_map
                    .iter()
                    .find(|(_, &idx)| idx == target_idx)
                    .map(|(&node, _)| node)
            }))
    }

    /// Note: Uses linear search for backindexing matrix indices to NI, this is slow.
    ///
    /// TODO: Store back-index ?
    fn incoming_edges(&self, node: NI) -> Result<impl Iterator<Item = NI>, Self::Error> {
        // Fast direct lookup of matrix index for this node
        let matrix_idx = self.index_map.get(&node).copied();

        Ok(self
            .inner
            .incoming_edges(matrix_idx.unwrap_or(usize::MAX))
            .map_err(|_| GraphError::Unexpected)?
            .filter(move |_| matrix_idx.is_some()) // Filter out everything if node doesn't exist
            .filter_map(move |source_idx| {
                self.index_map
                    .iter()
                    .find(|(_, &idx)| idx == source_idx)
                    .map(|(&node, _)| node)
            }))
    }
}

impl<const N: usize, NI, EDGEVALUE, M, COLUMNS, ROW>
    crate::graph::GraphWithEdgeValues<NI, EDGEVALUE>
    for MapMatrix<N, NI, EDGEVALUE, M, COLUMNS, ROW>
where
    NI: NodeIndex,
    ROW: AsRef<[Option<EDGEVALUE>]>,
    COLUMNS: AsRef<[ROW]>,
    M: MapTrait<NI, usize>,
{
    fn iter_edge_values<'a>(
        &'a self,
    ) -> Result<impl Iterator<Item = (NI, NI, Option<&'a EDGEVALUE>)>, Self::Error>
    where
        EDGEVALUE: 'a,
    {
        Ok(self
            .index_map
            .iter()
            .flat_map(move |(&from_node, &from_idx)| {
                self.index_map
                    .iter()
                    .filter_map(move |(&to_node, &to_idx)| {
                        let value = self.inner.get_edge_value(from_idx, to_idx);
                        if value.is_some() {
                            Some((from_node, to_node, value))
                        } else {
                            None
                        }
                    })
            }))
    }
}

impl<const N: usize, NI, EDGEVALUE, M, COLUMNS, ROW> GraphWithMutableNodes<NI>
    for MapMatrix<N, NI, EDGEVALUE, M, COLUMNS, ROW>
where
    NI: NodeIndex,
    ROW: AsRef<[Option<EDGEVALUE>]>,
    COLUMNS: AsRef<[ROW]>,
    M: MapTrait<NI, usize>,
{
    fn add_node(&mut self, node: NI) -> Result<(), Self::Error> {
        // Check if node already exists
        if self.index_map.contains_key(&node) {
            return Err(GraphError::DuplicateNode(node));
        }

        // Find an unused matrix index using iterator approach
        let unused_index = (0..N)
            .find(|&idx| !self.index_map.iter().any(|(_, &used_idx)| used_idx == idx))
            .ok_or(GraphError::OutOfCapacity)?;

        // Insert the new node mapping
        self.index_map
            .insert(node, unused_index)
            .map_err(|_| GraphError::OutOfCapacity)?;

        Ok(())
    }

    fn remove_node(&mut self, node: NI) -> Result<(), Self::Error> {
        // Check if node exists
        if !self.index_map.contains_key(&node) {
            return Err(GraphError::NodeNotFound(node));
        }

        // Check if node has incoming edges
        if self.incoming_edges(node)?.next().is_some() {
            return Err(GraphError::NodeHasIncomingEdges(node));
        }

        // Remove the node mapping (matrix position becomes available for reuse)
        self.index_map.remove(&node);
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::containers::maps::staticdict::Dictionary;
    use crate::graph::GraphWithEdgeValues;
    use crate::tests::{collect, collect_sorted};

    #[test]
    fn test_graphval_iter_nodes() {
        let matrix = [
            [Some(1), Some(2), None],
            [None, Some(5), Some(6)],
            [Some(7), None, Some(9)],
        ];

        let mut index_map = Dictionary::<u32, usize, 3>::new();
        index_map.insert(100, 0).unwrap();
        index_map.insert(200, 1).unwrap();
        index_map.insert(300, 2).unwrap();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 3>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        // Test Graph iter_nodes (returns owned values)
        let mut nodes = [0u32; 8];
        let nodes_slice = collect(map_matrix.iter_nodes().unwrap(), &mut nodes);
        assert_eq!(nodes_slice.len(), 3);

        // Check all expected nodes are present
        let mut found_100 = false;
        let mut found_200 = false;
        let mut found_300 = false;

        for &node in nodes_slice.iter() {
            match node {
                100 => found_100 = true,
                200 => found_200 = true,
                300 => found_300 = true,
                _ => panic!("Unexpected node: {}", node),
            }
        }

        assert!(found_100);
        assert!(found_200);
        assert!(found_300);
    }

    #[test]
    fn test_graphval_iter_edges() {
        let matrix = [
            [Some(1), Some(2), None],
            [None, Some(5), Some(6)],
            [Some(7), None, Some(9)],
        ];

        let mut index_map = Dictionary::<u32, usize, 3>::new();
        index_map.insert(10, 0).unwrap();
        index_map.insert(20, 1).unwrap();
        index_map.insert(30, 2).unwrap();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 3>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        // Test Graph iter_edges (returns owned values)
        let mut edges = [(0u32, 0u32); 16];
        let edges_slice = collect(map_matrix.iter_edges().unwrap(), &mut edges);
        assert_eq!(edges_slice.len(), 6); // 6 Some values in matrix, all mapped

        // Verify expected edges exist
        let expected_edges = [
            (10, 10), // (0,0) -> Some(1)
            (10, 20), // (0,1) -> Some(2)
            (20, 20), // (1,1) -> Some(5)
            (20, 30), // (1,2) -> Some(6)
            (30, 10), // (2,0) -> Some(7)
            (30, 30), // (2,2) -> Some(9)
        ];

        for &expected_edge in &expected_edges {
            assert!(
                edges_slice.contains(&expected_edge),
                "Expected edge {:?} not found",
                expected_edge
            );
        }
    }

    #[test]
    fn test_graphval_outgoing_edges() {
        let matrix = [
            [Some(1), Some(2), None], // 10 -> 10, 20
            [None, None, Some(6)],    // 20 -> 30
            [Some(7), None, None],    // 30 -> 10
        ];

        let mut index_map = Dictionary::<u32, usize, 3>::new();
        index_map.insert(10, 0).unwrap();
        index_map.insert(20, 1).unwrap();
        index_map.insert(30, 2).unwrap();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 3>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        // Test outgoing edges from node 10 (Graph version)
        let mut targets = [0u32; 8];
        let targets_slice = collect(map_matrix.outgoing_edges(10).unwrap(), &mut targets);
        assert_eq!(targets_slice.len(), 2);

        // Check both targets found
        let mut found_10 = false;
        let mut found_20 = false;
        for &target in targets_slice.iter() {
            match target {
                10 => found_10 = true,
                20 => found_20 = true,
                _ => panic!("Unexpected target: {}", target),
            }
        }
        assert!(found_10);
        assert!(found_20);

        // Test outgoing edges from node 20
        let mut targets = [0u32; 8];
        let targets_slice = collect(map_matrix.outgoing_edges(20).unwrap(), &mut targets);
        assert_eq!(targets_slice, &[30]);

        // Test outgoing edges from node 30
        let mut targets = [0u32; 8];
        let targets_slice = collect(map_matrix.outgoing_edges(30).unwrap(), &mut targets);
        assert_eq!(targets_slice, &[10]);
    }

    #[test]
    fn test_graphval_contains_node() {
        let matrix = [
            [Some(1), None, None],
            [None, None, None],
            [None, None, None],
        ];

        let mut index_map = Dictionary::<i32, usize, 3>::new();
        index_map.insert(42, 0).unwrap();
        index_map.insert(84, 1).unwrap();

        type ValMatrix = MapMatrix<
            3,
            i32,
            i32,
            Dictionary<i32, usize, 3>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        // Test Graph contains_node
        assert!(map_matrix.contains_node(42).unwrap());
        assert!(map_matrix.contains_node(84).unwrap());
        assert!(!map_matrix.contains_node(999).unwrap());
    }

    #[test]
    fn test_graphval_nonexistent_node_outgoing() {
        let matrix = [
            [Some(1), Some(2), None],
            [None, Some(5), Some(6)],
            [Some(7), None, Some(9)],
        ];

        let mut index_map = Dictionary::<i32, usize, 3>::new();
        index_map.insert(100, 0).unwrap();
        index_map.insert(200, 1).unwrap();
        index_map.insert(300, 2).unwrap();

        type ValMatrix = MapMatrix<
            3,
            i32,
            i32,
            Dictionary<i32, usize, 3>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        // Test outgoing edges for non-existent node should return empty iterator
        let outgoing_count = map_matrix.outgoing_edges(999).unwrap().count();
        assert_eq!(outgoing_count, 0);
    }

    #[test]
    fn test_graphval_with_char_nodes() {
        let matrix = [[Some(true), Some(false)], [None, Some(true)]];

        let mut index_map = Dictionary::<char, usize, 2>::new();
        index_map.insert('X', 0).unwrap();
        index_map.insert('Y', 1).unwrap();

        type CharMatrix = MapMatrix<
            2,
            char,
            bool,
            Dictionary<char, usize, 2>,
            [[Option<bool>; 2]; 2],
            [Option<bool>; 2],
        >;
        let map_matrix = CharMatrix::new(matrix, index_map).unwrap();

        // Test with char node types
        assert_eq!(map_matrix.iter_nodes().unwrap().count(), 2);
        assert_eq!(map_matrix.iter_edges().unwrap().count(), 3);

        // Test specific outgoing edges
        let x_outgoing = map_matrix.outgoing_edges('X').unwrap().count();
        assert_eq!(x_outgoing, 2); // X -> X, Y

        let y_outgoing = map_matrix.outgoing_edges('Y').unwrap().count();
        assert_eq!(y_outgoing, 1); // Y -> Y
    }

    #[test]
    fn test_graphval_empty_matrix() {
        let matrix = [[None, None, None], [None, None, None], [None, None, None]];

        let mut index_map = Dictionary::<u32, usize, 3>::new();
        index_map.insert(10, 0).unwrap();
        index_map.insert(20, 1).unwrap();
        index_map.insert(30, 2).unwrap();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 3>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        // Should have 3 nodes but no edges
        assert_eq!(map_matrix.iter_nodes().unwrap().count(), 3);
        assert_eq!(map_matrix.iter_edges().unwrap().count(), 0);
    }

    #[test]
    fn test_graphval_with_edge_values() {
        let matrix = [
            [Some(1), Some(2), None],
            [None, Some(5), Some(6)],
            [Some(7), None, Some(9)],
        ];

        let mut index_map = Dictionary::<u32, usize, 3>::new();
        index_map.insert(10, 0).unwrap();
        index_map.insert(20, 1).unwrap();
        index_map.insert(30, 2).unwrap();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 3>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        // Test iter_edge_values
        let mut edges_with_values = [(0u32, 0u32, 0i32); 16];
        let edges_slice = collect(
            map_matrix
                .iter_edge_values()
                .unwrap()
                .filter_map(|(src, dst, value_opt)| value_opt.map(|v| (src, dst, *v))),
            &mut edges_with_values,
        );
        assert_eq!(edges_slice.len(), 6); // 6 Some values in matrix

        // Verify expected edges with values exist
        let expected_edges = [
            (10, 10, 1), // (0,0) -> Some(1)
            (10, 20, 2), // (0,1) -> Some(2)
            (20, 20, 5), // (1,1) -> Some(5)
            (20, 30, 6), // (1,2) -> Some(6)
            (30, 10, 7), // (2,0) -> Some(7)
            (30, 30, 9), // (2,2) -> Some(9)
        ];

        for &expected_edge in &expected_edges {
            assert!(
                edges_slice.contains(&expected_edge),
                "Expected edge {:?} not found",
                expected_edge
            );
        }

        // Test outgoing_edge_values from node 10
        let mut outgoing = [(0u32, 0i32); 8];
        let outgoing_slice = collect(
            map_matrix
                .outgoing_edge_values(10)
                .unwrap()
                .filter_map(|(dst, value_opt)| value_opt.map(|v| (dst, *v))),
            &mut outgoing,
        );
        assert_eq!(outgoing_slice.len(), 2);
        assert!(outgoing_slice.contains(&(10, 1)));
        assert!(outgoing_slice.contains(&(20, 2)));
    }

    #[test]
    fn test_graphval_incoming_edges() {
        let matrix = [
            [Some(1), Some(2), None], // 10 -> 10, 20
            [Some(3), None, None],    // 20 -> 10
            [Some(4), Some(5), None], // 30 -> 10, 20
        ];

        let mut index_map = Dictionary::<u32, usize, 3>::new();
        index_map.insert(10, 0).unwrap();
        index_map.insert(20, 1).unwrap();
        index_map.insert(30, 2).unwrap();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 3>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        // Test incoming edges to node 10 (should be from 10, 20, 30)
        let mut sources = [0u32; 8];
        let sources_slice = collect(map_matrix.incoming_edges(10).unwrap(), &mut sources);
        assert_eq!(sources_slice.len(), 3);
        assert!(sources_slice.contains(&10));
        assert!(sources_slice.contains(&20));
        assert!(sources_slice.contains(&30));

        // Test incoming edges to node 20 (should be from 10, 30)
        let mut sources = [0u32; 8];
        let sources_slice = collect(map_matrix.incoming_edges(20).unwrap(), &mut sources);
        assert_eq!(sources_slice.len(), 2);
        assert!(sources_slice.contains(&10));
        assert!(sources_slice.contains(&30));

        // Test incoming edges to node 30 (should be empty)
        let incoming_count = map_matrix.incoming_edges(30).unwrap().count();
        assert_eq!(incoming_count, 0);
    }

    #[test]
    fn test_graphval_incoming_edges_nonexistent_node() {
        let matrix = [
            [Some(1), Some(2), None],
            [None, Some(5), Some(6)],
            [Some(7), None, Some(9)],
        ];

        let mut index_map = Dictionary::<u32, usize, 3>::new();
        index_map.insert(10, 0).unwrap();
        index_map.insert(20, 1).unwrap();
        index_map.insert(30, 2).unwrap();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 3>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        // Test incoming edges for non-existent node should return empty iterator
        let incoming_count = map_matrix.incoming_edges(999).unwrap().count();
        assert_eq!(incoming_count, 0);
    }

    #[test]
    fn test_add_node_to_empty_matrix() {
        let matrix = [[None, None, None], [None, None, None], [None, None, None]];
        let index_map = Dictionary::<u32, usize, 5>::new();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 5>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let mut map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        map_matrix.add_node(42).unwrap();

        let mut nodes = [0u32; 2];
        let nodes_slice = collect(map_matrix.iter_nodes().unwrap(), &mut nodes);
        assert_eq!(nodes_slice, &[42]);
        assert_eq!(map_matrix.outgoing_edges(42).unwrap().count(), 0);
    }

    #[test]
    fn test_add_node_to_existing_matrix() {
        let matrix = [
            [Some(1), None, None],
            [None, None, None],
            [None, None, None],
        ];
        let mut index_map = Dictionary::<u32, usize, 5>::new();
        index_map.insert(10, 0).unwrap();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 5>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let mut map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        map_matrix.add_node(20).unwrap();

        let mut nodes = [0u32; 4];
        let nodes_slice = collect_sorted(map_matrix.iter_nodes().unwrap(), &mut nodes);
        assert_eq!(nodes_slice, &[10, 20]);
        assert_eq!(map_matrix.outgoing_edges(20).unwrap().count(), 0);
        assert_eq!(map_matrix.outgoing_edges(10).unwrap().count(), 1);
    }

    #[test]
    fn test_add_duplicate_node() {
        let matrix = [[None, None, None], [None, None, None], [None, None, None]];
        let mut index_map = Dictionary::<u32, usize, 3>::new();
        index_map.insert(10, 0).unwrap();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 3>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let mut map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        let result = map_matrix.add_node(10);
        assert!(matches!(result, Err(GraphError::DuplicateNode(10))));

        let mut nodes = [0u32; 2];
        let nodes_slice = collect(map_matrix.iter_nodes().unwrap(), &mut nodes);
        assert_eq!(nodes_slice, &[10]);
    }

    #[test]
    fn test_add_node_capacity_exceeded() {
        let matrix = [[None, None], [None, None]];
        let mut index_map = Dictionary::<u32, usize, 3>::new();
        index_map.insert(10, 0).unwrap();
        index_map.insert(20, 1).unwrap();

        type ValMatrix = MapMatrix<
            2,
            u32,
            i32,
            Dictionary<u32, usize, 3>,
            [[Option<i32>; 2]; 2],
            [Option<i32>; 2],
        >;
        let mut map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        let result = map_matrix.add_node(30);
        assert!(matches!(result, Err(GraphError::OutOfCapacity)));

        let mut nodes = [0u32; 4];
        let nodes_slice = collect_sorted(map_matrix.iter_nodes().unwrap(), &mut nodes);
        assert_eq!(nodes_slice, &[10, 20]);
    }

    #[test]
    fn test_add_multiple_nodes() {
        let matrix = [
            [None, None, None, None],
            [None, None, None, None],
            [None, None, None, None],
            [None, None, None, None],
        ];
        let index_map = Dictionary::<u32, usize, 10>::new();

        type ValMatrix = MapMatrix<
            4,
            u32,
            i32,
            Dictionary<u32, usize, 10>,
            [[Option<i32>; 4]; 4],
            [Option<i32>; 4],
        >;
        let mut map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        map_matrix.add_node(100).unwrap();
        map_matrix.add_node(200).unwrap();
        map_matrix.add_node(300).unwrap();

        let mut nodes = [0u32; 4];
        let nodes_slice = collect_sorted(map_matrix.iter_nodes().unwrap(), &mut nodes);
        assert_eq!(nodes_slice, &[100, 200, 300]);
        assert_eq!(map_matrix.iter_edges().unwrap().count(), 0);
    }

    #[test]
    fn test_add_node_fills_gaps() {
        let matrix = [[None, None, None], [None, None, None], [None, None, None]];
        let mut index_map = Dictionary::<u32, usize, 5>::new();
        index_map.insert(10, 0).unwrap();
        index_map.insert(30, 2).unwrap();

        type ValMatrix = MapMatrix<
            3,
            u32,
            i32,
            Dictionary<u32, usize, 5>,
            [[Option<i32>; 3]; 3],
            [Option<i32>; 3],
        >;
        let mut map_matrix = ValMatrix::new(matrix, index_map).unwrap();

        map_matrix.add_node(20).unwrap();

        let mut nodes = [0u32; 4];
        let nodes_slice = collect_sorted(map_matrix.iter_nodes().unwrap(), &mut nodes);
        assert_eq!(nodes_slice, &[10, 20, 30]);
    }
}

kaidokert / heapless-graphs-rs / 15791628916

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous