297 lines · cpp
1//===- SimplePackedSerializationTest.cpp ----------------------------------===//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-exception6//7//===----------------------------------------------------------------------===//8//9// Tests for SimplePackedSerialization infrastructure.10//11//===----------------------------------------------------------------------===//12 13#include "orc-rt/SimplePackedSerialization.h"14 15#include "SimplePackedSerializationTestUtils.h"16#include "gtest/gtest.h"17 18using namespace orc_rt;19 20TEST(SimplePackedSerializationTest, SPSOutputBuffer) {21 constexpr unsigned NumBytes = 8;22 char Buffer[NumBytes];23 char Zero = 0;24 SPSOutputBuffer OB(Buffer, NumBytes);25 26 // Expect that we can write NumBytes of content.27 for (unsigned I = 0; I != NumBytes; ++I) {28 char C = I;29 EXPECT_TRUE(OB.write(&C, 1));30 }31 32 // Expect an error when we attempt to write an extra byte.33 EXPECT_FALSE(OB.write(&Zero, 1));34 35 // Check that the buffer contains the expected content.36 for (unsigned I = 0; I != NumBytes; ++I)37 EXPECT_EQ(Buffer[I], (char)I);38}39 40TEST(SimplePackedSerializationTest, SPSInputBuffer) {41 char Buffer[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};42 SPSInputBuffer IB(Buffer, sizeof(Buffer));43 44 char C;45 for (unsigned I = 0; I != sizeof(Buffer); ++I) {46 EXPECT_TRUE(IB.read(&C, 1));47 EXPECT_EQ(C, (char)I);48 }49 50 EXPECT_FALSE(IB.read(&C, 1));51}52 53template <typename T> static void testFixedIntegralTypeSerialization() {54 blobSerializationRoundTrip<T, T>(0);55 blobSerializationRoundTrip<T, T>(static_cast<T>(1));56 if (std::is_signed<T>::value) {57 blobSerializationRoundTrip<T, T>(static_cast<T>(-1));58 blobSerializationRoundTrip<T, T>(std::numeric_limits<T>::min());59 }60 blobSerializationRoundTrip<T, T>(std::numeric_limits<T>::max());61}62 63TEST(SimplePackedSerializationTest, BoolSerialization) {64 blobSerializationRoundTrip<bool, bool>(true);65 blobSerializationRoundTrip<bool, bool>(false);66}67 68TEST(SimplePackedSerializationTest, CharSerialization) {69 blobSerializationRoundTrip<char, char>((char)0x00);70 blobSerializationRoundTrip<char, char>((char)0xAA);71 blobSerializationRoundTrip<char, char>((char)0xFF);72}73 74TEST(SimplePackedSerializationTest, Int8Serialization) {75 testFixedIntegralTypeSerialization<int8_t>();76}77 78TEST(SimplePackedSerializationTest, UInt8Serialization) {79 testFixedIntegralTypeSerialization<uint8_t>();80}81 82TEST(SimplePackedSerializationTest, Int16Serialization) {83 testFixedIntegralTypeSerialization<int16_t>();84}85 86TEST(SimplePackedSerializationTest, UInt16Serialization) {87 testFixedIntegralTypeSerialization<uint16_t>();88}89 90TEST(SimplePackedSerializationTest, Int32Serialization) {91 testFixedIntegralTypeSerialization<int32_t>();92}93 94TEST(SimplePackedSerializationTest, UInt32Serialization) {95 testFixedIntegralTypeSerialization<uint32_t>();96}97 98TEST(SimplePackedSerializationTest, Int64Serialization) {99 testFixedIntegralTypeSerialization<int64_t>();100}101 102TEST(SimplePackedSerializationTest, UInt64Serialization) {103 testFixedIntegralTypeSerialization<uint64_t>();104}105 106TEST(SimplePackedSerializationTest, SizeTSerialization) {107 size_t V = 42;108 blobSerializationRoundTrip<SPSSize, size_t>(V);109}110 111TEST(SimplePackedSerializationTest, SequenceSerialization) {112 std::vector<int32_t> V({1, 2, -47, 139});113 blobSerializationRoundTrip<SPSSequence<int32_t>, std::vector<int32_t>>(V);114}115 116TEST(SimplePackedSerializationTest, ExecutorAddr) {117 int X = 42;118 auto A = ExecutorAddr::fromPtr(&X);119 blobSerializationRoundTrip<SPSExecutorAddr>(A);120}121 122TEST(SimplePackedSerializationTest, StringViewCharSequenceSerialization) {123 const char *HW = "Hello, world!";124 blobSerializationRoundTrip<SPSString, std::string_view>(std::string_view(HW));125}126 127TEST(SimplePackedSerializationTest, SpanSerialization) {128 const char Data[] = {3, 2, 1, 0, 1, 2, 3}; // Span should handle nulls.129 span<const char> OutS(Data, sizeof(Data));130 131 size_t Size = SPSArgList<SPSSequence<char>>::size(OutS);132 auto Buffer = std::make_unique<char[]>(Size);133 SPSOutputBuffer OB(Buffer.get(), Size);134 135 EXPECT_TRUE(SPSArgList<SPSSequence<char>>::serialize(OB, OutS));136 137 SPSInputBuffer IB(Buffer.get(), Size);138 139 span<const char> InS;140 141 EXPECT_TRUE(SPSArgList<SPSSequence<char>>::deserialize(IB, InS));142 143 // Check that the serialized and deserialized values match.144 EXPECT_EQ(InS.size(), OutS.size());145 EXPECT_EQ(memcmp(OutS.data(), InS.data(), InS.size()), 0);146 147 // Check that the span points directly to the input buffer.148 EXPECT_EQ(InS.data(), Buffer.get() + sizeof(uint64_t));149}150 151TEST(SimplePackedSerializationTest, StdTupleSerialization) {152 std::tuple<int32_t, std::string, bool> P(42, "foo", true);153 blobSerializationRoundTrip<SPSTuple<int32_t, SPSString, bool>>(P);154}155 156TEST(SimplePackedSerializationTest, StdPairSerialization) {157 std::pair<int32_t, std::string> P(42, "foo");158 blobSerializationRoundTrip<SPSTuple<int32_t, SPSString>,159 std::pair<int32_t, std::string>>(P);160}161 162TEST(SimplePackedSerializationTest, StdOptionalNoValueSerialization) {163 std::optional<int64_t> NoValue;164 blobSerializationRoundTrip<SPSOptional<int64_t>>(NoValue);165}166 167TEST(SimplePackedSerializationTest, StdOptionalValueSerialization) {168 std::optional<int64_t> Value(42);169 blobSerializationRoundTrip<SPSOptional<int64_t>>(Value);170}171 172TEST(SimplePackedSerializationTest, Pointers) {173 int X = 42;174 int *P = &X;175 blobSerializationRoundTrip<SPSExecutorAddr>(P);176}177 178TEST(SimplePackedSerializationTest, ArgListSerialization) {179 using BAL = SPSArgList<bool, int32_t, SPSString>;180 181 bool Arg1 = true;182 int32_t Arg2 = 42;183 std::string Arg3 = "foo";184 185 size_t Size = BAL::size(Arg1, Arg2, Arg3);186 auto Buffer = std::make_unique<char[]>(Size);187 SPSOutputBuffer OB(Buffer.get(), Size);188 189 EXPECT_TRUE(BAL::serialize(OB, Arg1, Arg2, Arg3));190 191 SPSInputBuffer IB(Buffer.get(), Size);192 193 bool ArgOut1;194 int32_t ArgOut2;195 std::string ArgOut3;196 197 EXPECT_TRUE(BAL::deserialize(IB, ArgOut1, ArgOut2, ArgOut3));198 199 EXPECT_EQ(Arg1, ArgOut1);200 EXPECT_EQ(Arg2, ArgOut2);201 EXPECT_EQ(Arg3, ArgOut3);202}203 204TEST(SimplePackedSerializationTest, SerializeErrorSuccess) {205 auto B = spsSerialize<SPSArgList<SPSError>>(206 SPSSerializableError(Error::success()));207 if (!B) {208 ADD_FAILURE() << "Unexpected failure to serialize error-success value";209 return;210 }211 SPSSerializableError SE;212 if (!spsDeserialize<SPSArgList<SPSError>>(*B, SE)) {213 ADD_FAILURE() << "Unexpected failure to deserialize error-success value";214 return;215 }216 217 auto E = SE.toError();218 EXPECT_FALSE(!!E); // Expect non-error, i.e. Error::success().219}220 221TEST(SimplePackedSerializationTest, SerializeErrorFailure) {222 auto B = spsSerialize<SPSArgList<SPSError>>(223 SPSSerializableError(make_error<StringError>("test error message")));224 if (!B) {225 ADD_FAILURE() << "Unexpected failure to serialize error-failure value";226 return;227 }228 SPSSerializableError SE;229 if (!spsDeserialize<SPSArgList<SPSError>>(*B, SE)) {230 ADD_FAILURE() << "Unexpected failure to deserialize error-failure value";231 return;232 }233 234 EXPECT_EQ(toString(SE.toError()), std::string("test error message"));235}236 237TEST(SimplePackedSerializationTest, SerializeExpectedSuccessViaExpected) {238 auto B = spsSerialize<SPSArgList<SPSExpected<uint32_t>>>(239 toSPSSerializableExpected(Expected<uint32_t>(42U)));240 if (!B) {241 ADD_FAILURE() << "Unexpected failure to serialize expected-success value";242 return;243 }244 SPSSerializableExpected<uint32_t> SE;245 if (!spsDeserialize<SPSArgList<SPSExpected<uint32_t>>>(*B, SE)) {246 ADD_FAILURE() << "Unexpected failure to deserialize expected-success value";247 return;248 }249 250 auto E = SE.toExpected();251 if (E)252 EXPECT_EQ(*E, 42U);253 else254 ADD_FAILURE() << "Unexpected failure value";255}256 257TEST(SimplePackedSerializationTest, SerializeExpectedSuccessViaValue) {258 auto B = spsSerialize<SPSArgList<SPSExpected<uint32_t>>>(259 toSPSSerializableExpected(uint32_t(42U)));260 if (!B) {261 ADD_FAILURE() << "Unexpected failure to serialize expected-success value";262 return;263 }264 SPSSerializableExpected<uint32_t> SE;265 if (!spsDeserialize<SPSArgList<SPSExpected<uint32_t>>>(*B, SE)) {266 ADD_FAILURE() << "Unexpected failure to deserialize expected-success value";267 return;268 }269 270 auto E = SE.toExpected();271 if (E)272 EXPECT_EQ(*E, 42U);273 else274 ADD_FAILURE() << "Unexpected failure value";275}276 277TEST(SimplePackedSerializationTest, SerializeExpectedFailure) {278 auto B = spsSerialize<SPSArgList<SPSExpected<uint32_t>>>(279 toSPSSerializableExpected<uint32_t>(280 make_error<StringError>("test error message")));281 if (!B) {282 ADD_FAILURE() << "Unexpected failure to serialize expected-failure value";283 return;284 }285 SPSSerializableExpected<uint32_t> SE;286 if (!spsDeserialize<SPSArgList<SPSExpected<uint32_t>>>(*B, SE)) {287 ADD_FAILURE() << "Unexpected failure to deserialize expected-failure value";288 return;289 }290 291 auto E = SE.toExpected();292 if (E)293 ADD_FAILURE() << "Unexpected failure value";294 else295 EXPECT_EQ(toString(E.takeError()), std::string("test error message"));296}297