[Orc] Add support for remote JITing to the ORC API.

[oota-llvm.git] / unittests / ExecutionEngine / Orc / RPCUtilsTest.cpp

diff --git a/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp b/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
new file mode 100644 (file)
index 0000000..8215144
--- /dev/null
+++ b/unittests/ExecutionEngine/Orc/RPCUtilsTest.cpp
@@ -0,0 +1,147 @@
+//===----------- RPCUtilsTest.cpp - Unit tests the Orc RPC utils ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/RPCChannel.h"
+#include "llvm/ExecutionEngine/Orc/RPCUtils.h"
+#include "gtest/gtest.h"
+
+#include <queue>
+
+using namespace llvm;
+using namespace llvm::orc;
+using namespace llvm::orc::remote;
+
+class QueueChannel : public RPCChannel {
+public:
+  QueueChannel(std::queue<char> &Queue) : Queue(Queue) {}
+
+  std::error_code readBytes(char *Dst, unsigned Size) override {
+    while (Size--) {
+      *Dst++ = Queue.front();
+      Queue.pop();
+    }
+    return std::error_code();
+  }
+
+  std::error_code appendBytes(const char *Src, unsigned Size) override {
+    while (Size--)
+      Queue.push(*Src++);
+    return std::error_code();
+  }
+
+  std::error_code send() override { return std::error_code(); }
+
+private:
+  std::queue<char> &Queue;
+};
+
+class DummyRPC : public testing::Test,
+                 public RPC<QueueChannel> {
+public:
+  typedef Procedure<1, bool> Proc1;
+  typedef Procedure<2, int8_t,
+                       uint8_t,
+                       int16_t,
+                       uint16_t,
+                       int32_t,
+                       uint32_t,
+                       int64_t,
+                       uint64_t,
+                       bool,
+                       std::string,
+                       std::vector<int>> AllTheTypes;
+};
+
+
+TEST_F(DummyRPC, TestBasic) {
+  std::queue<char> Queue;
+  QueueChannel C(Queue);
+
+  {
+    // Make a call to Proc1.
+    auto EC = call<Proc1>(C, true);
+    EXPECT_FALSE(EC) << "Simple call over queue failed";
+  }
+
+  {
+    // Expect a call to Proc1.
+    auto EC = expect<Proc1>(C,
+                [&](bool &B) {
+                  EXPECT_EQ(B, true)
+                    << "Bool serialization broken";
+                  return std::error_code();
+                });
+    EXPECT_FALSE(EC) << "Simple expect over queue failed";
+  }
+}
+
+TEST_F(DummyRPC, TestSerialization) {
+  std::queue<char> Queue;
+  QueueChannel C(Queue);
+
+  {
+    // Make a call to Proc1.
+    std::vector<int> v({42, 7});
+    auto EC = call<AllTheTypes>(C,
+                                -101,
+                                250,
+                                -10000,
+                                10000,
+                                -1000000000,
+                                1000000000,
+                                -10000000000,
+                                10000000000,
+                                true,
+                                "foo",
+                                v);
+    EXPECT_FALSE(EC) << "Big (serialization test) call over queue failed";
+  }
+
+  {
+    // Expect a call to Proc1.
+    auto EC = expect<AllTheTypes>(C,
+                [&](int8_t &s8,
+                    uint8_t &u8,
+                    int16_t &s16,
+                    uint16_t &u16,
+                    int32_t &s32,
+                    uint32_t &u32,
+                    int64_t &s64,
+                    uint64_t &u64,
+                    bool &b,
+                    std::string &s,
+                    std::vector<int> &v) {
+
+                    EXPECT_EQ(s8, -101)
+                      << "int8_t serialization broken";
+                    EXPECT_EQ(u8, 250)
+                      << "uint8_t serialization broken";
+                    EXPECT_EQ(s16, -10000)
+                      << "int16_t serialization broken";
+                    EXPECT_EQ(u16, 10000)
+                      << "uint16_t serialization broken";
+                    EXPECT_EQ(s32, -1000000000)
+                      << "int32_t serialization broken";
+                    EXPECT_EQ(u32, 1000000000ULL)
+                      << "uint32_t serialization broken";
+                    EXPECT_EQ(s64, -10000000000)
+                      << "int64_t serialization broken";
+                    EXPECT_EQ(u64, 10000000000ULL)
+                      << "uint64_t serialization broken";
+                    EXPECT_EQ(b, true)
+                      << "bool serialization broken";
+                    EXPECT_EQ(s, "foo")
+                      << "std::string serialization broken";
+                    EXPECT_EQ(v, std::vector<int>({42, 7}))
+                      << "std::vector serialization broken";
+                    return std::error_code();
+                  });
+    EXPECT_FALSE(EC) << "Big (serialization test) call over queue failed";
+  }
+}