diff --git a/src/runtime2/store/component.rs b/src/runtime2/store/component.rs
index 58de8ce520ba17e2f8b6a1293226bf4a55e0d2e1..52f8ace8bd4d3b0161ee35d3ce417d5e111d811c 100644
--- a/src/runtime2/store/component.rs
+++ b/src/runtime2/store/component.rs
@@ -336,14 +336,11 @@ impl<T: Sized> Drop for ComponentStore<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::runtime2::store::tests::Resource;
+    use super::super::tests::*;
 
     use rand::prelude::*;
     use rand_pcg::Pcg32;
 
-    use std::sync::Arc;
-    use std::sync::atomic::{AtomicU64, Ordering};
-
     fn seeds() -> Vec<[u8;16]> {
         return vec![
             [241, 47, 70, 87, 240, 246, 20, 173, 219, 143, 74, 23, 158, 58, 205, 172],
@@ -360,14 +357,13 @@ mod tests {
         const NUM_ELEMENTS: usize = 1024;
 
         let store = ComponentStore::new(32);
-        let ctor_counter = Arc::new(AtomicU64::new(0));
-        let dtor_counter = Arc::new(AtomicU64::new(0));
+        let counters = Counters::new();
 
         let mut indices = Vec::with_capacity(NUM_ELEMENTS);
         for _round_index in 0..NUM_ROUNDS {
             // Creation round
             for value in 0..NUM_ELEMENTS {
-                let new_resource = Resource::new(ctor_counter.clone(), dtor_counter.clone(), value as u64);
+                let new_resource = Resource::new(&counters, value as u64);
                 let new_index = store.create(new_resource);
                 indices.push(new_index);
             }
@@ -386,10 +382,9 @@ mod tests {
             indices.clear();
         }
 
-        let num_ctor_calls = ctor_counter.load(Ordering::Acquire);
-        let num_dtor_calls = dtor_counter.load(Ordering::Acquire);
-        assert_eq!(num_ctor_calls, num_dtor_calls);
-        assert_eq!(num_ctor_calls, (NUM_ROUNDS * NUM_ELEMENTS) as u64);
+        let num_expected = (NUM_ROUNDS * NUM_ELEMENTS) as u64;
+        assert_ctor_eq!(counters, num_expected);
+        assert_dtor_eq!(counters, num_expected);
     }
 
     #[test]
@@ -402,8 +397,7 @@ mod tests {
         assert!(MAX_SIZE % NUM_THREADS == 0);
 
         let store = Arc::new(ComponentStore::new(16));
-        let ctor_counter = Arc::new(AtomicU64::new(0));
-        let dtor_counter = Arc::new(AtomicU64::new(0));
+        let counters = Counters::new();
 
         let mut threads = Vec::with_capacity(NUM_THREADS);
         for thread_index in 0..NUM_THREADS {
@@ -411,15 +405,14 @@ mod tests {
             let store = store.clone();
             let first_index = thread_index * NUM_PER_THREAD;
             let last_index = (thread_index + 1) * NUM_PER_THREAD;
-            let ctor_counter = ctor_counter.clone();
-            let dtor_counter = dtor_counter.clone();
+            let counters = counters.clone();
 
             let handle = std::thread::spawn(move || {
                 let mut indices = Vec::with_capacity(last_index - first_index);
                 for _round_index in 0..NUM_ROUNDS {
                     // Creation round
                     for value in first_index..last_index {
-                        let el_index = store.create(Resource::new(ctor_counter.clone(), dtor_counter.clone(), value as u64));
+                        let el_index = store.create(Resource::new(&counters, value as u64));
                         indices.push(el_index);
                     }
 
@@ -444,10 +437,9 @@ mod tests {
             thread.join().expect("clean exit");
         }
 
-        let num_ctor_calls = ctor_counter.load(Ordering::Acquire);
-        let num_dtor_calls = dtor_counter.load(Ordering::Acquire);
-        assert_eq!(num_ctor_calls, num_dtor_calls);
-        assert_eq!(num_ctor_calls, (NUM_ROUNDS * MAX_SIZE) as u64);
+        let num_expected = (NUM_ROUNDS * MAX_SIZE) as u64;
+        assert_ctor_eq!(counters, num_expected);
+        assert_dtor_eq!(counters, num_expected);
     }
 
     #[test]
@@ -466,15 +458,13 @@ mod tests {
         for seed_index in 0..seeds.len() {
             // Setup store, counters and threads
             let store = Arc::new(ComponentStore::new(16));
-            let ctor_counter = Arc::new(AtomicU64::new(0));
-            let dtor_counter = Arc::new(AtomicU64::new(0));
+            let counters = Counters::new();
 
             let mut threads = Vec::with_capacity(NUM_THREADS);
             for thread_index in 0..NUM_THREADS {
                 // Setup local clones to move into the thread
                 let store = store.clone();
-                let ctor_counter = ctor_counter.clone();
-                let dtor_counter = dtor_counter.clone();
+                let counters = counters.clone();
 
                 // Setup local rng
                 let mut seed = seeds[seed_index];
@@ -499,9 +489,7 @@ mod tests {
 
                             if is_empty || (!is_full && should_create) {
                                 // Must create
-                                let el_index = store.create(Resource::new(
-                                    ctor_counter.clone(), dtor_counter.clone(), new_value
-                                ));
+                                let el_index = store.create(Resource::new(&counters, new_value));
                                 stored.push((el_index, new_value));
                             } else {
                                 // Must destroy
@@ -531,14 +519,14 @@ mod tests {
             }
 
             // Before store is dropped
-            let num_ctor_calls = ctor_counter.load(Ordering::Acquire);
-            let num_dtor_calls = dtor_counter.load(Ordering::Acquire);
-            assert_eq!(num_ctor_calls - total_left_allocated, num_dtor_calls);
+            // note: cannot determine number of creations, creation/destructor
+            // is random
+            let num_ctor = counters.ctor.load(Ordering::Acquire);
+            assert_dtor_eq!(counters, num_ctor - total_left_allocated);
 
             // After store is dropped
             drop(store);
-            let num_dtor_calls = dtor_counter.load(Ordering::Acquire);
-            assert_eq!(num_ctor_calls, num_dtor_calls);
+            assert_dtor_eq!(counters, num_ctor);
         }
     }
 }
\ No newline at end of file