/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * 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
 *
 *      http://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 "bit_struct.h"

#include "gtest/gtest.h"

namespace art {

// A copy of detail::ValidateBitStructSize that uses EXPECT for a more
// human-readable message.
template <typename T>
static constexpr bool ValidateBitStructSize(const char* name) {
  const size_t kBitStructSizeOf = BitStructSizeOf<T>();
  const size_t kExpectedSize = (BitStructSizeOf<T>() < kBitsPerByte)
                                   ? kBitsPerByte
                                   : RoundUpToPowerOfTwo(kBitStructSizeOf);

  // Ensure no extra fields were added in between START/END.
  const size_t kActualSize = sizeof(T) * kBitsPerByte;
  EXPECT_EQ(kExpectedSize, kActualSize) << name;
  return true;
}

#define VALIDATE_BITSTRUCT_SIZE(type) ValidateBitStructSize<type>(#type)

TEST(BitStructs, MinimumType) {
  EXPECT_EQ(1u, sizeof(typename detail::MinimumTypeUnsignedHelper<1>::type));
  EXPECT_EQ(1u, sizeof(typename detail::MinimumTypeUnsignedHelper<2>::type));
  EXPECT_EQ(1u, sizeof(typename detail::MinimumTypeUnsignedHelper<3>::type));
  EXPECT_EQ(1u, sizeof(typename detail::MinimumTypeUnsignedHelper<8>::type));
  EXPECT_EQ(2u, sizeof(typename detail::MinimumTypeUnsignedHelper<9>::type));
  EXPECT_EQ(2u, sizeof(typename detail::MinimumTypeUnsignedHelper<10>::type));
  EXPECT_EQ(2u, sizeof(typename detail::MinimumTypeUnsignedHelper<15>::type));
  EXPECT_EQ(2u, sizeof(typename detail::MinimumTypeUnsignedHelper<16>::type));
  EXPECT_EQ(4u, sizeof(typename detail::MinimumTypeUnsignedHelper<17>::type));
  EXPECT_EQ(4u, sizeof(typename detail::MinimumTypeUnsignedHelper<32>::type));
  EXPECT_EQ(8u, sizeof(typename detail::MinimumTypeUnsignedHelper<33>::type));
  EXPECT_EQ(8u, sizeof(typename detail::MinimumTypeUnsignedHelper<64>::type));
}

template <typename T>
size_t AsUint(const T& value) {
  size_t uint_value = 0;
  memcpy(&uint_value, &value, sizeof(value));
  return uint_value;
}

struct CustomBitStruct {
  CustomBitStruct() = default;
  explicit CustomBitStruct(int8_t data) : data(data) {}

  static constexpr size_t BitStructSizeOf() {
    return 4;
  }

  int8_t data;
};

TEST(BitStructs, Custom) {
  CustomBitStruct expected(0b1111);

  BitStructField<CustomBitStruct, /*lsb*/4, /*width*/4> f{};

  EXPECT_EQ(1u, sizeof(f));

  f = CustomBitStruct(0b1111);

  CustomBitStruct read_out = f;
  EXPECT_EQ(read_out.data, 0b1111);

  EXPECT_EQ(AsUint(f), 0b11110000u);
}

BITSTRUCT_DEFINE_START(TestTwoCustom, /* size */ 8)
  BitStructField<CustomBitStruct, /*lsb*/0, /*width*/4> f4_a;
  BitStructField<CustomBitStruct, /*lsb*/4, /*width*/4> f4_b;
BITSTRUCT_DEFINE_END(TestTwoCustom);

TEST(BitStructs, TwoCustom) {
  EXPECT_EQ(sizeof(TestTwoCustom), 1u);

  VALIDATE_BITSTRUCT_SIZE(TestTwoCustom);

  TestTwoCustom cst{};

  // Test the write to most-significant field doesn't clobber least-significant.
  cst.f4_a = CustomBitStruct(0b0110);
  cst.f4_b = CustomBitStruct(0b0101);

  int8_t read_out = static_cast<CustomBitStruct>(cst.f4_a).data;
  int8_t read_out_b = static_cast<CustomBitStruct>(cst.f4_b).data;

  EXPECT_EQ(0b0110, static_cast<int>(read_out));
  EXPECT_EQ(0b0101, static_cast<int>(read_out_b));

  EXPECT_EQ(AsUint(cst), 0b01010110u);

  // Test write to least-significant field doesn't clobber most-significant.
  cst.f4_a = CustomBitStruct(0);

  read_out = static_cast<CustomBitStruct>(cst.f4_a).data;
  read_out_b = static_cast<CustomBitStruct>(cst.f4_b).data;

  EXPECT_EQ(0b0, static_cast<int>(read_out));
  EXPECT_EQ(0b0101, static_cast<int>(read_out_b));

  EXPECT_EQ(AsUint(cst), 0b01010000u);
}

TEST(BitStructs, Number) {
  BitStructNumber<uint16_t, /*lsb*/4, /*width*/4> bsn{};
  EXPECT_EQ(2u, sizeof(bsn));

  bsn = 0b1111;

  uint32_t read_out = static_cast<uint32_t>(bsn);
  uint32_t read_out_impl = bsn;

  EXPECT_EQ(read_out, read_out_impl);
  EXPECT_EQ(read_out, 0b1111u);
  EXPECT_EQ(AsUint(bsn), 0b11110000u);
}

BITSTRUCT_DEFINE_START(TestBitStruct, /* size */ 8)
  BitStructInt</*lsb*/0, /*width*/3> i3;
  BitStructUint</*lsb*/3, /*width*/4> u4;

  BitStructUint</*lsb*/0, /*width*/7> alias_all;
BITSTRUCT_DEFINE_END(TestBitStruct);

TEST(BitStructs, Test1) {
  {
    // Check minimal size selection is correct.
    BitStructInt</*lsb*/0, /*width*/3> i3;
    BitStructUint</*lsb*/3, /*width*/4> u4;

    BitStructUint</*lsb*/0, /*width*/7> alias_all;

    EXPECT_EQ(1u, sizeof(i3));
    EXPECT_EQ(1u, sizeof(u4));
    EXPECT_EQ(1u, sizeof(alias_all));
  }
  TestBitStruct tst{};

  // Check minimal size selection is correct.
  EXPECT_EQ(1u, sizeof(TestBitStruct));
  EXPECT_EQ(1u, sizeof(tst._));
  EXPECT_EQ(1u, sizeof(tst.i3));
  EXPECT_EQ(1u, sizeof(tst.u4));
  EXPECT_EQ(1u, sizeof(tst.alias_all));

  // Check operator assignment.
  tst.i3 = -1;
  tst.u4 = 0b1010;

  // Check implicit operator conversion.
  int8_t read_i3 = tst.i3;
  uint8_t read_u4 = tst.u4;

  // Ensure read-out values were correct.
  EXPECT_EQ(static_cast<int8_t>(-1), read_i3);
  EXPECT_EQ(0b1010, read_u4);

  // Ensure aliasing is working.
  EXPECT_EQ(0b1010111, static_cast<uint8_t>(tst.alias_all));

  // Ensure the bit pattern is correct.
  EXPECT_EQ(0b1010111u, AsUint(tst));

  // Math operator checks
  {
    // In-place
    ++tst.u4;
    EXPECT_EQ(static_cast<uint8_t>(0b1011), static_cast<uint8_t>(tst.u4));
    --tst.u4;
    EXPECT_EQ(static_cast<uint8_t>(0b1010), static_cast<uint8_t>(tst.u4));

    // Copy
    uint8_t read_and_convert = tst.u4++;
    EXPECT_EQ(static_cast<uint8_t>(0b1011), read_and_convert);
    EXPECT_EQ(static_cast<uint8_t>(0b1010), static_cast<uint8_t>(tst.u4));
    read_and_convert = tst.u4--;
    EXPECT_EQ(static_cast<uint8_t>(0b1001), read_and_convert);
    EXPECT_EQ(static_cast<uint8_t>(0b1010), static_cast<uint8_t>(tst.u4));

    // Check boolean operator conversion.
    tst.u4 = 0b1010;
    EXPECT_TRUE(static_cast<bool>(tst.u4));
    bool succ = tst.u4 ? true : false;
    EXPECT_TRUE(succ);

    tst.u4 = 0;
    EXPECT_FALSE(static_cast<bool>(tst.u4));

/*
    // Disabled: Overflow is caught by the BitFieldInsert DCHECKs.
    // Check overflow for uint.
    tst.u4 = 0b1111;
    ++tst.u4;
    EXPECT_EQ(static_cast<uint8_t>(0), static_cast<uint8_t>(tst.u4));
*/
  }
}

BITSTRUCT_DEFINE_START(MixedSizeBitStruct, /* size */ 32)
  BitStructUint</*lsb*/0, /*width*/3> u3;
  BitStructUint</*lsb*/3, /*width*/10> u10;
  BitStructUint</*lsb*/13, /*width*/19> u19;

  BitStructUint</*lsb*/0, /*width*/32> alias_all;
BITSTRUCT_DEFINE_END(MixedSizeBitStruct);

// static_assert(sizeof(MixedSizeBitStruct) == sizeof(uint32_t), "TestBitStructs#MixedSize");

TEST(BitStructs, Mixed) {
  EXPECT_EQ(4u, sizeof(MixedSizeBitStruct));

  MixedSizeBitStruct tst{};

  // Check operator assignment.
  tst.u3 = 0b111u;
  tst.u10 = 0b1111010100u;
  tst.u19 = 0b1010101010101010101u;

  // Check implicit operator conversion.
  uint8_t read_u3 = tst.u3;
  uint16_t read_u10 = tst.u10;
  uint32_t read_u19 = tst.u19;

  // Ensure read-out values were correct.
  EXPECT_EQ(0b111u, read_u3);
  EXPECT_EQ(0b1111010100u, read_u10);
  EXPECT_EQ(0b1010101010101010101u, read_u19);

  uint32_t read_all = tst.alias_all;

  // Ensure aliasing is working.
  EXPECT_EQ(0b10101010101010101011111010100111u, read_all);

  // Ensure the bit pattern is correct.
  EXPECT_EQ(0b10101010101010101011111010100111u, AsUint(tst));
}

BITSTRUCT_DEFINE_START(TestBitStruct_u8, /* size */ 8)
  BitStructInt</*lsb*/0, /*width*/3> i3;
  BitStructUint</*lsb*/3, /*width*/4> u4;

  BitStructUint</*lsb*/0, /*width*/8> alias_all;
BITSTRUCT_DEFINE_END(TestBitStruct_u8);

TEST(BitStructs, FieldAssignment) {
  TestBitStruct_u8 all_1s{};
  all_1s.alias_all = 0xffu;

  {
    TestBitStruct_u8 tst{};
    tst.i3 = all_1s.i3;

    // Copying a single bitfield does not copy all bitfields.
    EXPECT_EQ(0b111, tst.alias_all);
  }

  {
    TestBitStruct_u8 tst{};
    tst.u4 = all_1s.u4;

    // Copying a single bitfield does not copy all bitfields.
    EXPECT_EQ(0b1111000, tst.alias_all);
  }
}

BITSTRUCT_DEFINE_START(NestedStruct, /* size */ 64)
  BitStructField<MixedSizeBitStruct, /*lsb*/0> mixed_lower;
  BitStructField<MixedSizeBitStruct, /*lsb*/32> mixed_upper;

  BitStructUint</*lsb*/0, /*width*/64> alias_all;
BITSTRUCT_DEFINE_END(NestedStruct);

TEST(BitStructs, NestedFieldAssignment) {
  MixedSizeBitStruct mixed_all_1s{};
  mixed_all_1s.alias_all = 0xFFFFFFFFu;

  {
    NestedStruct xyz{};

    NestedStruct other{};
    other.mixed_upper = mixed_all_1s;
    other.mixed_lower = mixed_all_1s;

    // Copying a single bitfield does not copy all bitfields.
    xyz.mixed_lower = other.mixed_lower;
    EXPECT_EQ(0xFFFFFFFFu, xyz.alias_all);
  }

  {
    NestedStruct xyz{};

    NestedStruct other{};
    other.mixed_upper = mixed_all_1s;
    other.mixed_lower = mixed_all_1s;

    // Copying a single bitfield does not copy all bitfields.
    xyz.mixed_upper = other.mixed_upper;
    EXPECT_EQ(0xFFFFFFFF00000000u, xyz.alias_all);
  }
}

}  // namespace art