revlog: make the rust test for node hex prefix resolution exercise the nodemap

rust/hg-core/src/revlog/mod.rs

@@ -156,6 +156,16 b' impl Revlog {'
         data_path: Option<&Path>,
         use_nodemap: bool,
     ) -> Result<Self, HgError> {
+        Self::open_gen(store_vfs, index_path, data_path, use_nodemap, None)
+    }
+
+    fn open_gen(
+        store_vfs: &Vfs,
+        index_path: impl AsRef<Path>,
+        data_path: Option<&Path>,
+        use_nodemap: bool,
+        nodemap_for_test: Option<nodemap::NodeTree>,
+    ) -> Result<Self, HgError> {
         let index_path = index_path.as_ref();
         let index = {
             match store_vfs.mmap_open_opt(&index_path)? {
@@ -193,6 +203,8 b' impl Revlog {'
             )
         };
 
+        let nodemap = nodemap_for_test.or(nodemap);
+
         Ok(Revlog {
             index,
             data_bytes,
@@ -790,7 +802,13 b' mod tests {'
             .flatten()
             .collect_vec();
         std::fs::write(temp.path().join("foo.i"), contents).unwrap();
-        let revlog = Revlog::open(&vfs, "foo.i", None, false).unwrap();
+
+        let mut idx = nodemap::tests::TestNtIndex::new();
+        idx.insert_node(0, node0).unwrap();
+        idx.insert_node(1, node1).unwrap();
+
+        let revlog =
+            Revlog::open_gen(&vfs, "foo.i", None, true, Some(idx.nt)).unwrap();
 
         // accessing the data shows the corruption
         revlog.get_entry(0).unwrap().data().unwrap_err();

rust/hg-core/src/revlog/nodemap.rs

@@ -680,7 +680,7 b' impl NodeMap for NodeTree {'
 }
 
 #[cfg(test)]
-mod tests {
+pub mod tests {
     use super::NodeMapError::*;
     use super::*;
     use crate::revlog::node::{hex_pad_right, Node};
@@ -844,28 +844,35 b' mod tests {'
         Ok(())
     }
 
-    struct TestNtIndex {
-        index: TestIndex,
-        nt: NodeTree,
+    pub struct TestNtIndex {
+        pub index: TestIndex,
+        pub nt: NodeTree,
     }
 
     impl TestNtIndex {
-        fn new() -> Self {
+        pub fn new() -> Self {
             TestNtIndex {
                 index: HashMap::new(),
                 nt: NodeTree::default(),
             }
         }
 
-        fn insert(
+        pub fn insert_node(
+            &mut self,
+            rev: Revision,
+            node: Node,
+        ) -> Result<(), NodeMapError> {
+            self.index.insert(rev, node);
+            self.nt.insert(&self.index, &node, rev)?;
+            Ok(())
+        }
+
+        pub fn insert(
             &mut self,
             rev: Revision,
             hex: &str,
         ) -> Result<(), NodeMapError> {
-            let node = pad_node(hex);
-            self.index.insert(rev, node);
-            self.nt.insert(&self.index, &node, rev)?;
-            Ok(())
+            return self.insert_node(rev, pad_node(hex));
         }
 
         fn find_hex(