revue 2.71.1

A Vue-style TUI framework for Rust with CSS styling
Documentation 
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70

//! Integration tests for lock utilities
//! Extracted from src/utils/lock.rs

use revue::utils::lock::*;
use std::sync::{Arc, Mutex, RwLock};
use std::thread;

#[test]
fn test_lock_or_recover_normal() {
    let mutex = Mutex::new(42);
    let guard = lock_or_recover(&mutex);
    assert_eq!(*guard, 42);
}

#[test]
fn test_lock_or_recover_poisoned() {
    let mutex = Arc::new(Mutex::new(42));
    let mutex_clone = Arc::clone(&mutex);

    // Poison the mutex by panicking while holding the lock
    let handle = thread::spawn(move || {
        let _guard = mutex_clone.lock().unwrap();
        panic!("intentional panic to poison mutex");
    });

    // Wait for the thread to panic
    let _ = handle.join();

    // Should recover instead of panicking
    let guard = lock_or_recover(&mutex);
    assert_eq!(*guard, 42);
}

#[test]
fn test_read_or_recover_normal() {
    let rwlock = RwLock::new(42);
    let guard = read_or_recover(&rwlock);
    assert_eq!(*guard, 42);
}

#[test]
fn test_write_or_recover_normal() {
    let rwlock = RwLock::new(42);
    let mut guard = write_or_recover(&rwlock);
    *guard = 100;
    drop(guard);
    assert_eq!(*read_or_recover(&rwlock), 100);
}

#[test]
fn test_rwlock_poisoned_by_write() {
    let rwlock = Arc::new(RwLock::new(42));
    let rwlock_clone = Arc::clone(&rwlock);

    // Poison by panicking during write
    let handle = thread::spawn(move || {
        let _guard = rwlock_clone.write().unwrap();
        panic!("intentional panic to poison rwlock");
    });

    let _ = handle.join();

    // Both read and write should recover
    let guard = read_or_recover(&rwlock);
    assert_eq!(*guard, 42);
    drop(guard);

    let guard = write_or_recover(&rwlock);
    assert_eq!(*guard, 42);
}