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