wslplugins-rs 0.1.0-beta.3

A Rust framework for developing WSL plugins using safe and idiomatic 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

use std::ffi::OsString;
#[cfg(test)]
use std::mem::{align_of, size_of};
use std::os::windows::ffi::OsStringExt as _;
use windows_core::PCWSTR;
#[cfg(test)]
pub fn test_transparence<T, U>() {
    assert_eq!(align_of::<T>(), align_of::<U>());
    assert_eq!(size_of::<T>(), size_of::<U>());
}

pub fn opt_wide_str(ptr: *const u16) -> Option<OsString> {
    if ptr.is_null() {
        None
    } else {
        let wide_str = PCWSTR::from_raw(ptr);
        // SAFETY: The caller guarantees that `ptr` is valid and points to a null-terminated wide string.
        unsafe {
            let wide = wide_str.as_wide();
            if wide.is_empty() {
                None
            } else {
                Some(OsString::from_wide(wide))
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use proptest::prelude::*;
    #[test]
    fn test_empty_as_wide_null() {
        let ptr = std::ptr::null();
        assert_eq!(opt_wide_str(ptr), None);
    }

    #[test]
    fn test_empty_as_wide_empty() {
        let wide_str = [0u16; 1];
        assert_eq!(opt_wide_str(wide_str.as_ptr()), None);
    }

    fn null_terminated_wide() -> impl Strategy<Value = Vec<u16>> {
        let unit = prop_oneof![(1u16..=0xD7FF), (0xE000u16..=0xFFFF),];

        proptest::collection::vec(unit, 0..100).prop_map(|wide| {
            let mut wide: Vec<u16> = wide;
            wide.push(0);
            wide
        })
    }

    proptest! {
        #[test]
        fn test_opt_wide_str_non_empty(wide in null_terminated_wide()) {
            prop_assume!(wide.len() > 1);

            let ptr = wide.as_ptr();

            let result = opt_wide_str(ptr);
            #[allow(clippy::indexing_slicing, reason="Safe because we know the last element is the null terminator")]
            let expected = OsString::from_wide(&wide[..wide.len() - 1]);

            prop_assert_eq!(result, Some(expected));
        }
    }
}