Merge pull request #31 from NordSecurity/scaffolding_error_fixes

Scaffolding error fixes

Author: Lipt0nas

bindgen/src/bindings/cpp/templates/scaffolding/callback.cpp

@@ -11,7 +11,15 @@ class {{ iface.name() }}Proxy: public {{ iface.name() }} {
             ~{{ iface.name() }}Proxy() override {
                 ForeignCallback *callback_stub = reinterpret_cast<ForeignCallback *>({{ ffi_converter_name|class_name }}::fn_handle.load());
 
-                callback_stub(this->handle, 0, nullptr, 0, nullptr);
+                RustBuffer out_buf = {
+                    .capacity = 0,
+                    .len = 0,
+                    .data = nullptr,
+                };
+
+                callback_stub(this->handle, 0, nullptr, 0, &out_buf);
+
+                rustbuffer_free(out_buf);
             }
 
             {% for m in iface.methods() %}

cpp-tests/scaffolding_tests/coverall/lib_coverall.cpp

@@ -96,7 +96,7 @@ bool coverall::Coveralls::maybe_throw_complex(uint8_t input) {
 }
 
 void coverall::Coveralls::panic(std::string message) {
-    throw std::runtime_error("coveralls->panic()");
+    throw std::runtime_error(message);
 }
 
 void coverall::Coveralls::fallible_panic(std::string message) {

cpp-tests/scaffolding_tests/coverall/lib_coverall.hpp

@@ -197,7 +197,7 @@ namespace {
         namespace coverall_error {
             class TooManyHoles: public std::runtime_error {
             public:
-                TooManyHoles() : TooManyHoles("") {}
+                TooManyHoles() : TooManyHoles("The coverall has too many holes") {}
                 TooManyHoles(const std::string &what_arg) : std::runtime_error(what_arg) {}
             };
         }

cpp-tests/scaffolding_tests/fixture_callbacks/lib_fixture_callbacks.cpp

@@ -17,6 +17,8 @@ std::optional<std::string> fixture_callbacks::RustGetters::get_option(std::share
         return foreign->get_option(v, argument_two);
     } catch (const fixture_callbacks::complex_error::ReallyBadArgument &e) {
         throw e;
+    } catch (const fixture_callbacks::complex_error::UnexpectedErrorWithReason &e) {
+        throw fixture_callbacks::complex_error::UnexpectedErrorWithReason(e.reason);
     } catch (const std::runtime_error &e) {
         throw fixture_callbacks::complex_error::UnexpectedErrorWithReason(e.what());
     }
@@ -28,7 +30,13 @@ std::vector<int32_t> fixture_callbacks::RustGetters::get_list(std::shared_ptr<fi
 
 std::optional<std::string> fixture_callbacks::RustGetters::get_string_optional_callback(std::shared_ptr<fixture_callbacks::ForeignGetters> foreign, std::string v, bool argument_two) {
     if (foreign) {
-        return foreign->get_string(v, argument_two);
+        try {
+            return foreign->get_string(v, argument_two);
+        } catch (const fixture_callbacks::simple_error::BadArgument &e) {
+            throw e;
+        } catch (const std::runtime_error &e) {
+            throw fixture_callbacks::simple_error::UnexpectedError();
+        }
     }
 
     return std::nullopt;

cpp-tests/scaffolding_tests/fixture_callbacks/lib_fixture_callbacks.hpp

@@ -16,13 +16,13 @@ namespace {
         namespace simple_error {
             class BadArgument : public SimpleError {
             public:
-                BadArgument() : SimpleError("") {}
+                BadArgument() : SimpleError("BadArgument") {}
                 BadArgument(const std::string &what_arg) : SimpleError(what_arg) {}
             };
 
             class UnexpectedError : public SimpleError {
             public:
-                UnexpectedError() : SimpleError("") {}
+                UnexpectedError() : SimpleError("UnexpectedError") {}
                 UnexpectedError(const std::string &what_arg) : SimpleError(what_arg) {}
             };
         }
@@ -36,15 +36,15 @@ namespace {
         namespace complex_error {
             class ReallyBadArgument : public ComplexError {
             public:
-                ReallyBadArgument() : ComplexError("") {}
+                ReallyBadArgument() : ComplexError("ReallyBadArgument") {}
                 ReallyBadArgument(const std::string &what_arg) : ComplexError(what_arg) {}
 
                 uint32_t code;
             };
 
             class UnexpectedErrorWithReason : public ComplexError {
             public:
-                UnexpectedErrorWithReason() : ComplexError("") {}
+                UnexpectedErrorWithReason() : ComplexError("InternalTelephoneError") {}
                 UnexpectedErrorWithReason(const std::string &what_arg) : ComplexError(what_arg), reason(what_arg) {}
 
                 std::string reason;