Migrate flavorful test to wit-bindgen test (#1267)

Splitting up the test instead of using the existing structure exactly,
but still testing the same thing.

Author: alexcrichton

crates/test-rust-wasm/Cargo.toml

@@ -11,10 +11,6 @@ wit-bindgen = { path = "../guest-rust" }
 test = false
 doctest = false
 
-[[bin]]
-name = "flavorful"
-test = false
-
 [[bin]]
 name = "results"
 test = false

crates/test-rust-wasm/src/bin/flavorful.rs

@@ -0,0 +1,132 @@
+//@ args = '--rename test:flavorful/to-test=test'
+
+#include <assert.h>
+#include <runner.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main() {
+  {
+    test_list_in_record1_t a;
+    runner_string_set(&a.a, "list_in_record1");
+    test_f_list_in_record1(&a);
+
+    test_list_in_record2_t b;
+    test_f_list_in_record2(&b);
+    assert(memcmp(b.a.ptr, "list_in_record2", b.a.len) == 0);
+    test_list_in_record2_free(&b);
+  }
+
+  {
+    test_list_in_record3_t a, b;
+    runner_string_set(&a.a, "list_in_record3 input");
+    test_f_list_in_record3(&a, &b);
+    assert(memcmp(b.a.ptr, "list_in_record3 output", b.a.len) == 0);
+    test_list_in_record3_free(&b);
+  }
+
+  {
+    test_list_in_record4_t a, b;
+    runner_string_set(&a.a, "input4");
+    test_f_list_in_record4(&a, &b);
+    assert(memcmp(b.a.ptr, "result4", b.a.len) == 0);
+    test_list_in_record4_free(&b);
+  }
+
+  {
+    test_list_in_variant1_v1_t a;
+    test_list_in_variant1_v2_t b;
+    a.is_some = true;
+    runner_string_set(&a.val, "foo");
+    b.is_err = true;
+    runner_string_set(&b.val.err, "bar");
+    test_f_list_in_variant1(&a.val, &b);
+  }
+
+  {
+    runner_string_t a;
+    assert(test_f_list_in_variant2(&a));
+    assert(memcmp(a.ptr, "list_in_variant2", a.len) == 0);
+    runner_string_free(&a);
+  }
+
+  {
+    test_list_in_variant3_t a;
+    a.is_some = true;
+    runner_string_set(&a.val, "input3");
+    runner_string_t b;
+    assert(test_f_list_in_variant3(&a.val, &b));
+    assert(memcmp(b.ptr, "output3", b.len) == 0);
+    runner_string_free(&b);
+  }
+
+  {
+    test_my_errno_t errno;
+    assert(!test_errno_result(&errno));
+    assert(errno == TEST_MY_ERRNO_B);
+  }
+
+  {
+    test_my_errno_t errno;
+    assert(test_errno_result(&errno));
+  }
+
+  {
+    runner_string_t a;
+    runner_string_set(&a, "typedef1");
+    runner_string_t b_str;
+    runner_string_set(&b_str, "typedef2");
+    test_list_typedef3_t b;
+    b.ptr = &b_str;
+    b.len = 1;
+    runner_tuple2_list_typedef2_list_typedef3_t ret;
+    test_list_typedefs(&a, &b, &ret);
+
+    assert(memcmp(ret.f0.ptr, "typedef3", ret.f0.len) == 0);
+    assert(ret.f1.len == 1);
+    assert(memcmp(ret.f1.ptr[0].ptr, "typedef4", ret.f1.ptr[0].len) == 0);
+
+    test_list_typedef2_free(&ret.f0);
+    test_list_typedef3_free(&ret.f1);
+  }
+
+  {
+    runner_list_bool_t a;
+    bool a_val[] = {true, false};
+    a.ptr = a_val;
+    a.len = 2;
+
+    test_list_result_void_void_t b;
+    test_result_void_void_t b_val[2];
+    b_val[0].is_err = false;
+    b_val[1].is_err = true;
+    b.ptr = b_val;
+    b.len = 2;
+
+    test_list_my_errno_t c;
+    test_my_errno_t c_val[2];
+    c_val[0] = TEST_MY_ERRNO_SUCCESS;
+    c_val[1] = TEST_MY_ERRNO_A;
+    c.ptr = c_val;
+    c.len = 2;
+
+    test_tuple3_list_bool_list_result_void_void_list_my_errno_t ret;
+    test_list_of_variants(&a, &b, &c, &ret);
+
+    assert(ret.f0.len == 2);
+    assert(ret.f0.ptr[0] == false);
+    assert(ret.f0.ptr[1] == true);
+
+    assert(ret.f1.len == 2);
+    assert(ret.f1.ptr[0].is_err == true);
+    assert(ret.f1.ptr[1].is_err == false);
+
+    assert(ret.f2.len == 2);
+    assert(ret.f2.ptr[0] == TEST_MY_ERRNO_A);
+    assert(ret.f2.ptr[1] == TEST_MY_ERRNO_B);
+
+    runner_list_bool_free(&ret.f0);
+    test_list_result_void_void_free(&ret.f1);
+    test_list_my_errno_free(&ret.f2);
+  }
+}

tests/runtime-new/flavorful/runner.c

@@ -0,0 +1,64 @@
+include!(env!("BINDINGS"));
+
+use crate::test::flavorful::to_test::*;
+
+#[path = "../lists/alloc.rs"]
+mod alloc;
+
+fn main() {
+    let before = alloc::get();
+    run();
+    assert_eq!(before, alloc::get());
+}
+
+fn run() {
+    f_list_in_record1(&ListInRecord1 {
+        a: "list_in_record1".to_string(),
+    });
+    assert_eq!(f_list_in_record2().a, "list_in_record2");
+
+    assert_eq!(
+        f_list_in_record3(&ListInRecord3 {
+            a: "list_in_record3 input".to_string()
+        })
+        .a,
+        "list_in_record3 output"
+    );
+
+    assert_eq!(
+        f_list_in_record4(&ListInAlias {
+            a: "input4".to_string()
+        })
+        .a,
+        "result4"
+    );
+
+    f_list_in_variant1(&Some("foo".to_string()), &Err("bar".to_string()));
+    assert_eq!(f_list_in_variant2(), Some("list_in_variant2".to_string()));
+    assert_eq!(
+        f_list_in_variant3(&Some("input3".to_string())),
+        Some("output3".to_string())
+    );
+
+    assert!(errno_result().is_err());
+    MyErrno::A.to_string();
+    _ = format!("{:?}", MyErrno::A);
+    fn assert_error<T: std::error::Error>() {}
+    assert_error::<MyErrno>();
+
+    assert!(errno_result().is_ok());
+
+    let (a, b) = list_typedefs(&"typedef1".to_string(), &vec!["typedef2".to_string()]);
+    assert_eq!(a, b"typedef3");
+    assert_eq!(b.len(), 1);
+    assert_eq!(b[0], "typedef4");
+
+    let (a, b, c) = list_of_variants(
+        &[true, false],
+        &[Ok(()), Err(())],
+        &[MyErrno::Success, MyErrno::A],
+    );
+    assert_eq!(a, [false, true]);
+    assert_eq!(b, [Err(()), Ok(())]);
+    assert_eq!(c, [MyErrno::A, MyErrno::B]);
+}

tests/runtime-new/flavorful/runner.rs

@@ -0,0 +1,117 @@
+//@ args = '--rename test:flavorful/to-test=test'
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "test.h"
+
+void exports_test_f_list_in_record1(exports_test_list_in_record1_t *a) {
+  assert(memcmp(a->a.ptr, "list_in_record1", a->a.len) == 0);
+  exports_test_list_in_record1_free(a);
+}
+
+void exports_test_f_list_in_record2(exports_test_list_in_record2_t *ret0) {
+  test_string_dup(&ret0->a, "list_in_record2");
+}
+
+void exports_test_f_list_in_record3(exports_test_list_in_record3_t *a, exports_test_list_in_record3_t *ret0) {
+  assert(memcmp(a->a.ptr, "list_in_record3 input", a->a.len) == 0);
+  exports_test_list_in_record3_free(a);
+  test_string_dup(&ret0->a, "list_in_record3 output");
+}
+
+void exports_test_f_list_in_record4(exports_test_list_in_alias_t *a, exports_test_list_in_alias_t *ret0) {
+  assert(memcmp(a->a.ptr, "input4", a->a.len) == 0);
+  exports_test_list_in_alias_free(a);
+  test_string_dup(&ret0->a, "result4");
+}
+
+void exports_test_f_list_in_variant1(test_string_t *maybe_a, exports_test_list_in_variant1_v2_t *b) {
+  assert(maybe_a != NULL);
+  assert(memcmp(maybe_a->ptr, "foo", maybe_a->len) == 0);
+  test_string_free(maybe_a);
+
+  assert(b->is_err);
+  assert(memcmp(b->val.err.ptr, "bar", b->val.err.len) == 0);
+  exports_test_list_in_variant1_v2_free(b);
+}
+
+bool exports_test_f_list_in_variant2(test_string_t *ret0) {
+  test_string_dup(ret0, "list_in_variant2");
+  return true;
+}
+
+bool exports_test_f_list_in_variant3(test_string_t *maybe_a, test_string_t *ret) {
+  assert(maybe_a != NULL);
+  assert(memcmp(maybe_a->ptr, "input3", maybe_a->len) == 0);
+  test_string_free(maybe_a);
+  test_string_dup(ret, "output3");
+  return true;
+}
+
+static bool RESULT_RETURNED = false;
+
+bool exports_test_errno_result(exports_test_my_errno_t *err) {
+  if (RESULT_RETURNED) {
+    return true;
+  } else {
+    RESULT_RETURNED = true;
+    *err = EXPORTS_TEST_MY_ERRNO_B;
+    return false;
+  }
+}
+
+void exports_test_list_typedefs(
+    exports_test_list_typedef_t *a,
+    exports_test_list_typedef3_t *c,
+    test_tuple2_list_typedef2_list_typedef3_t *ret) {
+  assert(memcmp(a->ptr, "typedef1", a->len) == 0);
+  exports_test_list_typedef_free(a);
+
+  assert(c->len == 1);
+  assert(memcmp(c->ptr[0].ptr, "typedef2", c->ptr[0].len) == 0);
+  exports_test_list_typedef3_free(c);
+
+  ret->f0.ptr = (uint8_t *) malloc(8);
+  ret->f0.len = 8;
+  memcpy(ret->f0.ptr, "typedef3", 8);
+
+  ret->f1.ptr = (test_string_t *) malloc(sizeof(test_string_t));
+  ret->f1.len = 1;
+  test_string_dup(&ret->f1.ptr[0], "typedef4");
+}
+
+void exports_test_list_of_variants(
+    test_list_bool_t *a,
+    exports_test_list_result_void_void_t *b,
+    exports_test_list_my_errno_t *c,
+    exports_test_tuple3_list_bool_list_result_void_void_list_my_errno_t *ret) {
+
+  assert(a->len == 2);
+  assert(a->ptr[0] == true);
+  assert(a->ptr[1] == false);
+
+  assert(b->len == 2);
+  assert(!b->ptr[0].is_err);
+  assert(b->ptr[1].is_err);
+
+  assert(c->len == 2);
+  assert(c->ptr[0] == EXPORTS_TEST_MY_ERRNO_SUCCESS);
+  assert(c->ptr[1] == EXPORTS_TEST_MY_ERRNO_A);
+
+  ret->f0.ptr = malloc(2 * sizeof(bool));
+  ret->f0.len = 2;
+  ret->f0.ptr[0] = false;
+  ret->f0.ptr[1] = true;
+
+  ret->f1.ptr = malloc(2 * sizeof(exports_test_result_void_void_t));
+  ret->f1.len = 2;
+  ret->f1.ptr[0].is_err = true;
+  ret->f1.ptr[1].is_err = false;
+
+  ret->f2.ptr = malloc(2 * sizeof(exports_test_my_errno_t));
+  ret->f2.len = 2;
+  ret->f2.ptr[0] = EXPORTS_TEST_MY_ERRNO_A;
+  ret->f2.ptr[1] = EXPORTS_TEST_MY_ERRNO_B;
+}