llvm/unittests/ExecutionEngine/Orc/WrapperFunctionUtilsTest.cpp

   1 //===----- WrapperFunctionUtilsTest.cpp - Test Wrapper-Function utils -----===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/ExecutionEngine/Orc/Shared/WrapperFunctionUtils.h"
  10 #include "llvm/ADT/FunctionExtras.h"
  11 #include "llvm/Testing/Support/Error.h"
  12 #include "gtest/gtest.h"
  13
  14 #include <future>
  15
  16 using namespace llvm;
  17 using namespace llvm::orc;
  18 using namespace llvm::orc::shared;
  19
  20 namespace {
  21 constexpr const char *TestString = "test string";
  22 } // end anonymous namespace
  23
  24 TEST(WrapperFunctionUtilsTest, DefaultWrapperFunctionResult) {
  25   WrapperFunctionResult R;
  26   EXPECT_TRUE(R.empty());
  27   EXPECT_EQ(R.size(), 0U);
  28   EXPECT_EQ(R.getOutOfBandError(), nullptr);
  29 }
  30
  31 TEST(WrapperFunctionUtilsTest, WrapperFunctionResultFromRange) {
  32   auto R = WrapperFunctionResult::copyFrom(TestString, strlen(TestString) + 1);
  33   EXPECT_EQ(R.size(), strlen(TestString) + 1);
  34   EXPECT_TRUE(strcmp(R.data(), TestString) == 0);
  35   EXPECT_FALSE(R.empty());
  36   EXPECT_EQ(R.getOutOfBandError(), nullptr);
  37 }
  38
  39 TEST(WrapperFunctionUtilsTest, WrapperFunctionResultFromCString) {
  40   auto R = WrapperFunctionResult::copyFrom(TestString);
  41   EXPECT_EQ(R.size(), strlen(TestString) + 1);
  42   EXPECT_TRUE(strcmp(R.data(), TestString) == 0);
  43   EXPECT_FALSE(R.empty());
  44   EXPECT_EQ(R.getOutOfBandError(), nullptr);
  45 }
  46
  47 TEST(WrapperFunctionUtilsTest, WrapperFunctionResultFromStdString) {
  48   auto R = WrapperFunctionResult::copyFrom(std::string(TestString));
  49   EXPECT_EQ(R.size(), strlen(TestString) + 1);
  50   EXPECT_TRUE(strcmp(R.data(), TestString) == 0);
  51   EXPECT_FALSE(R.empty());
  52   EXPECT_EQ(R.getOutOfBandError(), nullptr);
  53 }
  54
  55 TEST(WrapperFunctionUtilsTest, WrapperFunctionResultFromOutOfBandError) {
  56   auto R = WrapperFunctionResult::createOutOfBandError(TestString);
  57   EXPECT_FALSE(R.empty());
  58   EXPECT_TRUE(strcmp(R.getOutOfBandError(), TestString) == 0);
  59 }
  60
  61 TEST(WrapperFunctionUtilsTest, WrapperFunctionCCallCreateEmpty) {
  62   EXPECT_THAT_EXPECTED(
  63       WrapperFunctionCall::Create<SPSArgList<>>(ExecutorAddr()), Succeeded());
  64 }
  65
  66 static void voidNoop() {}
  67
  68 class AddClass {
  69 public:
  70   AddClass(int32_t X) : X(X) {}
  71   int32_t addMethod(int32_t Y) { return X + Y; }
  72 private:
  73   int32_t X;
  74 };
  75
  76 static WrapperFunctionResult voidNoopWrapper(const char *ArgData,
  77                                              size_t ArgSize) {
  78   return WrapperFunction<void()>::handle(ArgData, ArgSize, voidNoop);
  79 }
  80
  81 static WrapperFunctionResult addWrapper(const char *ArgData, size_t ArgSize) {
  82   return WrapperFunction<int32_t(int32_t, int32_t)>::handle(
  83       ArgData, ArgSize, [](int32_t X, int32_t Y) -> int32_t { return X + Y; });
  84 }
  85
  86 static WrapperFunctionResult addMethodWrapper(const char *ArgData,
  87                                               size_t ArgSize) {
  88   return WrapperFunction<int32_t(SPSExecutorAddr, int32_t)>::handle(
  89       ArgData, ArgSize, makeMethodWrapperHandler(&AddClass::addMethod));
  90 }
  91
  92 TEST(WrapperFunctionUtilsTest, WrapperFunctionCallAndHandleVoid) {
  93   EXPECT_FALSE(!!WrapperFunction<void()>::call(voidNoopWrapper));
  94 }
  95
  96 TEST(WrapperFunctionUtilsTest, WrapperFunctionCallAndHandleRet) {
  97   int32_t Result;
  98   EXPECT_FALSE(!!WrapperFunction<int32_t(int32_t, int32_t)>::call(
  99       addWrapper, Result, 1, 2));
 100   EXPECT_EQ(Result, (int32_t)3);
 101 }
 102
 103 TEST(WrapperFunctionUtilsTest, WrapperFunctionMethodCallAndHandleRet) {
 104   int32_t Result;
 105   AddClass AddObj(1);
 106   EXPECT_FALSE(!!WrapperFunction<int32_t(SPSExecutorAddr, int32_t)>::call(
 107       addMethodWrapper, Result, ExecutorAddr::fromPtr(&AddObj), 2));
 108   EXPECT_EQ(Result, (int32_t)3);
 109 }
 110
 111 static void voidNoopAsync(unique_function<void(SPSEmpty)> SendResult) {
 112   SendResult(SPSEmpty());
 113 }
 114
 115 static WrapperFunctionResult voidNoopAsyncWrapper(const char *ArgData,
 116                                                   size_t ArgSize) {
 117   std::promise<WrapperFunctionResult> RP;
 118   auto RF = RP.get_future();
 119
 120   WrapperFunction<void()>::handleAsync(
 121       ArgData, ArgSize, voidNoopAsync,
 122       [&](WrapperFunctionResult R) { RP.set_value(std::move(R)); });
 123
 124   return RF.get();
 125 }
 126
 127 static WrapperFunctionResult addAsyncWrapper(const char *ArgData,
 128                                              size_t ArgSize) {
 129   std::promise<WrapperFunctionResult> RP;
 130   auto RF = RP.get_future();
 131
 132   WrapperFunction<int32_t(int32_t, int32_t)>::handleAsync(
 133       ArgData, ArgSize,
 134       [](unique_function<void(int32_t)> SendResult, int32_t X, int32_t Y) {
 135         SendResult(X + Y);
 136       },
 137       [&](WrapperFunctionResult R) { RP.set_value(std::move(R)); });
 138   return RF.get();
 139 }
 140
 141 TEST(WrapperFunctionUtilsTest, WrapperFunctionCallAndHandleAsyncVoid) {
 142   EXPECT_FALSE(!!WrapperFunction<void()>::call(voidNoopAsyncWrapper));
 143 }
 144
 145 TEST(WrapperFunctionUtilsTest, WrapperFunctionCallAndHandleAsyncRet) {
 146   int32_t Result;
 147   EXPECT_FALSE(!!WrapperFunction<int32_t(int32_t, int32_t)>::call(
 148       addAsyncWrapper, Result, 1, 2));
 149   EXPECT_EQ(Result, (int32_t)3);
 150 }
 151
 152 static WrapperFunctionResult failingWrapper(const char *ArgData,
 153                                             size_t ArgSize) {
 154   return WrapperFunctionResult::createOutOfBandError("failed");
 155 }
 156
 157 void asyncFailingWrapperCaller(unique_function<void(WrapperFunctionResult)> F,
 158                                const char *ArgData, size_t ArgSize) {
 159   F(failingWrapper(ArgData, ArgSize));
 160 }
 161
 162 TEST(WrapperFunctionUtilsTest, WrapperFunctionCallFailingAsync) {
 163   WrapperFunction<void()>::callAsync(asyncFailingWrapperCaller, [](Error Err) {
 164     EXPECT_THAT_ERROR(std::move(Err), Failed());
 165   });
 166 }