more unit tests

src/sealed.rs

@@ -548,14 +548,14 @@ pub trait Wal<S> {
   fn minimum_version(&self) -> u64;
 
   #[inline]
-  fn update_versions(&mut self, version: u64) {
+  fn update_versions(&self, version: u64) {
     self.update_maximum_version(version);
     self.update_minimum_version(version);
   }
 
-  fn update_maximum_version(&mut self, version: u64);
+  fn update_maximum_version(&self, version: u64);
 
-  fn update_minimum_version(&mut self, version: u64);
+  fn update_minimum_version(&self, version: u64);
 
   #[inline]
   fn insert_pointer<'a>(
@@ -785,12 +785,19 @@ pub trait Wal<S> {
     };
 
     res.and_then(|(offset, kp, vp)| {
-      self.insert_pointer(version, kp, vp).map_err(|e| {
-        unsafe {
-          self.allocator().rewind(ArenaPosition::Start(offset as u32));
-        };
-        Among::Right(e)
-      })
+      self
+        .insert_pointer(version, kp, vp)
+        .map(|_| {
+          if let Some(version) = version {
+            self.update_versions(version)
+          }
+        })
+        .map_err(|e| {
+          unsafe {
+            self.allocator().rewind(ArenaPosition::Start(offset as u32));
+          };
+          Among::Right(e)
+        })
     })
   }
 
@@ -820,6 +827,8 @@ pub trait Wal<S> {
     let opts = self.options();
     let maximum_key_size = opts.maximum_key_size().to_u32();
     let minimum_value_size = opts.maximum_value_size();
+    let mut minimum_version = self.minimum_version();
+    let mut maximum_version = self.maximum_version();
     let start_offset = unsafe {
       let (mut cursor, allocator, mut buf) = batch
         .iter_mut()
@@ -864,9 +873,6 @@ pub trait Wal<S> {
         })
         .map_err(Among::Right)?;
 
-      let mut minimum = self.minimum_version();
-      let mut maximum = self.maximum_version();
-
       for ent in batch.iter_mut() {
         let meta = ent.encoded_meta();
         let version_size = if ent.internal_version().is_some() {
@@ -896,12 +902,12 @@ pub trait Wal<S> {
         let (key_ptr, val_ptr) = if let Some(version) = ent.internal_version() {
           buf.put_u64_le_unchecked(version);
 
-          if maximum < version {
-            maximum = version;
+          if maximum_version < version {
+            maximum_version = version;
           }
 
-          if minimum > version {
-            minimum = version;
+          if minimum_version > version {
+            minimum_version = version;
           }
 
           (
@@ -977,6 +983,10 @@ pub trait Wal<S> {
         let (kp, vp) = e.take_pointer().unwrap();
         (e.internal_version(), kp, vp)
       }))
+      .map(|_| {
+        self.update_maximum_version(maximum_version);
+        self.update_minimum_version(minimum_version);
+      })
       .map_err(|e| {
         // Safety: the writer is single threaded, the memory chunk in buf cannot be accessed by other threads,
         // so it's safe to rewind the arena.

src/swmr.rs

@@ -2,16 +2,17 @@ mod reader;
 mod wal;
 mod writer;
 
-#[cfg(all(
-  test,
-  any(
-    all_orderwal_tests,
-    test_swmr_constructor,
-    test_swmr_insert,
-    test_swmr_get,
-    test_swmr_iters,
-  )
-))]
+// #[cfg(all(
+//   test,
+//   any(
+//     all_orderwal_tests,
+//     test_swmr_constructor,
+//     test_swmr_insert,
+//     test_swmr_get,
+//     test_swmr_iters,
+//   )
+// ))]
+#[cfg(test)]
 mod tests;
 
 /// The ordered write-ahead log without multiple version support.

src/swmr/tests/constructor.rs

@@ -1,4 +1,5 @@
 use base::{Reader, Writer};
+use skl::KeySize;
 
 use crate::memtable::{
   alternative::{Table, TableOptions},
@@ -70,3 +71,40 @@ expand_unit_tests!(
     }),
   }
 );
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn reopen_wrong_kind() {
+  use crate::Builder;
+
+  let dir = tempfile::tempdir().unwrap();
+  let path = dir.path().join("test_reopen_wrong_kind");
+  let wal = unsafe {
+    Builder::new()
+      .with_capacity(MB)
+      .with_maximum_key_size(KeySize::with(10))
+      .with_maximum_value_size(10)
+      .with_create_new(true)
+      .with_read(true)
+      .with_write(true)
+      .map_mut::<OrderWal<Person, String>, _>(path.as_path())
+      .unwrap()
+  };
+
+  assert!(!wal.read_only());
+  assert_eq!(wal.capacity(), MB);
+  assert!(wal.remaining() < MB);
+  assert_eq!(wal.maximum_key_size(), 10);
+  assert_eq!(wal.maximum_value_size(), 10);
+  assert_eq!(wal.path().unwrap().as_path(), path.as_path());
+  assert_eq!(wal.options().maximum_key_size(), 10);
+
+  let err = unsafe {
+    Builder::new()
+      .with_capacity(MB)
+      .with_read(true)
+      .map_mut::<crate::multiple_version::OrderWal<Person, String>, _>(path.as_path())
+      .unwrap_err()
+  };
+  assert!(matches!(err, crate::error::Error::KindMismatch { .. }));
+}

src/swmr/tests/multiple_version_constructor.rs

@@ -1,4 +1,5 @@
 use multiple_version::{OrderWal, Reader, Writer};
+use skl::KeySize;
 
 use crate::memtable::{
   alternative::{MultipleVersionTable, TableOptions},
@@ -78,16 +79,26 @@ fn reopen_wrong_kind() {
 
   let dir = tempfile::tempdir().unwrap();
   let path = dir.path().join("test_reopen_wrong_kind");
-  let _ = unsafe {
+  let wal = unsafe {
     Builder::new()
       .with_capacity(MB)
+      .with_maximum_key_size(KeySize::with(10))
+      .with_maximum_value_size(10)
       .with_create_new(true)
       .with_read(true)
       .with_write(true)
       .map_mut::<OrderWal<Person, String>, _>(path.as_path())
       .unwrap()
   };
 
+  assert!(!wal.read_only());
+  assert_eq!(wal.capacity(), MB);
+  assert!(wal.remaining() < MB);
+  assert_eq!(wal.maximum_key_size(), 10);
+  assert_eq!(wal.maximum_value_size(), 10);
+  assert_eq!(wal.path().unwrap().as_path(), path.as_path());
+  assert_eq!(wal.options().maximum_key_size(), 10);
+
   let err = unsafe {
     Builder::new()
       .with_capacity(MB)