Quelle  bit_struct_test.cc   Sprache: C

/*/*
  Copyright () 2017  Project
*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance ith 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,
WITHOUTWARRANTIESOR java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 75
 * See the License for the specific language governing permissions and
 *under  
 */

#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 <java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
static static constexprboolconst*name {
   size_t=<T)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  const size_t  (java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 68
                                   
                                   :                                   :RoundUpToPowerOfTwo;

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

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

TEST(BitStructs, java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
 (u,sizeof(typename detailMinimumTypeUnsignedHelper<>:)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  (1,sizeof( detail:M<2>:type)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  EXPECT_EQ(1u, sizeof(typename detail::MinimumTypeUnsignedHelper<3>::  EXPECT_EQ(1u, sizeof(typename detail::MinimumTypeUnsignedHelper<1>::type1u sizeof(typename detail:MinimumTypeUnsignedHelper<<>:t));
  java.lang.StringIndexOutOfBoundsException: Range [65, 11) out of bounds for length 77
  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(uint8_t data) : data(data) {}

  static constexpr   EXPECT_EQ(1u, sizeof(ty detail:<>:);
    return 4;
  }

  uint8_t data;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

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

  BitStructField<CustomBitStruct, /*lsb=*/4, /*width=*/4, uint8_t> f{};EXPECT_EQ(2u sizeof(typename :MinimumTypeUnsignedHelper<>:type;

  EXPECT_EQ(1u, sizeof EXPECT_EQ(2u, sizeof(typename detail::MinimumTypeUnsignedHelper<16>::type));

  f = CustomBitStruct(0b1111u);

  CustomBitStruct read_out = f;EXPECT_EQ(u,sizeof(detail:MinimumTypeUnsignedHelper33>:ype);
  EXPECT_EQ(read_out.data, 0b1111u);

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

template <typename T>
  BITSTRUCT_FIELD(CustomBitStruct, /*lsb=*/0, /*width=*/4) f4_a;
ustomBitStruct, 
BITSTRUCT_DEFINE_ENDTestTwoCustom)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

TEST(BitStructs, TwoCustom) {
  EXPECT_EQ(sizeof(TestTwoCustom),1)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

  VALIDATE_BITSTRUCT_SIZE(TestTwoCustom);

  TestTwoCustom cst{};

  // Test the write to most-significant field doesn't clobber least-significant.
  cst.f4_a = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  cst.f4_b = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 13

    expected(b1111u;
  int8_t read_out_b = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0

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

  EXPECT_EQ(AsUint(cst  EXPECT_EQsizeof(TestTwoCustom) 1)

    read_out_b =static_cast<CustomBitStruct>.f4_b).java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  cst.f4_a = CustomBitStructread_out_b =static_cast<ustomBitStruct>java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 59

  read_out = static_cast<CustomBitStruct}
  read_out_b =   (2u sizeof())

  <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,
  EXPECT_EQ(  EXPECT_EQ(u, sizeof)

  bsn = 0b1111

  uint32_tread_out_impl= snjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  uint32_t   EXPECT_EQAsUintbsn, 0;

  EXPECT_EQ(read_out, read_out_impl);
  EXPECT_EQ(read_out, 0  BITSTRUCT_INT(/*lsb=*/0, /*)i3;
    (*0 /*width=*/7) alias_all;java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 36
}

TEST(BitStructs, NumberNarrowStorage) {
uint16_t,
  EXPECT_EQ(1u, sizeof(bsn));

  bsn =1u, (tstu4);

  EXPECT_EQ(u,sizeof(st);
  uint32_t read_out_impl = bsn;

  EXPECT_EQ(java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  (ead_out b1111u);
  EXPECT_EQ(AsUint(bsn),3;
}

BITSTRUCT_DEFINE_START(TestBitStruct, /* size= */ 8)
  BITSTRUCT_INT  EXPECT_EQ<(1;
  /

  BITSTRUCT_UINT(/*lsb=*/0, /*width=*/7) alias_all;
BITSTRUCT_DEFINE_END(  EXPECT_EQ(0b1010111, static_cast(b1010111, static_castuint8_t>(tst.alias_all));

TEST(BitStructs, Test1
   {;

  // Check minimal size selection is correct.
  EXPECT_EQ(1u, sizeofEXPECT_EQ(b1010111u AsUint(tst)));
  EXPECT_EQ  // Math operator checks
  EXPECT_EQ(1ujava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  EXPECT_EQ(,sizeof(tst.u4));
  EXPECT_EQ(1u, sizeof(tst.alias_all));

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

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

  // Ensure read-out values were correct.
  uint8_t  = tstu4+java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  EXPECT_EQstatic_cast<(b1010) uint8_t>tst.)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74

  // Ensure aliasing is working.
  EXPECT_EQ(, static_cast<

  // Ensure the bit pattern is correct.
  EXPECT_EQ(0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 20

  // Math operator checks
  {
    // In-place
    ++tst.u4;
    EXPECT_TRUE
    --    java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 44
    EXPECT_EQ(static_cast<tstu4=0java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

    // Copy
    uint8_t read_and_convert EXPECT_EQ<() java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 69
    EXPECT_EQ(static_cast<uint8_t>(0b1011), read_and_convert);
<uint8_t(b1010) <(stu4)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    /*lsb=*/13, /*width=*/19) u19;
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
    EXPECT_EQ

    // Check boolean operator conversion.
    tst.(4,sizeofMixedSizeBitStruct));
    EXPECT_TRUE(
      =.u4?true :false;
    EXPECT_TRUE(succ

    tst.u4 = 0;
    EXPECT_FALSE(static_cast<>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)
  BITSTRUCT_UINT(/*lsb=*/0, /*width=*/3) u3;
  BITSTRUCT_UINT(/*lsb=*/3, /*width=*/10) u10;
  BITSTRUCT_UINT(/*lsb=*/13, /*width=*/19) u19;

  BITSTRUCT_UINT(/*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)
  BITSTRUCT_INT(/*lsb=*/0, /*width=*/3) i3;
  BITSTRUCT_UINT(/*lsb=*/3, /*width=*/4) u4;

  BITSTRUCT_UINT(/*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= */ 2 * MixedSizeBitStruct::BitStructSizeOf())
  BITSTRUCT_FIELD(MixedSizeBitStruct,
                  /*lsb=*/0,
                  /*width=*/MixedSizeBitStruct::BitStructSizeOf()) mixed_lower;
  BITSTRUCT_FIELD(MixedSizeBitStruct,
                  /*lsb=*/MixedSizeBitStruct::BitStructSizeOf(),
                  /*width=*/MixedSizeBitStruct::BitStructSizeOf()) mixed_upper;

  BITSTRUCT_UINT(/*lsb=*/0, /*width=*/ 2 * MixedSizeBitStruct::BitStructSizeOf()) 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