Extract testing functionality into separate module

Author: laurmaedje

src/lib.rs

@@ -95,6 +95,9 @@ mod input;
 mod memoize;
 mod track;
 
+#[cfg(feature = "testing")]
+pub mod testing;
+
 pub use crate::hash::Prehashed;
 pub use crate::memoize::evict;
 pub use crate::track::{Track, Tracked, TrackedMut, Validate};
@@ -112,7 +115,4 @@ pub mod internal {
     pub use crate::input::{Input, Multi, assert_hashable_or_trackable};
     pub use crate::memoize::{Cache, CacheData, memoize, register_evictor};
     pub use crate::track::{Surfaces, to_parts_mut_mut, to_parts_mut_ref, to_parts_ref};
-
-    #[cfg(feature = "testing")]
-    pub use crate::memoize::last_was_hit;
 }

src/memoize.rs

@@ -12,12 +12,6 @@ use crate::input::Input;
 /// The global list of eviction functions.
 static EVICTORS: RwLock<Vec<fn(usize)>> = RwLock::new(Vec::new());
 
-#[cfg(feature = "testing")]
-thread_local! {
-    /// Whether the last call was a hit.
-    static LAST_WAS_HIT: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
-}
-
 /// Execute a function or use a cached result for it.
 pub fn memoize<'a, In, Out, F>(
     cache: &Cache<In::Constraint, Out>,
@@ -37,7 +31,7 @@ where
 
         // Ensure that the last call was a miss during testing.
         #[cfg(feature = "testing")]
-        LAST_WAS_HIT.with(|cell| cell.set(false));
+        crate::testing::register_miss();
 
         return output;
     }
@@ -59,7 +53,7 @@ where
         input.retrack(constraint).1.join(constrained);
 
         #[cfg(feature = "testing")]
-        LAST_WAS_HIT.with(|cell| cell.set(true));
+        crate::testing::register_hit();
 
         return value.clone();
     }
@@ -80,7 +74,7 @@ where
     borrow.insert::<In>(key, constraint.take(), output.clone());
 
     #[cfg(feature = "testing")]
-    LAST_WAS_HIT.with(|cell| cell.set(false));
+    crate::testing::register_miss();
 
     output
 }
@@ -104,12 +98,6 @@ pub fn register_evictor(evict: fn(usize)) {
     EVICTORS.write().push(evict);
 }
 
-/// Whether the last call was a hit.
-#[cfg(feature = "testing")]
-pub fn last_was_hit() -> bool {
-    LAST_WAS_HIT.with(|cell| cell.get())
-}
-
 /// A cache for a single memoized function.
 pub struct Cache<C, Out>(LazyLock<RwLock<CacheData<C, Out>>>);
 

src/testing.rs

@@ -0,0 +1,21 @@
+use std::cell::Cell;
+
+thread_local! {
+    /// Whether the last call was a cache hit.
+    static LAST_WAS_HIT: Cell<bool> = const { Cell::new(false) };
+}
+
+/// Whether the last call was a hit.
+pub fn last_was_hit() -> bool {
+    LAST_WAS_HIT.with(|cell| cell.get())
+}
+
+/// Marks the last call as a cache hit.
+pub(crate) fn register_hit() {
+    LAST_WAS_HIT.with(|cell| cell.set(true))
+}
+
+/// Marks the last call as a cache miss.
+pub(crate) fn register_miss() {
+    LAST_WAS_HIT.with(|cell| cell.set(false))
+}

tests/tests.rs

@@ -10,11 +10,11 @@ use serial_test::serial;
 macro_rules! test {
     (miss: $call:expr, $result:expr) => {{
         assert_eq!($call, $result);
-        assert!(!comemo::internal::last_was_hit());
+        assert!(!comemo::testing::last_was_hit());
     }};
     (hit: $call:expr, $result:expr) => {{
         assert_eq!($call, $result);
-        assert!(comemo::internal::last_was_hit());
+        assert!(comemo::testing::last_was_hit());
     }};
 }