1 #![allow(
2 clippy::assertions_on_constants,
3 clippy::cast_possible_truncation,
4 clippy::cast_possible_wrap,
5 clippy::float_cmp,
6 clippy::needless_pass_by_value,
7 clippy::unit_cmp,
8 clippy::unseparated_literal_suffix
9 )]
10
11 use cxx::SharedPtr;
12 use cxx_test_suite::module::ffi2;
13 use cxx_test_suite::{cast, ffi, R};
14 use std::cell::Cell;
15 use std::ffi::CStr;
16
17 thread_local! {
18 static CORRECT: Cell<bool> = Cell::new(false);
19 }
20
21 #[no_mangle]
cxx_test_suite_set_correct()22 extern "C" fn cxx_test_suite_set_correct() {
23 CORRECT.with(|correct| correct.set(true));
24 }
25
26 macro_rules! check {
27 ($run:expr) => {{
28 CORRECT.with(|correct| correct.set(false));
29 $run;
30 assert!(CORRECT.with(Cell::get), "{}", stringify!($run));
31 }};
32 }
33
34 #[test]
test_c_return()35 fn test_c_return() {
36 let shared = ffi::Shared { z: 2020 };
37 let ns_shared = ffi::AShared { z: 2020 };
38 let nested_ns_shared = ffi::ABShared { z: 2020 };
39
40 assert_eq!(2020, ffi::c_return_primitive());
41 assert_eq!(2020, ffi::c_return_shared().z);
42 assert_eq!(2020, ffi::c_return_box().0);
43 ffi::c_return_unique_ptr();
44 ffi2::c_return_ns_unique_ptr();
45 assert_eq!(2020, *ffi::c_return_ref(&shared));
46 assert_eq!(2020, *ffi::c_return_ns_ref(&ns_shared));
47 assert_eq!(2020, *ffi::c_return_nested_ns_ref(&nested_ns_shared));
48 assert_eq!("2020", ffi::c_return_str(&shared));
49 assert_eq!(
50 b"2020\0",
51 cast::c_char_to_unsigned(ffi::c_return_slice_char(&shared)),
52 );
53 assert_eq!("2020", ffi::c_return_rust_string());
54 assert_eq!("2020", ffi::c_return_unique_ptr_string().to_str().unwrap());
55 assert_eq!(4, ffi::c_return_unique_ptr_vector_u8().len());
56 assert_eq!(
57 200_u8,
58 ffi::c_return_unique_ptr_vector_u8().into_iter().sum(),
59 );
60 assert_eq!(
61 200.5_f64,
62 ffi::c_return_unique_ptr_vector_f64().into_iter().sum(),
63 );
64 assert_eq!(2, ffi::c_return_unique_ptr_vector_shared().len());
65 assert_eq!(
66 2021_usize,
67 ffi::c_return_unique_ptr_vector_shared()
68 .into_iter()
69 .map(|o| o.z)
70 .sum(),
71 );
72 assert_eq!(2020, ffi::c_return_identity(2020));
73 assert_eq!(2021, ffi::c_return_sum(2020, 1));
74 match ffi::c_return_enum(0) {
75 enm @ ffi::Enum::AVal => assert_eq!(0, enm.repr),
76 _ => assert!(false),
77 }
78 match ffi::c_return_enum(1) {
79 enm @ ffi::Enum::BVal => assert_eq!(2020, enm.repr),
80 _ => assert!(false),
81 }
82 match ffi::c_return_enum(2021) {
83 enm @ ffi::Enum::LastVal => assert_eq!(2021, enm.repr),
84 _ => assert!(false),
85 }
86 match ffi::c_return_ns_enum(0) {
87 enm @ ffi::AEnum::AAVal => assert_eq!(0, enm.repr),
88 _ => assert!(false),
89 }
90 match ffi::c_return_nested_ns_enum(0) {
91 enm @ ffi::ABEnum::ABAVal => assert_eq!(0, enm.repr),
92 _ => assert!(false),
93 }
94 }
95
96 #[test]
test_c_try_return()97 fn test_c_try_return() {
98 assert_eq!((), ffi::c_try_return_void().unwrap());
99 assert_eq!(2020, ffi::c_try_return_primitive().unwrap());
100 assert_eq!(
101 "logic error",
102 ffi::c_fail_return_primitive().unwrap_err().what(),
103 );
104 assert_eq!(2020, ffi::c_try_return_box().unwrap().0);
105 assert_eq!("2020", *ffi::c_try_return_ref(&"2020".to_owned()).unwrap());
106 assert_eq!("2020", ffi::c_try_return_str("2020").unwrap());
107 assert_eq!(b"2020", ffi::c_try_return_sliceu8(b"2020").unwrap());
108 assert_eq!("2020", ffi::c_try_return_rust_string().unwrap());
109 assert_eq!("2020", &*ffi::c_try_return_unique_ptr_string().unwrap());
110 }
111
112 #[test]
test_c_take()113 fn test_c_take() {
114 let unique_ptr = ffi::c_return_unique_ptr();
115 let unique_ptr_ns = ffi2::c_return_ns_unique_ptr();
116
117 check!(ffi::c_take_primitive(2020));
118 check!(ffi::c_take_shared(ffi::Shared { z: 2020 }));
119 check!(ffi::c_take_ns_shared(ffi::AShared { z: 2020 }));
120 check!(ffi::ns_c_take_ns_shared(ffi::AShared { z: 2020 }));
121 check!(ffi::c_take_nested_ns_shared(ffi::ABShared { z: 2020 }));
122 check!(ffi::c_take_box(Box::new(R(2020))));
123 check!(ffi::c_take_ref_c(&unique_ptr));
124 check!(ffi2::c_take_ref_ns_c(&unique_ptr_ns));
125 check!(cxx_test_suite::module::ffi::c_take_unique_ptr(unique_ptr));
126 check!(ffi::c_take_str("2020"));
127 check!(ffi::c_take_slice_char(cast::unsigned_to_c_char(b"2020")));
128 check!(ffi::c_take_slice_shared(&[
129 ffi::Shared { z: 2020 },
130 ffi::Shared { z: 2021 },
131 ]));
132 let shared_sort_slice = &mut [
133 ffi::Shared { z: 2 },
134 ffi::Shared { z: 0 },
135 ffi::Shared { z: 7 },
136 ffi::Shared { z: 4 },
137 ];
138 check!(ffi::c_take_slice_shared_sort(shared_sort_slice));
139 assert_eq!(shared_sort_slice[0].z, 0);
140 assert_eq!(shared_sort_slice[1].z, 2);
141 assert_eq!(shared_sort_slice[2].z, 4);
142 assert_eq!(shared_sort_slice[3].z, 7);
143 let r_sort_slice = &mut [R(2020), R(2050), R(2021)];
144 check!(ffi::c_take_slice_r(r_sort_slice));
145 check!(ffi::c_take_slice_r_sort(r_sort_slice));
146 assert_eq!(r_sort_slice[0].0, 2020);
147 assert_eq!(r_sort_slice[1].0, 2021);
148 assert_eq!(r_sort_slice[2].0, 2050);
149 check!(ffi::c_take_rust_string("2020".to_owned()));
150 check!(ffi::c_take_unique_ptr_string(
151 ffi::c_return_unique_ptr_string()
152 ));
153 check!(ffi::c_take_unique_ptr_vector_u8(
154 ffi::c_return_unique_ptr_vector_u8()
155 ));
156 check!(ffi::c_take_unique_ptr_vector_f64(
157 ffi::c_return_unique_ptr_vector_f64()
158 ));
159 check!(ffi::c_take_unique_ptr_vector_shared(
160 ffi::c_return_unique_ptr_vector_shared()
161 ));
162 check!(ffi::c_take_ref_vector(&ffi::c_return_unique_ptr_vector_u8()));
163 let test_vec = [86_u8, 75_u8, 30_u8, 9_u8].to_vec();
164 check!(ffi::c_take_rust_vec(test_vec.clone()));
165 check!(ffi::c_take_rust_vec_index(test_vec.clone()));
166 let shared_test_vec = vec![ffi::Shared { z: 1010 }, ffi::Shared { z: 1011 }];
167 check!(ffi::c_take_rust_vec_shared(shared_test_vec.clone()));
168 check!(ffi::c_take_rust_vec_shared_index(shared_test_vec.clone()));
169 check!(ffi::c_take_rust_vec_shared_push(shared_test_vec.clone()));
170 check!(ffi::c_take_rust_vec_shared_forward_iterator(
171 shared_test_vec,
172 ));
173 let shared_sort_vec = vec![
174 ffi::Shared { z: 2 },
175 ffi::Shared { z: 0 },
176 ffi::Shared { z: 7 },
177 ffi::Shared { z: 4 },
178 ];
179 check!(ffi::c_take_rust_vec_shared_sort(shared_sort_vec));
180 check!(ffi::c_take_ref_rust_vec(&test_vec));
181 check!(ffi::c_take_ref_rust_vec_index(&test_vec));
182 check!(ffi::c_take_ref_rust_vec_copy(&test_vec));
183 check!(ffi::c_take_ref_shared_string(&ffi::SharedString {
184 msg: "2020".to_owned()
185 }));
186 let ns_shared_test_vec = vec![ffi::AShared { z: 1010 }, ffi::AShared { z: 1011 }];
187 check!(ffi::c_take_rust_vec_ns_shared(ns_shared_test_vec));
188 let nested_ns_shared_test_vec = vec![ffi::ABShared { z: 1010 }, ffi::ABShared { z: 1011 }];
189 check!(ffi::c_take_rust_vec_nested_ns_shared(
190 nested_ns_shared_test_vec
191 ));
192
193 check!(ffi::c_take_enum(ffi::Enum::AVal));
194 check!(ffi::c_take_ns_enum(ffi::AEnum::AAVal));
195 check!(ffi::c_take_nested_ns_enum(ffi::ABEnum::ABAVal));
196 }
197
198 #[test]
test_c_callback()199 fn test_c_callback() {
200 fn callback(s: String) -> usize {
201 if s == "2020" {
202 cxx_test_suite_set_correct();
203 }
204 0
205 }
206
207 check!(ffi::c_take_callback(callback));
208 }
209
210 #[test]
test_c_call_r()211 fn test_c_call_r() {
212 fn cxx_run_test() {
213 extern "C" {
214 fn cxx_run_test() -> *const i8;
215 }
216 let failure = unsafe { cxx_run_test() };
217 if !failure.is_null() {
218 let msg = unsafe { CStr::from_ptr(failure as *mut std::os::raw::c_char) };
219 eprintln!("{}", msg.to_string_lossy());
220 }
221 }
222 check!(cxx_run_test());
223 }
224
225 #[test]
test_c_method_calls()226 fn test_c_method_calls() {
227 let mut unique_ptr = ffi::c_return_unique_ptr();
228
229 let old_value = unique_ptr.get();
230 assert_eq!(2020, old_value);
231 assert_eq!(2021, unique_ptr.pin_mut().set(2021));
232 assert_eq!(2021, unique_ptr.get());
233 assert_eq!(2021, unique_ptr.get2());
234 assert_eq!(2021, *unique_ptr.getRef());
235 assert_eq!(2021, *unique_ptr.pin_mut().getMut());
236 assert_eq!(2022, unique_ptr.pin_mut().set_succeed(2022).unwrap());
237 assert!(unique_ptr.pin_mut().get_fail().is_err());
238 assert_eq!(2021, ffi::Shared { z: 0 }.c_method_on_shared());
239 assert_eq!(2022, *ffi::Shared { z: 2022 }.c_method_ref_on_shared());
240 assert_eq!(2023, *ffi::Shared { z: 2023 }.c_method_mut_on_shared());
241
242 let val = 42;
243 let mut array = ffi::Array { a: [0, 0, 0, 0] };
244 array.c_set_array(val);
245 assert_eq!(array.a.len() as i32 * val, array.r_get_array_sum());
246 }
247
248 #[test]
test_shared_ptr_weak_ptr()249 fn test_shared_ptr_weak_ptr() {
250 let shared_ptr = ffi::c_return_shared_ptr();
251 let weak_ptr = SharedPtr::downgrade(&shared_ptr);
252 assert_eq!(1, ffi::c_get_use_count(&weak_ptr));
253
254 assert!(!weak_ptr.upgrade().is_null());
255 assert_eq!(1, ffi::c_get_use_count(&weak_ptr));
256
257 drop(shared_ptr);
258 assert_eq!(0, ffi::c_get_use_count(&weak_ptr));
259 assert!(weak_ptr.upgrade().is_null());
260 }
261
262 #[test]
test_c_ns_method_calls()263 fn test_c_ns_method_calls() {
264 let unique_ptr = ffi2::ns_c_return_unique_ptr_ns();
265
266 let old_value = unique_ptr.get();
267 assert_eq!(1000, old_value);
268 }
269
270 #[test]
test_enum_representations()271 fn test_enum_representations() {
272 assert_eq!(0, ffi::Enum::AVal.repr);
273 assert_eq!(2020, ffi::Enum::BVal.repr);
274 assert_eq!(2021, ffi::Enum::LastVal.repr);
275 }
276
277 #[test]
test_debug()278 fn test_debug() {
279 assert_eq!("Shared { z: 1 }", format!("{:?}", ffi::Shared { z: 1 }));
280 assert_eq!("BVal", format!("{:?}", ffi::Enum::BVal));
281 assert_eq!("Enum(9)", format!("{:?}", ffi::Enum { repr: 9 }));
282 }
283
284 #[no_mangle]
cxx_test_suite_get_box() -> *mut R285 extern "C" fn cxx_test_suite_get_box() -> *mut R {
286 Box::into_raw(Box::new(R(2020usize)))
287 }
288
289 #[no_mangle]
cxx_test_suite_r_is_correct(r: *const R) -> bool290 unsafe extern "C" fn cxx_test_suite_r_is_correct(r: *const R) -> bool {
291 (*r).0 == 2020
292 }
293
294 #[test]
test_rust_name_attribute()295 fn test_rust_name_attribute() {
296 assert_eq!("2020", ffi::i32_overloaded_function(2020));
297 assert_eq!("2020", ffi::str_overloaded_function("2020"));
298 let unique_ptr = ffi::c_return_unique_ptr();
299 assert_eq!("2020", unique_ptr.i32_overloaded_method(2020));
300 assert_eq!("2020", unique_ptr.str_overloaded_method("2020"));
301 }
302
303 #[test]
test_extern_trivial()304 fn test_extern_trivial() {
305 let mut d = ffi2::c_return_trivial();
306 check!(ffi2::c_take_trivial_ref(&d));
307 check!(d.c_take_trivial_ref_method());
308 check!(d.c_take_trivial_mut_ref_method());
309 check!(ffi2::c_take_trivial(d));
310 let mut d = ffi2::c_return_trivial_ptr();
311 check!(d.c_take_trivial_ref_method());
312 check!(d.c_take_trivial_mut_ref_method());
313 check!(ffi2::c_take_trivial_ptr(d));
314 cxx::UniquePtr::new(ffi2::D { d: 42 });
315 let d = ffi2::ns_c_return_trivial();
316 check!(ffi2::ns_c_take_trivial(d));
317
318 let g = ffi2::c_return_trivial_ns();
319 check!(ffi2::c_take_trivial_ns_ref(&g));
320 check!(ffi2::c_take_trivial_ns(g));
321 let g = ffi2::c_return_trivial_ns_ptr();
322 check!(ffi2::c_take_trivial_ns_ptr(g));
323 cxx::UniquePtr::new(ffi2::G { g: 42 });
324 }
325
326 #[test]
test_extern_opaque()327 fn test_extern_opaque() {
328 let mut e = ffi2::c_return_opaque_ptr();
329 check!(ffi2::c_take_opaque_ref(e.as_ref().unwrap()));
330 check!(e.c_take_opaque_ref_method());
331 check!(e.pin_mut().c_take_opaque_mut_ref_method());
332 check!(ffi2::c_take_opaque_ptr(e));
333
334 let f = ffi2::c_return_ns_opaque_ptr();
335 check!(ffi2::c_take_opaque_ns_ref(f.as_ref().unwrap()));
336 check!(ffi2::c_take_opaque_ns_ptr(f));
337 }
338
339 #[test]
test_raw_ptr()340 fn test_raw_ptr() {
341 let c = ffi::c_return_mut_ptr(2023);
342 let mut c_unique = unsafe { cxx::UniquePtr::from_raw(c) };
343 assert_eq!(2023, c_unique.pin_mut().set_succeed(2023).unwrap());
344 // c will be dropped as it's now in a UniquePtr
345
346 let c2 = ffi::c_return_mut_ptr(2024);
347 assert_eq!(2024, unsafe { ffi::c_take_const_ptr(c2) });
348 assert_eq!(2024, unsafe { ffi::c_take_mut_ptr(c2) }); // deletes c2
349
350 let c3 = ffi::c_return_const_ptr(2025);
351 assert_eq!(2025, unsafe { ffi::c_take_const_ptr(c3) });
352 assert_eq!(2025, unsafe { ffi::c_take_mut_ptr(c3 as *mut ffi::C) }); // deletes c3
353 }
354