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