// 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.

// Tests for the generated View class for Container and Box from
// nested_structure.emb.
//
// These tests check that nested structures work.
#include <stdint.h>

#include <vector>

#include "gtest/gtest.h"
#include "testdata/uint_sizes.emb.h"

namespace emboss {
namespace test {
namespace {

alignas(8) static const ::std::uint8_t kUIntSizes[36] = {
    0x02,                    // 0:1    one_byte == 2
    0x04, 0x01,              // 1:3    two_byte == 260
    0x66, 0x55, 0x44,        // 3:6    three_byte == 0x445566
    0x06, 0x05, 0x04, 0x03,  // 6:10   four_byte == 0x03040506
    0x21, 0x43, 0x65, 0x87,  // 10:14  five_byte
    0xa9,                    // 14:15  five_byte == 0xa987654321
    0xbc, 0x9a, 0x78, 0x56,  // 15:19  six_byte
    0x34, 0x12,              // 19:21  six_byte == 0x123456789abc
    0x97, 0xa6, 0xb5, 0xc4,  // 21:25  seven_byte
    0xd3, 0xe2, 0xf1,        // 25:28  seven_byte == 0xf1e2d3c4b5a697
    0x06, 0x05, 0x04, 0x03,  // 28:32  eight_byte
    0x02, 0x01, 0x00, 0xff,  // 32:36  eight_byte == 0xff00010203040506
};

TEST(SizesView, CanReadSizes) {
  auto view = MakeAlignedSizesView<const ::std::uint8_t, 8>(kUIntSizes,
                                                            sizeof kUIntSizes);
  EXPECT_EQ(2, view.one_byte().Read());
  EXPECT_EQ(260, view.two_byte().Read());
  EXPECT_EQ(0x445566U, view.three_byte().Read());
  EXPECT_EQ(0x03040506U, view.four_byte().Read());
  EXPECT_EQ(0xa987654321UL, view.five_byte().Read());
  EXPECT_EQ(0x123456789abcUL, view.six_byte().Read());
  EXPECT_EQ(0xf1e2d3c4b5a697UL, view.seven_byte().Read());
  EXPECT_EQ(0xff00010203040506UL, view.eight_byte().Read());
  // Test that the views return appropriate integer widths.
  EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
  EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
  EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
  EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
}

TEST(SizesWriter, CanWriteSizes) {
  ::std::uint8_t buffer[sizeof kUIntSizes];
  auto writer = SizesWriter(buffer, sizeof buffer);
  writer.one_byte().Write(2);
  writer.two_byte().Write(260);
  writer.three_byte().Write(0x445566U);
  writer.four_byte().Write(0x03040506U);
  writer.five_byte().Write(0xa987654321);
  writer.six_byte().Write(0x123456789abc);
  writer.seven_byte().Write(0xf1e2d3c4b5a697);
  writer.eight_byte().Write(0xff00010203040506UL);
  EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
                                               kUIntSizes + sizeof kUIntSizes),
            ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}

TEST(SizesView, CanReadSizesBigEndian) {
  auto view = BigEndianSizesView(kUIntSizes, sizeof kUIntSizes);
  EXPECT_EQ(2, view.one_byte().Read());
  EXPECT_EQ(0x0401, view.two_byte().Read());
  EXPECT_EQ(0x665544U, view.three_byte().Read());
  EXPECT_EQ(0x06050403U, view.four_byte().Read());
  EXPECT_EQ(0x21436587a9UL, view.five_byte().Read());
  EXPECT_EQ(0xbc9a78563412UL, view.six_byte().Read());
  EXPECT_EQ(0x97a6b5c4d3e2f1UL, view.seven_byte().Read());
  EXPECT_EQ(0x06050403020100ffUL, view.eight_byte().Read());
  // Test that the views return appropriate integer widths.
  EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
  EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
  EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
  EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
}

TEST(SizesWriter, CanWriteSizesBigEndian) {
  ::std::uint8_t buffer[sizeof kUIntSizes];
  auto writer = BigEndianSizesWriter(buffer, sizeof buffer);
  writer.one_byte().Write(2);
  writer.two_byte().Write(0x0401);
  writer.three_byte().Write(0x665544U);
  writer.four_byte().Write(0x06050403U);
  writer.five_byte().Write(0x21436587a9);
  writer.six_byte().Write(0xbc9a78563412);
  writer.seven_byte().Write(0x97a6b5c4d3e2f1);
  writer.eight_byte().Write(0x06050403020100ffUL);
  EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
                                               kUIntSizes + sizeof kUIntSizes),
            ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}

TEST(SizesView, CanReadSizesAlternatingEndian) {
  auto view = AlternatingEndianSizesView(kUIntSizes, sizeof kUIntSizes);
  EXPECT_EQ(2, view.one_byte().Read());
  EXPECT_EQ(0x0104, view.two_byte().Read());
  EXPECT_EQ(0x665544U, view.three_byte().Read());
  EXPECT_EQ(0x03040506U, view.four_byte().Read());
  EXPECT_EQ(0x21436587a9UL, view.five_byte().Read());
  EXPECT_EQ(0x123456789abcUL, view.six_byte().Read());
  EXPECT_EQ(0x97a6b5c4d3e2f1UL, view.seven_byte().Read());
  EXPECT_EQ(0xff00010203040506UL, view.eight_byte().Read());
  // Test that the views return appropriate integer widths.
  EXPECT_EQ(1U, sizeof(view.one_byte().Read()));
  EXPECT_EQ(2U, sizeof(view.two_byte().Read()));
  EXPECT_EQ(4U, sizeof(view.three_byte().Read()));
  EXPECT_EQ(4U, sizeof(view.four_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
}

TEST(SizesWriter, CanWriteSizesAlternatingEndian) {
  ::std::uint8_t buffer[sizeof kUIntSizes];
  auto writer = AlternatingEndianSizesWriter(buffer, sizeof buffer);
  writer.one_byte().Write(2);
  writer.two_byte().Write(0x0104);
  writer.three_byte().Write(0x665544U);
  writer.four_byte().Write(0x03040506);
  writer.five_byte().Write(0x21436587a9);
  writer.six_byte().Write(0x123456789abc);
  writer.seven_byte().Write(0x97a6b5c4d3e2f1);
  writer.eight_byte().Write(0xff00010203040506UL);
  EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
                                               kUIntSizes + sizeof kUIntSizes),
            ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}

TEST(SizesView, DecodeUIntsFromText) {
  ::std::uint8_t buffer[sizeof kUIntSizes] = {0};
  auto writer = SizesWriter(buffer, sizeof buffer);
  EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
    {
      one_byte: 2
      two_byte: 260
      three_byte: 0x445566
      four_byte: 0x03040506
      five_byte: 0xa987654321
      six_byte: 0x123456789abc
      seven_byte: 0xf1e2d3c4b5a697
      eight_byte: 0xff00010203040506
    }
  )"));
  EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
                                               kUIntSizes + sizeof kUIntSizes),
            ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
  EXPECT_EQ(2, writer.one_byte().Read());
  EXPECT_TRUE(::emboss::UpdateFromText(writer, "{one_byte:5}"));
  EXPECT_EQ(5, buffer[0]);
  EXPECT_EQ(5, writer.one_byte().Read());
  EXPECT_FALSE(::emboss::UpdateFromText(writer, "{one_byte:256}"));
  EXPECT_EQ(5, buffer[0]);
  EXPECT_EQ(5, writer.one_byte().Read());
  EXPECT_FALSE(::emboss::UpdateFromText(writer, "{three_byte:0x1000000}"));
  EXPECT_FALSE(::emboss::UpdateFromText(writer, "{no_byte:0}"));
}

TEST(SizesView, DecodeUIntsFromTextWithCommas) {
  ::std::uint8_t buffer[sizeof kUIntSizes] = {0};
  auto writer = SizesWriter(buffer, sizeof buffer);
  EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
    {
      one_byte: 2,
      two_byte: 260,
      three_byte: 0x445566,
      four_byte: 0x03040506,
      five_byte: 0xa987654321,
      six_byte: 0x123456789abc,
      seven_byte: 0xf1e2d3c4b5a697,
      eight_byte: 0xff00010203040506,
    }
  )"));
  EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
                                               kUIntSizes + sizeof kUIntSizes),
            ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}

TEST(SizesView, DecodeBigEndianUIntsFromText) {
  ::std::uint8_t buffer[sizeof kUIntSizes] = {0};
  auto writer = BigEndianSizesWriter(buffer, sizeof buffer);
  EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
    {
      one_byte: 2
      two_byte: 0x0401
      three_byte: 0x665544
      four_byte: 0x06050403
      five_byte: 0x21436587a9
      six_byte: 0xbc9a78563412
      seven_byte: 0x97a6b5c4d3e2f1
      eight_byte: 0x06050403020100ff
    }
  )"));
  EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kUIntSizes,
                                               kUIntSizes + sizeof kUIntSizes),
            ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}

TEST(SizesView, EncodeUIntsToText) {
  auto view = MakeAlignedSizesView<const ::std::uint8_t, 8>(kUIntSizes,
                                                            sizeof kUIntSizes);
  EXPECT_EQ(
      "{\n"
      "  one_byte: 2  # 0x2\n"
      "  two_byte: 260  # 0x104\n"
      "  three_byte: 4_478_310  # 0x44_5566\n"
      "  four_byte: 50_595_078  # 0x304_0506\n"
      "  five_byte: 728_121_033_505  # 0xa9_8765_4321\n"
      "  six_byte: 20_015_998_343_868  # 0x1234_5678_9abc\n"
      "  seven_byte: 68_084_868_553_483_927  # 0xf1_e2d3_c4b5_a697\n"
      "  eight_byte: 18_374_687_587_823_781_126  # 0xff00_0102_0304_0506\n"
      "}",
      ::emboss::WriteToString(view, ::emboss::MultilineText()));
  EXPECT_EQ(
      "{ one_byte: 2, two_byte: 260, three_byte: 4478310, four_byte: 50595078, "
      "five_byte: 728121033505, six_byte: 20015998343868, seven_byte: "
      "68084868553483927, eight_byte: 18374687587823781126 }",
      ::emboss::WriteToString(view));
}

static const ::std::uint8_t kEnumSizes[36] = {
    0x01,                    // 0:1    one_byte == VALUE1
    0x0a, 0x00,              // 1:3    two_byte == VALUE10
    0x10, 0x27, 0x00,        // 3:6    three_byte == VALUE10000
    0x64, 0x00, 0x00, 0x00,  // 6:10   four_byte == VALUE100
    0xa0, 0x86, 0x01, 0x00,  // 10:14  five_byte
    0x00,                    // 14:15  five_byte == VALUE100000
    0x40, 0x42, 0x0f, 0x00,  // 15:19  six_byte
    0x00, 0x00,              // 19:21  six_byte == VALUE1000000
    0x80, 0x96, 0x98, 0x00,  // 21:25  seven_byte
    0x00, 0x00, 0x00,        // 25:28  seven_byte == VALUE10000000
    0xe8, 0x03, 0x00, 0x00,  // 28:32  eight_byte
    0x00, 0x00, 0x00, 0x00,  // 32:36  eight_byte == VALUE1000
};

TEST(SizesView, CanReadEnumSizes) {
  auto view = EnumSizesView(kEnumSizes, sizeof kEnumSizes);
  EXPECT_EQ(Enum::VALUE1, view.one_byte().Read());
  EXPECT_EQ(Enum::VALUE10, view.two_byte().Read());
  EXPECT_EQ(Enum::VALUE10000, view.three_byte().Read());
  EXPECT_EQ(Enum::VALUE100, view.four_byte().Read());
  EXPECT_EQ(Enum::VALUE100000, view.five_byte().Read());
  EXPECT_EQ(Enum::VALUE1000000, view.six_byte().Read());
  EXPECT_EQ(Enum::VALUE10000000, view.seven_byte().Read());
  EXPECT_EQ(Enum::VALUE1000, view.eight_byte().Read());
  // Emboss enums are always derived from uint64_t.
  EXPECT_EQ(8U, sizeof(view.one_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.two_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.three_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.four_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.five_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.six_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.seven_byte().Read()));
  EXPECT_EQ(8U, sizeof(view.eight_byte().Read()));
}

TEST(SizesWriter, CanWriteEnumSizes) {
  ::std::uint8_t buffer[sizeof kEnumSizes];
  auto writer = EnumSizesWriter(buffer, sizeof buffer);
  writer.one_byte().Write(Enum::VALUE1);
  writer.two_byte().Write(Enum::VALUE10);
  writer.three_byte().Write(Enum::VALUE10000);
  writer.four_byte().Write(Enum::VALUE100);
  writer.five_byte().Write(Enum::VALUE100000);
  writer.six_byte().Write(Enum::VALUE1000000);
  writer.seven_byte().Write(Enum::VALUE10000000);
  writer.eight_byte().Write(Enum::VALUE1000);
  EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kEnumSizes,
                                               kEnumSizes + sizeof kEnumSizes),
            ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}

TEST(SizesView, DecodeEnumsFromText) {
  ::std::uint8_t buffer[sizeof kEnumSizes] = {0};
  auto writer = EnumSizesWriter(buffer, sizeof buffer);
  EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
    {
      one_byte: VALUE1
      two_byte: VALUE10
      three_byte: VALUE10000
      four_byte: VALUE100
      five_byte: VALUE100000
      six_byte: VALUE1000000
      seven_byte: VALUE10000000
      eight_byte: VALUE1000
    }
  )"));
  EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kEnumSizes,
                                               kEnumSizes + sizeof kEnumSizes),
            ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}

TEST(SizesView, DecodeEnumsFromIntegerText) {
  ::std::uint8_t buffer[sizeof kEnumSizes] = {0};
  auto writer = EnumSizesWriter(buffer, sizeof buffer);
  EXPECT_TRUE(::emboss::UpdateFromText(writer, R"(
    {
      one_byte: 1
      two_byte: 10
      three_byte: 10000
      four_byte: 100
      five_byte: 100000
      six_byte: 1000000
      seven_byte: 10000000
      eight_byte: 1000
    }
  )"));
  EXPECT_EQ(::std::vector</**/ ::std::uint8_t>(kEnumSizes,
                                               kEnumSizes + sizeof kEnumSizes),
            ::std::vector</**/ ::std::uint8_t>(buffer, buffer + sizeof buffer));
}

static const ::std::uint8_t kUIntArraySizes[72] = {
    0x02,                    // 0:2    one_byte[0] == 2
    0x03,                    // 0:2    one_byte[1] == 3
    0x04, 0x01,              // 2:6    two_byte[0] == 260
    0x05, 0x01,              // 2:6    two_byte[1] == 261
    0x66, 0x55, 0x44,        // 6:12   three_byte[0] == 0x445566
    0x67, 0x55, 0x44,        // 6:12   three_byte[1] == 0x445567
    0x06, 0x05, 0x04, 0x03,  // 12:20  four_byte[0] == 0x03040506
    0x07, 0x05, 0x04, 0x03,  // 12:20  four_byte[1] == 0x03040507
    0x21, 0x43, 0x65, 0x87,  // 20:30  five_byte[0]
    0xa9,                    // 20:30  five_byte[0] == 0xa987654321
    0x22, 0x43, 0x65, 0x87,  // 20:30  five_byte[1]
    0xa9,                    // 20:30  five_byte[1] == 0xa987654322
    0xbc, 0x9a, 0x78, 0x56,  // 30:42  six_byte[0]
    0x34, 0x12,              // 30:42  six_byte[0] == 0x123456789abc
    0xbd, 0x9a, 0x78, 0x56,  // 30:42  six_byte[1]
    0x34, 0x12,              // 30:42  six_byte[1] == 0x123456789abd
    0x97, 0xa6, 0xb5, 0xc4,  // 42:56  seven_byte[0]
    0xd3, 0xe2, 0xf1,        // 42:56  seven_byte[0] == 0xf1e2d3c4b5a697
    0x98, 0xa6, 0xb5, 0xc4,  // 42:56  seven_byte[1]
    0xd3, 0xe2, 0xf1,        // 42:56  seven_byte[1] == 0xf1e2d3c4b5a698
    0x06, 0x05, 0x04, 0x03,  // 56:72  eight_byte[0]
    0x02, 0x01, 0x00, 0xff,  // 56:72  eight_byte[0] == 0xff00010203040506
    0x07, 0x05, 0x04, 0x03,  // 56:72  eight_byte[1]
    0x02, 0x01, 0x00, 0xff,  // 56:72  eight_byte[1] == 0xff00010203040507
};

TEST(SizesView, CanReadArraySizes) {
  auto view = ArraySizesView(kUIntArraySizes, sizeof kUIntArraySizes);
  EXPECT_EQ(2, view.one_byte()[0].Read());
  EXPECT_EQ(3, view.one_byte()[1].Read());
  EXPECT_EQ(260, view.two_byte()[0].Read());
  EXPECT_EQ(261, view.two_byte()[1].Read());
  EXPECT_EQ(0x445566U, view.three_byte()[0].Read());
  EXPECT_EQ(0x445567U, view.three_byte()[1].Read());
  EXPECT_EQ(0x03040506U, view.four_byte()[0].Read());
  EXPECT_EQ(0x03040507U, view.four_byte()[1].Read());
  EXPECT_EQ(0xa987654321UL, view.five_byte()[0].Read());
  EXPECT_EQ(0xa987654322UL, view.five_byte()[1].Read());
  EXPECT_EQ(0x123456789abcUL, view.six_byte()[0].Read());
  EXPECT_EQ(0x123456789abdUL, view.six_byte()[1].Read());
  EXPECT_EQ(0xf1e2d3c4b5a697UL, view.seven_byte()[0].Read());
  EXPECT_EQ(0xf1e2d3c4b5a698UL, view.seven_byte()[1].Read());
  EXPECT_EQ(0xff00010203040506UL, view.eight_byte()[0].Read());
  EXPECT_EQ(0xff00010203040507UL, view.eight_byte()[1].Read());
  // Test that the views return appropriate integer widths.
  EXPECT_EQ(1U, sizeof(view.one_byte()[0].Read()));
  EXPECT_EQ(2U, sizeof(view.two_byte()[0].Read()));
  EXPECT_EQ(4U, sizeof(view.three_byte()[0].Read()));
  EXPECT_EQ(4U, sizeof(view.four_byte()[0].Read()));
  EXPECT_EQ(8U, sizeof(view.five_byte()[0].Read()));
  EXPECT_EQ(8U, sizeof(view.six_byte()[0].Read()));
  EXPECT_EQ(8U, sizeof(view.seven_byte()[0].Read()));
  EXPECT_EQ(8U, sizeof(view.eight_byte()[0].Read()));
}

TEST(SizesView, CopyFrom) {
  ::std::array</**/ ::std::uint8_t, sizeof kUIntArraySizes> buf_x = {};
  ::std::array</**/ ::std::uint8_t, sizeof kUIntArraySizes> buf_y = {};

  const auto x = SizesWriter(&buf_x);
  const auto y = SizesWriter(&buf_y);

  constexpr int kValue = 42;
  x.one_byte().Write(kValue);
  EXPECT_NE(x.one_byte().Read(), y.one_byte().Read());
  y.one_byte().CopyFrom(x.one_byte());
  EXPECT_EQ(x.one_byte().Read(), y.one_byte().Read());
}

TEST(SizesView, TryToCopyFrom) {
  ::std::array</**/ ::std::uint8_t, sizeof kUIntArraySizes> buf_x = {};
  ::std::array</**/ ::std::uint8_t, sizeof kUIntArraySizes> buf_y = {};

  const auto x = SizesWriter(&buf_x);
  const auto y = SizesWriter(&buf_y);

  constexpr int kValue = 42;
  x.one_byte().Write(kValue);
  EXPECT_NE(x.one_byte().Read(), y.one_byte().Read());
  EXPECT_TRUE(y.one_byte().TryToCopyFrom(x.one_byte()));
  EXPECT_EQ(x.one_byte().Read(), y.one_byte().Read());
}

}  // namespace
}  // namespace test
}  // namespace emboss