openharmony/third_party_rust_cxx
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_rust_cxx synced 2025-02-17 15:09:41 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Adding tests for types in namespaces.

Browse Source
This commit is contained in:
Adrian Taylor 2020-10-24 20:51:25 -07:00
parent cca5215060
commit 9a158e408f
4 changed files with 152 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
tests/ffi/lib.rs
View File

@ -49,6 +49,32 @@ pub mod ffi {
CVal,
}
#[namespace(namespace = A)]
#[derive(Clone)]
struct AShared {
z: usize,
}
#[namespace(namespace = A)]
enum AEnum {
AAVal,
ABVal = 2020,
ACVal,
}
#[namespace(namespace = A::B)]
enum ABEnum {
ABAVal,
ABBVal = 2020,
ABCVal,
}
#[namespace(namespace = A::B)]
#[derive(Clone)]
struct ABShared {
z: usize,
}
extern "C" {
include!("tests/ffi/tests.h");
@ -78,6 +104,10 @@ pub mod ffi {
fn c_return_identity(_: usize) -> usize;
fn c_return_sum(_: usize, _: usize) -> usize;
fn c_return_enum(n: u16) -> Enum;
fn c_return_ns_ref(shared: &AShared) -> &usize;
fn c_return_nested_ns_ref(shared: &ABShared) -> &usize;
fn c_return_ns_enum(n: u16) -> AEnum;
fn c_return_nested_ns_enum(n: u16) -> ABEnum;
fn c_take_primitive(n: usize);
fn c_take_shared(shared: Shared);
@ -108,6 +138,12 @@ pub mod ffi {
fn c_take_callback(callback: fn(String) -> usize);
*/
fn c_take_enum(e: Enum);
fn c_take_ns_enum(e: AEnum);
fn c_take_nested_ns_enum(e: ABEnum);
fn c_take_ns_shared(shared: AShared);
fn c_take_nested_ns_shared(shared: ABShared);
fn c_take_rust_vec_ns_shared(v: Vec<AShared>);
fn c_take_rust_vec_nested_ns_shared(v: Vec<ABShared>);
fn c_try_return_void() -> Result<()>;
fn c_try_return_primitive() -> Result<usize>;

72
tests/ffi/tests.cc
View File

@ -43,6 +43,10 @@ size_t c_return_primitive() { return 2020; }
Shared c_return_shared() { return Shared{2020}; }
::A::AShared c_return_ns_shared() { return ::A::AShared{2020}; }
::A::B::ABShared c_return_nested_ns_shared() { return ::A::B::ABShared{2020}; }
rust::Box<R> c_return_box() {
return rust::Box<R>::from_raw(cxx_test_suite_get_box());
}
@ -53,6 +57,10 @@ std::unique_ptr<C> c_return_unique_ptr() {
const size_t &c_return_ref(const Shared &shared) { return shared.z; }
const size_t &c_return_ns_ref(const ::A::AShared &shared) { return shared.z; }
const size_t &c_return_nested_ns_ref(const ::A::B::ABShared &shared) { return shared.z; }
size_t &c_return_mut(Shared &shared) { return shared.z; }
rust::Str c_return_str(const Shared &shared) {
@ -144,6 +152,26 @@ Enum c_return_enum(uint16_t n) {
}
}
::A::AEnum c_return_ns_enum(uint16_t n) {
if (n <= static_cast<uint16_t>(::A::AEnum::AAVal)) {
return ::A::AEnum::AAVal;
} else if (n <= static_cast<uint16_t>(::A::AEnum::ABVal)) {
return ::A::AEnum::ABVal;
} else {
return ::A::AEnum::ACVal;
}
}
::A::B::ABEnum c_return_nested_ns_enum(uint16_t n) {
if (n <= static_cast<uint16_t>(::A::B::ABEnum::ABAVal)) {
return ::A::B::ABEnum::ABAVal;
} else if (n <= static_cast<uint16_t>(::A::B::ABEnum::ABBVal)) {
return ::A::B::ABEnum::ABBVal;
} else {
return ::A::B::ABEnum::ABCVal;
}
}
void c_take_primitive(size_t n) {
if (n == 2020) {
cxx_test_suite_set_correct();
@ -156,6 +184,18 @@ void c_take_shared(Shared shared) {
}
}
void c_take_ns_shared(::A::AShared shared) {
if (shared.z == 2020) {
cxx_test_suite_set_correct();
}
}
void c_take_nested_ns_shared(::A::B::ABShared shared) {
if (shared.z == 2020) {
cxx_test_suite_set_correct();
}
}
void c_take_box(rust::Box<R> r) {
if (cxx_test_suite_r_is_correct(&*r)) {
cxx_test_suite_set_correct();
@ -258,6 +298,26 @@ void c_take_rust_vec_shared(rust::Vec<Shared> v) {
}
}
void c_take_rust_vec_ns_shared(rust::Vec<::A::AShared> v) {
uint32_t sum = 0;
for (auto i : v) {
sum += i.z;
}
if (sum == 2021) {
cxx_test_suite_set_correct();
}
}
void c_take_rust_vec_nested_ns_shared(rust::Vec<::A::B::ABShared> v) {
uint32_t sum = 0;
for (auto i : v) {
sum += i.z;
}
if (sum == 2021) {
cxx_test_suite_set_correct();
}
}
void c_take_rust_vec_string(rust::Vec<rust::String> v) {
(void)v;
cxx_test_suite_set_correct();
@ -326,6 +386,18 @@ void c_take_enum(Enum e) {
}
}
void c_take_ns_enum(::A::AEnum e) {
if (e == ::A::AEnum::AAVal) {
cxx_test_suite_set_correct();
}
}
void c_take_nested_ns_enum(::A::B::ABEnum e) {
if (e == ::A::B::ABEnum::ABAVal) {
cxx_test_suite_set_correct();
}
}
void c_try_return_void() {}
size_t c_try_return_primitive() { return 2020; }

21
tests/ffi/tests.h
View File

@ -3,6 +3,15 @@
#include <memory>
#include <string>
namespace A {
struct AShared;
enum class AEnum : uint16_t;
namespace B {
struct ABShared;
enum class ABEnum : uint16_t;
} // namespace B
} // namespace A
namespace tests {
struct R;
@ -44,9 +53,13 @@ enum COwnedEnum {
size_t c_return_primitive();
Shared c_return_shared();
::A::AShared c_return_ns_shared();
::A::B::ABShared c_return_nested_ns_shared();
rust::Box<R> c_return_box();
std::unique_ptr<C> c_return_unique_ptr();
const size_t &c_return_ref(const Shared &shared);
const size_t &c_return_ns_ref(const ::A::AShared &shared);
const size_t &c_return_nested_ns_ref(const ::A::B::ABShared &shared);
size_t &c_return_mut(Shared &shared);
rust::Str c_return_str(const Shared &shared);
rust::Slice<uint8_t> c_return_sliceu8(const Shared &shared);
@ -66,9 +79,13 @@ rust::Vec<rust::String> c_return_rust_vec_string();
size_t c_return_identity(size_t n);
size_t c_return_sum(size_t n1, size_t n2);
Enum c_return_enum(uint16_t n);
::A::AEnum c_return_ns_enum(uint16_t n);
::A::B::ABEnum c_return_nested_ns_enum(uint16_t n);
void c_take_primitive(size_t n);
void c_take_shared(Shared shared);
void c_take_ns_shared(::A::AShared shared);
void c_take_nested_ns_shared(::A::B::ABShared shared);
void c_take_box(rust::Box<R> r);
void c_take_unique_ptr(std::unique_ptr<C> c);
void c_take_ref_r(const R &r);
@ -86,6 +103,8 @@ void c_take_ref_vector(const std::vector<uint8_t> &v);
void c_take_rust_vec(rust::Vec<uint8_t> v);
void c_take_rust_vec_index(rust::Vec<uint8_t> v);
void c_take_rust_vec_shared(rust::Vec<Shared> v);
void c_take_rust_vec_ns_shared(rust::Vec<::A::AShared> v);
void c_take_rust_vec_nested_ns_shared(rust::Vec<::A::B::ABShared> v);
void c_take_rust_vec_string(rust::Vec<rust::String> v);
void c_take_rust_vec_shared_index(rust::Vec<Shared> v);
void c_take_rust_vec_shared_forward_iterator(rust::Vec<Shared> v);
@ -98,6 +117,8 @@ void c_take_ref_rust_vec_copy(const rust::Vec<uint8_t> &v);
void c_take_callback(rust::Fn<size_t(rust::String)> callback);
*/
void c_take_enum(Enum e);
void c_take_ns_enum(::A::AEnum e);
void c_take_nested_ns_enum(::A::B::ABEnum e);
void c_try_return_void();
size_t c_try_return_primitive();

23
tests/test.rs
View File

@ -23,12 +23,16 @@ macro_rules! check {
#[test]
fn test_c_return() {
let shared = ffi::Shared { z: 2020 };
let ns_shared = ffi::AShared { z: 2020 };
let nested_ns_shared = ffi::ABShared { z: 2020 };
assert_eq!(2020, ffi::c_return_primitive());
assert_eq!(2020, ffi::c_return_shared().z);
assert_eq!(2020, *ffi::c_return_box());
ffi::c_return_unique_ptr();
assert_eq!(2020, *ffi::c_return_ref(&shared));
assert_eq!(2020, *ffi::c_return_ns_ref(&ns_shared));
assert_eq!(2020, *ffi::c_return_nested_ns_ref(&nested_ns_shared));
assert_eq!("2020", ffi::c_return_str(&shared));
assert_eq!(b"2020\0", ffi::c_return_sliceu8(&shared));
assert_eq!("2020", ffi::c_return_rust_string());
@ -64,6 +68,14 @@ fn test_c_return() {
enm @ ffi::Enum::CVal => assert_eq!(2021, enm.repr),
_ => assert!(false),
}
match ffi::c_return_ns_enum(0) {
enm @ ffi::AEnum::AAVal => assert_eq!(0, enm.repr),
_ => assert!(false),
}
match ffi::c_return_nested_ns_enum(0) {
enm @ ffi::ABEnum::ABAVal => assert_eq!(0, enm.repr),
_ => assert!(false),
}
}
#[test]
@ -88,6 +100,8 @@ fn test_c_take() {
check!(ffi::c_take_primitive(2020));
check!(ffi::c_take_shared(ffi::Shared { z: 2020 }));
check!(ffi::c_take_ns_shared(ffi::AShared { z: 2020 }));
check!(ffi::c_take_nested_ns_shared(ffi::ABShared { z: 2020 }));
check!(ffi::c_take_box(Box::new(2020)));
check!(ffi::c_take_ref_c(&unique_ptr));
check!(cxx_test_suite::module::ffi::c_take_unique_ptr(unique_ptr));
@ -119,7 +133,16 @@ fn test_c_take() {
check!(ffi::c_take_ref_rust_vec(&test_vec));
check!(ffi::c_take_ref_rust_vec_index(&test_vec));
check!(ffi::c_take_ref_rust_vec_copy(&test_vec));
let ns_shared_test_vec = vec![ffi::AShared { z: 1010 }, ffi::AShared { z: 1011 }];
check!(ffi::c_take_rust_vec_ns_shared(ns_shared_test_vec));
let nested_ns_shared_test_vec = vec![ffi::ABShared { z: 1010 }, ffi::ABShared { z: 1011 }];
check!(ffi::c_take_rust_vec_nested_ns_shared(
nested_ns_shared_test_vec
));
check!(ffi::c_take_enum(ffi::Enum::AVal));
check!(ffi::c_take_ns_enum(ffi::AEnum::AAVal));
check!(ffi::c_take_nested_ns_enum(ffi::ABEnum::ABAVal));
}
/*