|
1 | | -use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; |
2 | | - |
3 | | -use signal_hook::consts::SIGTERM; |
4 | | - |
5 | | -#[test] |
6 | | -fn multi_registration() -> gix_testtools::Result { |
7 | | - static V1: AtomicUsize = AtomicUsize::new(0); |
8 | | - static V2: AtomicBool = AtomicBool::new(false); |
9 | | - |
10 | | - let reg1 = gix::interrupt::init_handler(3, || { |
11 | | - V1.fetch_add(1, Ordering::SeqCst); |
12 | | - }) |
13 | | - .expect("succeeds"); |
14 | | - assert!(!gix::interrupt::is_triggered()); |
15 | | - assert_eq!(V1.load(Ordering::Relaxed), 0); |
16 | | - let reg2 = |
17 | | - gix::interrupt::init_handler(2, || V2.store(true, Ordering::SeqCst)).expect("multi-initialization is OK"); |
18 | | - assert!(!V2.load(Ordering::Relaxed)); |
19 | | - |
20 | | - signal_hook::low_level::raise(SIGTERM).expect("signal can be raised"); |
21 | | - assert!(gix::interrupt::is_triggered(), "this happens automatically"); |
22 | | - assert_eq!(V1.load(Ordering::Relaxed), 1, "the first trigger is invoked"); |
23 | | - assert!(!V2.load(Ordering::Relaxed), "the second trigger was ignored"); |
24 | | - |
25 | | - reg1.deregister()?; |
26 | | - signal_hook::low_level::raise(SIGTERM).expect("signal can be raised"); |
27 | | - assert_eq!(V1.load(Ordering::Relaxed), 2, "the first trigger is still invoked"); |
28 | | - |
29 | | - assert!(gix::interrupt::is_triggered(), "this happens automatically"); |
30 | | - // now the registration is actually removed. |
31 | | - reg2.with_reset(true).deregister()?; |
32 | | - assert!( |
33 | | - !gix::interrupt::is_triggered(), |
34 | | - "the deregistration succeeded and this is an optional side-effect" |
35 | | - ); |
36 | | - |
37 | | - let reg1 = gix::interrupt::init_handler(3, || { |
38 | | - V1.fetch_add(1, Ordering::SeqCst); |
39 | | - }) |
40 | | - .expect("succeeds"); |
41 | | - assert_eq!(V1.load(Ordering::Relaxed), 2, "nothing changed yet"); |
42 | | - let reg2 = |
43 | | - gix::interrupt::init_handler(2, || V2.store(true, Ordering::SeqCst)).expect("multi-initialization is OK"); |
44 | | - assert!(!V2.load(Ordering::Relaxed)); |
45 | | - |
46 | | - signal_hook::low_level::raise(SIGTERM).expect("signal can be raised"); |
47 | | - assert_eq!(V1.load(Ordering::Relaxed), 3, "the first trigger is invoked"); |
48 | | - assert!(!V2.load(Ordering::Relaxed), "the second trigger was ignored"); |
49 | | - |
50 | | - reg2.auto_deregister(); |
51 | | - reg1.with_reset(true).auto_deregister(); |
52 | | - |
53 | | - assert!( |
54 | | - !gix::interrupt::is_triggered(), |
55 | | - "the deregistration succeeded and this is an optional side-effect" |
56 | | - ); |
57 | | - |
58 | | - Ok(()) |
| 1 | +#[cfg(feature = "interrupt")] |
| 2 | +mod needs_feature { |
| 3 | + use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; |
| 4 | + |
| 5 | + use signal_hook::consts::SIGTERM; |
| 6 | + |
| 7 | + #[test] |
| 8 | + fn multi_registration() -> gix_testtools::Result { |
| 9 | + static V1: AtomicUsize = AtomicUsize::new(0); |
| 10 | + static V2: AtomicBool = AtomicBool::new(false); |
| 11 | + |
| 12 | + let reg1 = gix::interrupt::init_handler(3, || { |
| 13 | + V1.fetch_add(1, Ordering::SeqCst); |
| 14 | + }) |
| 15 | + .expect("succeeds"); |
| 16 | + assert!(!gix::interrupt::is_triggered()); |
| 17 | + assert_eq!(V1.load(Ordering::Relaxed), 0); |
| 18 | + let reg2 = |
| 19 | + gix::interrupt::init_handler(2, || V2.store(true, Ordering::SeqCst)).expect("multi-initialization is OK"); |
| 20 | + assert!(!V2.load(Ordering::Relaxed)); |
| 21 | + |
| 22 | + signal_hook::low_level::raise(SIGTERM).expect("signal can be raised"); |
| 23 | + assert!(gix::interrupt::is_triggered(), "this happens automatically"); |
| 24 | + assert_eq!(V1.load(Ordering::Relaxed), 1, "the first trigger is invoked"); |
| 25 | + assert!(!V2.load(Ordering::Relaxed), "the second trigger was ignored"); |
| 26 | + |
| 27 | + reg1.deregister()?; |
| 28 | + signal_hook::low_level::raise(SIGTERM).expect("signal can be raised"); |
| 29 | + assert_eq!(V1.load(Ordering::Relaxed), 2, "the first trigger is still invoked"); |
| 30 | + |
| 31 | + assert!(gix::interrupt::is_triggered(), "this happens automatically"); |
| 32 | + // now the registration is actually removed. |
| 33 | + reg2.with_reset(true).deregister()?; |
| 34 | + assert!( |
| 35 | + !gix::interrupt::is_triggered(), |
| 36 | + "the deregistration succeeded and this is an optional side-effect" |
| 37 | + ); |
| 38 | + |
| 39 | + let reg1 = gix::interrupt::init_handler(3, || { |
| 40 | + V1.fetch_add(1, Ordering::SeqCst); |
| 41 | + }) |
| 42 | + .expect("succeeds"); |
| 43 | + assert_eq!(V1.load(Ordering::Relaxed), 2, "nothing changed yet"); |
| 44 | + let reg2 = |
| 45 | + gix::interrupt::init_handler(2, || V2.store(true, Ordering::SeqCst)).expect("multi-initialization is OK"); |
| 46 | + assert!(!V2.load(Ordering::Relaxed)); |
| 47 | + |
| 48 | + signal_hook::low_level::raise(SIGTERM).expect("signal can be raised"); |
| 49 | + assert_eq!(V1.load(Ordering::Relaxed), 3, "the first trigger is invoked"); |
| 50 | + assert!(!V2.load(Ordering::Relaxed), "the second trigger was ignored"); |
| 51 | + |
| 52 | + reg2.auto_deregister(); |
| 53 | + reg1.with_reset(true).auto_deregister(); |
| 54 | + |
| 55 | + assert!( |
| 56 | + !gix::interrupt::is_triggered(), |
| 57 | + "the deregistration succeeded and this is an optional side-effect" |
| 58 | + ); |
| 59 | + |
| 60 | + Ok(()) |
| 61 | + } |
59 | 62 | } |
0 commit comments