update stringref implementation (web-devkits#36)

* update stringref implementation --------- Signed-off-by: Xu Jun <[email protected]>
yviansu · Oct 23, 2023 · 562723e · 562723e
1 parent 47ad4c8
commit 562723e
Show file tree

Hide file tree

Showing 12 changed files with 264 additions and 121 deletions.
diff --git a/.github/workflows/libdyntype_ci.yaml b/.github/workflows/libdyntype_ci.yaml
@@ -43,6 +43,6 @@ jobs:
         run: |
           cd test
           mkdir build && cd build
-          cmake ..
+          cmake .. -DUNITTEST_USE_SANITIZER=1
           make
           make test
diff --git a/runtime-library/CMakeLists.txt b/runtime-library/CMakeLists.txt
@@ -26,12 +26,6 @@ if (USE_SANITIZER EQUAL 1)
                         -fno-sanitize-recover -Wall -Werror -Wformat")
 endif ()
 
-## stringref
-set(STRINGREF_DIR ${CMAKE_CURRENT_LIST_DIR}/stringref)
-set(WAMR_STRINGREF_IMPL_SOURCE
-    ${STRINGREF_DIR}/stringref_qjs.c
-)
-
 ## WAMR
 include(${CMAKE_CURRENT_LIST_DIR}/wamr_config.cmake)
 add_library(vmlib ${WAMR_RUNTIME_LIB_SOURCE})

diff --git a/runtime-library/libdyntype/test/CMakeLists.txt b/runtime-library/libdyntype/test/CMakeLists.txt
@@ -59,10 +59,12 @@ if (UNITTEST_USE_SANITIZER EQUAL 1)
 endif ()
 
 include(${LIBDYNTYPE_ROOT_DIR}/../wamr_config.cmake)
+include_directories(${LIBDYNTYPE_ROOT_DIR}/../deps/quickjs)
 add_subdirectory(${LIBDYNTYPE_ROOT_DIR} ${CMAKE_CURRENT_BINARY_DIR}/libdyntype)
 include_directories(${LIBDYNTYPE_ROOT_DIR})
 add_executable(
     dyntype_test
+    ${WAMR_STRINGREF_IMPL_SOURCE}
     ${CMAKE_CURRENT_LIST_DIR}/types_test.cc
     ${CMAKE_CURRENT_LIST_DIR}/object_property_test.cc
     ${CMAKE_CURRENT_LIST_DIR}/operator_test.cc

diff --git a/runtime-library/libdyntype/test/dump.cc b/runtime-library/libdyntype/test/dump.cc
@@ -4,6 +4,7 @@
  */
 
 #include "libdyntype_export.h"
+#include "stringref/string_object.h"
 #include <gtest/gtest.h>
 
 class DumpValueTest : public testing::Test {
@@ -49,7 +50,13 @@ TEST_F(DumpValueTest, dump_value) {
     // string
     testing::internal::CaptureStdout();
     // the output contains refer_count, output like "1`123456"
+#if WASM_ENABLE_STRINGREF != 0
+    WASMString wasm_string = wasm_string_new_const("123456");
+    dyn_value_t str = dyntype_new_string(ctx, wasm_string);
+    wasm_string_destroy(wasm_string);
+#else
     dyn_value_t str = dyntype_new_string(ctx, "123456", strlen("123456"));
+#endif
     dyntype_dump_value(ctx, str);
     const std::string output3 = testing::internal::GetCapturedStdout();
     EXPECT_STREQ(output3.c_str(), str_values[3]);

diff --git a/runtime-library/libdyntype/test/object_property_test.cc b/runtime-library/libdyntype/test/object_property_test.cc
@@ -6,6 +6,7 @@
 #include "libdyntype_export.h"
 #include <cstddef>
 #include <gtest/gtest.h>
+#include "stringref/string_object.h"
 #include "test_app.h"
 #include "wasm_export.h"
 
@@ -29,7 +30,13 @@ TEST_F(ObjectPropertyTest, object_set_and_has_and_get_property)
     dyn_value_t boolean = dyntype_new_boolean(ctx, true);
     dyn_value_t undefined = dyntype_new_undefined(ctx);
     dyn_value_t null = dyntype_new_null(ctx);
+#if WASM_ENABLE_STRINGREF != 0
+    WASMString wasm_string = wasm_string_new_const("string");
+    dyn_value_t str = dyntype_new_string(ctx, wasm_string);
+#else
     dyn_value_t str = dyntype_new_string(ctx, "string", strlen("string"));
+#endif
+
     dyn_value_t array = dyntype_new_array(ctx, 0);
     dyn_value_t extref = dyntype_new_extref(ctx, (void *)(uintptr_t)ext_data,
                                             external_ref_tag::ExtObj, NULL);
@@ -125,6 +132,10 @@ TEST_F(ObjectPropertyTest, object_set_and_has_and_get_property)
     dyntype_release(ctx, str);
     dyntype_release(ctx, array);
     dyntype_release(ctx, obj1);
+
+#if WASM_ENABLE_STRINGREF != 0
+    wasm_string_destroy(wasm_string);
+#endif
 }
 
 TEST_F(ObjectPropertyTest, object_define_and_has_and_get_property)
@@ -136,7 +147,12 @@ TEST_F(ObjectPropertyTest, object_define_and_has_and_get_property)
     dyn_value_t boolean = dyntype_new_boolean(ctx, true);
     dyn_value_t undefined = dyntype_new_undefined(ctx);
     dyn_value_t null = dyntype_new_null(ctx);
+#if WASM_ENABLE_STRINGREF != 0
+    WASMString wasm_string = wasm_string_new_const("  ");
+    dyn_value_t str = dyntype_new_string(ctx, wasm_string);
+#else
     dyn_value_t str = dyntype_new_string(ctx, "  ", 2);
+#endif
     dyn_value_t array = dyntype_new_array(ctx, 0);
     dyn_value_t extref = dyntype_new_extref(ctx, (void *)(uintptr_t)ext_data,
                                             external_ref_tag::ExtObj, NULL);
@@ -284,6 +300,10 @@ TEST_F(ObjectPropertyTest, object_define_and_has_and_get_property)
     dyntype_release(ctx, desc6);
     dyntype_release(ctx, desc7);
     dyntype_release(ctx, desc8);
+
+#if WASM_ENABLE_STRINGREF != 0
+    wasm_string_destroy(wasm_string);
+#endif
 }
 
 TEST_F(ObjectPropertyTest, object_set_and_delete_property)
@@ -296,7 +316,12 @@ TEST_F(ObjectPropertyTest, object_set_and_delete_property)
     dyn_value_t boolean = dyntype_new_boolean(ctx, true);
     dyn_value_t undefined = dyntype_new_undefined(ctx);
     dyn_value_t null = dyntype_new_null(ctx);
+#if WASM_ENABLE_STRINGREF != 0
+    WASMString wasm_string = wasm_string_new_const("string");
+    dyn_value_t str = dyntype_new_string(ctx, wasm_string);
+#else
     dyn_value_t str = dyntype_new_string(ctx, "string", strlen("string"));
+#endif
     dyn_value_t array = dyntype_new_array(ctx, 0);
     EXPECT_TRUE(dyntype_is_array(ctx, array));
     dyn_value_t extref = dyntype_new_extref(ctx, (void *)(uintptr_t)ext_data,
@@ -343,6 +368,10 @@ TEST_F(ObjectPropertyTest, object_set_and_delete_property)
     dyntype_release(ctx, array);
     dyntype_release(ctx, extref);
     dyntype_release(ctx, obj1);
+
+#if WASM_ENABLE_STRINGREF != 0
+    wasm_string_destroy(wasm_string);
+#endif
 }
 
 TEST_F(ObjectPropertyTest, object_define_and_delete_property)
@@ -354,7 +383,13 @@ TEST_F(ObjectPropertyTest, object_define_and_delete_property)
     dyn_value_t boolean = dyntype_new_boolean(ctx, true);
     dyn_value_t undefined = dyntype_new_undefined(ctx);
     dyn_value_t null = dyntype_new_null(ctx);
+
+#if WASM_ENABLE_STRINGREF != 0
+    WASMString wasm_string = wasm_string_new_const("  ");
+    dyn_value_t str = dyntype_new_string(ctx, wasm_string);
+#else
     dyn_value_t str = dyntype_new_string(ctx, "  ", 2);
+#endif
     dyn_value_t array = dyntype_new_array(ctx, 0);
     dyn_value_t extref = dyntype_new_extref(ctx, (void *)(uintptr_t)ext_data,
                                             external_ref_tag::ExtObj, NULL);
@@ -466,6 +501,10 @@ TEST_F(ObjectPropertyTest, object_define_and_delete_property)
     dyntype_release(ctx, desc6);
     dyntype_release(ctx, desc7);
     dyntype_release(ctx, desc8);
+
+#if WASM_ENABLE_STRINGREF != 0
+    wasm_string_destroy(wasm_string);
+#endif
 }
 
 TEST_F(ObjectPropertyTest, map_function_test)
@@ -474,7 +513,13 @@ TEST_F(ObjectPropertyTest, map_function_test)
 
     dyn_value_t num = dyntype_new_number(ctx, -10.1);
     dyn_value_t boolean = dyntype_new_boolean(ctx, true);
+#if WASM_ENABLE_STRINGREF != 0
+    WASMString wasm_string = wasm_string_new_const("123");
+    dyn_value_t str = dyntype_new_string(ctx, wasm_string);
+#else
     dyn_value_t str = dyntype_new_string(ctx, "123", strlen("123"));
+#endif
+
     dyn_value_t array = dyntype_new_array(ctx, 0);
 
     dyn_value_t argv[10];
@@ -534,6 +579,10 @@ TEST_F(ObjectPropertyTest, map_function_test)
     dyntype_release(ctx, array);
 
     dyntype_release(ctx, obj);
+
+#if WASM_ENABLE_STRINGREF != 0
+    wasm_string_destroy(wasm_string);
+#endif
 }
 
 static dyn_value_t
@@ -570,17 +619,31 @@ TEST_F(ObjectPropertyTest, map_callback_test)
 
     for (int i = 0, j = '0'; i < 10; i++, j++) {
         str[0] = j;
+#if WASM_ENABLE_STRINGREF != 0
+        WASMString wasm_string = wasm_string_new_const(str);
+        dyn_value_t key = dyntype_new_string(ctx, wasm_string);
+#else
         dyn_value_t key = dyntype_new_string(ctx, str, strlen(str));
+#endif
         dyn_value_t val = dyntype_new_number(ctx, i);
         argv[0] = key;
         argv[1] = val;
         ret = dyntype_invoke(ctx, "set", obj, 2, argv); // set  num -> boolean
         dyntype_release(ctx, ret);                      // release duplicate map
         dyntype_release(ctx, key);
         dyntype_release(ctx, val);
+#if WASM_ENABLE_STRINGREF != 0
+    wasm_string_destroy(wasm_string);
+#endif
     }
 
+#if WASM_ENABLE_STRINGREF != 0
+    WASMString wasm_string = wasm_string_new_const(str);
+    gkey = dyntype_new_string(ctx, wasm_string);
+    wasm_string_destroy(wasm_string);
+#else
     gkey = dyntype_new_string(ctx, str, strlen(str));
+#endif
     argv[0] = gkey;
     ret = dyntype_invoke(ctx, "has", obj, 1, argv);
     bool has;

diff --git a/runtime-library/libdyntype/test/operator_test.cc b/runtime-library/libdyntype/test/operator_test.cc
@@ -4,37 +4,46 @@
  */
 
 #include "libdyntype_export.h"
+#include "stringref/string_object.h"
 #include <gtest/gtest.h>
 
-class OperatorTest : public testing::Test {
+class OperatorTest : public testing::Test
+{
   protected:
-    virtual void SetUp() {
-        ctx = dyntype_context_init();
-    }
+    virtual void SetUp() { ctx = dyntype_context_init(); }
 
-    virtual void TearDown() {
-        dyntype_context_destroy(ctx);
-    }
+    virtual void TearDown() { dyntype_context_destroy(ctx); }
 
-    testing::AssertionResult is_type_eq(dyn_value_t lhs, dyn_value_t rhs, uint32_t l, uint32_t r) {
+    testing::AssertionResult is_type_eq(dyn_value_t lhs, dyn_value_t rhs,
+                                        uint32_t l, uint32_t r)
+    {
         if (dyntype_type_eq(ctx, lhs, rhs)) {
-            return testing::AssertionSuccess() << "they are value1[" << l << "], value2[" << r << "]";
+            return testing::AssertionSuccess()
+                   << "they are value1[" << l << "], value2[" << r << "]";
         }
-        return testing::AssertionFailure() << "they are value1[" << l << "], value2[" << r << "]";
+        return testing::AssertionFailure()
+               << "they are value1[" << l << "], value2[" << r << "]";
     }
 
     dyn_ctx_t ctx;
 };
 
-TEST_F(OperatorTest, typeof) {
+TEST_F(OperatorTest, typeof)
+{
     int ext_data = 1000;
 
     dyn_value_t num = dyntype_new_number(ctx, 2147483649);
     dyn_value_t boolean = dyntype_new_boolean(ctx, true);
     dyn_value_t undefined = dyntype_new_undefined(ctx);
     dyn_value_t null = dyntype_new_null(ctx);
     dyn_value_t obj = dyntype_new_object(ctx);
+#if WASM_ENABLE_STRINGREF != 0
+    WASMString wasm_string = wasm_string_new_const("string");
+    dyn_value_t str = dyntype_new_string(ctx, wasm_string);
+#else
     dyn_value_t str = dyntype_new_string(ctx, "string", strlen("string"));
+#endif
+
     dyn_value_t array = dyntype_new_array(ctx, 0);
     dyn_value_t extref_obj = dyntype_new_extref(
         ctx, (void *)(uintptr_t)ext_data, external_ref_tag::ExtObj, NULL);
@@ -58,16 +67,30 @@ TEST_F(OperatorTest, typeof) {
     dyntype_release(ctx, array);
     dyntype_release(ctx, extref_obj);
     dyntype_release(ctx, extref_func);
+
+#if WASM_ENABLE_STRINGREF != 0
+    wasm_string_destroy(wasm_string);
+#endif
 }
 
-TEST_F(OperatorTest, type_eq) {
+TEST_F(OperatorTest, type_eq)
+{
     int ext_data = 1000;
 
+#if WASM_ENABLE_STRINGREF != 0
+    WASMString wasm_string1 = wasm_string_new_const("string");
+    WASMString wasm_string2 = wasm_string_new_const("test");
+#endif
+
     dyn_value_t value1[] = {
         dyntype_new_number(ctx, 2147483649),
         dyntype_new_boolean(ctx, true),
         dyntype_new_undefined(ctx),
+#if WASM_ENABLE_STRINGREF != 0
+        dyntype_new_string(ctx, wasm_string1),
+#else
         dyntype_new_string(ctx, "string", strlen("string")),
+#endif
         dyntype_new_extref(ctx, (void *)(uintptr_t)ext_data,
                            external_ref_tag::ExtObj, NULL),
         dyntype_new_extref(ctx, (void *)(uintptr_t)ext_data,
@@ -78,7 +101,11 @@ TEST_F(OperatorTest, type_eq) {
         dyntype_new_number(ctx, -10.00),
         dyntype_new_boolean(ctx, false),
         dyntype_new_undefined(ctx),
+#if WASM_ENABLE_STRINGREF != 0
+        dyntype_new_string(ctx, wasm_string2),
+#else
         dyntype_new_string(ctx, "test", strlen("test")),
+#endif
         dyntype_new_extref(ctx, (void *)(uintptr_t)ext_data,
                            external_ref_tag::ExtObj, NULL),
         dyntype_new_extref(ctx, (void *)(uintptr_t)ext_data,
@@ -107,29 +134,34 @@ TEST_F(OperatorTest, type_eq) {
     // null, arary, object types
     for (uint32_t i = 8; i < len2; i++) {
         for (uint32_t j = 8; j < len3; j++) {
-                EXPECT_TRUE(is_type_eq(value2[i], value3[j], i, j));
+            EXPECT_TRUE(is_type_eq(value2[i], value3[j], i, j));
         }
     }
 
     for (uint32_t i = 0; i < len1; i++) {
         if (value1[i] == dyntype_new_undefined(ctx)
             || value1[i] == dyntype_new_null(ctx)) {
-                continue;
+            continue;
         }
         dyntype_release(ctx, value1[i]);
     }
     for (uint32_t i = 0; i < len2; i++) {
         if (value2[i] == dyntype_new_undefined(ctx)
             || value2[i] == dyntype_new_null(ctx)) {
-                continue;
+            continue;
         }
         dyntype_release(ctx, value2[i]);
     }
     for (uint32_t i = 0; i < len3; i++) {
         if (value3[i] == dyntype_new_undefined(ctx)
             || value3[i] == dyntype_new_null(ctx)) {
-                continue;
+            continue;
         }
         dyntype_release(ctx, value3[i]);
     }
+
+#if WASM_ENABLE_STRINGREF != 0
+    wasm_string_destroy(wasm_string1);
+    wasm_string_destroy(wasm_string2);
+#endif
 }