Jo is a procedural macro for Rust that allows you to ensure that functions are not running at the same time. This is especially useful for integration tests, where tests that are writing to the same database table should not run in parallel.
The goal of mutual exclusion is achieved by acquiring a mutex at the beginning
of the annotated function. So in essence this macro is syntactical sugar for
writing MUT.lock().unwrap() at the beginning of every function.
Different functions can synchronize on different mutexes. That's why a
static mutex reference must be passed to the jo annotation.
```rust use std::sync::Mutex; use lazystatic::lazystatic; use jo::jo;
// Create two locks lazystatic! { static ref MUTA: Mutex<()> = Mutex::new(()); } lazystatic! { static ref MUTB: Mutex<()> = Mutex::new(()); }
// Mutually exclude parallel runs of functions using those two locks
fn functiona1() { // This will not run in parallel to functiona2 }
fn functiona2() { // This will not run in parallel to functiona1 }
fn functionb() { // This may run in parallel to functiona* } ```
Licensed under either of
at your option.