test: add more tests

percpu.x

@@ -5,7 +5,7 @@ SECTIONS
     . = ALIGN(4K);
     _percpu_start = .;
     _percpu_end = _percpu_start + SIZEOF(.percpu);
-    .percpu 0x0 (NOLOAD) : AT(_percpu_start) {
+    .percpu (NOLOAD) : AT(_percpu_start) {
         _percpu_load_start = .;
         *(.percpu .percpu.*)
         _percpu_load_end = .;

tests/scope_local.rs

@@ -1,4 +1,4 @@
-use std::sync::Arc;
+use std::{panic, sync::Arc, thread};
 
 use ctor::ctor;
 use scope_local::{ActiveScope, Scope, scope_local};
@@ -54,4 +54,103 @@ fn shared() {
     }
 
     assert_eq!(Arc::strong_count(&SHARED), 1);
+
+    let panic = panic::catch_unwind(|| {
+        let mut scope = Scope::new();
+        *SHARED.scope_mut(&mut scope) = SHARED.clone();
+        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);
+
+    let handles: Vec<_> = (0..10)
+        .map(|_| {
+            thread::spawn(move || {
+                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()));
+            })
+        })
+        .collect();
+
+    for h in handles {
+        h.join().unwrap();
+    }
+
+    assert_eq!(Arc::strong_count(&T_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();
+                })
+            })
+            .collect();
+
+        for h in handles {
+            h.join().unwrap();
+        }
+    }
+
+    assert_eq!(Arc::strong_count(&T_SHARED), 1);
+}
+
+#[test]
+fn isolation() {
+    let handles: Vec<_> = (0..10)
+        .map(|i| {
+            thread::spawn(move || {
+                let mut scope = Scope::new();
+                *DATA.scope_mut(&mut scope) = i;
+
+                unsafe { ActiveScope::set(&scope) };
+                assert_eq!(*DATA, i);
+
+                ActiveScope::set_global();
+            })
+        })
+        .collect();
+
+    for h in handles {
+        h.join().unwrap();
+    }
+
+    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();
 }