// 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 "runtime/cpp/emboss_prelude.h"

#include <type_traits>

#include "gtest/gtest.h"
#include "runtime/cpp/emboss_cpp_util.h"
#include "runtime/cpp/emboss_text_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_EQ(0x090a0b0c0d0e0f10UL, uint64_view.UncheckedRead());
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(uint64_view.Read(), "");
  EXPECT_DEATH(uint64_view.Write(0x100f0e0d0c0b0a09UL), "");
#endif  // EMBOSS_CHECK_ABORTS
  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());
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(uint24_view.Write(0x1000000), "");
#endif  // EMBOSS_CHECK_ABORTS
  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_EQ(0x0e0f10U, uint24_view.UncheckedRead());
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(uint24_view.Read(), "");
  EXPECT_DEATH(uint24_view.Write(0x100f0e), "");
#endif  // EMBOSS_CHECK_ABORTS
  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));
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(uint23_view.Write(0x800f0e), "");
#endif  // EMBOSS_CHECK_ABORTS
  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_EQ(0x090a0b0c0d0e0f10L, int64_view.UncheckedRead());
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(int64_view.Read(), "");
  EXPECT_DEATH(int64_view.Write(0x100f0e0d0c0b0a09L), "");
#endif  // EMBOSS_CHECK_ABORTS
  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());
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(int24_view.Write(0x1000000), "");
#endif  // EMBOSS_CHECK_ABORTS
  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);
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(int24_view.Write(0x1000000), "");
#endif  // EMBOSS_CHECK_ABORTS
  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_EQ(0x0e0f10, int24_view.UncheckedRead());
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(int24_view.Read(), "");
  EXPECT_DEATH(int24_view.Write(0x100f0e), "");
#endif  // EMBOSS_CHECK_ABORTS
  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));
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(int23_view.Write(0x400f0e), "");
#endif  // EMBOSS_CHECK_ABORTS
  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));
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(int1_view.Write(1), "");
#endif  // EMBOSS_CHECK_ABORTS
  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_EQ(910111213141516UL, bcd64_view.UncheckedRead());
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(bcd64_view.Read(), "");
  EXPECT_DEATH(bcd64_view.Write(1615141312111009), "");
#endif  // EMBOSS_CHECK_ABORTS
  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);
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(bcd24_view.Write(1000000), "");
#endif  // EMBOSS_CHECK_ABORTS
  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_EQ(141516U, bcd24_view.UncheckedRead());
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(bcd24_view.Read(), "");
  EXPECT_DEATH(bcd24_view.Write(161514), "");
#endif  // EMBOSS_CHECK_ABORTS
  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));
#if EMBOSS_CHECK_ABORTS
  EXPECT_DEATH(bcd23_view.Write(800000), "");
#endif  // EMBOSS_CHECK_ABORTS
  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