add tests

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

Author: chaoqin-li1123

test/runtime_test.cc

@@ -137,6 +137,32 @@ TEST_P(TestVM, StraceLogLevel) {
   EXPECT_NE(integration->trace_message_, "");
 }
 
+TEST_P(TestVM, BadExportFunction) {
+  auto source = readTestWasmFile("callback.wasm");
+  ASSERT_TRUE(vm_->load(source, {}, {}));
+
+  TestContext context;
+  vm_->registerCallback(
+      "env", "callback", &callback,
+      &ConvertFunctionWordToUint32<decltype(callback), callback>::convertFunctionWordToUint32);
+  ASSERT_TRUE(vm_->link(""));
+
+  WasmCallVoid<0> run;
+  vm_->getFunction("non-existent", &run);
+  EXPECT_TRUE(run == nullptr);
+
+  WasmCallWord<2> bad_signature_run;
+  vm_->getFunction("run", &bad_signature_run);
+  EXPECT_TRUE(bad_signature_run == nullptr);
+
+  vm_->getFunction("run", &run);
+  EXPECT_TRUE(run != nullptr);
+  for (auto i = 0; i < 100; i++) {
+    run(&context);
+  }
+  ASSERT_EQ(context.counter, 100);
+}
+
 TEST_P(TestVM, Callback) {
   auto source = readTestWasmFile("callback.wasm");
   ASSERT_TRUE(vm_->load(source, {}, {}));

test/wasm_test.cc

@@ -15,6 +15,7 @@
 #include "include/proxy-wasm/wasm.h"
 
 #include "gtest/gtest.h"
+#include <memory>
 
 #include "test/utility.h"
 
@@ -111,4 +112,57 @@ TEST_P(TestVM, GetOrCreateThreadLocalWasmFailCallbacks) {
   ASSERT_NE(thread_local_plugin3->wasm(), thread_local_plugin2->wasm());
 }
 
+TEST_P(TestVM, 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");
+
+  // 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);
+  EXPECT_TRUE(getThreadLocalWasm(vm_id) == base_wasm_handle);
+  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");
+  EXPECT_TRUE(base_wasm_handle->wasm()->getRootContext(plugin2, false) == nullptr);
+
+  // Create context from a plugin2.
+  base_wasm_handle->wasm()->createContext(plugin2);
+  ContextBase *root_context2 = base_wasm_handle->wasm()->getRootContext(plugin2, false);
+  EXPECT_TRUE(root_context2 != nullptr);
+
+  // Verify that the 2 root contexts are different contexts with the same root id.
+  EXPECT_TRUE(root_context1->isRootContext() && root_context2->isRootContext());
+  EXPECT_TRUE(root_context1 != root_context2);
+  EXPECT_TRUE(root_context1->root_id() == root_context2->root_id());
+}
+
 } // namespace proxy_wasm