| // 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_prelude.h" |
| |
| #include <type_traits> |
| |
| #include "gtest/gtest.h" |
| #include "public/emboss_cpp_util.h" |
| |
| namespace emboss { |
| namespace prelude { |
| namespace test { |
| |
| using ::emboss::support::OffsetBitBlock; |
| using ::emboss::support::ReadWriteContiguousBuffer; |
| |
| template </**/ ::std::size_t kBits> |
| using BitBlockN = ::emboss::support::BitBlock< |
| ::emboss::support::LittleEndianByteOrderer<ReadWriteContiguousBuffer>, |
| kBits>; |
| |
| template </**/ ::std::size_t kBits> |
| using ViewParameters = ::emboss::support::FixedSizeViewParameters< |
| kBits, ::emboss::support::AllValuesAreOk>; |
| |
| TEST(FlagView, Methods) { |
| ::std::uint8_t byte = 0; |
| auto flag_view = |
| FlagView<ViewParameters<1>, OffsetBitBlock<BitBlockN<8>>>{BitBlockN<8>{ |
| ReadWriteContiguousBuffer{&byte, 1}}.GetOffsetStorage<1, 0>(0, 1)}; |
| EXPECT_FALSE(flag_view.Read()); |
| byte = 0xfe; |
| EXPECT_FALSE(flag_view.Read()); |
| byte = 0x01; |
| EXPECT_TRUE(flag_view.Read()); |
| byte = 0xff; |
| EXPECT_TRUE(flag_view.Read()); |
| EXPECT_TRUE(flag_view.CouldWriteValue(false)); |
| EXPECT_TRUE(flag_view.CouldWriteValue(true)); |
| flag_view.Write(false); |
| EXPECT_EQ(0xfe, byte); |
| byte = 0xaa; |
| flag_view.Write(true); |
| EXPECT_EQ(0xab, byte); |
| } |
| |
| TEST(FlagView, TextDecode) { |
| ::std::uint8_t byte = 0; |
| const auto flag_view = |
| FlagView<ViewParameters<1>, OffsetBitBlock<BitBlockN<8>>>{BitBlockN<8>{ |
| ReadWriteContiguousBuffer{&byte, 1}}.GetOffsetStorage<1, 0>(0, 1)}; |
| EXPECT_FALSE(UpdateFromText(flag_view, "")); |
| EXPECT_FALSE(UpdateFromText(flag_view, "FALSE")); |
| EXPECT_FALSE(UpdateFromText(flag_view, "TRUE")); |
| EXPECT_FALSE(UpdateFromText(flag_view, "+true")); |
| EXPECT_TRUE(UpdateFromText(flag_view, "true")); |
| EXPECT_EQ(0x01, byte); |
| EXPECT_TRUE(UpdateFromText(flag_view, "false")); |
| EXPECT_EQ(0x00, byte); |
| EXPECT_TRUE(UpdateFromText(flag_view, " true")); |
| EXPECT_EQ(0x01, byte); |
| { |
| auto stream = support::TextStream{" false xxx"}; |
| EXPECT_TRUE(flag_view.UpdateFromTextStream(&stream)); |
| EXPECT_EQ(0x00, byte); |
| ::std::string token; |
| EXPECT_TRUE(::emboss::support::ReadToken(&stream, &token)); |
| EXPECT_EQ("xxx", token); |
| } |
| } |
| |
| TEST(FlagView, TextEncode) { |
| ::std::uint8_t byte = 0; |
| const auto flag_view = |
| FlagView<ViewParameters<1>, OffsetBitBlock<BitBlockN<8>>>{BitBlockN<8>{ |
| ReadWriteContiguousBuffer{&byte, 1}}.GetOffsetStorage<1, 0>(0, 1)}; |
| EXPECT_EQ("false", WriteToString(flag_view)); |
| byte = 1; |
| EXPECT_EQ("true", WriteToString(flag_view)); |
| } |
| |
| template <template <typename, typename> class ViewType, int kMaxBits> |
| void CheckViewSizeInBits() { |
| const int size_in_bits = |
| ViewType<ViewParameters<kMaxBits>, BitBlockN<64>>::SizeInBits(); |
| EXPECT_EQ(size_in_bits, kMaxBits); |
| return CheckViewSizeInBits<ViewType, kMaxBits - 1>(); |
| } |
| |
| template <> |
| void CheckViewSizeInBits<UIntView, 0>() { |
| return; |
| } |
| |
| template <> |
| void CheckViewSizeInBits<IntView, 0>() { |
| return; |
| } |
| |
| template <> |
| void CheckViewSizeInBits<BcdView, 0>() { |
| return; |
| } |
| |
| TEST(UIntView, SizeInBits) { CheckViewSizeInBits<UIntView, 64>(); } |
| |
| TEST(IntView, SizeInBits) { CheckViewSizeInBits<IntView, 64>(); } |
| |
| TEST(BcdView, SizeInBits) { CheckViewSizeInBits<BcdView, 64>(); } |
| |
| template </**/ ::std::size_t kBits> |
| using UIntViewN = UIntView<ViewParameters<kBits>, BitBlockN<kBits>>; |
| |
| TEST(UIntView, ValueType) { |
| using BitBlockType = BitBlockN<64>; |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint8_t, |
| UIntView<ViewParameters<8>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint8_t, |
| UIntView<ViewParameters<6>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint16_t, |
| UIntView<ViewParameters<9>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint16_t, |
| UIntView<ViewParameters<16>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint32_t, |
| UIntView<ViewParameters<17>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint32_t, |
| UIntView<ViewParameters<32>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint64_t, |
| UIntView<ViewParameters<33>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint64_t, |
| UIntView<ViewParameters<64>, BitBlockType>::ValueType>::value)); |
| } |
| |
| TEST(UIntView, CouldWriteValue) { |
| EXPECT_TRUE(UIntViewN<8>::CouldWriteValue(0xff)); |
| EXPECT_TRUE(UIntViewN<8>::CouldWriteValue(0)); |
| EXPECT_FALSE(UIntViewN<8>::CouldWriteValue(0x100)); |
| EXPECT_FALSE(UIntViewN<8>::CouldWriteValue(-1)); |
| EXPECT_TRUE(UIntViewN<16>::CouldWriteValue(0xffff)); |
| EXPECT_TRUE(UIntViewN<16>::CouldWriteValue(0)); |
| EXPECT_FALSE(UIntViewN<16>::CouldWriteValue(0x10000)); |
| EXPECT_FALSE(UIntViewN<16>::CouldWriteValue(-1)); |
| EXPECT_TRUE(UIntViewN<32>::CouldWriteValue(0xffffffffU)); |
| EXPECT_TRUE(UIntViewN<32>::CouldWriteValue(0xffffffffL)); |
| EXPECT_TRUE(UIntViewN<32>::CouldWriteValue(0)); |
| EXPECT_FALSE(UIntViewN<32>::CouldWriteValue(0x100000000L)); |
| EXPECT_FALSE(UIntViewN<32>::CouldWriteValue(-1)); |
| EXPECT_TRUE(UIntViewN<48>::CouldWriteValue(0x0000ffffffffffffUL)); |
| EXPECT_TRUE(UIntViewN<48>::CouldWriteValue(0x0000ffffffffffffL)); |
| EXPECT_TRUE(UIntViewN<48>::CouldWriteValue(0)); |
| EXPECT_FALSE(UIntViewN<48>::CouldWriteValue(0x1000000000000UL)); |
| EXPECT_FALSE(UIntViewN<48>::CouldWriteValue(0x1000000000000L)); |
| EXPECT_FALSE(UIntViewN<48>::CouldWriteValue(-1)); |
| EXPECT_TRUE(UIntViewN<64>::CouldWriteValue(0xffffffffffffffffUL)); |
| EXPECT_TRUE(UIntViewN<64>::CouldWriteValue(0)); |
| EXPECT_FALSE(UIntViewN<64>::CouldWriteValue(-1)); |
| } |
| |
| TEST(UIntView, CouldWriteValueNarrowing) { |
| auto narrowing_could_write = [](int value) { |
| return UIntViewN<8>::CouldWriteValue(value); |
| }; |
| EXPECT_TRUE(narrowing_could_write(0)); |
| EXPECT_TRUE(narrowing_could_write(255)); |
| EXPECT_FALSE(narrowing_could_write(-1)); |
| EXPECT_FALSE(narrowing_could_write(256)); |
| } |
| |
| TEST(UIntView, ReadAndWriteWithSufficientBuffer) { |
| ::std::vector</**/ ::std::uint8_t> bytes = { |
| {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08}}; |
| auto uint64_view = |
| UIntViewN<64>{BitBlockN<64>{ReadWriteContiguousBuffer{bytes.data(), 8}}}; |
| EXPECT_EQ(0x090a0b0c0d0e0f10UL, uint64_view.Read()); |
| EXPECT_EQ(0x090a0b0c0d0e0f10UL, uint64_view.UncheckedRead()); |
| uint64_view.Write(0x100f0e0d0c0b0a09UL); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x08}}), |
| bytes); |
| uint64_view.UncheckedWrite(0x090a0b0c0d0e0f10UL); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08}}), |
| bytes); |
| EXPECT_TRUE(uint64_view.TryToWrite(0x100f0e0d0c0b0a09UL)); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x08}}), |
| bytes); |
| EXPECT_TRUE(uint64_view.TryToWrite(0x090a0b0c0d0e0f10UL)); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08}}), |
| bytes); |
| EXPECT_TRUE(uint64_view.Ok()); |
| EXPECT_TRUE(uint64_view.IsComplete()); |
| } |
| |
| TEST(UIntView, ReadAndWriteWithInsufficientBuffer) { |
| ::std::vector</**/ ::std::uint8_t> bytes = { |
| {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08}}; |
| auto uint64_view = |
| UIntViewN<64>{BitBlockN<64>{ReadWriteContiguousBuffer{bytes.data(), 4}}}; |
| EXPECT_DEATH(uint64_view.Read(), ""); |
| EXPECT_EQ(0x090a0b0c0d0e0f10UL, uint64_view.UncheckedRead()); |
| EXPECT_DEATH(uint64_view.Write(0x100f0e0d0c0b0a09UL), ""); |
| EXPECT_FALSE(uint64_view.TryToWrite(0x100f0e0d0c0b0a09UL)); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08}}), |
| bytes); |
| uint64_view.UncheckedWrite(0x100f0e0d0c0b0a09UL); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x08}}), |
| bytes); |
| EXPECT_FALSE(uint64_view.Ok()); |
| EXPECT_FALSE(uint64_view.IsComplete()); |
| uint64_view.UncheckedWrite(0x090a0b0c0d0e0f10UL); |
| } |
| |
| TEST(UIntView, NonPowerOfTwoSize) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x10, 0x0f, 0x0e, 0x0d}}; |
| auto uint24_view = |
| UIntViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 3}}}; |
| EXPECT_EQ(0x0e0f10U, uint24_view.Read()); |
| EXPECT_EQ(0x0e0f10U, uint24_view.UncheckedRead()); |
| EXPECT_DEATH(uint24_view.Write(0x1000000), ""); |
| uint24_view.Write(0x100f0e); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x0e, 0x0f, 0x10, 0x0d}}), |
| bytes); |
| uint24_view.UncheckedWrite(0x1000000); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0x00, 0x0d}}), |
| bytes); |
| EXPECT_TRUE(uint24_view.Ok()); |
| EXPECT_TRUE(uint24_view.IsComplete()); |
| } |
| |
| TEST(UIntView, NonPowerOfTwoSizeInsufficientBuffer) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x10, 0x0f, 0x0e, 0x0d}}; |
| auto uint24_view = |
| UIntViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 2}}}; |
| EXPECT_DEATH(uint24_view.Read(), ""); |
| EXPECT_EQ(0x0e0f10U, uint24_view.UncheckedRead()); |
| EXPECT_DEATH(uint24_view.Write(0x100f0e), ""); |
| uint24_view.UncheckedWrite(0x100f0e); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x0e, 0x0f, 0x10, 0x0d}}), |
| bytes); |
| uint24_view.UncheckedWrite(0x1000000); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0x00, 0x0d}}), |
| bytes); |
| EXPECT_FALSE(uint24_view.Ok()); |
| EXPECT_FALSE(uint24_view.IsComplete()); |
| } |
| |
| TEST(UIntView, NonByteSize) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x00, 0x00, 0x80, 0x80}}; |
| auto uint23_view = |
| UIntView<ViewParameters<23>, OffsetBitBlock<BitBlockN<24>>>{BitBlockN<24>{ |
| ReadWriteContiguousBuffer{bytes.data(), |
| 3}}.GetOffsetStorage<1, 0>(0, 23)}; |
| EXPECT_EQ(0x0U, uint23_view.Read()); |
| EXPECT_FALSE(uint23_view.CouldWriteValue(0x800f0e)); |
| EXPECT_FALSE(uint23_view.CouldWriteValue(0x800000)); |
| EXPECT_TRUE(uint23_view.CouldWriteValue(0x7fffff)); |
| EXPECT_DEATH(uint23_view.Write(0x800f0e), ""); |
| uint23_view.Write(0x400f0e); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x0e, 0x0f, 0xc0, 0x80}}), |
| bytes); |
| uint23_view.UncheckedWrite(0x1000000); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0x80, 0x80}}), |
| bytes); |
| EXPECT_TRUE(uint23_view.Ok()); |
| EXPECT_TRUE(uint23_view.IsComplete()); |
| } |
| |
| TEST(UIntView, TextDecode) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x00, 0x00, 0x00, 0xff}}; |
| const auto uint24_view = |
| UIntViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 3}}}; |
| EXPECT_TRUE(UpdateFromText(uint24_view, "23")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{23, 0x00, 0x00, 0xff}}), |
| bytes); |
| EXPECT_EQ(23U, uint24_view.Read()); |
| EXPECT_FALSE(UpdateFromText(uint24_view, "16777216")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{23, 0x00, 0x00, 0xff}}), |
| bytes); |
| EXPECT_TRUE(UpdateFromText(uint24_view, "16777215")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0xff, 0xff, 0xff, 0xff}}), |
| bytes); |
| EXPECT_TRUE(UpdateFromText(uint24_view, "0x01_0203")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x03, 0x02, 0x01, 0xff}}), |
| bytes); |
| } |
| |
| template </**/ ::std::size_t kBits> |
| using IntViewN = IntView<ViewParameters<kBits>, BitBlockN<kBits>>; |
| |
| TEST(IntView, ValueType) { |
| using BitBlockType = BitBlockN<64>; |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::int8_t, |
| IntView<ViewParameters<8>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::int8_t, |
| IntView<ViewParameters<6>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::int16_t, |
| IntView<ViewParameters<9>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::int16_t, |
| IntView<ViewParameters<16>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::int32_t, |
| IntView<ViewParameters<17>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::int32_t, |
| IntView<ViewParameters<32>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::int64_t, |
| IntView<ViewParameters<33>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::int64_t, |
| IntView<ViewParameters<64>, BitBlockType>::ValueType>::value)); |
| } |
| |
| TEST(IntView, CouldWriteValue) { |
| // Note that many values are in decimal in order to avoid C++'s implicit |
| // conversions to unsigned for hex constants. |
| EXPECT_TRUE(IntViewN<8>::CouldWriteValue(0x7f)); |
| EXPECT_TRUE(IntViewN<8>::CouldWriteValue(-0x80)); |
| EXPECT_FALSE(IntViewN<8>::CouldWriteValue(0x80)); |
| EXPECT_FALSE(IntViewN<8>::CouldWriteValue(0x8000000000000000UL)); |
| EXPECT_FALSE(IntViewN<8>::CouldWriteValue(-0x81)); |
| EXPECT_TRUE(IntViewN<16>::CouldWriteValue(32767)); |
| EXPECT_TRUE(IntViewN<16>::CouldWriteValue(0)); |
| EXPECT_FALSE(IntViewN<16>::CouldWriteValue(0x8000)); |
| EXPECT_FALSE(IntViewN<16>::CouldWriteValue(-0x8001)); |
| EXPECT_TRUE(IntViewN<32>::CouldWriteValue(0x7fffffffU)); |
| EXPECT_TRUE(IntViewN<32>::CouldWriteValue(0x7fffffffL)); |
| EXPECT_FALSE(IntViewN<32>::CouldWriteValue(0x80000000U)); |
| EXPECT_FALSE(IntViewN<32>::CouldWriteValue(-2147483649L)); |
| EXPECT_TRUE(IntViewN<48>::CouldWriteValue(0x00007fffffffffffUL)); |
| EXPECT_FALSE(IntViewN<48>::CouldWriteValue(140737488355328L)); |
| EXPECT_FALSE(IntViewN<48>::CouldWriteValue(-140737488355329L)); |
| EXPECT_TRUE(IntViewN<64>::CouldWriteValue(0x7fffffffffffffffUL)); |
| EXPECT_TRUE(IntViewN<64>::CouldWriteValue(9223372036854775807L)); |
| EXPECT_TRUE(IntViewN<64>::CouldWriteValue(-9223372036854775807L - 1)); |
| EXPECT_FALSE(IntViewN<64>::CouldWriteValue(0x8000000000000000UL)); |
| } |
| |
| TEST(IntView, CouldWriteValueNarrowing) { |
| auto narrowing_could_write = [](int value) { |
| return IntViewN<8>::CouldWriteValue(value); |
| }; |
| EXPECT_TRUE(narrowing_could_write(-128)); |
| EXPECT_TRUE(narrowing_could_write(127)); |
| EXPECT_FALSE(narrowing_could_write(-129)); |
| EXPECT_FALSE(narrowing_could_write(128)); |
| } |
| |
| TEST(IntView, ReadAndWriteWithSufficientBuffer) { |
| ::std::vector</**/ ::std::uint8_t> bytes = { |
| {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08}}; |
| auto int64_view = |
| IntViewN<64>{BitBlockN<64>{ReadWriteContiguousBuffer{bytes.data(), 8}}}; |
| EXPECT_EQ(0x090a0b0c0d0e0f10L, int64_view.Read()); |
| EXPECT_EQ(0x090a0b0c0d0e0f10L, int64_view.UncheckedRead()); |
| int64_view.Write(0x100f0e0d0c0b0a09L); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x08}}), |
| bytes); |
| int64_view.UncheckedWrite(0x090a0b0c0d0e0f10L); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08}}), |
| bytes); |
| EXPECT_TRUE(int64_view.TryToWrite(0x100f0e0d0c0b0a09L)); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x08}}), |
| bytes); |
| int64_view.Write(-0x100f0e0d0c0b0a09L); |
| EXPECT_EQ(-0x100f0e0d0c0b0a09L, int64_view.Read()); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0xf7, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0, 0xef, 0x08}}), |
| bytes); |
| EXPECT_TRUE(int64_view.Ok()); |
| EXPECT_TRUE(int64_view.IsComplete()); |
| } |
| |
| TEST(IntView, ReadAndWriteWithInsufficientBuffer) { |
| ::std::vector</**/ ::std::uint8_t> bytes = { |
| {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08}}; |
| auto int64_view = |
| IntViewN<64>{BitBlockN<64>{ReadWriteContiguousBuffer{bytes.data(), 4}}}; |
| EXPECT_DEATH(int64_view.Read(), ""); |
| EXPECT_EQ(0x090a0b0c0d0e0f10L, int64_view.UncheckedRead()); |
| EXPECT_DEATH(int64_view.Write(0x100f0e0d0c0b0a09L), ""); |
| EXPECT_FALSE(int64_view.TryToWrite(0x100f0e0d0c0b0a09L)); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08}}), |
| bytes); |
| int64_view.UncheckedWrite(0x100f0e0d0c0b0a09L); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x08}}), |
| bytes); |
| EXPECT_FALSE(int64_view.Ok()); |
| EXPECT_FALSE(int64_view.IsComplete()); |
| } |
| |
| TEST(IntView, NonPowerOfTwoSize) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x10, 0x0f, 0x0e, 0x0d}}; |
| auto int24_view = |
| IntViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 3}}}; |
| EXPECT_EQ(0x0e0f10, int24_view.Read()); |
| EXPECT_EQ(0x0e0f10, int24_view.UncheckedRead()); |
| EXPECT_DEATH(int24_view.Write(0x1000000), ""); |
| int24_view.Write(0x100f0e); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x0e, 0x0f, 0x10, 0x0d}}), |
| bytes); |
| int24_view.Write(-0x100f0e); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0xf2, 0xf0, 0xef, 0x0d}}), |
| bytes); |
| EXPECT_DEATH(int24_view.Write(0x1000000), ""); |
| int24_view.UncheckedWrite(0x1000000); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0x00, 0x0d}}), |
| bytes); |
| EXPECT_TRUE(int24_view.Ok()); |
| EXPECT_TRUE(int24_view.IsComplete()); |
| } |
| |
| TEST(IntView, NonPowerOfTwoSizeInsufficientBuffer) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x10, 0x0f, 0x0e, 0x0d}}; |
| auto int24_view = |
| IntViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 2}}}; |
| EXPECT_DEATH(int24_view.Read(), ""); |
| EXPECT_EQ(0x0e0f10, int24_view.UncheckedRead()); |
| EXPECT_DEATH(int24_view.Write(0x100f0e), ""); |
| int24_view.UncheckedWrite(0x100f0e); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x0e, 0x0f, 0x10, 0x0d}}), |
| bytes); |
| int24_view.UncheckedWrite(0x1000000); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0x00, 0x0d}}), |
| bytes); |
| EXPECT_FALSE(int24_view.Ok()); |
| EXPECT_FALSE(int24_view.IsComplete()); |
| } |
| |
| TEST(IntView, NonByteSize) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x00, 0x00, 0x80, 0x80}}; |
| auto int23_view = |
| IntView<ViewParameters<23>, OffsetBitBlock<BitBlockN<24>>>{BitBlockN<24>{ |
| ReadWriteContiguousBuffer{bytes.data(), |
| 3}}.GetOffsetStorage<1, 0>(0, 23)}; |
| EXPECT_EQ(0x0, int23_view.Read()); |
| EXPECT_FALSE(int23_view.CouldWriteValue(0x400f0e)); |
| EXPECT_DEATH(int23_view.Write(0x400f0e), ""); |
| int23_view.Write(0x200f0e); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x0e, 0x0f, 0xa0, 0x80}}), |
| bytes); |
| int23_view.Write(-0x400000); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0xc0, 0x80}}), |
| bytes); |
| int23_view.UncheckedWrite(0x1000000); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0x80, 0x80}}), |
| bytes); |
| EXPECT_TRUE(int23_view.Ok()); |
| EXPECT_TRUE(int23_view.IsComplete()); |
| } |
| |
| TEST(IntView, OneBit) { |
| ::std::uint8_t bytes[] = {0xfe}; |
| auto int1_view = |
| IntView<ViewParameters<1>, OffsetBitBlock<BitBlockN<8>>>{BitBlockN<8>{ |
| ReadWriteContiguousBuffer{bytes, 1}}.GetOffsetStorage<1, 0>(0, 1)}; |
| EXPECT_TRUE(int1_view.Ok()); |
| EXPECT_TRUE(int1_view.IsComplete()); |
| EXPECT_EQ(0, int1_view.Read()); |
| EXPECT_FALSE(int1_view.CouldWriteValue(1)); |
| EXPECT_TRUE(int1_view.CouldWriteValue(0)); |
| EXPECT_TRUE(int1_view.CouldWriteValue(-1)); |
| EXPECT_DEATH(int1_view.Write(1), ""); |
| int1_view.Write(-1); |
| EXPECT_EQ(0xff, bytes[0]); |
| EXPECT_EQ(-1, int1_view.Read()); |
| int1_view.Write(0); |
| EXPECT_EQ(0xfe, bytes[0]); |
| bytes[0] = 0; |
| int1_view.Write(-1); |
| EXPECT_EQ(0x01, bytes[0]); |
| } |
| |
| TEST(IntView, TextDecode) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x00, 0x00, 0x00, 0xff}}; |
| const auto int24_view = |
| IntViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 3}}}; |
| EXPECT_TRUE(UpdateFromText(int24_view, "23")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{23, 0x00, 0x00, 0xff}}), |
| bytes); |
| EXPECT_EQ(23, int24_view.Read()); |
| EXPECT_FALSE(UpdateFromText(int24_view, "16777216")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{23, 0x00, 0x00, 0xff}}), |
| bytes); |
| EXPECT_FALSE(UpdateFromText(int24_view, "16777215")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{23, 0x00, 0x00, 0xff}}), |
| bytes); |
| EXPECT_FALSE(UpdateFromText(int24_view, "8388608")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{23, 0x00, 0x00, 0xff}}), |
| bytes); |
| EXPECT_TRUE(UpdateFromText(int24_view, "8388607")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0xff, 0xff, 0x7f, 0xff}}), |
| bytes); |
| EXPECT_TRUE(UpdateFromText(int24_view, "-8388608")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0x80, 0xff}}), |
| bytes); |
| EXPECT_TRUE(UpdateFromText(int24_view, "-1")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0xff, 0xff, 0xff, 0xff}}), |
| bytes); |
| EXPECT_TRUE(UpdateFromText(int24_view, "0x01_0203")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x03, 0x02, 0x01, 0xff}}), |
| bytes); |
| EXPECT_TRUE(UpdateFromText(int24_view, "-0x01_0203")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0xfd, 0xfd, 0xfe, 0xff}}), |
| bytes); |
| EXPECT_FALSE(UpdateFromText(int24_view, "- 0x01_0203")); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0xfd, 0xfd, 0xfe, 0xff}}), |
| bytes); |
| } |
| |
| TEST(MaxBcd, Values) { |
| EXPECT_EQ(0U, MaxBcd</**/ ::std::uint64_t>(0)); |
| EXPECT_EQ(1U, MaxBcd</**/ ::std::uint64_t>(1)); |
| EXPECT_EQ(3U, MaxBcd</**/ ::std::uint64_t>(2)); |
| EXPECT_EQ(7U, MaxBcd</**/ ::std::uint64_t>(3)); |
| EXPECT_EQ(9U, MaxBcd</**/ ::std::uint64_t>(4)); |
| EXPECT_EQ(19U, MaxBcd</**/ ::std::uint64_t>(5)); |
| EXPECT_EQ(39U, MaxBcd</**/ ::std::uint64_t>(6)); |
| EXPECT_EQ(79U, MaxBcd</**/ ::std::uint64_t>(7)); |
| EXPECT_EQ(99U, MaxBcd</**/ ::std::uint64_t>(8)); |
| EXPECT_EQ(199U, MaxBcd</**/ ::std::uint64_t>(9)); |
| EXPECT_EQ(999U, MaxBcd</**/ ::std::uint64_t>(12)); |
| EXPECT_EQ(9999U, MaxBcd</**/ ::std::uint64_t>(16)); |
| EXPECT_EQ(999999U, MaxBcd</**/ ::std::uint64_t>(24)); |
| EXPECT_EQ(3999999999999999UL, MaxBcd</**/ ::std::uint64_t>(62)); |
| EXPECT_EQ(7999999999999999UL, MaxBcd</**/ ::std::uint64_t>(63)); |
| EXPECT_EQ(9999999999999999UL, MaxBcd</**/ ::std::uint64_t>(64)); |
| // Max uint64_t is 18446744073709551616, which is big enough to hold a 76-bit |
| // BCD value. |
| EXPECT_EQ(19999999999999999UL, MaxBcd</**/ ::std::uint64_t>(65)); |
| EXPECT_EQ(39999999999999999UL, MaxBcd</**/ ::std::uint64_t>(66)); |
| EXPECT_EQ(99999999999999999UL, MaxBcd</**/ ::std::uint64_t>(68)); |
| EXPECT_EQ(999999999999999999UL, MaxBcd</**/ ::std::uint64_t>(72)); |
| EXPECT_EQ(9999999999999999999UL, MaxBcd</**/ ::std::uint64_t>(76)); |
| } |
| |
| TEST(IsBcd, Values) { |
| EXPECT_TRUE(IsBcd(0x00U)); |
| EXPECT_TRUE(IsBcd(0x12U)); |
| EXPECT_TRUE(IsBcd(0x91U)); |
| EXPECT_TRUE(IsBcd(0x99U)); |
| EXPECT_TRUE(IsBcd(::std::uint8_t{0x00})); |
| EXPECT_TRUE(IsBcd(::std::uint8_t{0x99})); |
| EXPECT_TRUE(IsBcd(::std::uint16_t{0x0000})); |
| EXPECT_TRUE(IsBcd(::std::uint16_t{0x9999})); |
| EXPECT_TRUE(IsBcd(0x9999999999999999UL)); |
| EXPECT_FALSE(IsBcd(::std::uint8_t{0x0a})); |
| EXPECT_FALSE(IsBcd(::std::uint8_t{0xa0})); |
| EXPECT_FALSE(IsBcd(::std::uint8_t{0xff})); |
| EXPECT_FALSE(IsBcd(::std::uint16_t{0x0a00})); |
| EXPECT_FALSE(IsBcd(::std::uint16_t{0x000a})); |
| EXPECT_FALSE(IsBcd(0x999999999999999aUL)); |
| EXPECT_FALSE(IsBcd(0xaUL)); |
| EXPECT_FALSE(IsBcd(0xa000000000000000UL)); |
| EXPECT_FALSE(IsBcd(0xf000000000000000UL)); |
| EXPECT_FALSE(IsBcd(0xffffffffffffffffUL)); |
| } |
| |
| TEST(BcdView, ValueType) { |
| using BitBlockType = BitBlockN<64>; |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint8_t, |
| BcdView<ViewParameters<8>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint8_t, |
| BcdView<ViewParameters<6>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint16_t, |
| BcdView<ViewParameters<9>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint16_t, |
| BcdView<ViewParameters<16>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint32_t, |
| BcdView<ViewParameters<17>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint32_t, |
| BcdView<ViewParameters<32>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint64_t, |
| BcdView<ViewParameters<33>, BitBlockType>::ValueType>::value)); |
| EXPECT_TRUE((::std::is_same< |
| /**/ ::std::uint64_t, |
| BcdView<ViewParameters<64>, BitBlockType>::ValueType>::value)); |
| } |
| |
| TEST(BcdView, CouldWriteValue) { |
| EXPECT_TRUE((BcdView<ViewParameters<64>, int>::CouldWriteValue(0))); |
| EXPECT_TRUE( |
| (BcdView<ViewParameters<64>, int>::CouldWriteValue(9999999999999999))); |
| EXPECT_FALSE( |
| (BcdView<ViewParameters<64>, int>::CouldWriteValue(10000000000000000))); |
| EXPECT_FALSE(( |
| BcdView<ViewParameters<64>, int>::CouldWriteValue(0xffffffffffffffffUL))); |
| EXPECT_FALSE( |
| (BcdView<ViewParameters<48>, int>::CouldWriteValue(9999999999999999))); |
| EXPECT_TRUE( |
| (BcdView<ViewParameters<48>, int>::CouldWriteValue(999999999999))); |
| EXPECT_TRUE((BcdView<ViewParameters<48>, int>::CouldWriteValue(0))); |
| EXPECT_FALSE((BcdView<ViewParameters<48>, int>::CouldWriteValue( |
| (0xffUL << 48) + 999999999999))); |
| EXPECT_FALSE( |
| (BcdView<ViewParameters<48>, int>::CouldWriteValue(10000000000000000))); |
| EXPECT_FALSE(( |
| BcdView<ViewParameters<48>, int>::CouldWriteValue(0xffffffffffffffffUL))); |
| } |
| |
| template </**/ ::std::size_t kBits> |
| using BcdViewN = BcdView<ViewParameters<kBits>, BitBlockN<kBits>>; |
| |
| TEST(BcdView, ReadAndWriteWithSufficientBuffer) { |
| ::std::vector</**/ ::std::uint8_t> bytes = { |
| {0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x09, 0x08}}; |
| auto bcd64_view = |
| BcdViewN<64>{BitBlockN<64>{ReadWriteContiguousBuffer{bytes.data(), 8}}}; |
| EXPECT_EQ(910111213141516UL, bcd64_view.Read()); |
| EXPECT_EQ(910111213141516UL, bcd64_view.UncheckedRead()); |
| bcd64_view.Write(1615141312111009); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x08}}), |
| bytes); |
| bcd64_view.UncheckedWrite(910111213141516UL); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x09, 0x08}}), |
| bytes); |
| EXPECT_TRUE(bcd64_view.TryToWrite(1615141312111009)); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x08}}), |
| bytes); |
| EXPECT_TRUE(bcd64_view.Ok()); |
| EXPECT_TRUE(bcd64_view.IsComplete()); |
| } |
| |
| TEST(BcdView, ReadAndWriteWithInsufficientBuffer) { |
| ::std::vector</**/ ::std::uint8_t> bytes = { |
| {0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x09, 0x08}}; |
| auto bcd64_view = |
| BcdViewN<64>{BitBlockN<64>{ReadWriteContiguousBuffer{bytes.data(), 4}}}; |
| EXPECT_DEATH(bcd64_view.Read(), ""); |
| EXPECT_EQ(910111213141516UL, bcd64_view.UncheckedRead()); |
| EXPECT_DEATH(bcd64_view.Write(1615141312111009), ""); |
| EXPECT_FALSE(bcd64_view.TryToWrite(1615141312111009)); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x09, 0x08}}), |
| bytes); |
| bcd64_view.UncheckedWrite(1615141312111009); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{ |
| {0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x08}}), |
| bytes); |
| EXPECT_FALSE(bcd64_view.Ok()); |
| EXPECT_FALSE(bcd64_view.IsComplete()); |
| } |
| |
| TEST(BcdView, NonPowerOfTwoSize) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x16, 0x15, 0x14, 0x13}}; |
| auto bcd24_view = |
| BcdViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 3}}}; |
| EXPECT_EQ(141516U, bcd24_view.Read()); |
| EXPECT_EQ(141516U, bcd24_view.UncheckedRead()); |
| bcd24_view.Write(161514); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x14, 0x15, 0x16, 0x13}}), |
| bytes); |
| EXPECT_DEATH(bcd24_view.Write(1000000), ""); |
| bcd24_view.UncheckedWrite(1000000); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0x00, 0x13}}), |
| bytes); |
| bcd24_view.UncheckedWrite(141516); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x16, 0x15, 0x14, 0x13}}), |
| bytes); |
| EXPECT_TRUE(bcd24_view.Ok()); |
| EXPECT_TRUE(bcd24_view.IsComplete()); |
| } |
| |
| TEST(BcdView, NonPowerOfTwoSizeInsufficientBuffer) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x16, 0x15, 0x14, 0x13}}; |
| auto bcd24_view = |
| BcdViewN<24>{BitBlockN<24>{ReadWriteContiguousBuffer{bytes.data(), 2}}}; |
| EXPECT_DEATH(bcd24_view.Read(), ""); |
| EXPECT_EQ(141516U, bcd24_view.UncheckedRead()); |
| EXPECT_DEATH(bcd24_view.Write(161514), ""); |
| bcd24_view.UncheckedWrite(161514); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x14, 0x15, 0x16, 0x13}}), |
| bytes); |
| bcd24_view.UncheckedWrite(1000000); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0x00, 0x13}}), |
| bytes); |
| EXPECT_FALSE(bcd24_view.Ok()); |
| EXPECT_FALSE(bcd24_view.IsComplete()); |
| } |
| |
| TEST(BcdView, NonByteSize) { |
| ::std::vector</**/ ::std::uint8_t> bytes = {{0x00, 0x00, 0x80, 0x80}}; |
| auto bcd23_view = |
| BcdView<ViewParameters<23>, OffsetBitBlock<BitBlockN<24>>>{BitBlockN<24>{ |
| ReadWriteContiguousBuffer{bytes.data(), |
| 3}}.GetOffsetStorage<1, 0>(0, 23)}; |
| EXPECT_EQ(0x0U, bcd23_view.Read()); |
| EXPECT_FALSE(bcd23_view.CouldWriteValue(800000)); |
| EXPECT_TRUE(bcd23_view.CouldWriteValue(799999)); |
| EXPECT_DEATH(bcd23_view.Write(800000), ""); |
| bcd23_view.Write(432198); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x98, 0x21, 0xc3, 0x80}}), |
| bytes); |
| bcd23_view.UncheckedWrite(800000); |
| EXPECT_EQ((::std::vector</**/ ::std::uint8_t>{{0x00, 0x00, 0x80, 0x80}}), |
| bytes); |
| EXPECT_TRUE(bcd23_view.Ok()); |
| EXPECT_TRUE(bcd23_view.IsComplete()); |
| } |
| |
| TEST(BcdLittleEndianView, AllByteValues) { |
| ::std::uint8_t byte = 0; |
| auto bcd8_view = |
| BcdViewN<8>{BitBlockN<8>{ReadWriteContiguousBuffer{&byte, 1}}}; |
| for (int i = 0; i < 15; ++i) { |
| for (int j = 0; j < 15; ++j) { |
| byte = i * 16 + j; |
| if (i > 9 || j > 9) { |
| EXPECT_FALSE(bcd8_view.Ok()) << i << ", " << j; |
| } else { |
| EXPECT_TRUE(bcd8_view.Ok()) << i << ", " << j; |
| } |
| } |
| } |
| } |
| |
| } // namespace test |
| } // namespace prelude |
| } // namespace emboss |
