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 "gtest/gtest.h"
  12
  13 #include <future>
  14
  15 using namespace llvm;
  16 using namespace llvm::orc::shared;
  17
  18 namespace {
  19 constexpr const char *TestString = "test string";
  20 } // end anonymous namespace
  21
  22 TEST(WrapperFunctionUtilsTest, DefaultWrapperFunctionResult) {
  23   WrapperFunctionResult R;
  24   EXPECT_TRUE(R.empty());
  25   EXPECT_EQ(R.size(), 0U);
  26   EXPECT_EQ(R.getOutOfBandError(), nullptr);
  27 }
  28
  29 TEST(WrapperFunctionUtilsTest, WrapperFunctionResultFromRange) {
  30   auto R = WrapperFunctionResult::copyFrom(TestString, strlen(TestString) + 1);
  31   EXPECT_EQ(R.size(), strlen(TestString) + 1);
  32   EXPECT_TRUE(strcmp(R.data(), TestString) == 0);
  33   EXPECT_FALSE(R.empty());
  34   EXPECT_EQ(R.getOutOfBandError(), nullptr);
  35 }
  36
  37 TEST(WrapperFunctionUtilsTest, WrapperFunctionResultFromCString) {
  38   auto R = WrapperFunctionResult::copyFrom(TestString);
  39   EXPECT_EQ(R.size(), strlen(TestString) + 1);
  40   EXPECT_TRUE(strcmp(R.data(), TestString) == 0);
  41   EXPECT_FALSE(R.empty());
  42   EXPECT_EQ(R.getOutOfBandError(), nullptr);
  43 }
  44
  45 TEST(WrapperFunctionUtilsTest, WrapperFunctionResultFromStdString) {
  46   auto R = WrapperFunctionResult::copyFrom(std::string(TestString));
  47   EXPECT_EQ(R.size(), strlen(TestString) + 1);
  48   EXPECT_TRUE(strcmp(R.data(), TestString) == 0);
  49   EXPECT_FALSE(R.empty());
  50   EXPECT_EQ(R.getOutOfBandError(), nullptr);
  51 }
  52
  53 TEST(WrapperFunctionUtilsTest, WrapperFunctionResultFromOutOfBandError) {
  54   auto R = WrapperFunctionResult::createOutOfBandError(TestString);
  55   EXPECT_FALSE(R.empty());
  56   EXPECT_TRUE(strcmp(R.getOutOfBandError(), TestString) == 0);
  57 }
  58
  59 static void voidNoop() {}
  60
  61 static WrapperFunctionResult voidNoopWrapper(const char *ArgData,
  62                                              size_t ArgSize) {
  63   return WrapperFunction<void()>::handle(ArgData, ArgSize, voidNoop);
  64 }
  65
  66 static WrapperFunctionResult addWrapper(const char *ArgData, size_t ArgSize) {
  67   return WrapperFunction<int32_t(int32_t, int32_t)>::handle(
  68       ArgData, ArgSize, [](int32_t X, int32_t Y) -> int32_t { return X + Y; });
  69 }
  70
  71 TEST(WrapperFunctionUtilsTest, WrapperFunctionCallAndHandleVoid) {
  72   EXPECT_FALSE(!!WrapperFunction<void()>::call(voidNoopWrapper));
  73 }
  74
  75 TEST(WrapperFunctionUtilsTest, WrapperFunctionCallAndHandleRet) {
  76   int32_t Result;
  77   EXPECT_FALSE(!!WrapperFunction<int32_t(int32_t, int32_t)>::call(
  78       addWrapper, Result, 1, 2));
  79   EXPECT_EQ(Result, (int32_t)3);
  80 }
  81
  82 static void voidNoopAsync(unique_function<void(SPSEmpty)> SendResult) {
  83   SendResult(SPSEmpty());
  84 }
  85
  86 static WrapperFunctionResult voidNoopAsyncWrapper(const char *ArgData,
  87                                                   size_t ArgSize) {
  88   std::promise<WrapperFunctionResult> RP;
  89   auto RF = RP.get_future();
  90
  91   WrapperFunction<void()>::handleAsync(
  92       ArgData, ArgSize, voidNoopAsync,
  93       [&](WrapperFunctionResult R) { RP.set_value(std::move(R)); });
  94
  95   return RF.get();
  96 }
  97
  98 static WrapperFunctionResult addAsyncWrapper(const char *ArgData,
  99                                              size_t ArgSize) {
 100   std::promise<WrapperFunctionResult> RP;
 101   auto RF = RP.get_future();
 102
 103   WrapperFunction<int32_t(int32_t, int32_t)>::handleAsync(
 104       ArgData, ArgSize,
 105       [](unique_function<void(int32_t)> SendResult, int32_t X, int32_t Y) {
 106         SendResult(X + Y);
 107       },
 108       [&](WrapperFunctionResult R) { RP.set_value(std::move(R)); });
 109   return RF.get();
 110 }
 111
 112 TEST(WrapperFunctionUtilsTest, WrapperFunctionCallAndHandleAsyncVoid) {
 113   EXPECT_FALSE(!!WrapperFunction<void()>::call(voidNoopAsyncWrapper));
 114 }
 115
 116 TEST(WrapperFunctionUtilsTest, WrapperFunctionCallAndHandleAsyncRet) {
 117   int32_t Result;
 118   EXPECT_FALSE(!!WrapperFunction<int32_t(int32_t, int32_t)>::call(
 119       addAsyncWrapper, Result, 1, 2));
 120   EXPECT_EQ(Result, (int32_t)3);
 121 }