test: improve

Author: AsakuraMizu

tests/scope_local.rs

@@ -1,10 +1,17 @@
-use std::{panic, sync::Arc, thread};
+use std::{
+    panic,
+    sync::{
+        Arc,
+        atomic::{AtomicUsize, Ordering},
+    },
+    thread,
+};
 
 use ctor::ctor;
 use scope_local::{ActiveScope, Scope, scope_local};
 
 #[ctor]
-fn init() {
+fn init_percpu() {
     percpu::init();
 
     unsafe { percpu::write_percpu_reg(percpu::percpu_area_base(0)) };
@@ -14,18 +21,22 @@ fn init() {
     println!("per-CPU area size = {}", percpu::percpu_area_size());
 }
 
-scope_local! {
-    static DATA: usize = 0;
-}
-
 #[test]
-fn global() {
-    assert_eq!(*DATA, 0);
+fn scope_init() {
+    scope_local! {
+        static DATA: usize = 42;
+    }
+    assert_eq!(*DATA, 42);
 }
 
 #[test]
 fn scope() {
+    scope_local! {
+        static DATA: usize = 0;
+    }
+
     let mut scope = Scope::new();
+    assert_eq!(*DATA, 0);
     assert_eq!(*DATA.scope(&scope), 0);
 
     *DATA.scope_mut(&mut scope) = 42;
@@ -35,14 +46,16 @@ fn scope() {
     assert_eq!(*DATA, 42);
 
     ActiveScope::set_global();
-}
-
-scope_local! {
-    static SHARED: Arc<String> = Arc::new("qwq".to_string());
+    assert_eq!(*DATA, 0);
+    assert_eq!(*DATA.scope(&scope), 42);
 }
 
 #[test]
-fn shared() {
+fn scope_drop() {
+    scope_local! {
+        static SHARED: Arc<()> = Arc::new(());
+    }
+
     assert_eq!(Arc::strong_count(&SHARED), 1);
 
     {
@@ -54,32 +67,45 @@ fn shared() {
     }
 
     assert_eq!(Arc::strong_count(&SHARED), 1);
+}
+
+#[test]
+fn scope_panic_unwind_drop() {
+    scope_local! {
+        static SHARED: Arc<()> = Arc::new(());
+    }
 
     let panic = panic::catch_unwind(|| {
         let mut scope = Scope::new();
         *SHARED.scope_mut(&mut scope) = SHARED.clone();
+        assert_eq!(Arc::strong_count(&SHARED), 2);
         panic!("panic");
     });
     assert!(panic.is_err());
 
     assert_eq!(Arc::strong_count(&SHARED), 1);
 }
 
-scope_local! {
-    static T_SHARED: Arc<String> = Arc::new("qwq".to_string());
-}
-
 #[test]
-fn threads_shared() {
-    assert_eq!(Arc::strong_count(&SHARED), 1);
+fn thread_share_item() {
+    scope_local! {
+        static SHARED: Arc<()> = Arc::new(());
+    }
 
     let handles: Vec<_> = (0..10)
         .map(|_| {
             thread::spawn(move || {
+                let global = &*SHARED;
+
                 let mut scope = Scope::new();
-                *T_SHARED.scope_mut(&mut scope) = T_SHARED.clone();
-                assert!(Arc::strong_count(&T_SHARED) >= 2);
-                assert_eq!(*T_SHARED, Arc::new("qwq".to_string()));
+                *SHARED.scope_mut(&mut scope) = global.clone();
+
+                unsafe { ActiveScope::set(&scope) };
+
+                assert!(Arc::strong_count(&SHARED) >= 2);
+                assert!(Arc::ptr_eq(&SHARED, global));
+
+                ActiveScope::set_global();
             })
         })
         .collect();
@@ -88,35 +114,44 @@ fn threads_shared() {
         h.join().unwrap();
     }
 
-    assert_eq!(Arc::strong_count(&T_SHARED), 1);
+    assert_eq!(Arc::strong_count(&SHARED), 1);
+}
 
-    {
-        let mut scope = Scope::new();
-        *T_SHARED.scope_mut(&mut scope) = T_SHARED.clone();
-        let scope = Arc::new(scope);
-
-        let handles: Vec<_> = (0..10)
-            .map(|_| {
-                let scope = scope.clone();
-                thread::spawn(move || {
-                    unsafe { ActiveScope::set(&scope) };
-                    assert_eq!(Arc::strong_count(&T_SHARED), 2);
-                    assert_eq!(*T_SHARED, Arc::new("qwq".to_string()));
-                    ActiveScope::set_global();
-                })
+#[test]
+fn thread_share_scope() {
+    scope_local! {
+        static SHARED: Arc<()> = Arc::new(());
+    }
+
+    let scope = Arc::new(Scope::new());
+
+    let handles: Vec<_> = (0..10)
+        .map(|_| {
+            let scope = scope.clone();
+            thread::spawn(move || {
+                unsafe { ActiveScope::set(&scope) };
+                assert_eq!(Arc::strong_count(&SHARED), 1);
+                assert!(Arc::ptr_eq(&SHARED, &SHARED.scope(&scope)));
+                ActiveScope::set_global();
             })
-            .collect();
+        })
+        .collect();
 
-        for h in handles {
-            h.join().unwrap();
-        }
+    for h in handles {
+        h.join().unwrap();
     }
 
-    assert_eq!(Arc::strong_count(&T_SHARED), 1);
+    assert_eq!(Arc::strong_count(&SHARED), 1);
+    assert_eq!(Arc::strong_count(&SHARED.scope(&scope)), 1);
 }
 
 #[test]
-fn isolation() {
+fn thread_isolation() {
+    scope_local! {
+        static DATA: usize = 0;
+        static DATA2: AtomicUsize = AtomicUsize::new(0);
+    }
+
     let handles: Vec<_> = (0..10)
         .map(|i| {
             thread::spawn(move || {
@@ -126,6 +161,8 @@ fn isolation() {
                 unsafe { ActiveScope::set(&scope) };
                 assert_eq!(*DATA, i);
 
+                DATA2.store(i, Ordering::Relaxed);
+
                 ActiveScope::set_global();
             })
         })
@@ -136,21 +173,5 @@ fn isolation() {
     }
 
     assert_eq!(*DATA, 0);
-}
-
-#[test]
-fn nested() {
-    let mut outer = Scope::new();
-    unsafe { ActiveScope::set(&outer) };
-    *DATA.scope_mut(&mut outer) = 1;
-
-    let mut inner = Scope::new();
-    unsafe { ActiveScope::set(&inner) };
-    *DATA.scope_mut(&mut inner) = 2;
-    assert_eq!(*DATA, 2);
-
-    unsafe { ActiveScope::set(&outer) };
-    assert_eq!(*DATA, 1);
-
-    ActiveScope::set_global();
+    assert_eq!(DATA2.load(Ordering::Relaxed), 0);
 }