mry 0.14.0

A simple but powerful mocking library that supports struct, trait, and function.
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use mry::send_wrapper::SendWrapper;

#[mry::mry]
struct Test {}

#[mry::mry]
impl Test {
    fn get_raw_pointer(&self) -> *mut String {
        Box::into_raw(Box::new(String::from("Hello, world!")))
    }

    fn use_ptr(&self, ptr: *const String, data: u8) -> u8 {
        unsafe {
            println!("{} {}", *ptr, data);
        }
        data
    }

    fn use_mut_ptr(&self, ptr: *mut String, data: u8) -> u8 {
        unsafe {
            println!("{} {}", *ptr, data);
        }
        data
    }

    fn use_ptr_array(&self, ptr: [*mut String; 3], data: u8) -> u8 {
        unsafe {
            println!("{} {}", *ptr[0], data);
        }
        data
    }

    fn use_slice_of_ptr(&self, ptr: &[*mut String], data: u8) -> u8 {
        unsafe {
            println!("{} {}", *ptr[0], data);
        }
        data
    }
}

#[test]
fn test_use_pointer() {
    let mut test = Test {
        mry: Default::default(),
    };
    let ptr1 = Box::into_raw(Box::new(String::from("Hello, world!")));
    test.mock_use_ptr(ptr1 as *const String, 1)
        .returns_with(|_: SendWrapper<*const String>, value| value * 10);
    test.mock_use_ptr(mry::Any, mry::Any).calls_real_impl();
    test.mock_use_mut_ptr(ptr1, 2)
        .returns_with(|_: SendWrapper<*mut String>, value| value * 10);
    test.mock_use_mut_ptr(mry::Any, mry::Any).calls_real_impl();
    let ptr2 = Box::into_raw(Box::new(String::from("Hello, world!"))); // same contents

    assert_eq!(test.use_ptr(ptr1, 1), 10);
    assert_eq!(test.use_mut_ptr(ptr1, 2), 20);
    assert_eq!(test.use_ptr(ptr2, 5), 5);
    assert_eq!(test.use_mut_ptr(ptr2, 6), 6);

    unsafe {
        // Clean up to avoid memory leaks
        let _ = Box::from_raw(ptr1);
        let _ = Box::from_raw(ptr2);
    }
}

#[test]
fn test_raw_pointer_return() {
    let mut test = Test {
        mry: Default::default(),
    };

    // Create a mock string to return
    let mock_ptr = Box::into_raw(Box::new("Mocked value".to_string()));

    // Mock the get_raw_pointer method to return our mock pointer
    // The mock system should handle wrapping it in SendWrapper internally
    test.mock_get_raw_pointer().returns(mock_ptr);

    // Call the method and verify the result
    let result_ptr = test.get_raw_pointer();

    unsafe {
        assert_eq!(*result_ptr, "Mocked value");

        // Clean up to avoid memory leaks
        let _ = Box::from_raw(result_ptr);
    }
}

#[test]
fn test_raw_pointer_return_once() {
    let mut test = Test {
        mry: Default::default(),
    };

    let mock_ptr = Box::into_raw(Box::new("Mocked value".to_string()));
    test.mock_get_raw_pointer().returns_once(mock_ptr);

    let result_ptr = test.get_raw_pointer();

    unsafe {
        assert_eq!(*result_ptr, "Mocked value");

        // Clean up to avoid memory leaks
        let _ = Box::from_raw(result_ptr);
    }
}

#[test]
fn test_raw_pointer_return_with() {
    let mut test = Test {
        mry: Default::default(),
    };

    // Mock the get_raw_pointer method with a dynamic implementation
    test.mock_get_raw_pointer()
        .returns_with(|| Box::into_raw(Box::new("Dynamically created value".to_string())));

    // Call the method and verify the result
    let result_ptr = test.get_raw_pointer();

    unsafe {
        assert_eq!(*result_ptr, "Dynamically created value");

        // Clean up to avoid memory leaks
        let _ = Box::from_raw(result_ptr);
    }
}

#[test]
fn test_use_ptr_array() {
    let mut test = Test {
        mry: Default::default(),
    };
    let ptr1 = Box::into_raw(Box::new(String::from("Hello, world!")));
    let ptr2 = Box::into_raw(Box::new(String::from("Hello, world!")));
    let ptr3 = Box::into_raw(Box::new(String::from("Hello, world!")));
    let ptr_array = [ptr1, ptr2, ptr3];
    test.mock_use_ptr_array(ptr_array, 1)
        .returns_with(|vec: Vec<SendWrapper<*mut String>>, _| vec.len() as u8);
    assert_eq!(test.use_ptr_array(ptr_array, 1), 3);
}

#[test]
fn test_use_slice_of_ptr() {
    let mut test = Test {
        mry: Default::default(),
    };
    let ptr1 = Box::into_raw(Box::new(String::from("Hello, world!")));
    let ptr2 = Box::into_raw(Box::new(String::from("Hello, world!")));
    let ptr3 = Box::into_raw(Box::new(String::from("Hello, world!")));
    let ptr_slice = &[ptr1, ptr2, ptr3] as &[*mut String];
    test.mock_use_slice_of_ptr(ptr_slice, 1)
        .returns_with(|vec: Vec<SendWrapper<*mut String>>, _| vec.len() as u8);
    assert_eq!(test.use_slice_of_ptr(ptr_slice, 1), 3);
}