test: add test for wrap-static-fns in C++ mode

Author: sehnryr

bindgen-tests/tests/expectations/tests/generated/wrap_static_fns.cpp

@@ -0,0 +1,33 @@
+#include "tests/headers/wrap-static-fns.hpp"
+
+// Static wrappers
+
+int foo__extern(void) { return foo(); }
+int bar__extern(void) { return bar(); }
+int takes_ptr__extern(int *arg) { return takes_ptr(arg); }
+int takes_fn_ptr__extern(int (*f) (int)) { return takes_fn_ptr(f); }
+int takes_fn__extern(int (f) (int)) { return takes_fn(f); }
+int takes_alias__extern(func f) { return takes_alias(f); }
+int takes_qualified__extern(const int *const *arg) { return takes_qualified(arg); }
+enum foo takes_enum__extern(const enum foo f) { return takes_enum(f); }
+void nevermore__extern(void) { nevermore(); }
+int takes_fn_with_no_args__extern(int (f) (void)) { return takes_fn_with_no_args(f); }
+void no_extra_argument__extern(__builtin_va_list va) { no_extra_argument(va); }
+int many_va_list__extern(int i, __builtin_va_list va1, __builtin_va_list va2) { return many_va_list(i, va1, va2); }
+int wrap_as_variadic_fn1__extern(int i, ...) {
+    int ret;
+    va_list ap;
+
+    va_start(ap, i);
+    ret = wrap_as_variadic_fn1(i, ap);
+    va_end(ap);
+    return ret;
+}
+void wrap_as_variadic_fn2__extern(int i, ...) {
+    va_list ap;
+
+    va_start(ap, i);
+    wrap_as_variadic_fn2(i, ap);
+    va_end(ap);
+}
+int foo__extern(void) { return foo(); }

bindgen-tests/tests/headers/wrap-static-fns.hpp

@@ -0,0 +1,90 @@
+// bindgen-flags: --wrap-static-fns
+// bindgen-parse-callbacks: wrap-as-variadic-fn
+
+// to avoid polluting the expectation tests we put the stdarg.h behind a conditional
+// variable only used in bindgen-integration
+#ifdef USE_VA_HEADER
+#include <stdarg.h>
+#endif
+
+static inline int foo() {
+    return 11;
+}
+static int bar();
+static int bar() {
+    return 1;
+}
+inline int baz() {
+    return 2;
+}
+
+static inline int takes_ptr(int* arg) {
+    return *arg + 1;
+}
+
+static inline int takes_fn_ptr(int (*f)(int)) {
+    return f(1);
+}
+
+static inline int takes_fn(int (f)(int)) {
+    return f(2);
+}
+
+typedef int (func)(int);
+
+static inline int takes_alias(func f) {
+    return f(3);
+}
+
+static inline int takes_qualified(const int *const *arg) {
+    return **arg;
+}
+
+enum foo {
+    BAR = 0x0,
+};
+
+static inline enum foo takes_enum(const enum foo f) {
+    return f;
+}
+
+static inline void nevermore() {
+    while (1) { }
+}
+
+static inline int takes_fn_with_no_args(int(f)(void)) {
+    return f();
+}
+
+static inline int variadic(int x, ...) {
+    return x;
+}
+
+static inline void no_extra_argument(__builtin_va_list va) {}
+
+static inline int many_va_list(int i, __builtin_va_list va1, __builtin_va_list va2) {
+    return i;
+}
+
+#ifndef USE_VA_HEADER
+static inline int wrap_as_variadic_fn1(int i, __builtin_va_list va) {
+    return i;
+}
+
+static inline void wrap_as_variadic_fn2(int i, __builtin_va_list va) {}
+#else
+static inline int wrap_as_variadic_fn1(int i, va_list va) {
+    int res = 0;
+
+    for (int j = 0; j < i; j++)
+        res += (int) va_arg(va, int);
+
+    return res;
+}
+
+static inline void wrap_as_variadic_fn2(int i, va_list va) {}
+#endif
+
+namespace qux {
+    static int foo();
+}

bindgen-tests/tests/tests.rs

@@ -757,3 +757,41 @@ fn test_wrap_static_fns() {
         .unwrap();
     }
 }
+
+#[test]
+fn test_wrap_static_fns_cpp() {
+    // This test is for testing diffs of the generated C source and header files
+    // TODO: If another such feature is added, convert this test into a more generic
+    //      test that looks at `tests/headers/generated` directory.
+    let expect_path = PathBuf::from("tests/expectations/tests/generated")
+        .join("wrap_static_fns");
+    println!("In path is ::: {}", expect_path.display());
+
+    let generated_path =
+        PathBuf::from(env::var("OUT_DIR").unwrap()).join("wrap_static_fns");
+    println!("Out path is ::: {}", generated_path.display());
+
+    let _bindings = Builder::default()
+        .header("tests/headers/wrap-static-fns.hpp")
+        .wrap_static_fns(true)
+        .wrap_static_fns_path(generated_path.display().to_string())
+        .parse_callbacks(Box::new(parse_callbacks::WrapAsVariadicFn))
+        .generate()
+        .expect("Failed to generate bindings");
+
+    let expected_cpp = fs::read_to_string(expect_path.with_extension("cpp"))
+        .expect("Could not read generated wrap_static_fns.cpp");
+
+    let actual_cpp = fs::read_to_string(generated_path.with_extension("cpp"))
+        .expect("Could not read actual wrap_static_fns.cpp");
+
+    if expected_cpp != actual_cpp {
+        error_diff_mismatch(
+            &actual_cpp,
+            &expected_cpp,
+            None,
+            &expect_path.with_extension("cpp"),
+        )
+        .unwrap();
+    }
+}