openharmony/third_party_rust_cxx
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_rust_cxx synced 2024-11-28 01:41:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
15a6c76352
third_party_rust_cxx/tests/test.rs

179 lines
5.3 KiB
Rust
Raw Normal View History

Test rust calling to c++
2020-01-27 01:47:11 +00:00
use cxx_test_suite::ffi;
use std::cell::Cell;
Test c++ calling to rust
2020-02-23 03:55:43 +00:00
use std::ffi::CStr;
Test rust calling to c++
2020-01-27 01:47:11 +00:00
thread_local! {
static CORRECT: Cell<bool> = Cell::new(false);
}
#[no_mangle]
extern "C" fn cxx_test_suite_set_correct() {
CORRECT.with(|correct| correct.set(true));
}
Test c++ calling to rust
2020-02-23 03:55:43 +00:00
macro_rules! check {
($run:expr) => {{
CORRECT.with(|correct| correct.set(false));
$run;
assert!(CORRECT.with(|correct| correct.get()), stringify!($run));
}};
}
Test rust calling to c++
2020-01-27 01:47:11 +00:00
#[test]
fn test_c_return() {
let shared = ffi::Shared { z: 2020 };
assert_eq!(2020, ffi::c_return_primitive());
assert_eq!(2020, ffi::c_return_shared().z);
Test Box returned from C++ to Rust
2020-03-06 23:45:39 +00:00
assert_eq!(2020, *ffi::c_return_box());
Test rust calling to c++
2020-01-27 01:47:11 +00:00
ffi::c_return_unique_ptr();
assert_eq!(2020, *ffi::c_return_ref(&shared));
assert_eq!("2020", ffi::c_return_str(&shared));
Adding missing tests; fixing typo.
2020-04-14 23:09:58 +00:00
assert_eq!(b"2020\0", ffi::c_return_sliceu8(&shared));
Test rust calling to c++
2020-01-27 01:47:11 +00:00
assert_eq!("2020", ffi::c_return_rust_string());
Rely on UniquePtr Deref impl in tests
2020-04-17 22:02:16 +00:00
assert_eq!("2020", ffi::c_return_unique_ptr_string().to_str().unwrap());
Rename CxxVector::size to len to match Rust conventions
2020-04-24 20:30:44 +00:00
assert_eq!(4, ffi::c_return_unique_ptr_vector_u8().len());
C++ std::vector<T> and Rust std::vec::Vec<T> support Add basic std::vector and std::vec::Vec support across FFI boundary.
2020-02-05 12:41:51 +00:00
assert_eq!(
200_u8,
Simplify vector tests using UniquePtr deref
2020-04-25 20:08:38 +00:00
ffi::c_return_unique_ptr_vector_u8().into_iter().sum(),
C++ std::vector<T> and Rust std::vec::Vec<T> support Add basic std::vector and std::vec::Vec support across FFI boundary.
2020-02-05 12:41:51 +00:00
);
assert_eq!(
200.5_f64,
Simplify vector tests using UniquePtr deref
2020-04-25 20:08:38 +00:00
ffi::c_return_unique_ptr_vector_f64().into_iter().sum(),
C++ std::vector<T> and Rust std::vec::Vec<T> support Add basic std::vector and std::vec::Vec support across FFI boundary.
2020-02-05 12:41:51 +00:00
);
Rename CxxVector::size to len to match Rust conventions
2020-04-24 20:30:44 +00:00
assert_eq!(2, ffi::c_return_unique_ptr_vector_shared().len());
C++ std::vector<T> and Rust std::vec::Vec<T> support Add basic std::vector and std::vec::Vec support across FFI boundary.
2020-02-05 12:41:51 +00:00
assert_eq!(
2021_usize,
ffi::c_return_unique_ptr_vector_shared()
.into_iter()
.map(|o| o.z)
Simplify vector tests using UniquePtr deref
2020-04-25 20:08:38 +00:00
.sum(),
C++ std::vector<T> and Rust std::vec::Vec<T> support Add basic std::vector and std::vec::Vec support across FFI boundary.
2020-02-05 12:41:51 +00:00
);
Allow wildcard argument names. This adds support for wildcard variable names by internally giving them unique names.
2020-04-27 22:55:45 +00:00
assert_eq!(2020, ffi::c_return_identity(2020));
assert_eq!(2021, ffi::c_return_sum(2020, 1));
Support C-style enums This adds support for passing C-style enums between Rust and C++. We use the Rust representation for enums suggested by dtolnay in #132. Note that as this does not use real enums, Rust code cannot treat them as normal enums, e.g., by converting them to integers. But common uses such as pattern matching remain unchanged.
2020-04-24 00:31:09 +00:00
match ffi::c_return_enum(0) {
Expose the enum value to Rust as a field
2020-05-01 20:57:32 +00:00
enm @ ffi::Enum::AVal => assert_eq!(0, enm.repr),
Support C-style enums This adds support for passing C-style enums between Rust and C++. We use the Rust representation for enums suggested by dtolnay in #132. Note that as this does not use real enums, Rust code cannot treat them as normal enums, e.g., by converting them to integers. But common uses such as pattern matching remain unchanged.
2020-04-24 00:31:09 +00:00
_ => assert!(false),
}
match ffi::c_return_enum(1) {
Expose the enum value to Rust as a field
2020-05-01 20:57:32 +00:00
enm @ ffi::Enum::BVal => assert_eq!(2020, enm.repr),
Support C-style enums This adds support for passing C-style enums between Rust and C++. We use the Rust representation for enums suggested by dtolnay in #132. Note that as this does not use real enums, Rust code cannot treat them as normal enums, e.g., by converting them to integers. But common uses such as pattern matching remain unchanged.
2020-04-24 00:31:09 +00:00
_ => assert!(false),
}
match ffi::c_return_enum(2021) {
Expose the enum value to Rust as a field
2020-05-01 20:57:32 +00:00
enm @ ffi::Enum::CVal => assert_eq!(2021, enm.repr),
Support C-style enums This adds support for passing C-style enums between Rust and C++. We use the Rust representation for enums suggested by dtolnay in #132. Note that as this does not use real enums, Rust code cannot treat them as normal enums, e.g., by converting them to integers. But common uses such as pattern matching remain unchanged.
2020-04-24 00:31:09 +00:00
_ => assert!(false),
}
Implement and test some more fallible return types
2020-03-25 20:07:35 +00:00
}
Implement fallible C++ functions
2020-03-17 22:33:47 +00:00
Implement and test some more fallible return types
2020-03-25 20:07:35 +00:00
#[test]
fn test_c_try_return() {
Implement fallible C++ functions
2020-03-17 22:33:47 +00:00
assert_eq!((), ffi::c_try_return_void().unwrap());
assert_eq!(2020, ffi::c_try_return_primitive().unwrap());
assert_eq!(
"logic error",
ffi::c_fail_return_primitive().unwrap_err().what(),
);
Implement and test some more fallible return types
2020-03-25 20:07:35 +00:00
assert_eq!(2020, *ffi::c_try_return_box().unwrap());
assert_eq!("2020", *ffi::c_try_return_ref(&"2020".to_owned()).unwrap());
assert_eq!("2020", ffi::c_try_return_str("2020").unwrap());
Adding missing tests; fixing typo.
2020-04-14 23:09:58 +00:00
assert_eq!(b"2020", ffi::c_try_return_sliceu8(b"2020").unwrap());
Implement and test some more fallible return types
2020-03-25 20:07:35 +00:00
assert_eq!("2020", ffi::c_try_return_rust_string().unwrap());
Rely on UniquePtr Deref impl in tests
2020-04-17 22:02:16 +00:00
assert_eq!("2020", &*ffi::c_try_return_unique_ptr_string().unwrap());
Test rust calling to c++
2020-01-27 01:47:11 +00:00
}
#[test]
fn test_c_take() {
let unique_ptr = ffi::c_return_unique_ptr();
check!(ffi::c_take_primitive(2020));
check!(ffi::c_take_shared(ffi::Shared { z: 2020 }));
Test Box returned from C++ to Rust
2020-03-06 23:45:39 +00:00
check!(ffi::c_take_box(Box::new(2020)));
Rely on UniquePtr Deref impl in tests
2020-04-17 22:02:16 +00:00
check!(ffi::c_take_ref_c(&unique_ptr));
Test rust calling to c++
2020-01-27 01:47:11 +00:00
check!(ffi::c_take_unique_ptr(unique_ptr));
check!(ffi::c_take_str("2020"));
Adding &[u8] support. This change adds specifically, support for &[u8] with a corresponding rust::Slice<uint8_t> type. No other types of slice are permitted. The rationale is that it may be common to pass binary data back and forth across the FFI boundary, so it's more urgent to get this in place sooner. Broader support for other slices can wait for the future. But, both C++ and Rust-side bindings should allow the existing support to be broadened to other Slice types in future without code changes. A few specific notes: * The name "rust::Slice" might be better as "rust::SliceRef" but I'm following the precedent of "rust::Str". * It would be good to add constructors from std::span but as that's a C++20 feature, that may have to wait until C++ feature detection is resolved. * Internally, this follows the pattern of &str, where the parser will initially recognize this as Type::Ref (of Type::Slice) but then will replace that with Type::SliceRefU8. Type::Slice should not persist through later stages. As we later come to support other types of slice, we would probably want to remove Type::SliceRefU8.
2020-04-13 23:50:14 +00:00
check!(ffi::c_take_sliceu8(b"2020"));
Test rust calling to c++
2020-01-27 01:47:11 +00:00
check!(ffi::c_take_rust_string("2020".to_owned()));
check!(ffi::c_take_unique_ptr_string(
ffi::c_return_unique_ptr_string()
));
C++ std::vector<T> and Rust std::vec::Vec<T> support Add basic std::vector and std::vec::Vec support across FFI boundary.
2020-02-05 12:41:51 +00:00
check!(ffi::c_take_unique_ptr_vector_u8(
ffi::c_return_unique_ptr_vector_u8()
));
check!(ffi::c_take_unique_ptr_vector_f64(
ffi::c_return_unique_ptr_vector_f64()
));
check!(ffi::c_take_unique_ptr_vector_shared(
ffi::c_return_unique_ptr_vector_shared()
));
Test passing CxxVector by reference from Rust to C
2020-04-25 20:58:18 +00:00
check!(ffi::c_take_ref_vector(&ffi::c_return_unique_ptr_vector_u8()));
Add all std::iterator_traits required types to const_iterator of rust::Vec<T> (#157) https://en.cppreference.com/w/cpp/iterator/iterator_traits `std::iterator_traits` requires the following 5 types: - `difference_type` - a signed integer type that can be used to identify distance between iterators - `value_type` - the type of the values that can be obtained by dereferencing the iterator. This type is void for output iterators. - `pointer` - defines a pointer to the type iterated over (value_type) - `reference` - defines a reference to the type iterated over (value_type) - `iterator_category` - the category of the iterator. Must be one of iterator category tags. The current `const_iterator` for `rust::Vec<T>` only defined `value_type` and `reference` which caused an error when using `std::copy` on gcc 7.5.0 on Ubuntu but seemed to work fine on MacOS.
2020-04-28 22:47:23 +00:00
let test_vec = [86_u8, 75_u8, 30_u8, 9_u8].to_vec();
check!(ffi::c_take_rust_vec(test_vec.clone()));
Fix and test passing Vec by value from Rust to C
2020-04-25 23:16:45 +00:00
check!(ffi::c_take_rust_vec_shared(vec![
C++ std::vector<T> and Rust std::vec::Vec<T> support Add basic std::vector and std::vec::Vec support across FFI boundary.
2020-02-05 12:41:51 +00:00
ffi::Shared { z: 1010 },
ffi::Shared { z: 1011 }
]));
Add all std::iterator_traits required types to const_iterator of rust::Vec<T> (#157) https://en.cppreference.com/w/cpp/iterator/iterator_traits `std::iterator_traits` requires the following 5 types: - `difference_type` - a signed integer type that can be used to identify distance between iterators - `value_type` - the type of the values that can be obtained by dereferencing the iterator. This type is void for output iterators. - `pointer` - defines a pointer to the type iterated over (value_type) - `reference` - defines a reference to the type iterated over (value_type) - `iterator_category` - the category of the iterator. Must be one of iterator category tags. The current `const_iterator` for `rust::Vec<T>` only defined `value_type` and `reference` which caused an error when using `std::copy` on gcc 7.5.0 on Ubuntu but seemed to work fine on MacOS.
2020-04-28 22:47:23 +00:00
check!(ffi::c_take_rust_vec_shared_forward_iterator(vec![
ffi::Shared { z: 1010 },
ffi::Shared { z: 1011 }
]));
check!(ffi::c_take_ref_rust_vec(&test_vec));
check!(ffi::c_take_ref_rust_vec_copy(&test_vec));
Support C-style enums This adds support for passing C-style enums between Rust and C++. We use the Rust representation for enums suggested by dtolnay in #132. Note that as this does not use real enums, Rust code cannot treat them as normal enums, e.g., by converting them to integers. But common uses such as pattern matching remain unchanged.
2020-04-24 00:31:09 +00:00
check!(ffi::c_take_enum(ffi::Enum::AVal));
Test rust calling to c++
2020-01-27 01:47:11 +00:00
}
Test c++ calling to rust
2020-02-23 03:55:43 +00:00
Passing function pointer from Rust to C++
2020-03-26 03:17:52 +00:00
#[test]
fn test_c_callback() {
fn callback(s: String) -> usize {
if s == "2020" {
cxx_test_suite_set_correct();
}
0
}
check!(ffi::c_take_callback(callback));
}
Test c++ calling to rust
2020-02-23 03:55:43 +00:00
#[test]
fn test_c_call_r() {
fn cxx_run_test() {
extern "C" {
fn cxx_run_test() -> *const i8;
}
let failure = unsafe { cxx_run_test() };
if !failure.is_null() {
let msg = unsafe { CStr::from_ptr(failure) };
eprintln!("{}", msg.to_string_lossy());
}
}
check!(cxx_run_test());
}
Test Box returned from C++ to Rust
2020-03-06 23:45:39 +00:00
Support calling C++ methods from Rust These methods can be declared in the bridge by naming the first argument self and making it a reference to the containing class, e.g., fn get(self: &C) -> usize; fn set(self: &mut C, n: usize); This syntax requires Rust 1.43. Note that the implementation also changes the internal naming of shim functions so that they also contain the name of the owning class, if any. This allows defining multiple methods with the same name on different objects.
2020-04-07 22:54:05 +00:00
#[test]
fn test_c_method_calls() {
let mut unique_ptr = ffi::c_return_unique_ptr();
Rely on UniquePtr Deref impl in tests
2020-04-17 22:02:16 +00:00
let old_value = unique_ptr.get();
Support calling C++ methods from Rust These methods can be declared in the bridge by naming the first argument self and making it a reference to the containing class, e.g., fn get(self: &C) -> usize; fn set(self: &mut C, n: usize); This syntax requires Rust 1.43. Note that the implementation also changes the internal naming of shim functions so that they also contain the name of the owning class, if any. This allows defining multiple methods with the same name on different objects.
2020-04-07 22:54:05 +00:00
assert_eq!(2020, old_value);
Rely on UniquePtr Deref impl in tests
2020-04-17 22:02:16 +00:00
assert_eq!(2021, unique_ptr.set(2021));
assert_eq!(2021, unique_ptr.get());
Allow &self without a type when the block only has one type
2020-04-21 19:50:20 +00:00
assert_eq!(old_value, unique_ptr.set2(old_value));
assert_eq!(old_value, unique_ptr.get2())
Support calling C++ methods from Rust These methods can be declared in the bridge by naming the first argument self and making it a reference to the containing class, e.g., fn get(self: &C) -> usize; fn set(self: &mut C, n: usize); This syntax requires Rust 1.43. Note that the implementation also changes the internal naming of shim functions so that they also contain the name of the owning class, if any. This allows defining multiple methods with the same name on different objects.
2020-04-07 22:54:05 +00:00
}
Expose the enum value to Rust as a field
2020-05-01 20:57:32 +00:00
#[test]
fn test_enum_representations() {
assert_eq!(0, ffi::Enum::AVal.repr);
assert_eq!(2020, ffi::Enum::BVal.repr);
assert_eq!(2021, ffi::Enum::CVal.repr);
}
Test Box returned from C++ to Rust
2020-03-06 23:45:39 +00:00
#[no_mangle]
extern "C" fn cxx_test_suite_get_box() -> *mut cxx_test_suite::R {
Box::into_raw(Box::new(2020usize))
}
Test &R passed from Rust to C++
2020-03-06 23:50:14 +00:00
#[no_mangle]
unsafe extern "C" fn cxx_test_suite_r_is_correct(r: *const cxx_test_suite::R) -> bool {
*r == 2020
}
Reference in New Issue Copy Permalink