zipora 3.0.0

High-performance Rust implementation providing advanced data structures and compression algorithms with memory safety guarantees. Features LRU page cache, sophisticated caching layer, fiber-based concurrency, real-time compression, secure memory pools, SIMD optimizations, and complete C FFI for migration from C++.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

//! Simple compilation tests for the new thread module

#[cfg(test)]
mod tests {
    use super::super::*;
    use std::sync::Arc;
    use std::thread;

    #[test]
    fn test_platform_sync_compilation() {
        // Just ensure it compiles
        let _ = std::marker::PhantomData::<DefaultPlatformSync>;
    }

    #[cfg(target_os = "linux")]
    #[test]
    fn test_futex_mutex_basic() {
        let mutex = FutexMutex::new();
        let _guard = mutex.lock().unwrap();
        // Guard should automatically unlock on drop
    }

    #[test]
    fn test_atomic_stack_basic() {
        let stack = AtomicStack::new();
        stack.push(42);
        assert_eq!(stack.pop(), Some(42));
        assert_eq!(stack.pop(), None);
    }

    #[test]
    fn test_atomic_ext_basic() {
        let atomic = std::sync::atomic::AtomicU32::new(10);
        
        // Test atomic maximize
        let result = atomic.atomic_maximize(5, std::sync::atomic::Ordering::Relaxed);
        assert_eq!(result, 10);
        
        let result = atomic.atomic_maximize(15, std::sync::atomic::Ordering::Relaxed);
        assert_eq!(result, 15);
    }

    #[test]
    fn test_memory_ordering() {
        // Just test that the functions compile and run
        memory_ordering::full_barrier();
        memory_ordering::load_barrier();
        memory_ordering::store_barrier();
    }

    #[test]
    fn test_spin_loop_hint() {
        // Test that it compiles and runs
        spin_loop_hint();
    }
}