Test: Add tests for custom exception and exception forwarding

Author: schreter

tests/ffi/lib.rs

@@ -15,11 +15,30 @@
 pub mod cast;
 pub mod module;
 
-use cxx::{type_id, CxxString, CxxVector, ExternType, SharedPtr, UniquePtr};
+use cxx::{
+    type_id, CxxException, CxxString, CxxVector, ExternType, SharedPtr, ToCxxException, UniquePtr,
+};
 use std::fmt::{self, Display};
 use std::mem::MaybeUninit;
 use std::os::raw::c_char;
 
+/// A custom error with special exception handling.
+pub struct CustomError {
+    pub data: i32,
+}
+
+impl CustomError {
+    pub fn get_data(&self) -> i32 {
+        self.data
+    }
+}
+
+impl ToCxxException for CustomError {
+    fn to_cxx_exception(&self) -> CxxException {
+        ffi::make_custom_exception(self)
+    }
+}
+
 #[cxx::bridge(namespace = "tests")]
 pub mod ffi {
     #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
@@ -218,6 +237,21 @@ pub mod ffi {
         fn ns_c_take_ns_shared(shared: AShared);
     }
 
+    extern "Rust" {
+        type CustomError;
+        fn get_data(&self) -> i32;
+    }
+
+    unsafe extern "C++" {
+        include!("tests/ffi/tests.h");
+
+        fn make_custom_exception(error: &CustomError) -> CxxException;
+        fn catch_custom_exception() -> Result<()>;
+
+        fn forward_exception_inner() -> Result<()>;
+        fn forward_exception_outer() -> Result<()>;
+    }
+
     extern "C++" {
         include!("tests/ffi/module.rs.h");
 
@@ -312,6 +346,9 @@ pub mod ffi {
 
         #[cxx_name = "rAliasedFunction"]
         fn r_aliased_function(x: i32) -> String;
+
+        fn throw_custom_exception() -> Result<()>;
+        fn forward_exception_middle() -> Result<()>;
     }
 
     struct Dag0 {
@@ -646,3 +683,14 @@ fn r_try_return_mutsliceu8(slice: &mut [u8]) -> Result<&mut [u8], Error> {
 fn r_aliased_function(x: i32) -> String {
     x.to_string()
 }
+
+fn throw_custom_exception() -> Result<(), CustomError> {
+    Err(CustomError { data: 4711 })
+}
+
+fn forward_exception_middle() -> Result<(), CxxException> {
+    ffi::forward_exception_inner().map_err(|e| {
+        assert_eq!(e.what(), "forward test exc");
+        e.into()
+    })
+}

tests/ffi/tests.cc

@@ -902,6 +902,49 @@ extern "C" const char *cxx_run_test() noexcept {
   return nullptr;
 }
 
+std::exception_ptr make_custom_exception(const CustomError &error) {
+  auto data = error.get_data();
+  std::string msg("custom ");
+  msg += std::to_string(data);
+  return std::make_exception_ptr(std::logic_error(msg));
+}
+
+void catch_custom_exception() {
+  // call a Rust function throwing a custom error
+  try {
+    throw_custom_exception();
+  } catch (std::logic_error &ex) {
+    // yes, we caught the expected exception, just rethrow it to the outer
+    // call from Rust to evaluate
+    throw;
+  } catch (...) {
+    // something wrong, throw an exception with a different message, so the
+    // test will fail
+    throw std::logic_error("unexpected exception caught in the outer layer");
+  }
+}
+
+void forward_exception_inner() {
+  // throw a special exception in the inner call
+  throw std::logic_error("forward test exc");
+}
+
+void forward_exception_outer() {
+  try {
+    // call Rust function, which calls `forward_exception_inner()` to generate
+    // the exception, which is passed 1:1 through the Rust layer
+    forward_exception_middle();
+  } catch (std::logic_error &) {
+    // yes, we caught the expected exception, just rethrow it to the outer
+    // call from Rust to evaluate
+    throw;
+  } catch (...) {
+    // something wrong, throw an exception with a different message, so the
+    // test will fail
+    throw std::logic_error("unexpected exception caught in the outer layer");
+  }
+}
+
 } // namespace tests
 
 namespace other {

tests/ffi/tests.h

@@ -215,6 +215,13 @@ std::unique_ptr<::F::F> c_return_ns_opaque_ptr();
 rust::String cOverloadedFunction(int32_t x);
 rust::String cOverloadedFunction(rust::Str x);
 
+struct CustomError;
+std::exception_ptr make_custom_exception(const CustomError &error);
+void catch_custom_exception();
+
+void forward_exception_inner();
+void forward_exception_outer();
+
 } // namespace tests
 
 namespace other {

tests/test.rs

@@ -378,3 +378,19 @@ fn test_raw_ptr() {
     assert_eq!(2025, unsafe { ffi::c_take_const_ptr(c3) });
     assert_eq!(2025, unsafe { ffi::c_take_mut_ptr(c3 as *mut ffi::C) }); // deletes c3
 }
+
+/// Test throwing a custom exception from a Rust call via `ToCxxException`
+/// trait.
+#[test]
+fn test_custom_exception() {
+    let err = ffi::catch_custom_exception().expect_err("Error expected");
+    assert_eq!(err.what(), "custom 4711");
+}
+
+/// Test forwarding the exception from the inner C++ function via a middle Rust
+/// function into the outer C++ function unmodified.
+#[test]
+fn test_forward_exception() {
+    let err = ffi::forward_exception_outer().expect_err("Error expected");
+    assert_eq!(err.what(), "forward test exc");
+}