ntsync 0.4.0

An simple crate for using the new ntsync linux driver with rust.
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

use std::time::{
    Duration,
    SystemTime,
};

use log::*;
use ntsync::{
    Error,
    NTSyncObjects,
    NtSync,
    NtSyncFlags,
    OwnerId,
};
use rstest::rstest;
use std::collections::HashSet;
use test_log::test;

mod fixtures;
use fixtures::*;

macro_rules! test_op {
    ($object_op:expr, $op_name:literal) => {
        match $object_op {
            Err(Error::AlreadyClosed) => {},
            Err(other) => {
                error!("{} returned {:?} not {:?}", $op_name, other, Error::AlreadyClosed);
                return Err(other);
            },
            Ok(_) => {
                error!("{} returned Ok not {:?}", $op_name, Error::InvalidValue);
                return Err(Error::InvalidValue);
            },
        }
    };
}

fn common_tests<T: NTSyncObjects>(object: T, instance: NtSync) -> Result<(), Error> {
    let result = instance.wait_any(
        {
            let mut s = HashSet::with_capacity(1);
            s.insert(object.into());
            s
        },
        Some(SystemTime::now() + Duration::from_millis(200)),
        Some(OwnerId::random()),
        NtSyncFlags::default(),
        None,
    );
    match result {
        Ok(_) => return Err(Error::InvalidValue),
        Err(Error::InvalidValue) => {},
        Err(error) => {
            info!("got unexpected error on after trying to wait on object: {error}");
            return Err(error);
        },
    }
    test_op!(object.read(), "object.read");
    test_op!(object.delete(), "object.delete");
    Ok(())
}

#[test(rstest)]
fn delete_event(instance: NtSync) -> Result<(), Error> {
    let object = instance.new_event(true, false)?;
    if let Err(error) = object.delete() {
        error!("Failed to delete event: {error}");
        return Err(error);
    }
    common_tests(object, instance)?;
    test_op!(object.pulse(), "object.pulse");
    test_op!(object.signal(), "object.signal");
    test_op!(object.reset(), "object.reset");
    Ok(())
}

#[test(rstest)]
fn delete_mutex(instance: NtSync) -> Result<(), Error> {
    let object = instance.new_mutex()?;
    if let Err(error) = object.delete() {
        error!("Failed to delete event: {error}");
        return Err(error);
    }
    common_tests(object, instance)?;
    test_op!(object.kill(OwnerId::random()), "object.kill");
    test_op!(object.unlock(OwnerId::random()), "object.unlock");
    Ok(())
}

#[test(rstest)]
fn delete_semaphore(instance: NtSync) -> Result<(), Error> {
    let object = instance.new_semaphore(1)?;
    if let Err(error) = object.delete() {
        error!("Failed to delete event: {error}");
        return Err(error);
    }
    common_tests(object, instance)?;
    Ok(())
}