refactored test to work with new test structure

Author: Timmy Silesmo

crates/csharp/src/function.rs

@@ -892,13 +892,6 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 }
 
                 results.push(format!("{length}"));
-                if FunctionKind::Freestanding == *self.kind || self.interface_gen.direction == Direction::Export {
-                    self.interface_gen.require_interop_using("System.Text");
-                    self.interface_gen.require_interop_using("System.Runtime.InteropServices");
-                } else {
-                    self.interface_gen.require_using("System.Text");
-                    self.interface_gen.require_using("System.Runtime.InteropServices");
-                }
             }
 
             Instruction::StringLift { .. } => {

tests/runtime/lists/runner.c

@@ -232,4 +232,33 @@ void exports_runner_run() {
     runner_list_f32_free(&ret.f0);
     runner_list_f64_free(&ret.f1);
   }
+
+  {
+    runner_tuple2_string_list_u8_t headers_data[2];
+    runner_string_set(&headers_data[0].f0, "Content-Type");
+    uint8_t val0[] = "text/plain";
+    headers_data[0].f1.ptr = val0;
+    headers_data[0].f1.len = 10;
+
+    runner_string_set(&headers_data[1].f0, "Content-Length");
+    uint8_t val1[] = "9";
+    headers_data[1].f1.ptr = val1;
+    headers_data[1].f1.len = 1;
+
+    runner_list_tuple2_string_list_u8_t headers = { headers_data, 2 };
+    runner_list_tuple2_string_list_u8_t result;
+    test_lists_to_test_wasi_http_headers_roundtrip(&headers, &result);
+
+    assert(result.len == 2);
+    assert(result.ptr[0].f0.len == 12);
+    assert(memcmp(result.ptr[0].f0.ptr, "Content-Type", 12) == 0);
+    assert(result.ptr[0].f1.len == 10);
+    assert(memcmp(result.ptr[0].f1.ptr, "text/plain", 10) == 0);
+    assert(result.ptr[1].f0.len == 14);
+    assert(memcmp(result.ptr[1].f0.ptr, "Content-Length", 14) == 0);
+    assert(result.ptr[1].f1.len == 1);
+    assert(result.ptr[1].f1.ptr[0] == '9');
+
+    runner_list_tuple2_string_list_u8_free(&result);
+  }
 }

tests/runtime/lists/runner.cpp

@@ -105,4 +105,18 @@ void exports::runner::Run()
             std::vector<double>{DBL_MIN, DBL_MAX, -HUGE_VAL, HUGE_VAL}
         )
     ));
+
+    {
+        std::vector<uint8_t> val0 = {'t', 'e', 'x', 't', '/', 'p', 'l', 'a', 'i', 'n'};
+        std::vector<uint8_t> val1 = {'9'};
+        std::vector<std::tuple<std::string_view, std::span<const uint8_t>>> headers;
+        headers.push_back(std::make_tuple(std::string_view("Content-Type"), std::span<const uint8_t>(val0)));
+        headers.push_back(std::make_tuple(std::string_view("Content-Length"), std::span<const uint8_t>(val1)));
+        auto result = WasiHttpHeadersRoundtrip(headers);
+        assert(result.size() == 2);
+        assert(equal(std::get<0>(result[0]), "Content-Type"));
+        assert(equal(std::get<1>(result[0]), std::vector<uint8_t>{'t', 'e', 'x', 't', '/', 'p', 'l', 'a', 'i', 'n'}));
+        assert(equal(std::get<0>(result[1]), "Content-Length"));
+        assert(equal(std::get<1>(result[1]), std::vector<uint8_t>{'9'}));
+    }
 }

tests/runtime/lists/runner.go

@@ -32,6 +32,19 @@ func Run() {
 	assertEqual(test.ListResult2(), "hello!")
 	assert(slices.Equal(test.ListResult3(), []string{"hello,", "world!"}))
 	assert(slices.Equal(test.ListRoundtrip([]uint8{}), []uint8{}))
+
+	{
+		headers := []Tuple2[string, []uint8]{
+			{V1: "Content-Type", V2: []uint8("text/plain")},
+			{V1: "Content-Length", V2: []uint8("9")},
+		}
+		result := test.WasiHttpHeadersRoundtrip(headers)
+		assertEqual(len(result), 2)
+		assertEqual(result[0].V1, "Content-Type")
+		assert(slices.Equal(result[0].V2, []uint8("text/plain")))
+		assertEqual(result[1].V1, "Content-Length")
+		assert(slices.Equal(result[1].V2, []uint8("9")))
+	}
 }
 
 func assertEqual[T comparable](a T, b T) {

tests/runtime/lists/test.c

@@ -161,3 +161,7 @@ void exports_test_lists_to_test_list_minmax_float(test_list_f32_t *a, test_list_
   ret->f0 = *a;
   ret->f1 = *b;
 }
+
+void exports_test_lists_to_test_wasi_http_headers_roundtrip(test_list_tuple2_string_list_u8_t *a, test_list_tuple2_string_list_u8_t *ret0) {
+  *ret0 = *a;
+}

tests/runtime/lists/test.cpp

@@ -129,3 +129,7 @@ std::tuple<wit::vector<uint64_t>, wit::vector<int64_t>> exports::test::lists::to
 std::tuple<wit::vector<float>, wit::vector<double>> exports::test::lists::to_test::ListMinmaxFloat(wit::vector<float> a, wit::vector<double> b) {
     return std::make_tuple(std::move(a), std::move(b));
 }
+
+wit::vector<std::tuple<wit::string, wit::vector<uint8_t>>> exports::test::lists::to_test::WasiHttpHeadersRoundtrip(wit::vector<std::tuple<wit::string, wit::vector<uint8_t>>> a) {
+    return a;
+}

tests/runtime/lists/test.go

@@ -111,3 +111,7 @@ func ListMinmax64(x []uint64, y []int64) ([]uint64, []int64) {
 func ListMinmaxFloat(x []float32, y []float64) ([]float32, []float64) {
 	return x, y
 }
+
+func WasiHttpHeadersRoundtrip(x []Tuple2[string, []uint8]) []Tuple2[string, []uint8] {
+	return x
+}

tests/runtime/lists/test.mbt

@@ -124,6 +124,11 @@ pub fn string_roundtrip(a : String) -> String {
   a
 }
 
+///|
+pub fn wasi_http_headers_roundtrip(a : Array[(String, FixedArray[Byte])]) -> Array[(String, FixedArray[Byte])] {
+  a
+}
+
 ///|
 pub fn allocated_bytes() -> UInt {
   // not quite sure about this