move around some components

fsrc-core/tests/pool_test.rs

@@ -1,91 +1,36 @@
+use std::ops::DerefMut;
 use std::sync::{Arc, RwLock};
 use std::thread;
+use fsrc_core::pool::{LocalPool, PoolCfg, StoreAddr, PoolGuard};
+use std::sync::mpsc::{Sender, Receiver};
+use std::sync::mpsc;
 
-struct PoolDummy {
-    test_buf: [u8; 128],
-}
+const DUMMY_DATA: [u8; 4] = [0, 1, 2, 3];
 
-struct PoolAccessDummy<'a> {
-    pool_dummy: &'a mut PoolDummy,
-    no_deletion: bool,
-}
-
-impl PoolAccessDummy<'_> {
-    fn modify(&mut self) -> &mut [u8] {
-        self.pool_dummy.modify()
-    }
-
-    fn release(&mut self) {
-        self.no_deletion = true;
-    }
-}
-
-impl Drop for PoolAccessDummy<'_> {
-    fn drop(&mut self) {
-        if self.no_deletion {
-            println!("Pool access: Drop with no deletion")
-        } else {
-            self.pool_dummy.delete();
-            println!("Pool access: Drop with deletion");
-        }
-    }
-}
-
-impl Default for PoolDummy {
-    fn default() -> Self {
-        PoolDummy { test_buf: [0; 128] }
-    }
-}
-
-impl PoolDummy {
-    fn modify(&mut self) -> &mut [u8] {
-        self.test_buf.as_mut_slice()
-    }
-
-    fn modify_with_accessor(&mut self) -> PoolAccessDummy {
-        PoolAccessDummy {
-            pool_dummy: self,
-            no_deletion: false,
-        }
-    }
-
-    fn read(&self) -> &[u8] {
-        self.test_buf.as_slice()
-    }
-
-    fn delete(&mut self) {
-        println!("Store content was deleted");
-    }
-}
-
-fn pool_test() {
-    println!("Hello World");
-    let shared_dummy = Arc::new(RwLock::new(PoolDummy::default()));
+#[test]
+fn threaded_usage() {
+    let pool_cfg = PoolCfg::new(vec![(16, 6), (32, 3), (8, 12)]);
+    let shared_dummy = Arc::new(RwLock::new(LocalPool::new(pool_cfg)));
     let shared_clone = shared_dummy.clone();
-    let jh0 = thread::spawn(move || loop {
+    let (tx, rx): (Sender<StoreAddr>, Receiver<StoreAddr>) = mpsc::channel();
+    let jh0 = thread::spawn(move || {
         {
             let mut dummy = shared_dummy.write().unwrap();
-            let buf = dummy.modify();
-            buf[0] = 1;
-
-            let mut accessor = dummy.modify_with_accessor();
-            let buf = accessor.modify();
-            buf[0] = 2;
+            let addr = dummy.add(&DUMMY_DATA).expect("Writing data failed");
+            tx.send(addr).expect("Sending store address failed");
         }
     });
 
-    let jh1 = thread::spawn(move || loop {
+    let jh1 = thread::spawn(move || {
+        let mut pool_access = shared_clone.write().unwrap();
+        let addr;
         {
-            let dummy = shared_clone.read().unwrap();
-            let buf = dummy.read();
-            println!("Buffer 0: {:?}", buf[0]);
+            addr = rx.recv().expect("Receiving store address failed");
+            let pg = PoolGuard::new(pool_access.deref_mut(), addr);
+            let read_res = pg.read().expect("Reading failed");
+            assert_eq!(read_res, DUMMY_DATA);
         }
-
-        let mut dummy = shared_clone.write().unwrap();
-        let mut accessor = dummy.modify_with_accessor();
-        let buf = accessor.modify();
-        buf[0] = 3;
-        accessor.release();
+        assert!(!pool_access.has_element_at(&addr).expect("Invalid address"));
     });
     jh0.join().unwrap();
     jh1.join().unwrap();