| /* |
| * Copyright 2019 Google LLC |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <iomanip> |
| #include <sstream> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| |
| #include "cppbor.h" |
| #include "cppbor_parse.h" |
| |
| using namespace cppbor; |
| using namespace std; |
| |
| using ::testing::_; |
| using ::testing::AllOf; |
| using ::testing::ByRef; |
| using ::testing::InSequence; |
| using ::testing::IsNull; |
| using ::testing::NotNull; |
| using ::testing::Return; |
| using ::testing::Truly; |
| using ::testing::Unused; |
| |
| string hexDump(const string& str) { |
| stringstream s; |
| for (auto c : str) { |
| s << setfill('0') << setw(2) << hex << (static_cast<unsigned>(c) & 0xff); |
| } |
| return s.str(); |
| } |
| |
| TEST(SimpleValueTest, UnsignedValueSizes) { |
| // Check that unsigned integers encode to correct lengths, and that encodedSize() is correct. |
| vector<pair<uint64_t /* value */, size_t /* expected encoded size */>> testCases{ |
| {0, 1}, |
| {1, 1}, |
| {23, 1}, |
| {24, 2}, |
| {255, 2}, |
| {256, 3}, |
| {65535, 3}, |
| {65536, 5}, |
| {4294967295, 5}, |
| {4294967296, 9}, |
| {std::numeric_limits<uint64_t>::max(), 9}, |
| }; |
| for (auto& testCase : testCases) { |
| Uint val(testCase.first); |
| EXPECT_EQ(testCase.second, val.encodedSize()) << "Wrong size for value " << testCase.first; |
| EXPECT_EQ(val.encodedSize(), val.toString().size()) |
| << "encodedSize and encoding disagree for value " << testCase.first; |
| } |
| } |
| |
| TEST(SimpleValueTest, UnsignedValueEncodings) { |
| EXPECT_EQ("\x00"s, Uint(0u).toString()); |
| EXPECT_EQ("\x01"s, Uint(1u).toString()); |
| EXPECT_EQ("\x0a"s, Uint(10u).toString()); |
| EXPECT_EQ("\x17"s, Uint(23u).toString()); |
| EXPECT_EQ("\x18\x18"s, Uint(24u).toString()); |
| EXPECT_EQ("\x18\x19"s, Uint(25u).toString()); |
| EXPECT_EQ("\x18\x64"s, Uint(100u).toString()); |
| EXPECT_EQ("\x19\x03\xe8"s, Uint(1000u).toString()); |
| EXPECT_EQ("\x1a\x00\x0f\x42\x40"s, Uint(1000000u).toString()); |
| EXPECT_EQ("\x1b\x00\x00\x00\xe8\xd4\xa5\x10\x00"s, Uint(1000000000000u).toString()); |
| EXPECT_EQ("\x1B\x7f\xff\xff\xff\xff\xff\xff\xff"s, |
| Uint(std::numeric_limits<int64_t>::max()).toString()); |
| } |
| |
| TEST(SimpleValueTest, NegativeValueEncodings) { |
| EXPECT_EQ("\x20"s, Nint(-1).toString()); |
| EXPECT_EQ("\x28"s, Nint(-9).toString()); |
| EXPECT_EQ("\x29"s, Nint(-10).toString()); |
| EXPECT_EQ("\x36"s, Nint(-23).toString()); |
| EXPECT_EQ("\x37"s, Nint(-24).toString()); |
| EXPECT_EQ("\x38\x18"s, Nint(-25).toString()); |
| EXPECT_EQ("\x38\x62"s, Nint(-99).toString()); |
| EXPECT_EQ("\x38\x63"s, Nint(-100).toString()); |
| EXPECT_EQ("\x39\x03\xe6"s, Nint(-999).toString()); |
| EXPECT_EQ("\x39\x03\xe7"s, Nint(-1000).toString()); |
| EXPECT_EQ("\x3a\x00\x0f\x42\x3F"s, Nint(-1000000).toString()); |
| EXPECT_EQ("\x3b\x00\x00\x00\xe8\xd4\xa5\x0f\xff"s, Nint(-1000000000000).toString()); |
| EXPECT_EQ("\x3B\x7f\xff\xff\xff\xff\xff\xff\xff"s, |
| Nint(std::numeric_limits<int64_t>::min()).toString()); |
| } |
| |
| TEST(SimpleValueDeathTest, NegativeValueEncodings) { |
| EXPECT_DEATH(Nint(0), ""); |
| EXPECT_DEATH(Nint(1), ""); |
| } |
| |
| TEST(SimpleValueTest, BooleanEncodings) { |
| EXPECT_EQ("\xf4"s, Bool(false).toString()); |
| EXPECT_EQ("\xf5"s, Bool(true).toString()); |
| } |
| |
| TEST(SimpleValueTest, NullEncodings) { |
| EXPECT_EQ("\xf6"s, Null().toString()); |
| } |
| |
| TEST(SimpleValueTest, ByteStringEncodings) { |
| EXPECT_EQ("\x40", Bstr("").toString()); |
| EXPECT_EQ("\x41\x61", Bstr("a").toString()); |
| EXPECT_EQ("\x41\x41", Bstr("A").toString()); |
| EXPECT_EQ("\x44\x49\x45\x54\x46", Bstr("IETF").toString()); |
| EXPECT_EQ("\x42\x22\x5c", Bstr("\"\\").toString()); |
| EXPECT_EQ("\x42\xc3\xbc", Bstr("\xc3\xbc").toString()); |
| EXPECT_EQ("\x43\xe6\xb0\xb4", Bstr("\xe6\xb0\xb4").toString()); |
| EXPECT_EQ("\x44\xf0\x90\x85\x91", Bstr("\xf0\x90\x85\x91").toString()); |
| EXPECT_EQ("\x44\x01\x02\x03\x04", Bstr("\x01\x02\x03\x04").toString()); |
| EXPECT_EQ("\x44\x40\x40\x40\x40", Bstr("@@@@").toString()); |
| } |
| |
| TEST(SimpleValueTest, TextStringEncodings) { |
| EXPECT_EQ("\x60"s, Tstr("").toString()); |
| EXPECT_EQ("\x61\x61"s, Tstr("a").toString()); |
| EXPECT_EQ("\x61\x41"s, Tstr("A").toString()); |
| EXPECT_EQ("\x64\x49\x45\x54\x46"s, Tstr("IETF").toString()); |
| EXPECT_EQ("\x62\x22\x5c"s, Tstr("\"\\").toString()); |
| EXPECT_EQ("\x62\xc3\xbc"s, Tstr("\xc3\xbc").toString()); |
| EXPECT_EQ("\x63\xe6\xb0\xb4"s, Tstr("\xe6\xb0\xb4").toString()); |
| EXPECT_EQ("\x64\xf0\x90\x85\x91"s, Tstr("\xf0\x90\x85\x91").toString()); |
| EXPECT_EQ("\x64\x01\x02\x03\x04"s, Tstr("\x01\x02\x03\x04").toString()); |
| } |
| |
| TEST(SimpleValueTest, SemanticTagEncoding) { |
| EXPECT_EQ("\xDB\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x63\x41\x45\x53"s, |
| Semantic(std::numeric_limits<uint64_t>::max(), "AES").toString()); |
| } |
| |
| TEST(IsIteratorPairOverTest, All) { |
| EXPECT_TRUE(( |
| details::is_iterator_pair_over<pair<string::iterator, string::iterator>, char>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over<pair<string::const_iterator, string::iterator>, |
| char>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over<pair<string::iterator, string::const_iterator>, |
| char>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over<pair<char*, char*>, char>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over<pair<const char*, char*>, char>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over<pair<char*, const char*>, char>::value)); |
| EXPECT_FALSE((details::is_iterator_pair_over<pair<string::iterator, string::iterator>, |
| uint8_t>::value)); |
| EXPECT_FALSE((details::is_iterator_pair_over<pair<char*, char*>, uint8_t>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over< |
| pair<vector<uint8_t>::iterator, vector<uint8_t>::iterator>, uint8_t>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over< |
| pair<vector<uint8_t>::const_iterator, vector<uint8_t>::iterator>, |
| uint8_t>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over< |
| pair<vector<uint8_t>::iterator, vector<uint8_t>::const_iterator>, |
| uint8_t>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over<pair<uint8_t*, uint8_t*>, uint8_t>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over<pair<const uint8_t*, uint8_t*>, uint8_t>::value)); |
| EXPECT_TRUE((details::is_iterator_pair_over<pair<uint8_t*, const uint8_t*>, uint8_t>::value)); |
| EXPECT_FALSE((details::is_iterator_pair_over< |
| pair<vector<uint8_t>::iterator, vector<uint8_t>::iterator>, char>::value)); |
| EXPECT_FALSE((details::is_iterator_pair_over<pair<uint8_t*, const uint8_t*>, char>::value)); |
| } |
| |
| TEST(IsUniquePtrSubclassOf, All) { |
| EXPECT_TRUE((details::is_unique_ptr_of_subclass_of_v<Item, std::unique_ptr<Bool>>::value)); |
| EXPECT_TRUE((details::is_unique_ptr_of_subclass_of_v<Item, std::unique_ptr<Map>>::value)); |
| EXPECT_TRUE((details::is_unique_ptr_of_subclass_of_v<Item, std::unique_ptr<Array>>::value)); |
| EXPECT_TRUE((details::is_unique_ptr_of_subclass_of_v<Item, std::unique_ptr<Semantic>>::value)); |
| EXPECT_FALSE( |
| (details::is_unique_ptr_of_subclass_of_v<std::string, std::unique_ptr<Bool>>::value)); |
| EXPECT_FALSE(( |
| details::is_unique_ptr_of_subclass_of_v<uint8_t, std::unique_ptr<std::string>>::value)); |
| } |
| |
| TEST(MakeEntryTest, Boolean) { |
| EXPECT_EQ("\xf4"s, details::makeItem(false)->toString()); |
| } |
| |
| TEST(MakeEntryTest, Null) { |
| EXPECT_EQ("\xf6"s, details::makeItem(nullptr)->toString()); |
| } |
| |
| TEST(MakeEntryTest, Integers) { |
| EXPECT_EQ("\x00"s, details::makeItem(static_cast<uint8_t>(0))->toString()); |
| EXPECT_EQ("\x00"s, details::makeItem(static_cast<uint16_t>(0))->toString()); |
| EXPECT_EQ("\x00"s, details::makeItem(static_cast<uint32_t>(0))->toString()); |
| EXPECT_EQ("\x00"s, details::makeItem(static_cast<uint64_t>(0))->toString()); |
| EXPECT_EQ("\x00"s, details::makeItem(static_cast<int8_t>(0))->toString()); |
| EXPECT_EQ("\x00"s, details::makeItem(static_cast<int16_t>(0))->toString()); |
| EXPECT_EQ("\x00"s, details::makeItem(static_cast<int32_t>(0))->toString()); |
| EXPECT_EQ("\x00"s, details::makeItem(static_cast<int64_t>(0))->toString()); |
| EXPECT_EQ("\x20"s, details::makeItem(static_cast<int8_t>(-1))->toString()); |
| EXPECT_EQ("\x20"s, details::makeItem(static_cast<int16_t>(-1))->toString()); |
| EXPECT_EQ("\x20"s, details::makeItem(static_cast<int32_t>(-1))->toString()); |
| EXPECT_EQ("\x20"s, details::makeItem(static_cast<int64_t>(-1))->toString()); |
| |
| EXPECT_EQ("\x1b\xff\xff\xff\xff\xff\xff\xff\xff"s, |
| details::makeItem(static_cast<uint64_t>(std::numeric_limits<uint64_t>::max())) |
| ->toString()); |
| } |
| |
| TEST(MakeEntryTest, StdStrings) { |
| string s1("hello"); |
| const string s2("hello"); |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s1)->toString()); // copy of string |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, |
| details::makeItem(s2)->toString()); // copy of const string |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, |
| details::makeItem(std::move(s1))->toString()); // move string |
| EXPECT_EQ(0U, s1.size()); // Prove string was moved, not copied. |
| } |
| |
| TEST(MakeEntryTest, StdStringViews) { |
| string_view s1("hello"); |
| const string_view s2("hello"); |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s1)->toString()); |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s2)->toString()); |
| } |
| |
| TEST(MakeEntryTest, CStrings) { |
| char s1[] = "hello"; |
| const char s2[] = "hello"; |
| const char* s3 = "hello"; |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s1)->toString()); |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s2)->toString()); |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(s3)->toString()); |
| } |
| |
| TEST(MakeEntryTest, StringIteratorPairs) { |
| // Use iterators from string to prove that "real" iterators work |
| string s1 = "hello"s; |
| pair<string::iterator, string::iterator> p1 = make_pair(s1.begin(), s1.end()); |
| |
| const pair<string::iterator, string::iterator> p2 = p1; |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(p1)->toString()); |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(p2)->toString()); |
| |
| // Use char*s as iterators |
| const char* s2 = "hello"; |
| pair p3 = make_pair(s2, s2 + 5); |
| const pair p4 = p3; |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(p3)->toString()); |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(p4)->toString()); |
| } |
| |
| TEST(MakeEntryTest, ByteStrings) { |
| vector<uint8_t> v1 = {0x00, 0x01, 0x02}; |
| const vector<uint8_t> v2 = {0x00, 0x01, 0x02}; |
| EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(v1)->toString()); // copy of vector |
| EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(v2)->toString()); // copy of const vector |
| EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(std::move(v1))->toString()); // move vector |
| EXPECT_EQ(0U, v1.size()); // Prove vector was moved, not copied. |
| } |
| |
| TEST(MakeEntryTest, ByteStringIteratorPairs) { |
| using vec = vector<uint8_t>; |
| using iter = vec::iterator; |
| vec v1 = {0x00, 0x01, 0x02}; |
| pair<iter, iter> p1 = make_pair(v1.begin(), v1.end()); |
| const pair<iter, iter> p2 = make_pair(v1.begin(), v1.end()); |
| EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p1)->toString()); |
| EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p2)->toString()); |
| |
| // Use uint8_t*s as iterators |
| uint8_t v2[] = {0x00, 0x01, 0x02}; |
| uint8_t* v3 = v2; |
| pair<uint8_t*, uint8_t*> p3 = make_pair(v2, v2 + 3); |
| const pair<uint8_t*, uint8_t*> p4 = make_pair(v2, v2 + 3); |
| pair<uint8_t*, uint8_t*> p5 = make_pair(v3, v3 + 3); |
| const pair<uint8_t*, uint8_t*> p6 = make_pair(v3, v3 + 3); |
| EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p3)->toString()); |
| EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p4)->toString()); |
| EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p5)->toString()); |
| EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(p6)->toString()); |
| } |
| |
| TEST(MakeEntryTest, ByteStringBuffers) { |
| uint8_t v1[] = {0x00, 0x01, 0x02}; |
| EXPECT_EQ("\x43\x00\x01\x02"s, details::makeItem(make_pair(v1, 3))->toString()); |
| } |
| |
| TEST(MakeEntryTest, ItemPointer) { |
| Uint* p1 = new Uint(0); |
| EXPECT_EQ("\x00"s, details::makeItem(p1)->toString()); |
| EXPECT_EQ("\x60"s, details::makeItem(new Tstr(string()))->toString()); |
| } |
| |
| TEST(MakeEntryTest, ItemReference) { |
| Tstr str("hello"s); |
| Tstr& strRef = str; |
| const Tstr& strConstRef = str; |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(str)->toString()); |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(strRef)->toString()); |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(strConstRef)->toString()); |
| EXPECT_EQ("\x65\x68\x65\x6c\x6c\x6f"s, details::makeItem(std::move(str))->toString()); |
| EXPECT_EQ("\x60"s, details::makeItem(str)->toString()); // Prove that it moved |
| |
| EXPECT_EQ("\x00"s, details::makeItem(Uint(0))->toString()); |
| |
| EXPECT_EQ("\x43\x00\x01\x02"s, |
| details::makeItem(Bstr(vector<uint8_t>{0x00, 0x01, 0x02}))->toString()); |
| |
| EXPECT_EQ("\x80"s, details::makeItem(Array())->toString()); |
| EXPECT_EQ("\xa0"s, details::makeItem(Map())->toString()); |
| } |
| |
| TEST(CompoundValueTest, ArrayOfInts) { |
| EXPECT_EQ("\x80"s, Array().toString()); |
| Array(Uint(0)).toString(); |
| |
| EXPECT_EQ("\x81\x00"s, Array(Uint(0U)).toString()); |
| EXPECT_EQ("\x82\x00\x01"s, Array(Uint(0), Uint(1)).toString()); |
| EXPECT_EQ("\x83\x00\x01\x38\x62"s, Array(Uint(0), Uint(1), Nint(-99)).toString()); |
| |
| EXPECT_EQ("\x81\x00"s, Array(0).toString()); |
| EXPECT_EQ("\x82\x00\x01"s, Array(0, 1).toString()); |
| EXPECT_EQ("\x83\x00\x01\x38\x62"s, Array(0, 1, -99).toString()); |
| } |
| |
| TEST(CompoundValueTest, MapOfInts) { |
| EXPECT_EQ("\xA0"s, Map().toString()); |
| EXPECT_EQ("\xA1\x00\x01"s, Map(Uint(0), Uint(1)).toString()); |
| // Maps with an odd number of arguments will fail to compile. Uncomment the next lines to test. |
| // EXPECT_EQ("\xA1\x00"s, Map(Int(0)).toString()); |
| // EXPECT_EQ("\xA1\x00\x01\x02"s, Map(Int(0), Int(1), Int(2)).toString()); |
| } |
| |
| TEST(CompoundValueTest, MixedArray) { |
| vector<uint8_t> vec = {3, 2, 1}; |
| EXPECT_EQ("\x84\x01\x20\x43\x03\x02\x01\x65\x68\x65\x6C\x6C\x6F"s, |
| Array(Uint(1), Nint(-1), Bstr(vec), Tstr("hello")).toString()); |
| |
| EXPECT_EQ("\x84\x01\x20\x43\x03\x02\x01\x65\x68\x65\x6C\x6C\x6F"s, |
| Array(1, -1, vec, "hello").toString()); |
| } |
| |
| TEST(CompoundValueTest, MixedMap) { |
| vector<uint8_t> vec = {3, 2, 1}; |
| EXPECT_EQ("\xA2\x01\x20\x43\x03\x02\x01\x65\x68\x65\x6C\x6C\x6F"s, |
| Map(Uint(1), Nint(-1), Bstr(vec), Tstr("hello")).toString()); |
| |
| EXPECT_EQ("\xA2\x01\x20\x43\x03\x02\x01\x65\x68\x65\x6C\x6C\x6F"s, |
| Map(1, -1, vec, "hello").toString()); |
| } |
| |
| TEST(CompoundValueTest, NestedStructures) { |
| vector<uint8_t> vec = {3, 2, 1}; |
| |
| string expectedEncoding = |
| "\xA2\x66\x4F\x75\x74\x65\x72\x31\x82\xA2\x66\x49\x6E\x6E\x65\x72\x31\x18\x63\x66\x49" |
| "\x6E" |
| "\x6E\x65\x72\x32\x43\x03\x02\x01\x63\x66\x6F\x6F\x66\x4F\x75\x74\x65\x72\x32\x0A"s; |
| |
| // Do it with explicity-created Items |
| EXPECT_EQ(expectedEncoding, |
| Map(Tstr("Outer1"), |
| Array( // |
| Map(Tstr("Inner1"), Uint(99), Tstr("Inner2"), Bstr(vec)), Tstr("foo")), |
| Tstr("Outer2"), // |
| Uint(10)) |
| .toString()); |
| EXPECT_EQ(3U, vec.size()); |
| |
| // Now just use convertible types |
| EXPECT_EQ(expectedEncoding, Map("Outer1", |
| Array(Map("Inner1", 99, // |
| "Inner2", vec), |
| "foo"), |
| "Outer2", 10) |
| .toString()); |
| EXPECT_EQ(3U, vec.size()); |
| |
| // Finally, do it with the .add() method. This is slightly less efficient, but has the |
| // advantage you can build a structure up incrementally, or somewhat fluently if you like. |
| // First, fluently. |
| EXPECT_EQ(expectedEncoding, Map().add("Outer1", Array().add(Map() // |
| .add("Inner1", 99) |
| .add("Inner2", vec)) |
| .add("foo")) |
| .add("Outer2", 10) |
| .toString()); |
| EXPECT_EQ(3U, vec.size()); |
| |
| // Next, more incrementally |
| Array arr; |
| arr.add(Map() // |
| .add("Inner1", 99) |
| .add("Inner2", vec)) |
| .add("foo"); |
| EXPECT_EQ(3U, vec.size()); |
| |
| Map m; |
| m.add("Outer1", std::move(arr)); // Moving is necessary; Map and Array cannot be copied. |
| m.add("Outer2", 10); |
| auto s = m.toString(); |
| EXPECT_EQ(expectedEncoding, s); |
| } |
| |
| TEST(EncodingMethodsTest, AllVariants) { |
| Map map; |
| map.add("key1", Array().add(Map() // |
| .add("key_a", 9999999) |
| .add("key_b", std::vector<uint8_t>{0x01, 0x02, 0x03}) |
| .add("key_c", std::numeric_limits<uint64_t>::max()) |
| .add("key_d", std::numeric_limits<int16_t>::min())) |
| .add("foo")) |
| .add("key2", true) |
| .add("key3", Semantic(987654321, "Zhai gana test")); |
| |
| std::vector<uint8_t> buf; |
| buf.resize(map.encodedSize()); |
| |
| EXPECT_EQ(buf.data() + buf.size(), map.encode(buf.data(), buf.data() + buf.size())); |
| |
| EXPECT_EQ(buf, map.encode()); |
| |
| std::vector<uint8_t> buf2; |
| map.encode(std::back_inserter(buf2)); |
| EXPECT_EQ(buf, buf2); |
| |
| auto iter = buf.begin(); |
| map.encode([&](uint8_t c) { EXPECT_EQ(c, *iter++); }); |
| } |
| |
| TEST(EncodingMethodsTest, UintWithTooShortBuf) { |
| Uint val(100000); |
| vector<uint8_t> buf(val.encodedSize() - 1); |
| EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size())); |
| } |
| |
| TEST(EncodingMethodsTest, TstrWithTooShortBuf) { |
| Tstr val("01234567890123456789012345"s); |
| vector<uint8_t> buf(1); |
| EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size())); |
| |
| buf.resize(val.encodedSize() - 1); |
| EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size())); |
| } |
| |
| TEST(EncodingMethodsTest, BstrWithTooShortBuf) { |
| Bstr val("01234567890123456789012345"s); |
| vector<uint8_t> buf(1); |
| EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size())); |
| |
| buf.resize(val.encodedSize() - 1); |
| EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size())); |
| } |
| |
| TEST(EncodingMethodsTest, ArrayWithTooShortBuf) { |
| Array val("a", 5, -100); |
| |
| std::vector<uint8_t> buf(val.encodedSize() - 1); |
| EXPECT_EQ(nullptr, val.encode(buf.data(), buf.data() + buf.size())); |
| } |
| |
| TEST(EncodingMethodsTest, MapWithTooShortBuf) { |
| Map map; |
| map.add("key1", Array().add(Map() // |
| .add("key_a", 99) |
| .add("key_b", std::vector<uint8_t>{0x01, 0x02, 0x03})) |
| .add("foo")) |
| .add("key2", true); |
| |
| std::vector<uint8_t> buf(map.encodedSize() - 1); |
| EXPECT_EQ(nullptr, map.encode(buf.data(), buf.data() + buf.size())); |
| } |
| |
| TEST(EncodingMethodsTest, SemanticWithTooShortBuf) { |
| Semantic tag(4321, Array().add(Array().add("Qaiyrly kesh!").add("Kesh zharyq!").add("431")) |
| .add(Map().add("kilt_1", 777).add("kilt_2", 999))); |
| std::vector<uint8_t> buf(tag.encodedSize() - 1); |
| EXPECT_EQ(nullptr, tag.encode(buf.data(), buf.data() + buf.size())); |
| } |
| |
| TEST(EqualityTest, Uint) { |
| Uint val(99); |
| EXPECT_EQ(val, Uint(99)); |
| |
| EXPECT_NE(val, Uint(98)); |
| EXPECT_NE(val, Nint(-1)); |
| EXPECT_NE(val, Tstr("99")); |
| EXPECT_NE(val, Bstr("99")); |
| EXPECT_NE(val, Bool(false)); |
| EXPECT_NE(val, Array(99, 1)); |
| EXPECT_NE(val, Map(99, 1)); |
| } |
| |
| TEST(EqualityTest, Nint) { |
| Nint val(-1); |
| EXPECT_EQ(val, Nint(-1)); |
| |
| EXPECT_NE(val, Uint(99)); |
| EXPECT_NE(val, Nint(-4)); |
| EXPECT_NE(val, Tstr("99")); |
| EXPECT_NE(val, Bstr("99")); |
| EXPECT_NE(val, Bool(false)); |
| EXPECT_NE(val, Array(99)); |
| EXPECT_NE(val, Map(99, 1)); |
| } |
| |
| TEST(EqualityTest, Tstr) { |
| Tstr val("99"); |
| EXPECT_EQ(val, Tstr("99")); |
| |
| EXPECT_NE(val, Uint(99)); |
| EXPECT_NE(val, Nint(-1)); |
| EXPECT_NE(val, Nint(-4)); |
| EXPECT_NE(val, Tstr("98")); |
| EXPECT_NE(val, Bstr("99")); |
| EXPECT_NE(val, Bool(false)); |
| EXPECT_NE(val, Array(99, 1)); |
| EXPECT_NE(val, Map(99, 1)); |
| } |
| |
| TEST(EqualityTest, Bstr) { |
| Bstr val("99"); |
| EXPECT_EQ(val, Bstr("99")); |
| |
| EXPECT_NE(val, Uint(99)); |
| EXPECT_NE(val, Nint(-1)); |
| EXPECT_NE(val, Nint(-4)); |
| EXPECT_NE(val, Tstr("99")); |
| EXPECT_NE(val, Bstr("98")); |
| EXPECT_NE(val, Bool(false)); |
| EXPECT_NE(val, Array(99, 1)); |
| EXPECT_NE(val, Map(99, 1)); |
| } |
| |
| TEST(EqualityTest, Bool) { |
| Bool val(false); |
| EXPECT_EQ(val, Bool(false)); |
| |
| EXPECT_NE(val, Uint(99)); |
| EXPECT_NE(val, Nint(-1)); |
| EXPECT_NE(val, Nint(-4)); |
| EXPECT_NE(val, Tstr("99")); |
| EXPECT_NE(val, Bstr("98")); |
| EXPECT_NE(val, Bool(true)); |
| EXPECT_NE(val, Array(99, 1)); |
| EXPECT_NE(val, Map(99, 1)); |
| } |
| |
| TEST(EqualityTest, Array) { |
| Array val(99, 1); |
| EXPECT_EQ(val, Array(99, 1)); |
| |
| EXPECT_NE(val, Uint(99)); |
| EXPECT_NE(val, Nint(-1)); |
| EXPECT_NE(val, Nint(-4)); |
| EXPECT_NE(val, Tstr("99")); |
| EXPECT_NE(val, Bstr("98")); |
| EXPECT_NE(val, Bool(true)); |
| EXPECT_NE(val, Array(99, 2)); |
| EXPECT_NE(val, Array(98, 1)); |
| EXPECT_NE(val, Array(99, 1, 2)); |
| EXPECT_NE(val, Map(99, 1)); |
| } |
| |
| TEST(EqualityTest, Map) { |
| Map val(99, 1); |
| EXPECT_EQ(val, Map(99, 1)); |
| |
| EXPECT_NE(val, Uint(99)); |
| EXPECT_NE(val, Nint(-1)); |
| EXPECT_NE(val, Nint(-4)); |
| EXPECT_NE(val, Tstr("99")); |
| EXPECT_NE(val, Bstr("98")); |
| EXPECT_NE(val, Bool(true)); |
| EXPECT_NE(val, Array(99, 1)); |
| EXPECT_NE(val, Map(99, 2)); |
| EXPECT_NE(val, Map(99, 1, 99, 2)); |
| } |
| |
| TEST(EqualityTest, Null) { |
| Null val; |
| EXPECT_EQ(val, Null()); |
| |
| EXPECT_NE(val, Uint(99)); |
| EXPECT_NE(val, Nint(-1)); |
| EXPECT_NE(val, Nint(-4)); |
| EXPECT_NE(val, Tstr("99")); |
| EXPECT_NE(val, Bstr("98")); |
| EXPECT_NE(val, Bool(true)); |
| EXPECT_NE(val, Array(99, 1)); |
| EXPECT_NE(val, Map(99, 2)); |
| EXPECT_NE(val, Map(99, 1, 99, 2)); |
| } |
| |
| TEST(EqualityTest, Semantic) { |
| Semantic val(215, Bstr("asd")); |
| EXPECT_EQ(val, Semantic(215, Bstr("asd"))); |
| |
| EXPECT_NE(val, Uint(99)); |
| EXPECT_NE(val, Nint(-1)); |
| EXPECT_NE(val, Nint(-4)); |
| EXPECT_NE(val, Tstr("99")); |
| EXPECT_NE(val, Bstr("98")); |
| EXPECT_NE(val, Bool(true)); |
| EXPECT_NE(val, Array(99, 1)); |
| EXPECT_NE(val, Map(99, 2)); |
| EXPECT_NE(val, Null()); |
| } |
| |
| TEST(ConvertTest, Uint) { |
| unique_ptr<Item> item = details::makeItem(10); |
| |
| EXPECT_EQ(UINT, item->type()); |
| EXPECT_NE(nullptr, item->asInt()); |
| EXPECT_NE(nullptr, item->asUint()); |
| EXPECT_EQ(nullptr, item->asNint()); |
| EXPECT_EQ(nullptr, item->asTstr()); |
| EXPECT_EQ(nullptr, item->asBstr()); |
| EXPECT_EQ(nullptr, item->asSimple()); |
| EXPECT_EQ(nullptr, item->asMap()); |
| EXPECT_EQ(nullptr, item->asArray()); |
| |
| EXPECT_EQ(10, item->asInt()->value()); |
| EXPECT_EQ(10, item->asUint()->value()); |
| } |
| |
| TEST(ConvertTest, Nint) { |
| unique_ptr<Item> item = details::makeItem(-10); |
| |
| EXPECT_EQ(NINT, item->type()); |
| EXPECT_NE(nullptr, item->asInt()); |
| EXPECT_EQ(nullptr, item->asUint()); |
| EXPECT_NE(nullptr, item->asNint()); |
| EXPECT_EQ(nullptr, item->asTstr()); |
| EXPECT_EQ(nullptr, item->asBstr()); |
| EXPECT_EQ(nullptr, item->asSimple()); |
| EXPECT_EQ(nullptr, item->asMap()); |
| EXPECT_EQ(nullptr, item->asArray()); |
| |
| EXPECT_EQ(-10, item->asInt()->value()); |
| EXPECT_EQ(-10, item->asNint()->value()); |
| } |
| |
| TEST(ConvertTest, Tstr) { |
| unique_ptr<Item> item = details::makeItem("hello"); |
| |
| EXPECT_EQ(TSTR, item->type()); |
| EXPECT_EQ(nullptr, item->asInt()); |
| EXPECT_EQ(nullptr, item->asUint()); |
| EXPECT_EQ(nullptr, item->asNint()); |
| EXPECT_NE(nullptr, item->asTstr()); |
| EXPECT_EQ(nullptr, item->asBstr()); |
| EXPECT_EQ(nullptr, item->asSimple()); |
| EXPECT_EQ(nullptr, item->asMap()); |
| EXPECT_EQ(nullptr, item->asArray()); |
| |
| EXPECT_EQ("hello"s, item->asTstr()->value()); |
| } |
| |
| TEST(ConvertTest, Bstr) { |
| vector<uint8_t> vec{0x23, 0x24, 0x22}; |
| unique_ptr<Item> item = details::makeItem(vec); |
| |
| EXPECT_EQ(BSTR, item->type()); |
| EXPECT_EQ(nullptr, item->asInt()); |
| EXPECT_EQ(nullptr, item->asUint()); |
| EXPECT_EQ(nullptr, item->asNint()); |
| EXPECT_EQ(nullptr, item->asTstr()); |
| EXPECT_NE(nullptr, item->asBstr()); |
| EXPECT_EQ(nullptr, item->asSimple()); |
| EXPECT_EQ(nullptr, item->asMap()); |
| EXPECT_EQ(nullptr, item->asArray()); |
| |
| EXPECT_EQ(vec, item->asBstr()->value()); |
| } |
| |
| TEST(ConvertTest, Bool) { |
| unique_ptr<Item> item = details::makeItem(false); |
| |
| EXPECT_EQ(SIMPLE, item->type()); |
| EXPECT_EQ(nullptr, item->asInt()); |
| EXPECT_EQ(nullptr, item->asUint()); |
| EXPECT_EQ(nullptr, item->asNint()); |
| EXPECT_EQ(nullptr, item->asTstr()); |
| EXPECT_EQ(nullptr, item->asBstr()); |
| EXPECT_NE(nullptr, item->asSimple()); |
| EXPECT_EQ(nullptr, item->asMap()); |
| EXPECT_EQ(nullptr, item->asArray()); |
| |
| EXPECT_EQ(BOOLEAN, item->asSimple()->simpleType()); |
| EXPECT_NE(nullptr, item->asSimple()->asBool()); |
| EXPECT_EQ(nullptr, item->asSimple()->asNull()); |
| |
| EXPECT_FALSE(item->asSimple()->asBool()->value()); |
| } |
| |
| TEST(ConvertTest, Map) { |
| unique_ptr<Item> item(new Map); |
| |
| EXPECT_EQ(MAP, item->type()); |
| EXPECT_EQ(nullptr, item->asInt()); |
| EXPECT_EQ(nullptr, item->asUint()); |
| EXPECT_EQ(nullptr, item->asNint()); |
| EXPECT_EQ(nullptr, item->asTstr()); |
| EXPECT_EQ(nullptr, item->asBstr()); |
| EXPECT_EQ(nullptr, item->asSimple()); |
| EXPECT_NE(nullptr, item->asMap()); |
| EXPECT_EQ(nullptr, item->asArray()); |
| |
| EXPECT_EQ(0U, item->asMap()->size()); |
| } |
| |
| TEST(ConvertTest, Array) { |
| unique_ptr<Item> item(new Array); |
| |
| EXPECT_EQ(ARRAY, item->type()); |
| EXPECT_EQ(nullptr, item->asInt()); |
| EXPECT_EQ(nullptr, item->asUint()); |
| EXPECT_EQ(nullptr, item->asNint()); |
| EXPECT_EQ(nullptr, item->asTstr()); |
| EXPECT_EQ(nullptr, item->asBstr()); |
| EXPECT_EQ(nullptr, item->asSimple()); |
| EXPECT_EQ(nullptr, item->asMap()); |
| EXPECT_NE(nullptr, item->asArray()); |
| |
| EXPECT_EQ(0U, item->asArray()->size()); |
| } |
| |
| TEST(ConvertTest, Semantic) { |
| unique_ptr<Item> item(new Semantic(1, "DSA")); |
| |
| EXPECT_EQ(SEMANTIC, item->type()); |
| EXPECT_EQ(nullptr, item->asInt()); |
| EXPECT_EQ(nullptr, item->asUint()); |
| EXPECT_EQ(nullptr, item->asNint()); |
| EXPECT_EQ(nullptr, item->asTstr()); |
| EXPECT_EQ(nullptr, item->asBstr()); |
| EXPECT_EQ(nullptr, item->asSimple()); |
| EXPECT_EQ(nullptr, item->asMap()); |
| EXPECT_EQ(nullptr, item->asArray()); |
| EXPECT_NE(nullptr, item->asSemantic()); |
| |
| EXPECT_EQ(1U, item->asSemantic()->size()); |
| } |
| |
| TEST(ConvertTest, Null) { |
| unique_ptr<Item> item(new Null); |
| |
| EXPECT_EQ(SIMPLE, item->type()); |
| EXPECT_EQ(nullptr, item->asInt()); |
| EXPECT_EQ(nullptr, item->asUint()); |
| EXPECT_EQ(nullptr, item->asNint()); |
| EXPECT_EQ(nullptr, item->asTstr()); |
| EXPECT_EQ(nullptr, item->asBstr()); |
| EXPECT_NE(nullptr, item->asSimple()); |
| EXPECT_EQ(nullptr, item->asMap()); |
| EXPECT_EQ(nullptr, item->asArray()); |
| |
| EXPECT_EQ(NULL_T, item->asSimple()->simpleType()); |
| EXPECT_EQ(nullptr, item->asSimple()->asBool()); |
| EXPECT_NE(nullptr, item->asSimple()->asNull()); |
| } |
| |
| TEST(CloningTest, Uint) { |
| Uint item(10); |
| auto clone = item.clone(); |
| EXPECT_EQ(clone->type(), UINT); |
| EXPECT_NE(clone->asUint(), nullptr); |
| EXPECT_EQ(item, *clone->asUint()); |
| std::move(item); |
| EXPECT_EQ(*clone->asUint(), Uint(10)); |
| } |
| |
| TEST(CloningTest, Nint) { |
| Nint item(-1000000); |
| auto clone = item.clone(); |
| EXPECT_EQ(clone->type(), NINT); |
| EXPECT_NE(clone->asNint(), nullptr); |
| EXPECT_EQ(item, *clone->asNint()); |
| std::move(item); |
| EXPECT_EQ(*clone->asNint(), Nint(-1000000)); |
| } |
| |
| TEST(CloningTest, Tstr) { |
| Tstr item("qwertyasdfgh"); |
| auto clone = item.clone(); |
| EXPECT_EQ(clone->type(), TSTR); |
| EXPECT_NE(clone->asTstr(), nullptr); |
| EXPECT_EQ(item, *clone->asTstr()); |
| std::move(item); |
| EXPECT_EQ(*clone->asTstr(), Tstr("qwertyasdfgh")); |
| } |
| |
| TEST(CloningTest, Bstr) { |
| Bstr item(std::vector<uint8_t>{1, 2, 3, 255, 0}); |
| auto clone = item.clone(); |
| EXPECT_EQ(clone->type(), BSTR); |
| EXPECT_NE(clone->asBstr(), nullptr); |
| EXPECT_EQ(item, *clone->asBstr()); |
| std::move(item); |
| EXPECT_EQ(*clone->asBstr(), Bstr(std::vector<uint8_t>{1, 2, 3, 255, 0})); |
| } |
| |
| TEST(CloningTest, Array) { |
| Array item(-1000000, 22222222, "item", Map(1, 2, 4, Array(1, "das", true, nullptr)), |
| Semantic(16, "DATA")), |
| copy(-1000000, 22222222, "item", Map(1, 2, 4, Array(1, "das", true, nullptr)), |
| Semantic(16, "DATA")); |
| auto clone = item.clone(); |
| EXPECT_EQ(clone->type(), ARRAY); |
| EXPECT_NE(clone->asArray(), nullptr); |
| EXPECT_EQ(item, *clone->asArray()); |
| std::move(item[0]); |
| std::move(item[1]); |
| std::move(item[3]); |
| std::move(item); |
| EXPECT_EQ(*clone->asArray(), copy); |
| } |
| |
| TEST(CloningTest, Map) { |
| Map item("key", Array("value1", "value2", 3), 15, Null(), -5, 45), |
| copy("key", Array("value1", "value2", 3), 15, Null(), -5, 45); |
| auto clone = item.clone(); |
| EXPECT_EQ(clone->type(), MAP); |
| EXPECT_NE(clone->asMap(), nullptr); |
| EXPECT_EQ(item, *clone->asMap()); |
| auto [key, value] = item[0]; |
| std::move(key); |
| std::move(value); |
| std::move(item); |
| EXPECT_EQ(*clone->asMap(), copy); |
| } |
| |
| TEST(CloningTest, Bool) { |
| Bool item(true); |
| auto clone = item.clone(); |
| EXPECT_EQ(clone->type(), SIMPLE); |
| EXPECT_NE(clone->asSimple(), nullptr); |
| EXPECT_EQ(clone->asSimple()->simpleType(), BOOLEAN); |
| EXPECT_NE(clone->asSimple()->asBool(), nullptr); |
| EXPECT_EQ(item, *clone->asSimple()->asBool()); |
| std::move(item); |
| EXPECT_EQ(*clone->asSimple()->asBool(), Bool(true)); |
| } |
| |
| TEST(CloningTest, Null) { |
| Null item; |
| auto clone = item.clone(); |
| EXPECT_EQ(clone->type(), SIMPLE); |
| EXPECT_NE(clone->asSimple(), nullptr); |
| EXPECT_EQ(clone->asSimple()->simpleType(), NULL_T); |
| EXPECT_NE(clone->asSimple()->asNull(), nullptr); |
| EXPECT_EQ(item, *clone->asSimple()->asNull()); |
| std::move(item); |
| EXPECT_EQ(*clone->asSimple()->asNull(), Null()); |
| } |
| |
| TEST(CloningTest, Semantic) { |
| Semantic item(96, Array(1, 2, 3, "entry", Map("key", "value"))), |
| copy(96, Array(1, 2, 3, "entry", Map("key", "value"))); |
| auto clone = item.clone(); |
| EXPECT_EQ(clone->type(), SEMANTIC); |
| EXPECT_NE(clone->asSemantic(), nullptr); |
| EXPECT_EQ(item, *clone->asSemantic()); |
| std::move(item); |
| EXPECT_EQ(*clone->asSemantic(), copy); |
| } |
| |
| class MockParseClient : public ParseClient { |
| public: |
| MOCK_METHOD4(item, ParseClient*(std::unique_ptr<Item>& item, const uint8_t* hdrBegin, |
| const uint8_t* valueBegin, const uint8_t* end)); |
| MOCK_METHOD4(itemEnd, ParseClient*(std::unique_ptr<Item>& item, const uint8_t* hdrBegin, |
| const uint8_t* valueBegin, const uint8_t* end)); |
| MOCK_METHOD2(error, void(const uint8_t* position, const std::string& errorMessage)); |
| }; |
| |
| MATCHER_P(IsType, value, std::string("Type ") + (negation ? "doesn't match" : "matches")) { |
| return arg->type() == value; |
| } |
| |
| MATCHER_P(MatchesItem, value, "") { |
| return arg && *arg == value; |
| } |
| |
| MATCHER_P(IsArrayOfSize, value, "") { |
| return arg->type() == ARRAY && arg->asArray()->size() == value; |
| } |
| |
| MATCHER_P(IsSemanticTagOfValue, value, "") { |
| return arg->type() == SEMANTIC && arg->asSemantic()->value() == value; |
| } |
| |
| MATCHER_P(IsMapOfSize, value, "") { |
| return arg->type() == MAP && arg->asMap()->size() == value; |
| } |
| |
| TEST(StreamParseTest, Uint) { |
| MockParseClient mpc; |
| |
| Uint val(100); |
| auto encoded = val.encode(); |
| uint8_t* encBegin = encoded.data(); |
| uint8_t* encEnd = encoded.data() + encoded.size(); |
| |
| EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encEnd, encEnd)).WillOnce(Return(&mpc)); |
| EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0); |
| EXPECT_CALL(mpc, error(_, _)).Times(0); |
| |
| parse(encoded.data(), encoded.data() + encoded.size(), &mpc); |
| } |
| |
| TEST(StreamParseTest, Nint) { |
| MockParseClient mpc; |
| |
| Nint val(-10); |
| auto encoded = val.encode(); |
| uint8_t* encBegin = encoded.data(); |
| uint8_t* encEnd = encoded.data() + encoded.size(); |
| |
| EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encEnd, encEnd)).WillOnce(Return(&mpc)); |
| |
| EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0); |
| EXPECT_CALL(mpc, error(_, _)).Times(0); |
| |
| parse(encoded.data(), encoded.data() + encoded.size(), &mpc); |
| } |
| |
| TEST(StreamParseTest, Bool) { |
| MockParseClient mpc; |
| |
| Bool val(true); |
| auto encoded = val.encode(); |
| uint8_t* encBegin = encoded.data(); |
| uint8_t* encEnd = encoded.data() + encoded.size(); |
| |
| EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encEnd, encEnd)).WillOnce(Return(&mpc)); |
| EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0); |
| EXPECT_CALL(mpc, error(_, _)).Times(0); |
| |
| parse(encoded.data(), encoded.data() + encoded.size(), &mpc); |
| } |
| |
| TEST(StreamParseTest, Null) { |
| MockParseClient mpc; |
| |
| Null val; |
| auto encoded = val.encode(); |
| uint8_t* encBegin = encoded.data(); |
| uint8_t* encEnd = encoded.data() + encoded.size(); |
| |
| EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encEnd, encEnd)).WillOnce(Return(&mpc)); |
| EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0); |
| EXPECT_CALL(mpc, error(_, _)).Times(0); |
| |
| parse(encoded.data(), encoded.data() + encoded.size(), &mpc); |
| } |
| |
| TEST(StreamParseTest, Tstr) { |
| MockParseClient mpc; |
| |
| Tstr val("Hello"); |
| auto encoded = val.encode(); |
| uint8_t* encBegin = encoded.data(); |
| uint8_t* encEnd = encoded.data() + encoded.size(); |
| |
| EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encBegin + 1, encEnd)).WillOnce(Return(&mpc)); |
| EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0); |
| EXPECT_CALL(mpc, error(_, _)).Times(0); |
| |
| parse(encoded.data(), encoded.data() + encoded.size(), &mpc); |
| } |
| |
| TEST(StreamParseTest, Bstr) { |
| MockParseClient mpc; |
| |
| Bstr val("Hello"); |
| auto encoded = val.encode(); |
| uint8_t* encBegin = encoded.data(); |
| uint8_t* encEnd = encoded.data() + encoded.size(); |
| |
| EXPECT_CALL(mpc, item(MatchesItem(val), encBegin, encBegin + 1, encEnd)).WillOnce(Return(&mpc)); |
| EXPECT_CALL(mpc, itemEnd(_, _, _, _)).Times(0); |
| EXPECT_CALL(mpc, error(_, _)).Times(0); |
| |
| parse(encoded.data(), encoded.data() + encoded.size(), &mpc); |
| } |
| |
| TEST(StreamParseTest, Array) { |
| MockParseClient mpc; |
| |
| Array val("Hello", 4, Array(-9, "Goodbye"), std::numeric_limits<uint64_t>::max()); |
| ASSERT_NE(val[2]->asArray(), nullptr); |
| const Array& interior = *(val[2]->asArray()); |
| auto encoded = val.encode(); |
| uint8_t* encBegin = encoded.data(); |
| uint8_t* encEnd = encoded.data() + encoded.size(); |
| |
| { |
| InSequence s; |
| const uint8_t* pos = encBegin; |
| EXPECT_CALL(mpc, item(IsArrayOfSize(val.size()), pos, pos + 1, pos + 1)) |
| .WillOnce(Return(&mpc)); |
| ++pos; |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[0])), pos, pos + 1, pos + 6)) |
| .WillOnce(Return(&mpc)); |
| pos += 6; |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[1])), pos, pos + 1, pos + 1)) |
| .WillOnce(Return(&mpc)); |
| ++pos; |
| const uint8_t* innerArrayBegin = pos; |
| EXPECT_CALL(mpc, item(IsArrayOfSize(interior.size()), pos, pos + 1, pos + 1)) |
| .WillOnce(Return(&mpc)); |
| ++pos; |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*interior[0])), pos, pos + 1, pos + 1)) |
| .WillOnce(Return(&mpc)); |
| ++pos; |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*interior[1])), pos, pos + 1, pos + 8)) |
| .WillOnce(Return(&mpc)); |
| pos += 8; |
| EXPECT_CALL(mpc, itemEnd(IsArrayOfSize(interior.size()), innerArrayBegin, |
| innerArrayBegin + 1, pos)) |
| .WillOnce(Return(&mpc)); |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[3])), pos, pos + 9, pos + 9)) |
| .WillOnce(Return(&mpc)); |
| EXPECT_CALL(mpc, itemEnd(IsArrayOfSize(val.size()), encBegin, encBegin + 1, encEnd)) |
| .WillOnce(Return(&mpc)); |
| } |
| |
| EXPECT_CALL(mpc, error(_, _)) // |
| .Times(0); |
| |
| parse(encoded.data(), encoded.data() + encoded.size(), &mpc); |
| } |
| |
| TEST(StreamParseTest, Semantic) { |
| MockParseClient mpc; |
| Semantic val(15, Array(-5, "Hi")); |
| auto encoded = val.encode(); |
| ASSERT_NE(val.child()->asArray(), nullptr); |
| const Array& array = *(val.child()->asArray()); |
| uint8_t* encBegin = encoded.data(); |
| uint8_t* encEnd = encoded.data() + encoded.size(); |
| |
| { |
| InSequence s; |
| const uint8_t* pos = encBegin; |
| EXPECT_CALL(mpc, item(IsSemanticTagOfValue(val.value()), pos, pos + 1, pos + 1)) |
| .WillOnce(Return(&mpc)); |
| ++pos; |
| const uint8_t* innerArrayBegin = pos; |
| EXPECT_CALL(mpc, item(IsArrayOfSize(array.size()), pos, pos + 1, pos + 1)) |
| .WillOnce(Return(&mpc)); |
| ++pos; |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*array[0])), pos, pos + 1, pos + 1)) |
| .WillOnce(Return(&mpc)); |
| ++pos; |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*array[1])), pos, pos + 1, pos + 3)) |
| .WillOnce(Return(&mpc)); |
| pos += 3; |
| EXPECT_CALL(mpc, |
| itemEnd(IsArrayOfSize(array.size()), innerArrayBegin, innerArrayBegin + 1, pos)) |
| .WillOnce(Return(&mpc)); |
| EXPECT_CALL(mpc, itemEnd(IsSemanticTagOfValue(val.value()), encBegin, encBegin + 1, encEnd)) |
| .WillOnce(Return(&mpc)); |
| } |
| |
| EXPECT_CALL(mpc, error(_, _)) // |
| .Times(0); |
| parse(encoded.data(), encoded.data() + encoded.size(), &mpc); |
| } |
| |
| TEST(StreamParseTest, Map) { |
| MockParseClient mpc; |
| |
| Map val("Hello", 4, Array(-9, "Goodbye"), std::numeric_limits<uint64_t>::max()); |
| ASSERT_NE(val[1].first->asArray(), nullptr); |
| const Array& interior = *(val[1].first->asArray()); |
| auto encoded = val.encode(); |
| uint8_t* encBegin = encoded.data(); |
| uint8_t* encEnd = encoded.data() + encoded.size(); |
| |
| { |
| InSequence s; |
| const uint8_t* pos = encBegin; |
| EXPECT_CALL(mpc, item(_, pos, pos + 1, pos + 1)).WillOnce(Return(&mpc)); |
| ++pos; |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[0].first)), pos, pos + 1, pos + 6)) |
| .WillOnce(Return(&mpc)); |
| pos += 6; |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[0].second)), pos, pos + 1, pos + 1)) |
| .WillOnce(Return(&mpc)); |
| ++pos; |
| const uint8_t* innerArrayBegin = pos; |
| EXPECT_CALL(mpc, item(IsArrayOfSize(interior.size()), pos, pos + 1, pos + 1)) |
| .WillOnce(Return(&mpc)); |
| ++pos; |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*interior[0])), pos, pos + 1, pos + 1)) |
| .WillOnce(Return(&mpc)); |
| ++pos; |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*interior[1])), pos, pos + 1, pos + 8)) |
| .WillOnce(Return(&mpc)); |
| pos += 8; |
| EXPECT_CALL(mpc, itemEnd(IsArrayOfSize(interior.size()), innerArrayBegin, |
| innerArrayBegin + 1, pos)) |
| .WillOnce(Return(&mpc)); |
| EXPECT_CALL(mpc, item(MatchesItem(ByRef(*val[1].second)), pos, pos + 9, pos + 9)) |
| .WillOnce(Return(&mpc)); |
| EXPECT_CALL(mpc, itemEnd(IsMapOfSize(val.size()), encBegin, encBegin + 1, encEnd)) |
| .WillOnce(Return(&mpc)); |
| } |
| |
| EXPECT_CALL(mpc, error(_, _)) // |
| .Times(0); |
| |
| parse(encoded.data(), encoded.data() + encoded.size(), &mpc); |
| } |
| |
| TEST(FullParserTest, Uint) { |
| Uint val(10); |
| |
| auto [item, pos, message] = parse(val.encode()); |
| EXPECT_THAT(item, MatchesItem(val)); |
| } |
| |
| TEST(FullParserTest, Null) { |
| Null val; |
| |
| auto [item, pos, message] = parse(val.encode()); |
| EXPECT_THAT(item, MatchesItem(val)); |
| } |
| |
| TEST(FullParserTest, Nint) { |
| Nint val(-10); |
| |
| auto [item, pos, message] = parse(val.encode()); |
| EXPECT_THAT(item, MatchesItem(val)); |
| |
| vector<uint8_t> minNint = {0x3B, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; |
| |
| std::tie(item, pos, message) = parse(minNint); |
| EXPECT_THAT(item, NotNull()); |
| EXPECT_EQ(item->asNint()->value(), std::numeric_limits<int64_t>::min()); |
| } |
| |
| TEST(FullParserTest, NintOutOfRange) { |
| vector<uint8_t> outOfRangeNint = {0x3B, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; |
| |
| auto [item, pos, message] = parse(outOfRangeNint); |
| EXPECT_THAT(item, IsNull()); |
| EXPECT_EQ(pos, outOfRangeNint.data()); |
| EXPECT_EQ(message, "NINT values that don't fit in int64_t are not supported."); |
| } |
| |
| TEST(FullParserTest, Tstr) { |
| Tstr val("Hello"); |
| |
| auto [item, pos, message] = parse(val.encode()); |
| EXPECT_THAT(item, MatchesItem(val)); |
| } |
| |
| TEST(FullParserTest, Bstr) { |
| Bstr val("\x00\x01\0x02"s); |
| |
| auto [item, pos, message] = parse(val.encode()); |
| EXPECT_THAT(item, MatchesItem(val)); |
| } |
| |
| TEST(FullParserTest, Array) { |
| Array val("hello", -4, 3); |
| |
| auto encoded = val.encode(); |
| auto [item, pos, message] = parse(encoded); |
| EXPECT_THAT(item, MatchesItem(ByRef(val))); |
| EXPECT_EQ(pos, encoded.data() + encoded.size()); |
| EXPECT_EQ("", message); |
| |
| // We've already checked it all, but walk it just for fun. |
| ASSERT_NE(nullptr, item->asArray()); |
| const Array& arr = *(item->asArray()); |
| ASSERT_EQ(arr[0]->type(), TSTR); |
| EXPECT_EQ(arr[0]->asTstr()->value(), "hello"); |
| } |
| |
| TEST(FullParserTest, Map) { |
| Map val("hello", -4, 3, Bstr("hi")); |
| |
| auto [item, pos, message] = parse(val.encode()); |
| EXPECT_THAT(item, MatchesItem(ByRef(val))); |
| } |
| |
| TEST(FullParserTest, Semantic) { |
| Semantic val(99, "Salem"); |
| |
| auto [item, pos, message] = parse(val.encode()); |
| EXPECT_THAT(item, MatchesItem(ByRef(val))); |
| } |
| |
| TEST(FullParserTest, Complex) { |
| vector<uint8_t> vec = {0x01, 0x02, 0x08, 0x03}; |
| Map val("Outer1", |
| Array(Map("Inner1", 99, // |
| "Inner2", vec), |
| "foo"), |
| "Outer2", 10); |
| |
| std::unique_ptr<Item> item; |
| const uint8_t* pos; |
| std::string message; |
| std::tie(item, pos, message) = parse(val.encode()); |
| EXPECT_THAT(item, MatchesItem(ByRef(val))); |
| } |
| |
| TEST(FullParserTest, IncompleteUint) { |
| Uint val(1000); |
| |
| auto encoding = val.encode(); |
| auto [item, pos, message] = parse(encoding.data(), encoding.size() - 1); |
| EXPECT_EQ(nullptr, item.get()); |
| EXPECT_EQ(encoding.data(), pos); |
| EXPECT_EQ("Need 2 byte(s) for length field, have 1.", message); |
| } |
| |
| TEST(FullParserTest, IncompleteString) { |
| Tstr val("hello"); |
| |
| auto encoding = val.encode(); |
| auto [item, pos, message] = parse(encoding.data(), encoding.size() - 2); |
| EXPECT_EQ(nullptr, item.get()); |
| EXPECT_EQ(encoding.data(), pos); |
| EXPECT_EQ("Need 5 byte(s) for text string, have 3.", message); |
| } |
| |
| TEST(FullParserTest, ArrayWithInsufficientEntries) { |
| Array val(1, 2, 3, 4); |
| |
| auto encoding = val.encode(); |
| auto [item, pos, message] = parse(encoding.data(), encoding.size() - 1); |
| EXPECT_EQ(nullptr, item.get()); |
| EXPECT_EQ(encoding.data(), pos); |
| EXPECT_EQ("Not enough entries for array.", message); |
| } |
| |
| TEST(FullParserTest, ArrayWithTruncatedEntry) { |
| Array val(1, 2, 3, 400000); |
| |
| auto encoding = val.encode(); |
| auto [item, pos, message] = parse(encoding.data(), encoding.size() - 1); |
| EXPECT_EQ(nullptr, item.get()); |
| EXPECT_EQ(encoding.data() + encoding.size() - 5, pos); |
| EXPECT_EQ("Need 4 byte(s) for length field, have 3.", message); |
| } |
| |
| TEST(FullParserTest, MapWithTruncatedEntry) { |
| Map val(1, 2, 300000, 4); |
| |
| auto encoding = val.encode(); |
| auto [item, pos, message] = parse(encoding.data(), encoding.size() - 2); |
| EXPECT_EQ(nullptr, item.get()); |
| EXPECT_EQ(encoding.data() + 3, pos); |
| EXPECT_EQ("Need 4 byte(s) for length field, have 3.", message); |
| } |
| |
| TEST(ItemDowncastingTest, Uint) { |
| auto item = std::unique_ptr<Item>(new Uint(1)); |
| EXPECT_NE(downcastItem<Uint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Nint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Tstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Array>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Map>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bool>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Null>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Semantic>(std::move(item)).get(), nullptr); |
| // Uncommenting following lines should not compile |
| // EXPECT_EQ(downcastItem<Int>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<CompoundItem>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Simple>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Item>(std::move(item)).get(), nullptr); |
| } |
| |
| TEST(ItemDowncastingTest, Nint) { |
| auto item = std::unique_ptr<Item>(new Nint(-211)); |
| EXPECT_EQ(downcastItem<Uint>(std::move(item)).get(), nullptr); |
| EXPECT_NE(downcastItem<Nint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Tstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Array>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Map>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bool>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Null>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Semantic>(std::move(item)).get(), nullptr); |
| // Uncommenting following lines should not compile |
| // EXPECT_EQ(downcastItem<Int>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<CompoundItem>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Simple>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Item>(std::move(item)).get(), nullptr); |
| } |
| |
| TEST(ItemDowncastingTest, Tstr) { |
| auto item = std::unique_ptr<Item>(new Tstr("string")); |
| EXPECT_EQ(downcastItem<Uint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Nint>(std::move(item)).get(), nullptr); |
| EXPECT_NE(downcastItem<Tstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Array>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Map>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bool>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Null>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Semantic>(std::move(item)).get(), nullptr); |
| // Uncommenting following lines should not compile |
| // EXPECT_EQ(downcastItem<Int>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<CompoundItem>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Simple>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Item>(std::move(item)).get(), nullptr); |
| } |
| |
| TEST(ItemDowncastingTest, Bstr) { |
| auto item = std::unique_ptr<Item>(new Bstr(std::vector<uint8_t>{1, 2, 3, 4, 5, 6})); |
| EXPECT_EQ(downcastItem<Uint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Nint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Tstr>(std::move(item)).get(), nullptr); |
| EXPECT_NE(downcastItem<Bstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Array>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Map>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bool>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Null>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Semantic>(std::move(item)).get(), nullptr); |
| // Uncommenting following lines should not compile |
| // EXPECT_EQ(downcastItem<Int>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<CompoundItem>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Simple>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Item>(std::move(item)).get(), nullptr); |
| } |
| |
| TEST(ItemDowncastingTest, Array) { |
| auto item = std::unique_ptr<Item>(new Array(1, 2, "3", "4", Array(5, "6"))); |
| EXPECT_EQ(downcastItem<Uint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Nint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Tstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bstr>(std::move(item)).get(), nullptr); |
| EXPECT_NE(downcastItem<Array>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Map>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bool>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Null>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Semantic>(std::move(item)).get(), nullptr); |
| // Uncommenting following lines should not compile |
| // EXPECT_EQ(downcastItem<Int>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<CompoundItem>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Simple>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Item>(std::move(item)).get(), nullptr); |
| } |
| |
| TEST(ItemDowncastingTest, Map) { |
| auto item = std::unique_ptr<Item>(new Map(1, 2, "key", "value")); |
| EXPECT_EQ(downcastItem<Uint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Nint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Tstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Array>(std::move(item)).get(), nullptr); |
| EXPECT_NE(downcastItem<Map>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bool>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Null>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Semantic>(std::move(item)).get(), nullptr); |
| // Uncommenting following lines should not compile |
| // EXPECT_EQ(downcastItem<Int>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<CompoundItem>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Simple>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Item>(std::move(item)).get(), nullptr); |
| } |
| |
| TEST(ItemDowncastingTest, Bool) { |
| auto item = std::unique_ptr<Item>(new Bool(false)); |
| EXPECT_EQ(downcastItem<Uint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Nint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Tstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Array>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Map>(std::move(item)).get(), nullptr); |
| EXPECT_NE(downcastItem<Bool>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Null>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Semantic>(std::move(item)).get(), nullptr); |
| // Uncommenting following lines should not compile |
| // EXPECT_EQ(downcastItem<Int>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<CompoundItem>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Simple>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Item>(std::move(item)).get(), nullptr); |
| } |
| |
| TEST(ItemDowncastingTest, Null) { |
| auto item = std::unique_ptr<Item>(new Null()); |
| EXPECT_EQ(downcastItem<Uint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Nint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Tstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Array>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Map>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bool>(std::move(item)).get(), nullptr); |
| EXPECT_NE(downcastItem<Null>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Semantic>(std::move(item)).get(), nullptr); |
| // Uncommenting following lines should not compile |
| // EXPECT_EQ(downcastItem<Int>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<CompoundItem>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Simple>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Item>(std::move(item)).get(), nullptr); |
| } |
| |
| TEST(ItemDowncastingTest, Semantic) { |
| auto item = std::unique_ptr<Item>(new Semantic(11, Map("key", Array(1, 2, 3)))); |
| EXPECT_EQ(downcastItem<Uint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Nint>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Tstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bstr>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Array>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Map>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Bool>(std::move(item)).get(), nullptr); |
| EXPECT_EQ(downcastItem<Null>(std::move(item)).get(), nullptr); |
| EXPECT_NE(downcastItem<Semantic>(std::move(item)).get(), nullptr); |
| // Uncommenting following lines should not compile |
| // EXPECT_EQ(downcastItem<Int>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<CompoundItem>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Simple>(std::move(item)).get(), nullptr); |
| // EXPECT_EQ(downcastItem<Item>(std::move(item)).get(), nullptr); |
| } |
| |
| TEST(MapGetValueByKeyTest, Map) { |
| Array compoundItem(1, 2, 3, 4, 5, Map(4, 5, "a", "b")); |
| auto clone = compoundItem.clone(); |
| Map item(1, 2, "key", "value", "item", std::move(compoundItem)); |
| auto [value1, found1] = item.get(1); |
| EXPECT_TRUE(found1); |
| EXPECT_EQ(*value1, Uint(2)); |
| auto [value2, found2] = item.get("key"); |
| EXPECT_TRUE(found2); |
| EXPECT_EQ(*value2, Tstr("value")); |
| auto [value3, found3] = item.get("item"); |
| EXPECT_TRUE(found3); |
| EXPECT_EQ(*value3, *clone); |
| auto [value4, found4] = item.get("wrong"); |
| EXPECT_FALSE(found4); |
| } |
| |
| TEST(EmptyBstrTest, Bstr) { |
| Bstr bstr(std::vector<uint8_t>{}); |
| auto encoding = bstr.encode(); |
| auto [obj, pos, message] = parse(encoding.data(), encoding.size()); |
| EXPECT_NE(obj.get(), nullptr); |
| EXPECT_EQ(*obj, bstr); |
| } |
| |
| int main(int argc, char** argv) { |
| ::testing::InitGoogleTest(&argc, argv); |
| return RUN_ALL_TESTS(); |
| } |
