Rename bigendian test to more generic "arg passing"

Signed-off-by: Matt Leon <mattleon@google.com>

Author: leonm1

test/BUILD

@@ -71,7 +71,7 @@ cc_test(
     srcs = ["runtime_test.cc"],
     data = [
         "//test/test_data:callback.wasm",
-        "//test/test_data:bigendian.wasm",
+        "//test/test_data:arg_passing.wasm",
         "//test/test_data:clock.wasm",
         "//test/test_data:resource_limits.wasm",
         "//test/test_data:trap.wasm",

test/runtime_test.cc

@@ -190,31 +190,31 @@ TEST_P(TestVm, Trap2) {
   }
 }
 
-TEST_P(TestVm, BigendianValuesTranslatedProperly) {
-  auto source = readTestWasmFile("bigendian.wasm");
+TEST_P(TestVm, PassingValuesAcrossWasmBoundary) {
+  auto source = readTestWasmFile("arg_passing.wasm");
   ASSERT_FALSE(source.empty());
   auto wasm = TestWasm(std::move(vm_));
   ASSERT_TRUE(wasm.load(source, false));
   ASSERT_TRUE(wasm.initialize());
   auto *context = dynamic_cast<TestContext *>(wasm.vm_context());
   ASSERT_NE(context, nullptr);
-  WasmCall_WWlfd test_bigendian;
-  wasm.wasm_vm()->getFunction("test_bigendian", &test_bigendian);
-  WasmCall_WWlfd test_bigendian_negatives;
-  wasm.wasm_vm()->getFunction("test_bigendian_negatives", &test_bigendian_negatives);
+  WasmCall_WWlfd test_primitives;
+  wasm.wasm_vm()->getFunction("test_primitives", &test_primitives);
+  WasmCall_WWlfd test_negative_primitives;
+  wasm.wasm_vm()->getFunction("test_negative_primitives", &test_negative_primitives);
   WasmCallWord<0> test_buffer_from_wasm;
-  wasm.wasm_vm()->getFunction("test_bigendian_buffer_from_wasm", &test_buffer_from_wasm);
+  wasm.wasm_vm()->getFunction("test_buffer_from_wasm", &test_buffer_from_wasm);
   WasmCallWord<0> test_buffer_from_host;
-  wasm.wasm_vm()->getFunction("test_bigendian_buffer_from_host", &test_buffer_from_host);
+  wasm.wasm_vm()->getFunction("test_buffer_from_host", &test_buffer_from_host);
 
-  ASSERT_FALSE(test_bigendian(context, 3333333333U, 11111111111111111111UL, 1111, 1111111111));
+  ASSERT_FALSE(test_primitives(context, 3333333333U, 11111111111111111111UL, 1111, 1111111111));
   ASSERT_FALSE(
-      test_bigendian_negatives(context, -1111111111, -1111111111111111111, -1111, -1111111111));
+      test_negative_primitives(context, -1111111111, -1111111111111111111, -1111, -1111111111));
 
   ASSERT_FALSE(test_buffer_from_wasm(context));
-  context->isLogged("hello from little-endian wasm land!");
+  context->isLogged("hello from wasm land!");
 
-  context->setBuffer(0, "hello from host land endianness!");
+  context->setBuffer(0, "hello from host land!");
   ASSERT_FALSE(test_buffer_from_host(context));
 }
 

test/test_data/BUILD

@@ -58,8 +58,8 @@ wasm_rust_binary(
 )
 
 wasm_rust_binary(
-    name = "bigendian.wasm",
-    srcs = ["bigendian.rs"],
+    name = "arg_passing.wasm",
+    srcs = ["arg_passing.rs"],
 )
 
 wasm_rust_binary(

test/test_data/bigendian.rs test/test_data/arg_passing.rstest/test_data/bigendian.rs renamed to test/test_data/arg_passing.rs

@@ -25,56 +25,66 @@ pub extern "C" fn proxy_on_memory_allocate(size: usize) -> *mut u8 {
     Box::into_raw(slice) as *mut u8
 }
 
+extern "C" {
+    fn proxy_log(level: u32, message_data: *const u8, message_size: usize) -> bool;
+}
+
+fn log(message: &str) {
+    unsafe {
+        proxy_log(/*error*/ 4, message.as_bytes().as_ptr(), message.len());
+    }
+}
+
 #[no_mangle]
-pub extern "C" fn test_bigendian(uint32: u32, uint64: u64, float32: f32, float64: f64) -> i32 {
+pub extern "C" fn test_primitives(uint32: u32, uint64: u64, float32: f32, float64: f64) -> i32 {
     if uint32 != 3333333333 {
-        println!("uint32 was not little-endian: {}", uint32);
+        log(&format!("unexpected uint32 value: {}", uint32));
         return 1;
     }
     if uint64 != 11111111111111111111 {
-        println!("uint64 was not little-endian: {}", uint32);
+        log(&format!("unexpected uint64 value: {}", uint32));
         return 2;
     }
     if float32 < 1110.0 || float32 > 1112.0 {
-        println!("float32 was not little-endian: {}", float32);
+        log(&format!("unexpected float32 value: {}", float32));
         return 3;
     }
     if float64 < 1111111110.0 || float64 > 1111111112.0 {
-        println!("float64 was not little-endian: {}", float64);
+        log(&format!("unexpected float64 value: {}", float64));
         return 4;
     }
     return 0;
 }
 
 #[no_mangle]
-pub extern "C" fn test_bigendian_negatives(
+pub extern "C" fn test_negative_primitives(
     int32: i32,
     int64: i64,
     float32: f32,
     float64: f64,
 ) -> i32 {
     if int32 != -1111111111 {
+        log(&format!("unexpected int32 value: {}", int32));
         return 1;
     }
     if int64 != -1111111111111111111 {
+        log(&format!("unexpected int64 value: {}", int32));
         return 2;
     }
     if float32 > -1110.0 || float32 < -1112.0 {
+        log(&format!("unexpected float32 value: {}", float32));
         return 3;
     }
     if float64 > -1111111110.0 || float64 < -1111111112.0 {
+        log(&format!("unexpected float64 value: {}", float64));
         return 4;
     }
     return 0;
 }
 
-extern "C" {
-    fn proxy_log(level: u32, message_data: *const u8, message_size: usize) -> bool;
-}
-
 #[no_mangle]
-pub extern "C" fn test_bigendian_buffer_from_wasm() -> bool {
-    let message = "hello from little-endian wasm land!";
+pub extern "C" fn test_buffer_from_wasm() -> bool {
+    let message = "hello from wasm land!";
     unsafe {
         match proxy_log(/*info*/ 2, message.as_ptr(), message.len()) {
             false => false,
@@ -94,7 +104,7 @@ extern "C" {
 }
 
 #[no_mangle]
-pub extern "C" fn test_bigendian_buffer_from_host() -> bool {
+pub extern "C" fn test_buffer_from_host() -> bool {
     let mut return_data: *mut u8 = std::ptr::null_mut();
     let mut return_size: usize = 0;
     unsafe {
@@ -105,7 +115,7 @@ pub extern "C" fn test_bigendian_buffer_from_host() -> bool {
                 }
                 let result =
                     String::from_utf8(Vec::from_raw_parts(return_data, return_size, return_size));
-                if result.unwrap() != "hello from host land endianness" {
+                if result.unwrap() != "hello from host land" {
                     panic!("message did not match expectation");
                 }
                 false