Refactor ElementMap, removing its copy-on-write feature

src/testing/graph_topology_addition_testing.rs

@@ -15,8 +15,10 @@ macro_rules! graph_topology_addition_tests {
             reserve_edges_does_not_affect_vertex_capacity,
             add_vertex,
             add_edge,
-            vertex_map_new_vertex,
-            edge_map_new_edge,
+            sync_vertex_map_after_add,
+            sync_edge_map_after_add,
+            sync_vertex_map_preserves_values,
+            sync_edge_map_preserves_values,
         );
     };
 
@@ -122,31 +124,68 @@ where
     assert_ne!(graph.add_edge(u, v), e, "unexpected duplicate edge");
 }
 
-pub fn vertex_map_new_vertex<G: GraphTopologyAddition>() {
+pub fn sync_vertex_map_after_add<G: GraphTopologyAddition>() {
     let mut graph = G::default();
     let mut map = graph.vertex_map(27);
+    let u = graph.add_vertex();
     let v = graph.add_vertex();
+    graph.sync_vertex_map(&mut map);
     assert_eq!(
-        map[v], 27,
+        map[u], 27,
         "unexpected value from default map read for new vertex"
     );
-    map[v] = 9;
+    map[u] = 9;
     assert_eq!(
-        map[v], 9,
+        map[u], 9,
         "unexpected value from map read after write for new vertex"
     );
+    assert_eq!(
+        map[v], 27,
+        "unexpected value from default map read for second new vertex"
+    );
 }
 
-pub fn edge_map_new_edge<G: GraphTopologyAddition>() {
+pub fn sync_edge_map_after_add<G: GraphTopologyAddition>() {
     let mut graph = G::default();
     let u = graph.add_vertex();
     let v = graph.add_vertex();
     let mut map = graph.edge_map(28);
     let e = graph.add_edge(u, v);
-    assert_eq!(map[e], 28);
+    let f = graph.add_edge(u, v);
+    graph.sync_edge_map(&mut map);
+    assert_eq!(
+        map[e], 28,
+        "unexpected value from default map read for new edge"
+    );
     map[e] = 8;
     assert_eq!(
         map[e], 8,
         "unexpected value from map read after write for new edge"
     );
+    assert_eq!(
+        map[f], 28,
+        "unexpected value from default map read for second new edge"
+    );
+}
+
+pub fn sync_vertex_map_preserves_values<G: GraphTopologyAddition>() {
+    let mut graph = G::default();
+    let v = graph.add_vertex();
+    let mut map = graph.vertex_map(0);
+    map[v] = 5;
+    graph.reserve_vertices(20);
+    graph.sync_vertex_map(&mut map);
+    assert_eq!(map[v], 5, "sync should not change existing map values");
+}
+
+pub fn sync_edge_map_preserves_values<G: GraphTopologyAddition>() {
+    let mut graph = G::default();
+    let u = graph.add_vertex();
+    let v = graph.add_vertex();
+    let e = graph.add_edge(u, v);
+    let mut map = graph.edge_map(0);
+    map[e] = 6;
+    graph.reserve_edges(20);
+    graph.sync_edge_map(&mut map);
+    assert_eq!(map[e], 6, "sync should not change existing map values");
 }

src/testing/graph_topology_testing.rs

@@ -72,12 +72,22 @@ pub fn vertex_count<G: MakeTestGraph>() {
     assert_eq!(graph.vertex_count(), 10, "unexpected vertex count");
 }
 
-pub fn vertex_map<G: MakeTestGraph>() {
-    let (graph, v) = G::single_vertex();
-    let mut map = graph.vertex_map(27);
-    assert_eq!(map[v], 27, "unexpected value from default map read");
-    map[v] = 9;
-    assert_eq!(map[v], 9, "unexpected value from map after write");
+pub fn vertex_map<G: MakeTestGraph>()
+where
+    G::Vertex: Debug,
+{
+    let (graph, vertices, _, _) = G::standard();
+    let mut map = graph.vertex_map(88);
+    for (i, &v) in vertices.iter().enumerate() {
+        assert_eq!(
+            map[v], 88,
+            "unexpected value from default map read for vertex {v:?}"
+        );
+        map[v] = i;
+    }
+    for (i, &v) in vertices.iter().enumerate() {
+        assert_eq!(map[v], i, "unexpected value after write for vertex {v:?}");
+    }
 }
 
 pub fn edge_count_empty<G: MakeTestGraph>() {
@@ -90,12 +100,22 @@ pub fn edge_count<G: MakeTestGraph>() {
     assert_eq!(graph.edge_count(), 18, "unexpected edge count");
 }
 
-pub fn edge_map<G: MakeTestGraph>() {
-    let (graph, _, e) = G::single_edge();
-    let mut map = graph.edge_map(28);
-    assert_eq!(map[e], 28, "unexpected value from default map read");
-    map[e] = 8;
-    assert_eq!(map[e], 8, "unexpected value from map after write");
+pub fn edge_map<G: MakeTestGraph>()
+where
+    G::Edge: Debug,
+{
+    let (graph, _, edges, _) = G::standard();
+    let mut map = graph.edge_map(99);
+    for (i, &(e, _, _)) in edges.iter().enumerate() {
+        assert_eq!(
+            map[e], 99,
+            "unexpected value from default map read for edge {e:?}"
+        );
+        map[e] = i;
+    }
+    for (i, &(e, _, _)) in edges.iter().enumerate() {
+        assert_eq!(map[e], i, "unexpected value after write for edge {e:?}");
+    }
 }
 
 pub fn degree_zero<G: MakeTestGraph>() {