kernaux-sys 0.0.0

Unsafe no-std binding to libkernaux - auxiliary library for kernel development
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

#[cfg(test)]
use libc::{c_char, c_int};

#[cfg(test)]
#[link(name = "kernaux")]
extern "C" {
    fn kernaux_utoa(
        value: u64,
        buffer: *mut c_char,
        base: c_int,
    ) -> *mut c_char;
    fn kernaux_itoa(
        value: i64,
        buffer: *mut c_char,
        base: c_int,
    ) -> *mut c_char;
    fn kernaux_utoa10(value: u64, buffer: *mut c_char);
    fn kernaux_itoa10(value: i64, buffer: *mut c_char);
    fn kernaux_utoa16(value: u64, buffer: *mut c_char);
    fn kernaux_itoa16(value: i64, buffer: *mut c_char);
}

#[cfg(test)]
mod tests {
    use super::*;

    use std::ffi::CStr;

    #[test]
    fn utoa() {
        let mut buffer: [i8; 1000] = [0; 1000];
        let end: *mut c_char =
            unsafe { kernaux_utoa(0x123, buffer.as_mut_ptr(), 'x' as c_int) };
        let result =
            unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_str().unwrap();
        assert_eq!(result, "123");
        assert_eq!(end, unsafe { buffer.as_mut_ptr().offset(3) });
    }

    #[test]
    fn itoa() {
        let mut buffer: [i8; 1000] = [0; 1000];
        let end: *mut c_char =
            unsafe { kernaux_itoa(0x123, buffer.as_mut_ptr(), 'x' as c_int) };
        let result =
            unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_str().unwrap();
        assert_eq!(result, "123");
        assert_eq!(end, unsafe { buffer.as_mut_ptr().offset(3) });

        let mut buffer: [i8; 1000] = [0; 1000];
        let end: *mut c_char =
            unsafe { kernaux_itoa(-0x123, buffer.as_mut_ptr(), 'x' as c_int) };
        let result =
            unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_str().unwrap();
        assert_eq!(result, "-123");
        assert_eq!(end, unsafe { buffer.as_mut_ptr().offset(4) });
    }

    #[test]
    fn utoa10() {
        let mut buffer: [i8; 1000] = [0; 1000];
        unsafe { kernaux_utoa10(123, buffer.as_mut_ptr()) };
        let result =
            unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_str().unwrap();
        assert_eq!(result, "123");
    }

    #[test]
    fn itoa10() {
        let mut buffer: [i8; 1000] = [0; 1000];
        unsafe { kernaux_itoa10(123, buffer.as_mut_ptr()) };
        let result =
            unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_str().unwrap();
        assert_eq!(result, "123");

        let mut buffer: [i8; 1000] = [0; 1000];
        unsafe { kernaux_itoa10(-123, buffer.as_mut_ptr()) };
        let result =
            unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_str().unwrap();
        assert_eq!(result, "-123");
    }

    #[test]
    fn utoa16() {
        let mut buffer: [i8; 1000] = [0; 1000];
        unsafe { kernaux_utoa16(0x123, buffer.as_mut_ptr()) };
        let result =
            unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_str().unwrap();
        assert_eq!(result, "123");
    }

    #[test]
    fn itoa16() {
        let mut buffer: [i8; 1000] = [0; 1000];
        unsafe { kernaux_itoa16(0x123, buffer.as_mut_ptr()) };
        let result =
            unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_str().unwrap();
        assert_eq!(result, "123");

        let mut buffer: [i8; 1000] = [0; 1000];
        unsafe { kernaux_itoa16(-0x123, buffer.as_mut_ptr()) };
        let result =
            unsafe { CStr::from_ptr(buffer.as_ptr()) }.to_str().unwrap();
        assert_eq!(result, "-123");
    }
}