| // 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 "public/emboss_array_view.h" |
| |
| #include <gtest/gtest.h> |
| |
| #include <string> |
| #include <type_traits> |
| |
| #include "absl/strings/str_format.h" |
| #include "public/emboss_prelude.h" |
| |
| namespace emboss { |
| namespace support { |
| namespace test { |
| |
| using ::emboss::prelude::IntView; |
| using ::emboss::prelude::UIntView; |
| |
| template <class ElementView, class BufferType, ::std::size_t kElementSize> |
| using ArrayView = GenericArrayView<ElementView, BufferType, kElementSize, 8>; |
| |
| template <class ElementView, class BufferType, ::std::size_t kElementSize> |
| using BitArrayView = GenericArrayView<ElementView, BufferType, kElementSize, 1>; |
| |
| template </**/ ::std::size_t kBits> |
| using LittleEndianBitBlockN = |
| BitBlock<LittleEndianByteOrderer<ReadWriteContiguousBuffer>, kBits>; |
| |
| template </**/ ::std::size_t kBits> |
| using FixedUIntView = UIntView<FixedSizeViewParameters<kBits, AllValuesAreOk>, |
| LittleEndianBitBlockN<kBits>>; |
| |
| template </**/ ::std::size_t kBits> |
| using FixedIntView = IntView<FixedSizeViewParameters<kBits, AllValuesAreOk>, |
| LittleEndianBitBlockN<kBits>>; |
| |
| TEST(ArrayView, Methods) { |
| ::std::uint8_t bytes[] = {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, |
| 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01}; |
| auto byte_array = ArrayView<FixedUIntView<8>, ReadWriteContiguousBuffer, 1>{ |
| ReadWriteContiguousBuffer{bytes, sizeof bytes - 4}}; |
| EXPECT_EQ(sizeof bytes - 4, byte_array.SizeInBytes()); |
| EXPECT_EQ(bytes[0], byte_array[0].Read()); |
| EXPECT_EQ(bytes[1], byte_array[1].Read()); |
| EXPECT_EQ(bytes[2], byte_array[2].Read()); |
| EXPECT_DEATH(byte_array[sizeof bytes - 4].Read(), ""); |
| EXPECT_EQ(bytes[sizeof bytes - 4], |
| byte_array[sizeof bytes - 4].UncheckedRead()); |
| EXPECT_TRUE(byte_array[sizeof bytes - 5].IsComplete()); |
| EXPECT_FALSE(byte_array[sizeof bytes - 4].IsComplete()); |
| EXPECT_TRUE(byte_array.Ok()); |
| EXPECT_TRUE(byte_array.IsComplete()); |
| EXPECT_FALSE((ArrayView<FixedUIntView<8>, ReadWriteContiguousBuffer, 1>{ |
| ReadWriteContiguousBuffer{ |
| nullptr}}.Ok())); |
| EXPECT_TRUE(byte_array.IsComplete()); |
| |
| auto uint32_array = |
| ArrayView<FixedUIntView<32>, ReadWriteContiguousBuffer, 4>{ |
| ReadWriteContiguousBuffer{bytes, sizeof bytes - 4}}; |
| EXPECT_EQ(sizeof bytes - 4, uint32_array.SizeInBytes()); |
| EXPECT_TRUE(uint32_array[0].Ok()); |
| EXPECT_EQ(0x0d0e0f10U, uint32_array[0].Read()); |
| EXPECT_EQ(0x090a0b0cU, uint32_array[1].Read()); |
| EXPECT_EQ(0x05060708U, uint32_array[2].Read()); |
| EXPECT_DEATH(uint32_array[3].Read(), ""); |
| EXPECT_EQ(0x01020304U, uint32_array[3].UncheckedRead()); |
| EXPECT_TRUE(uint32_array[2].IsComplete()); |
| EXPECT_FALSE(uint32_array[3].IsComplete()); |
| EXPECT_TRUE(uint32_array.Ok()); |
| EXPECT_TRUE(uint32_array.IsComplete()); |
| EXPECT_FALSE((ArrayView<FixedUIntView<32>, ReadWriteContiguousBuffer, 1>{ |
| ReadWriteContiguousBuffer{ |
| nullptr}}.Ok())); |
| } |
| |
| TEST(ArrayView, Ok) { |
| ::std::uint8_t bytes[] = {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, |
| 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01}; |
| // All elements are complete and, themselves, Ok(), so the array should be |
| // Ok(). |
| auto byte_array = ArrayView<FixedUIntView<16>, ReadWriteContiguousBuffer, 2>( |
| ReadWriteContiguousBuffer(bytes, sizeof bytes - 4)); |
| EXPECT_TRUE(byte_array.Ok()); |
| |
| // An array with a partial element at the end should not be Ok(). |
| byte_array = ArrayView<FixedUIntView<16>, ReadWriteContiguousBuffer, 2>( |
| ReadWriteContiguousBuffer(bytes, sizeof bytes - 3)); |
| EXPECT_FALSE(byte_array.Ok()); |
| |
| // An empty array should be Ok(). |
| byte_array = ArrayView<FixedUIntView<16>, ReadWriteContiguousBuffer, 2>( |
| ReadWriteContiguousBuffer(bytes, 0)); |
| EXPECT_TRUE(byte_array.Ok()); |
| } |
| |
| TEST(ArrayView, TextFormatInput) { |
| ::std::uint8_t bytes[16] = {0}; |
| auto byte_array = ArrayView<FixedUIntView<8>, ReadWriteContiguousBuffer, 1>{ |
| ReadWriteContiguousBuffer{bytes, sizeof bytes}}; |
| EXPECT_FALSE(UpdateFromText(byte_array, "")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "[]")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{[0")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{[0:0}")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{[]:0}")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{[0] 0}")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{[0] 0}")); |
| EXPECT_TRUE(UpdateFromText(byte_array, "{}")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{,1}")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{1,,}")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{ a }")); |
| EXPECT_TRUE(UpdateFromText(byte_array, "{1}")); |
| EXPECT_EQ(1, bytes[0]); |
| EXPECT_TRUE(UpdateFromText(byte_array, " {2}")); |
| EXPECT_EQ(2, bytes[0]); |
| EXPECT_TRUE(UpdateFromText(byte_array, " {\t\r\n4 } junk")); |
| EXPECT_EQ(4, bytes[0]); |
| EXPECT_TRUE(UpdateFromText(byte_array, "{3,}")); |
| EXPECT_EQ(3, bytes[0]); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{4 5}")); |
| EXPECT_TRUE(UpdateFromText(byte_array, "{4, 5}")); |
| EXPECT_EQ(4, bytes[0]); |
| EXPECT_EQ(5, bytes[1]); |
| EXPECT_TRUE(UpdateFromText(byte_array, "{5, [6]: 5}")); |
| EXPECT_EQ(5, bytes[0]); |
| EXPECT_EQ(5, bytes[1]); |
| EXPECT_EQ(5, bytes[6]); |
| EXPECT_TRUE(UpdateFromText(byte_array, "{6, [7]:6, 6}")); |
| EXPECT_EQ(6, bytes[0]); |
| EXPECT_EQ(5, bytes[1]); |
| EXPECT_EQ(5, bytes[6]); |
| EXPECT_EQ(6, bytes[7]); |
| EXPECT_EQ(6, bytes[8]); |
| EXPECT_TRUE(UpdateFromText(byte_array, "{[7]: 7, 7, [0]: 7, 7}")); |
| EXPECT_EQ(7, bytes[0]); |
| EXPECT_EQ(7, bytes[1]); |
| EXPECT_EQ(7, bytes[7]); |
| EXPECT_EQ(7, bytes[8]); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{[16]: 0}")); |
| EXPECT_FALSE(UpdateFromText(byte_array, "{[15]: 0, 0}")); |
| } |
| |
| TEST(ArrayView, TextFormatOutput_WithAndWithoutComments) { |
| signed char bytes[16] = {-3, 2, -1, 1, 0, 1, 1, 2, |
| 3, 5, 8, 13, 21, 34, 55, 89}; |
| auto buffer = ReadWriteContiguousBuffer{ |
| reinterpret_cast</**/ ::std::uint8_t *>(bytes), sizeof bytes}; |
| auto byte_array = |
| ArrayView<FixedIntView<8>, ReadWriteContiguousBuffer, 1>{buffer}; |
| EXPECT_EQ( |
| "{ [0]: -3, 2, -1, 1, 0, 1, 1, 2, [8]: 3, 5, 8, 13, 21, 34, 55, 89 }", |
| WriteToString(byte_array)); |
| EXPECT_EQ(WriteToString(byte_array, MultilineText()), |
| R"({ |
| # ............."7Y |
| [0]: -3 # -0x3 |
| [1]: 2 # 0x2 |
| [2]: -1 # -0x1 |
| [3]: 1 # 0x1 |
| [4]: 0 # 0x0 |
| [5]: 1 # 0x1 |
| [6]: 1 # 0x1 |
| [7]: 2 # 0x2 |
| [8]: 3 # 0x3 |
| [9]: 5 # 0x5 |
| [10]: 8 # 0x8 |
| [11]: 13 # 0xd |
| [12]: 21 # 0x15 |
| [13]: 34 # 0x22 |
| [14]: 55 # 0x37 |
| [15]: 89 # 0x59 |
| })"); |
| EXPECT_EQ( |
| WriteToString(byte_array, |
| MultilineText().WithIndent(" ").WithComments(false)), |
| R"({ |
| [0]: -3 |
| [1]: 2 |
| [2]: -1 |
| [3]: 1 |
| [4]: 0 |
| [5]: 1 |
| [6]: 1 |
| [7]: 2 |
| [8]: 3 |
| [9]: 5 |
| [10]: 8 |
| [11]: 13 |
| [12]: 21 |
| [13]: 34 |
| [14]: 55 |
| [15]: 89 |
| })"); |
| EXPECT_EQ( |
| WriteToString(byte_array, TextOutputOptions().WithNumericBase(16)), |
| "{ [0x0]: -0x3, 0x2, -0x1, 0x1, 0x0, 0x1, 0x1, 0x2, [0x8]: 0x3, 0x5, " |
| "0x8, 0xd, 0x15, 0x22, 0x37, 0x59 }"); |
| } |
| |
| TEST(ArrayView, TextFormatOutput_8BitIntElementTypes) { |
| ::std::uint8_t bytes[1] = {65}; |
| auto buffer = ReadWriteContiguousBuffer{bytes, sizeof bytes}; |
| const ::std::string expected_text = R"({ |
| # A |
| [0]: 65 # 0x41 |
| })"; |
| EXPECT_EQ( |
| WriteToString( |
| ArrayView<FixedIntView<8>, ReadWriteContiguousBuffer, 1>{buffer}, |
| MultilineText()), |
| expected_text); |
| EXPECT_EQ( |
| WriteToString( |
| ArrayView<FixedUIntView<8>, ReadWriteContiguousBuffer, 1>{buffer}, |
| MultilineText()), |
| expected_text); |
| } |
| |
| TEST(ArrayView, TextFormatOutput_16BitIntElementTypes) { |
| ::std::uint16_t bytes[1] = {65}; |
| auto buffer = ReadWriteContiguousBuffer{ |
| reinterpret_cast</**/ ::std::uint8_t *>(bytes), sizeof bytes}; |
| const ::std::string expected_text = R"({ |
| [0]: 65 # 0x41 |
| })"; |
| EXPECT_EQ( |
| WriteToString( |
| ArrayView<FixedIntView<16>, ReadWriteContiguousBuffer, 2>{buffer}, |
| MultilineText()), |
| expected_text); |
| EXPECT_EQ( |
| WriteToString( |
| ArrayView<FixedUIntView<16>, ReadWriteContiguousBuffer, 2>{buffer}, |
| MultilineText()), |
| expected_text); |
| } |
| |
| TEST(ArrayView, TextFormatOutput_MultilineComment) { |
| ::std::uint8_t bytes[65]; |
| for (::std::size_t i = 0; i < sizeof bytes; ++i) { |
| bytes[i] = '0' + (i % 10); |
| } |
| for (const ::std::size_t length : {63, 64, 65}) { |
| auto buffer = ReadWriteContiguousBuffer{bytes, length}; |
| ::std::string expected_text = |
| "{\n # " |
| "012345678901234567890123456789012345678901234567890123456789012"; |
| if (length > 63) expected_text += "3"; |
| if (length > 64) expected_text += "\n # 4"; |
| expected_text += "\n"; |
| for (::std::size_t i = 0; i < length; ++i) { |
| expected_text += |
| absl::StrFormat(" [%d]: %d # 0x%02x\n", i, bytes[i], bytes[i]); |
| } |
| expected_text += "}"; |
| EXPECT_EQ( |
| WriteToString( |
| ArrayView<FixedIntView<8>, ReadWriteContiguousBuffer, 1>{buffer}, |
| MultilineText()), |
| expected_text); |
| } |
| } |
| |
| } // namespace test |
| } // namespace support |
| } // namespace emboss |