bounded_graph 0.3.0

use petgraph::{
    visit::{
        EdgeIndexable, EdgeRef, IntoNodeIdentifiers, IntoNodeReferences, NodeIndexable, VisitMap,
        Visitable,
    },
    Direction,
};

use crate::{BoundedGraph, BoundedUnGraph, SymmetricFixedEdgeCount};

#[test]
fn test_node_identifiers() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    let node_ids: Vec<_> = graph.node_identifiers().collect();
    assert_eq!(node_ids.len(), 3);
    assert!(node_ids.contains(&n1));
    assert!(node_ids.contains(&n2));
    assert!(node_ids.contains(&n3));
}

#[test]
fn test_node_references() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<2, i32>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::new(10));
    let n2 = graph.add_node(SymmetricFixedEdgeCount::new(20));

    let node_refs: Vec<_> = graph.node_references().collect();
    assert_eq!(node_refs.len(), 2);

    // Check that we can access node IDs and weights
    assert_eq!(node_refs[0].0, n1);
    assert_eq!(node_refs[0].1.data, 10);
    assert_eq!(node_refs[1].0, n2);
    assert_eq!(node_refs[1].1.data, 20);
}

#[test]
fn test_edge_references() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, i32>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    graph.add_edge(n1, n2, 100).unwrap();
    graph.add_edge(n2, n3, 200).unwrap();

    let edge_refs: Vec<_> = graph.edge_references().collect();
    assert_eq!(edge_refs.len(), 2);

    // Check source, target, and weight
    assert_eq!(edge_refs[0].source(), n1);
    assert_eq!(edge_refs[0].target(), n2);
    assert_eq!(*edge_refs[0].weight(), 100);

    assert_eq!(edge_refs[1].source(), n2);
    assert_eq!(edge_refs[1].target(), n3);
    assert_eq!(*edge_refs[1].weight(), 200);
}

#[test]
fn test_into_edge_references() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, i32>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    graph.add_edge(n1, n2, 42).unwrap();
    graph.add_edge(n2, n3, 84).unwrap();
    graph.add_edge(n1, n3, 126).unwrap();

    // Explicitly use IntoEdgeReferences trait on a reference to the graph
    let graph_ref = &graph;
    let edge_refs: Vec<_> = graph_ref.edge_references().collect();

    assert_eq!(edge_refs.len(), 3);

    // Verify each edge reference has correct source, target, and weight
    assert_eq!(edge_refs[0].source(), n1);
    assert_eq!(edge_refs[0].target(), n2);
    assert_eq!(*edge_refs[0].weight(), 42);

    assert_eq!(edge_refs[1].source(), n2);
    assert_eq!(edge_refs[1].target(), n3);
    assert_eq!(*edge_refs[1].weight(), 84);

    assert_eq!(edge_refs[2].source(), n1);
    assert_eq!(edge_refs[2].target(), n3);
    assert_eq!(*edge_refs[2].weight(), 126);
}

#[test]
fn test_neighbors() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    graph.add_edge(n1, n2, ()).unwrap();
    graph.add_edge(n1, n3, ()).unwrap();

    let neighbors: Vec<_> = graph.neighbors(n1).collect();
    assert_eq!(neighbors.len(), 2);
    assert!(neighbors.contains(&n2));
    assert!(neighbors.contains(&n3));

    let neighbors_n2: Vec<_> = graph.neighbors(n2).collect();
    assert_eq!(neighbors_n2.len(), 0); // n2 has no outgoing edges
}

#[test]
fn test_neighbors_directed() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    graph.add_edge(n1, n2, ()).unwrap();
    graph.add_edge(n2, n3, ()).unwrap();
    graph.add_edge(n3, n1, ()).unwrap();

    // Outgoing neighbors
    let outgoing: Vec<_> = graph.neighbors_directed(n1, Direction::Outgoing).collect();
    assert_eq!(outgoing.len(), 1);
    assert_eq!(outgoing[0], n2);

    // Incoming neighbors
    let incoming: Vec<_> = graph.neighbors_directed(n1, Direction::Incoming).collect();
    assert_eq!(incoming.len(), 1);
    assert_eq!(incoming[0], n3);
}

#[test]
fn test_edges_directed() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    graph.add_edge(n1, n2, ()).unwrap();
    graph.add_edge(n2, n3, ()).unwrap();
    graph.add_edge(n3, n1, ()).unwrap();

    // Outgoing edges from n1
    let outgoing: Vec<_> = graph.edges_directed(n1, Direction::Outgoing).collect();
    assert_eq!(outgoing.len(), 1);
    assert_eq!(*outgoing[0].weight(), ());

    // Incoming edges to n1
    let incoming: Vec<_> = graph.edges_directed(n1, Direction::Incoming).collect();
    assert_eq!(incoming.len(), 1);
    assert_eq!(*incoming[0].weight(), ());
}

#[test]
fn test_into_edges_directed() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, i32>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    graph.add_edge(n1, n2, 10).unwrap();
    graph.add_edge(n2, n3, 20).unwrap();
    graph.add_edge(n3, n1, 30).unwrap();
    graph.add_edge(n1, n3, 40).unwrap();

    // Explicitly use IntoEdgesDirected trait on a reference to the graph
    let graph_ref = &graph;

    // Test outgoing edges from n1
    let outgoing: Vec<_> = graph_ref.edges_directed(n1, Direction::Outgoing).collect();
    assert_eq!(outgoing.len(), 2);

    // Check that both edges are present (order may vary)
    let targets: Vec<_> = outgoing.iter().map(|e| e.target()).collect();
    let weights: Vec<_> = outgoing.iter().map(|e| *e.weight()).collect();
    assert!(targets.contains(&n2));
    assert!(targets.contains(&n3));
    assert!(weights.contains(&10));
    assert!(weights.contains(&40));

    // Test incoming edges to n1
    let incoming: Vec<_> = graph_ref.edges_directed(n1, Direction::Incoming).collect();
    assert_eq!(incoming.len(), 1);
    assert_eq!(incoming[0].source(), n3);
    assert_eq!(*incoming[0].weight(), 30);

    // Test edges for n2
    let outgoing_n2: Vec<_> = graph_ref.edges_directed(n2, Direction::Outgoing).collect();
    assert_eq!(outgoing_n2.len(), 1);
    assert_eq!(outgoing_n2[0].target(), n3);
    assert_eq!(*outgoing_n2[0].weight(), 20);

    let incoming_n2: Vec<_> = graph_ref.edges_directed(n2, Direction::Incoming).collect();
    assert_eq!(incoming_n2.len(), 1);
    assert_eq!(incoming_n2[0].source(), n1);
    assert_eq!(*incoming_n2[0].weight(), 10);
}

#[test]
fn test_visitable() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let _ = graph.add_node(SymmetricFixedEdgeCount::empty());
    let _ = graph.add_node(SymmetricFixedEdgeCount::empty());
    let _ = graph.add_node(SymmetricFixedEdgeCount::empty());

    // Get a visit map
    let mut visit_map = graph.visit_map();

    assert!(!visit_map.is_visited(&graph.node_identifiers().next().unwrap()));

    // Visit a node
    visit_map.visit(graph.node_identifiers().next().unwrap());
    assert!(visit_map.is_visited(&graph.node_identifiers().next().unwrap()));
}

#[test]
fn test_node_indexable() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());

    // Test to_index and from_index
    let idx1 = NodeIndexable::to_index(&graph, n1);
    let idx2 = NodeIndexable::to_index(&graph, n2);

    assert_eq!(NodeIndexable::from_index(&graph, idx1), n1);
    assert_eq!(NodeIndexable::from_index(&graph, idx2), n2);

    // Test node_bound - it should be at least 2
    let bound = NodeIndexable::node_bound(&graph);
    assert!(bound >= 2);
    // Verify we can convert back and forth within the bound
    assert_eq!(NodeIndexable::from_index(&graph, idx1), n1);
    assert_eq!(NodeIndexable::from_index(&graph, idx2), n2);
}

#[test]
fn test_edge_indexable() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let e1 = graph.add_edge(n1, n2, ()).unwrap();

    // Test to_index and from_index
    let idx = EdgeIndexable::to_index(&graph, e1);
    assert_eq!(EdgeIndexable::from_index(&graph, idx), e1);

    // Test edge_bound - it should be at least 1 (the next available edge index)
    let bound = EdgeIndexable::edge_bound(&graph);
    assert!(bound >= 1);
    // Verify we can convert back and forth within the bound
    assert_eq!(EdgeIndexable::from_index(&graph, idx), e1);
}

#[test]
fn test_node_count_trait() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    assert_eq!(graph.node_count(), 0);

    let _ = graph.add_node(SymmetricFixedEdgeCount::empty());
    assert_eq!(graph.node_count(), 1);

    let _ = graph.add_node(SymmetricFixedEdgeCount::empty());
    assert_eq!(graph.node_count(), 2);
}

#[test]
fn test_edge_count_trait() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());

    assert_eq!(graph.edge_count(), 0);

    graph.add_edge(n1, n2, ()).unwrap();
    assert_eq!(graph.edge_count(), 1);
}

#[test]
fn test_contains_edge() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    assert!(!graph.contains_edge(n1, n2));

    graph.add_edge(n1, n2, ()).unwrap();
    assert!(graph.contains_edge(n1, n2));
    assert!(!graph.contains_edge(n2, n1)); // Directed graph
    assert!(!graph.contains_edge(n1, n3));
}

#[test]
fn test_find_edge() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    assert!(graph.find_edge(n1, n2).is_none());

    let e1 = graph.add_edge(n1, n2, ()).unwrap();
    assert_eq!(graph.find_edge(n1, n2), Some(e1));
    assert!(graph.find_edge(n2, n1).is_none());
    assert!(graph.find_edge(n1, n3).is_none());
}

#[test]
fn test_graph_base_types() {
    use petgraph::graph::{EdgeIndex, NodeIndex};
    use petgraph::visit::GraphBase;

    let _graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();

    // Test that the types are correct
    let _: NodeIndex = <BoundedGraph<SymmetricFixedEdgeCount<3>, ()> as GraphBase>::NodeId::new(0);
    let _: EdgeIndex = <BoundedGraph<SymmetricFixedEdgeCount<3>, ()> as GraphBase>::EdgeId::new(0);
}

#[test]
fn test_data_trait() {
    use petgraph::visit::Data;

    let _graph = BoundedGraph::<SymmetricFixedEdgeCount<3, i32>, String>::new();

    // The Data trait should expose the correct weight types
    type NodeWeight = <BoundedGraph<SymmetricFixedEdgeCount<3, i32>, String> as Data>::NodeWeight;
    type EdgeWeight = <BoundedGraph<SymmetricFixedEdgeCount<3, i32>, String> as Data>::EdgeWeight;

    let _node: NodeWeight = SymmetricFixedEdgeCount::new(42);
    let _edge: EdgeWeight = "test".to_string();
}

#[test]
fn test_graph_prop_directed() {
    use petgraph::visit::GraphProp;

    let graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    assert!(graph.is_directed());
}

#[test]
fn test_graph_prop_undirected() {
    use petgraph::visit::GraphProp;

    let graph = BoundedUnGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    assert!(!graph.is_directed());
}

#[test]
fn test_data_map_mut_edge_weight() {
    use petgraph::data::DataMapMut;

    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, i32>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let e1 = graph.add_edge(n1, n2, 100).unwrap();

    // Mutate edge weight
    if let Some(weight) = graph.edge_weight_mut(e1) {
        *weight = 200;
    }

    assert_eq!(*graph.edge_weight(e1).unwrap(), 200);
}

#[test]
fn test_data_map_mut_node_weight() {
    use petgraph::data::DataMapMut;

    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3, i32>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::new(10));

    // Mutate node weight data (SymmetricFixedEdgeCount implements ImmutableEdgeBounds)
    if let Some(node) = graph.node_weight_mut(n1) {
        node.data = 20;
    }

    assert_eq!(graph[n1].data, 20);
}

#[test]
fn test_into_edges() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    graph.add_edge(n1, n2, ()).unwrap();
    graph.add_edge(n1, n3, ()).unwrap();

    let edges: Vec<_> = graph.edges(n1).collect();
    assert_eq!(edges.len(), 2);
}

#[test]
fn test_to_graph6_undirected() {
    use petgraph::graph6::ToGraph6;

    let mut graph = BoundedUnGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    graph.add_edge(n1, n2, ()).unwrap();

    // Just check that it produces a non-empty graph6 string
    // The actual format details may vary, but it should work
    let g6 = graph.graph6_string();
    assert!(!g6.is_empty());
}

#[test]
fn test_visitable_reset_map() {
    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let _ = graph.add_node(SymmetricFixedEdgeCount::empty());

    let mut visit_map = graph.visit_map();
    visit_map.visit(n1);
    assert!(visit_map.is_visited(&n1));

    // Reset the map
    graph.reset_map(&mut visit_map);
    assert!(!visit_map.is_visited(&n1));
}

#[test]
fn test_node_compact_indexable() {
    use petgraph::visit::NodeCompactIndexable;

    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let _ = graph.add_node(SymmetricFixedEdgeCount::empty());
    let _ = graph.add_node(SymmetricFixedEdgeCount::empty());

    // The trait is a marker, just ensure it's implemented
    fn is_compact<G: NodeCompactIndexable>(_g: &G) -> bool {
        true
    }
    assert!(is_compact(&graph));
}

#[test]
fn test_data_map_node_weight() {
    use petgraph::data::DataMap;

    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3, i32>, String>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::new(42));
    let n2 = graph.add_node(SymmetricFixedEdgeCount::new(100));

    // Read node weights
    assert_eq!(graph.node_weight(n1).unwrap().data, 42);
    assert_eq!(graph.node_weight(n2).unwrap().data, 100);

    // Try invalid node
    use petgraph::graph::NodeIndex;
    let invalid_node = NodeIndex::new(999);
    assert!(graph.node_weight(invalid_node).is_none());
}

#[test]
fn test_data_map_edge_weight() {
    use petgraph::data::DataMap;

    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, String>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let e1 = graph.add_edge(n1, n2, "test".to_string()).unwrap();

    // Read edge weight
    assert_eq!(graph.edge_weight(e1).unwrap(), "test");

    // Try invalid edge
    use petgraph::graph::EdgeIndex;
    let invalid_edge = EdgeIndex::new(999);
    assert!(graph.edge_weight(invalid_edge).is_none());
}

#[test]
fn test_data_map_mut_invalid_indices() {
    use petgraph::data::DataMapMut;

    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3, i32>, String>::new();
    let _n1 = graph.add_node(SymmetricFixedEdgeCount::new(10));

    // Try invalid node
    use petgraph::graph::{EdgeIndex, NodeIndex};
    let invalid_node = NodeIndex::new(999);
    assert!(graph.node_weight_mut(invalid_node).is_none());

    // Try invalid edge
    let invalid_edge = EdgeIndex::new(999);
    assert!(graph.edge_weight_mut(invalid_edge).is_none());
}

#[test]
fn test_into_neighbors_trait() {
    use petgraph::visit::IntoNeighbors;

    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    graph.add_edge(n1, n2, ()).unwrap();
    graph.add_edge(n1, n3, ()).unwrap();

    // Use the IntoNeighbors trait via a reference
    let graph_ref = &graph;
    let neighbors: Vec<_> = graph_ref.neighbors(n1).collect();
    assert_eq!(neighbors.len(), 2);
    assert!(neighbors.contains(&n2));
    assert!(neighbors.contains(&n3));

    // Test with node that has no neighbors
    let neighbors_n2: Vec<_> = graph_ref.neighbors(n2).collect();
    assert_eq!(neighbors_n2.len(), 0);
}

#[test]
fn test_into_neighbors_directed_trait() {
    use petgraph::visit::IntoNeighborsDirected;

    let mut graph = BoundedGraph::<SymmetricFixedEdgeCount<3>, ()>::new();
    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    graph.add_edge(n1, n2, ()).unwrap();
    graph.add_edge(n2, n3, ()).unwrap();
    graph.add_edge(n3, n1, ()).unwrap();

    // Use the IntoNeighborsDirected trait via a reference
    let graph_ref = &graph;

    // Test outgoing neighbors
    let outgoing: Vec<_> = graph_ref
        .neighbors_directed(n1, Direction::Outgoing)
        .collect();
    assert_eq!(outgoing.len(), 1);
    assert_eq!(outgoing[0], n2);

    // Test incoming neighbors
    let incoming: Vec<_> = graph_ref
        .neighbors_directed(n1, Direction::Incoming)
        .collect();
    assert_eq!(incoming.len(), 1);
    assert_eq!(incoming[0], n3);

    // Test node with no outgoing neighbors
    let outgoing_n3: Vec<_> = graph_ref
        .neighbors_directed(n3, Direction::Outgoing)
        .collect();
    assert_eq!(outgoing_n3.len(), 1);
    assert_eq!(outgoing_n3[0], n1);
}

#[test]
fn test_stable_graph_petgraph_traits() {
    use crate::BoundedStableDiGraph;
    use petgraph::visit::{IntoNodeIdentifiers, Visitable};

    // Verify that petgraph traits work correctly with StableGraph backing
    let mut graph = BoundedStableDiGraph::<SymmetricFixedEdgeCount<3>, i32>::new();

    let n1 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n2 = graph.add_node(SymmetricFixedEdgeCount::empty());
    let n3 = graph.add_node(SymmetricFixedEdgeCount::empty());

    let e1 = graph.add_edge(n1, n2, 100).unwrap();
    graph.add_edge(n2, n3, 200).unwrap();

    // Test NodeCount trait
    assert_eq!(graph.node_count(), 3);

    // Test EdgeCount trait
    assert_eq!(graph.edge_count(), 2);

    // Test IntoNodeIdentifiers trait
    let node_ids: Vec<_> = graph.node_identifiers().collect();
    assert_eq!(node_ids.len(), 3);

    // Test Data trait
    assert_eq!(
        *graph.node_weight(n1).unwrap(),
        SymmetricFixedEdgeCount::empty()
    );
    assert_eq!(*graph.edge_weight(e1).unwrap(), 100);

    // Test Visitable trait
    let mut visit_map = graph.visit_map();
    assert!(!visit_map.is_visited(&n1));
    visit_map.visit(n1);
    assert!(visit_map.is_visited(&n1));

    // Verify StableGraph specific behavior - indices remain valid after node removal
    graph.graph.remove_node(n2);
    assert_eq!(graph.node_count(), 2);
    assert!(graph.node_weight(n1).is_some());
    assert!(graph.node_weight(n2).is_none()); // Removed
    assert!(graph.node_weight(n3).is_some());
}