serial_test 3.4.0

Allows for the creation of serialised Rust tests
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#[cfg(feature = "logging")]
use log::debug;
use parking_lot::{Condvar, Mutex, ReentrantMutex, ReentrantMutexGuard};
use std::{sync::Arc, time::Duration};

struct LockState {
    parallels: u32,
}

struct LockData {
    mutex: Mutex<LockState>,
    serial: ReentrantMutex<()>,
    condvar: Condvar,
}

#[derive(Clone)]
pub(crate) struct Locks {
    arc: Arc<LockData>,
    // Name we're locking for (mostly test usage)
    #[cfg(feature = "logging")]
    pub(crate) name: String,
}

pub(crate) struct MutexGuardWrapper<'a> {
    #[allow(dead_code)] // need it around to get dropped
    mutex_guard: ReentrantMutexGuard<'a, ()>,
    locks: Locks,
}

impl Drop for MutexGuardWrapper<'_> {
    fn drop(&mut self) {
        #[cfg(feature = "logging")]
        debug!("End serial");
        self.locks.arc.condvar.notify_one();
    }
}

impl Locks {
    #[allow(unused_variables)]
    pub fn new(name: &str) -> Locks {
        Locks {
            arc: Arc::new(LockData {
                mutex: Mutex::new(LockState { parallels: 0 }),
                condvar: Condvar::new(),
                serial: Default::default(),
            }),
            #[cfg(feature = "logging")]
            name: name.to_owned(),
        }
    }

    #[cfg(test)]
    pub fn is_locked(&self) -> bool {
        self.arc.serial.is_locked()
    }

    pub fn is_locked_by_current_thread(&self) -> bool {
        self.arc.serial.is_owned_by_current_thread()
    }

    pub fn serial(&self) -> MutexGuardWrapper<'_> {
        #[cfg(feature = "logging")]
        debug!("Get serial lock '{}'", self.name);
        let mut lock_state = self.arc.mutex.lock();
        loop {
            #[cfg(feature = "logging")]
            debug!("Serial acquire {} {}", lock_state.parallels, self.name);
            // If all the things we want are true, try to lock out serial
            if lock_state.parallels == 0 {
                let possible_serial_lock = self.arc.serial.try_lock();
                if let Some(serial_lock) = possible_serial_lock {
                    #[cfg(feature = "logging")]
                    debug!("Got serial '{}'", self.name);
                    return MutexGuardWrapper {
                        mutex_guard: serial_lock,
                        locks: self.clone(),
                    };
                } else {
                    #[cfg(feature = "logging")]
                    debug!("Someone else has serial '{}'", self.name);
                }
            }

            self.arc
                .condvar
                .wait_for(&mut lock_state, Duration::from_secs(1));
        }
    }

    pub fn start_parallel(&self) {
        #[cfg(feature = "logging")]
        debug!("Get parallel lock '{}'", self.name);
        let mut lock_state = self.arc.mutex.lock();
        loop {
            #[cfg(feature = "logging")]
            debug!(
                "Parallel, existing {} '{}'",
                lock_state.parallels, self.name
            );
            if lock_state.parallels > 0 {
                // fast path, as someone else already has it locked
                lock_state.parallels += 1;
                return;
            }

            let possible_serial_lock = self.arc.serial.try_lock();
            if possible_serial_lock.is_some() {
                #[cfg(feature = "logging")]
                debug!("Parallel first '{}'", self.name);
                // We now know no-one else has the serial lock, so we can add to parallel
                lock_state.parallels = 1; // Had to have been 0 before, as otherwise we'd have hit the fast path
                return;
            }

            #[cfg(feature = "logging")]
            debug!("Parallel waiting '{}'", self.name);
            self.arc
                .condvar
                .wait_for(&mut lock_state, Duration::from_secs(1));
        }
    }

    pub fn end_parallel(&self) {
        #[cfg(feature = "logging")]
        debug!("End parallel '{}", self.name);
        let mut lock_state = self.arc.mutex.lock();
        assert!(lock_state.parallels > 0);
        lock_state.parallels -= 1;
        drop(lock_state);
        self.arc.condvar.notify_one();
    }

    #[cfg(test)]
    pub fn parallel_count(&self) -> u32 {
        let lock_state = self.arc.mutex.lock();
        lock_state.parallels
    }
}