more tests

Signed-off-by: chaoqin-li1123 <[email protected]>

Author: chaoqin-li1123

src/shared_queue.h

@@ -31,9 +31,9 @@ class SharedQueue {
   WasmResult enqueue(uint32_t token, std::string_view value);
 
   void deleteByVmId(std::string_view vm_id);
-  uint32_t nextQueueToken();
 
 private:
+  uint32_t nextQueueToken();
   struct Queue {
     std::string vm_key;
     uint32_t context_id;

test/BUILD

@@ -131,7 +131,9 @@ cc_library(
     hdrs = ["utility.h"],
     deps = [
         "//:lib",
-        "//:wasmtime_lib",
+        "//:wamr_lib",
+        # wamr and wasmtime can't coexist for now because they have different definitions for same set of abi.
+        # "//:wasmtime_lib",
         "//:wavm_lib",
         "@com_google_googletest//:gtest",
     ],

test/runtime_test.cc

@@ -16,7 +16,6 @@
 
 #include <fstream>
 #include <iostream>
-#include <memory>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -108,11 +107,7 @@ void callback() {
 Word callback2(Word val) { return val + 100; }
 
 TEST_P(TestVM, StraceLogLevel) {
-  if (runtime_ == "wavm") {
-    // TODO(mathetake): strace is yet to be implemented for WAVM.
-    // See https://github.com/proxy-wasm/proxy-wasm-cpp-host/issues/120.
-    return;
-  }
+  SKIP_TEST_FOR_RUNTIME(wavm)
 
   auto integration = static_cast<DummyIntegration *>(vm_->integration().get());
   auto source = readTestWasmFile("callback.wasm");

test/shared_queue_test.cc

@@ -15,6 +15,7 @@
 #include "src/shared_queue.h"
 
 #include <thread>
+#include <atomic>
 
 #include "gtest/gtest.h"
 
@@ -24,10 +25,14 @@ namespace proxy_wasm {
 
 TEST(SharedQueue, NextQueueToken) {
   SharedQueue shared_queue(false);
-  for (auto i = 1; i < 5; i++) {
-    EXPECT_EQ(i, shared_queue.nextQueueToken());
+  std::string_view vm_id = "id";
+  std::string_view vm_key = "vm_key";
+  std::string_view queue_name = "name";
+  uint32_t context_id = 1;
+
+  for (auto i = 1; i <= 5; i++) {
+    EXPECT_EQ(i, shared_queue.registerQueue(vm_id, std::to_string(i), context_id, nullptr, vm_key));
   }
-  EXPECT_EQ(5, shared_queue.registerQueue("a", "b", 1, nullptr, "c"));
 }
 
 TEST(SharedQueue, SingleThread) {
@@ -88,7 +93,7 @@ TEST(SharedQueue, Concurrent) {
   std::string_view queue_name = "name";
   uint32_t context_id = 1;
 
-  auto queued_count = 0;
+  std::atomic<uint32_t> queued_count = 0;
   std::mutex mutex;
   std::function<void(std::function<void()>)> call_on_thread =
       [&mutex, &queued_count](const std::function<void()> &f) {

test/utility.h

@@ -36,6 +36,11 @@
 #include "include/proxy-wasm/wamr.h"
 #endif
 
+#define SKIP_TEST_FOR_RUNTIME(runtime)                                                             \
+  if (runtime_ == #runtime) {                                                                      \
+    return;                                                                                        \
+  }
+
 namespace proxy_wasm {
 
 std::vector<std::string> getRuntimes();

test/wasm_test.cc

@@ -23,58 +23,61 @@ namespace proxy_wasm {
 
 auto test_values = testing::ValuesIn(getRuntimes());
 
-INSTANTIATE_TEST_SUITE_P(Runtimes, TestVM, test_values);
+struct WasmTest : public TestVM {
+  WasmTest() {
+    wasm_handle_factory_ = [this](std::string_view vm_key) -> std::shared_ptr<WasmHandleBase> {
+      auto base_wasm = std::make_shared<WasmBase>(newVm(), vm_id_, vm_config_, vm_key,
+                                                  std::unordered_map<std::string, std::string>{},
+                                                  AllowedCapabilitiesMap{});
+      return std::make_shared<WasmHandleBase>(base_wasm);
+    };
+
+    wasm_handle_clone_factory_ =
+        [this](
+            std::shared_ptr<WasmHandleBase> base_wasm_handle) -> std::shared_ptr<WasmHandleBase> {
+      auto wasm = std::make_shared<WasmBase>(
+          base_wasm_handle, [this]() -> std::unique_ptr<WasmVm> { return newVm(); });
+      return std::make_shared<WasmHandleBase>(wasm);
+    };
+
+    plugin_handle_factory_ =
+        [](std::shared_ptr<WasmHandleBase> base_wasm,
+           std::shared_ptr<PluginBase> plugin) -> std::shared_ptr<PluginHandleBase> {
+      return std::make_shared<PluginHandleBase>(base_wasm, plugin);
+    };
+  }
+  const std::string vm_id_ = "vm_id";
+  const std::string vm_config_ = "vm_config";
+  std::string source_ = readTestWasmFile("abi_export.wasm");
+  WasmHandleFactory wasm_handle_factory_;
+  WasmHandleCloneFactory wasm_handle_clone_factory_;
+  PluginHandleFactory plugin_handle_factory_;
+};
+
+INSTANTIATE_TEST_SUITE_P(Runtimes, WasmTest, test_values);
 
 // Failcallbacks only used for runtimes - not available for nullvm.
-TEST_P(TestVM, GetOrCreateThreadLocalWasmFailCallbacks) {
-  const auto plugin_name = "plugin_name";
-  const auto root_id = "root_id";
-  const auto vm_id = "vm_id";
-  const auto vm_config = "vm_config";
-  const auto plugin_config = "plugin_config";
-  const auto fail_open = false;
-
+TEST_P(WasmTest, GetOrCreateThreadLocalWasmFailCallbacks) {
+  const std::string plugin_name = "plugin_name";
+  const std::string root_id = "root_id";
+  const std::string plugin_config = "plugin_config";
+  const bool fail_open = false;
   // Create a plugin.
-  const auto plugin = std::make_shared<PluginBase>(plugin_name, root_id, vm_id, runtime_,
+  const auto plugin = std::make_shared<PluginBase>(plugin_name, root_id, vm_id_, runtime_,
                                                    plugin_config, fail_open, "plugin_key");
 
-  // Define callbacks.
-  WasmHandleFactory wasm_handle_factory =
-      [this, vm_id, vm_config](std::string_view vm_key) -> std::shared_ptr<WasmHandleBase> {
-    auto base_wasm = std::make_shared<WasmBase>(newVm(), vm_id, vm_config, vm_key,
-                                                std::unordered_map<std::string, std::string>{},
-                                                AllowedCapabilitiesMap{});
-    return std::make_shared<WasmHandleBase>(base_wasm);
-  };
-
-  WasmHandleCloneFactory wasm_handle_clone_factory =
-      [this](std::shared_ptr<WasmHandleBase> base_wasm_handle) -> std::shared_ptr<WasmHandleBase> {
-    auto wasm = std::make_shared<WasmBase>(base_wasm_handle,
-                                           [this]() -> std::unique_ptr<WasmVm> { return newVm(); });
-    return std::make_shared<WasmHandleBase>(wasm);
-  };
-
-  PluginHandleFactory plugin_handle_factory =
-      [](std::shared_ptr<WasmHandleBase> base_wasm,
-         std::shared_ptr<PluginBase> plugin) -> std::shared_ptr<PluginHandleBase> {
-    return std::make_shared<PluginHandleBase>(base_wasm, plugin);
-  };
-
-  // Read the minimal loadable binary.
-  auto source = readTestWasmFile("abi_export.wasm");
-
   // Create base Wasm via createWasm.
-  auto base_wasm_handle =
-      createWasm("vm_key", source, plugin, wasm_handle_factory, wasm_handle_clone_factory, false);
-  ASSERT_TRUE(base_wasm_handle && base_wasm_handle->wasm());
+  auto base_wasm_handle = createWasm("vm_key", source_, plugin, wasm_handle_factory_,
+                                     wasm_handle_clone_factory_, false);
 
+  ASSERT_TRUE(base_wasm_handle && base_wasm_handle->wasm());
   // Create a thread local plugin.
   auto thread_local_plugin = getOrCreateThreadLocalPlugin(
-      base_wasm_handle, plugin, wasm_handle_clone_factory, plugin_handle_factory);
+      base_wasm_handle, plugin, wasm_handle_clone_factory_, plugin_handle_factory_);
   ASSERT_TRUE(thread_local_plugin && thread_local_plugin->plugin());
   // If the VM is not failed, same WasmBase should be used for the same configuration.
-  ASSERT_EQ(getOrCreateThreadLocalPlugin(base_wasm_handle, plugin, wasm_handle_clone_factory,
-                                         plugin_handle_factory)
+  ASSERT_EQ(getOrCreateThreadLocalPlugin(base_wasm_handle, plugin, wasm_handle_clone_factory_,
+                                         plugin_handle_factory_)
                 ->wasm(),
             thread_local_plugin->wasm());
 
@@ -87,7 +90,7 @@ TEST_P(TestVM, GetOrCreateThreadLocalWasmFailCallbacks) {
   // Create another thread local plugin with the same configuration.
   // This one should not end up using the failed VM.
   auto thread_local_plugin2 = getOrCreateThreadLocalPlugin(
-      base_wasm_handle, plugin, wasm_handle_clone_factory, plugin_handle_factory);
+      base_wasm_handle, plugin, wasm_handle_clone_factory_, plugin_handle_factory_);
   ASSERT_TRUE(thread_local_plugin2 && thread_local_plugin2->plugin());
   ASSERT_FALSE(thread_local_plugin2->wasm()->isFailed());
   // Verify the pointer to WasmBase is different from the failed one.
@@ -101,58 +104,36 @@ TEST_P(TestVM, GetOrCreateThreadLocalWasmFailCallbacks) {
 
   // This time, create another thread local plugin with *different* plugin key for the same vm_key.
   // This one also should not end up using the failed VM.
-  const auto plugin2 = std::make_shared<PluginBase>(plugin_name, root_id, vm_id, runtime_,
+  const auto plugin2 = std::make_shared<PluginBase>(plugin_name, root_id, vm_id_, runtime_,
                                                     plugin_config, fail_open, "another_plugin_key");
   auto thread_local_plugin3 = getOrCreateThreadLocalPlugin(
-      base_wasm_handle, plugin2, wasm_handle_clone_factory, plugin_handle_factory);
+      base_wasm_handle, plugin2, wasm_handle_clone_factory_, plugin_handle_factory_);
   ASSERT_TRUE(thread_local_plugin3 && thread_local_plugin3->plugin());
   ASSERT_FALSE(thread_local_plugin3->wasm()->isFailed());
   // Verify the pointer to WasmBase is different from the failed one.
   ASSERT_NE(thread_local_plugin3->wasm(), thread_local_plugin->wasm());
   ASSERT_NE(thread_local_plugin3->wasm(), thread_local_plugin2->wasm());
 }
 
-TEST_P(TestVM, DifferentRootContextsFromDifferentPluginKeys) {
+TEST_P(WasmTest, DifferentRootContextsFromDifferentPluginKeys) {
   const std::string plugin_name = "plugin_name";
   const std::string root_id = "root_id";
-  const std::string vm_id = "vm_id";
-  const std::string vm_config = "vm_config";
   const std::string plugin_config = "plugin_config";
   const bool fail_open = false;
-
   const std::shared_ptr<PluginBase> plugin1 = std::make_shared<PluginBase>(
-      plugin_name, root_id, vm_id, runtime_, plugin_config, fail_open, "plugin1_key");
-
-  // Define callbacks.
-  WasmHandleFactory wasm_handle_factory =
-      [this, vm_id, vm_config](std::string_view vm_key) -> std::shared_ptr<WasmHandleBase> {
-    auto base_wasm = std::make_shared<WasmBase>(newVm(), vm_id, vm_config, vm_key,
-                                                std::unordered_map<std::string, std::string>{},
-                                                AllowedCapabilitiesMap{});
-    return std::make_shared<WasmHandleBase>(base_wasm);
-  };
-
-  WasmHandleCloneFactory wasm_handle_clone_factory =
-      [this](std::shared_ptr<WasmHandleBase> base_wasm_handle) -> std::shared_ptr<WasmHandleBase> {
-    std::shared_ptr<WasmBase> wasm = std::make_shared<WasmBase>(
-        base_wasm_handle, [this]() -> std::unique_ptr<WasmVm> { return newVm(); });
-    return std::make_shared<WasmHandleBase>(wasm);
-  };
-
-  // Read the minimal loadable binary.
-  std::string source = readTestWasmFile("abi_export.wasm");
+      plugin_name, root_id, vm_id_, runtime_, plugin_config, fail_open, "plugin1_key");
 
   const std::string vm_key = "vm_key";
   // Create base Wasm via createWasm.
   std::shared_ptr<WasmHandleBase> base_wasm_handle =
-      createWasm(vm_key, source, plugin1, wasm_handle_factory, wasm_handle_clone_factory, false);
+      createWasm(vm_key, source_, plugin1, wasm_handle_factory_, wasm_handle_clone_factory_, false);
   base_wasm_handle->wasm()->start(plugin1);
   ContextBase *root_context1 = base_wasm_handle->wasm()->getRootContext(plugin1, false);
   EXPECT_TRUE(root_context1 != nullptr);
 
   // Create a new plugin with different key.
   const std::shared_ptr<PluginBase> plugin2 = std::make_shared<PluginBase>(
-      plugin_name, root_id, vm_id, runtime_, plugin_config, fail_open, "plugin2_key");
+      plugin_name, root_id, vm_id_, runtime_, plugin_config, fail_open, "plugin2_key");
   EXPECT_TRUE(base_wasm_handle->wasm()->getRootContext(plugin2, false) == nullptr);
 
   // Create context from a plugin2.