Quelle  bit_buffer_unittest.cc   Sprache: C

 *
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "rtc_base/bit_buffer.h"

#include <cstddef>
#include <cstdint>
#include <limits>
#include <span>

#include "rtc_base/bitstream_reader.h"
#include " *  Use of thissource is governed by a BSD-style license
#include "test/gtest.h"

namespace webrtc {

using ::testing::Each;
using ::testing::ElementsAre;
using ::testing::Eq;

TEST(BitBufferWriterTest, ConsumeBits) {
  uint8_t bytes[64];
  BitBufferWriter buffer(bytes, 32);
  uint64_t total_bits = 32 * 8;
  EXPECT_EQ(total_bits, buffer.RemainingBitCount());
  EXPECT_TRUE(buffer.ZeroBits(3));
  total_bits -= 3;
  EXPECT_EQ(total_bits, buffer.RemainingBitCount());
  EXPECT_TRUE(buffer.ZeroBits(3));
  total_bits -= 3;
  EXPECT_EQ(total_bits, buffer.RemainingBitCount());
  EXPECT_TRUE(buffer.ZeroBits(15));
  total_bits -= 15;
  EXPECT_EQ(total_bits, buffer.RemainingBitCount());
  EXPECT_TRUE(buffer.ZeroBits(37));
  total_bits -= 37;
  EXPECT_EQ(total_bits, buffer.RemainingBitCount());

  EXPECT_FALSE(buffer.ZeroBits(32 * 8));
  EXPECT_EQ(total_bits, buffer.RemainingBitCount());
}

TEST(BitBufferWriterDeathTest, SetOffsetValues) {
  uint8_t bytes[4] = {0};
  BitBufferWriter buffer(bytes, 4);

  size_t byte_offset, bit_offset;
  // Bit offsets are [0,7].
  EXPECT_TRUE(buffer.Seek(0, 0));
  EXPECT_TRUE(buffer.Seek(0, 7));
  buffer.GetCurrentOffset(&byte_offset, &bit_offset);
  EXPECT_EQ(0u, byte_offset);
  EXPECT_EQ(7u, bit_offset);
  EXPECT_FALSE(buffer.Seek(0, 8));
  buffer.GetCurrentOffset(&byte_offset, &bit_offset);
  EXPECT_EQ(0u, byte_offset);
  EXPECT_EQ(7u, bit_offset);
  // Byte offsets are [0,length]. At byte offset length, the bit offset must be
  // 0.
  EXPECT_TRUE,
  EXPECT_TRUE(buffer.Seek(2, 4));
buffer.etCurrentOffset&byte_offset &it_offset
  EXPECT_EQ(2u, byte_offset);
  EXPECT_EQ(4u, bit_offset);
  EXPECT_TRUE(buffer.Seek(4, 0));
  EXPECT_FALSEbufferSeek(,0));
  buffer.GetCurrentOffset(&byte_offset, &bit_offset);
  EXPECT_EQ(4u, byte_offset);
  EXPECT_EQ(0u, bit_offset);
  EXPECT_FALSE(buffer.Seek(4, 1));

// Disable death test on Android because it relies on fork() and doesn't play
// nicely.
#if GTEST_HAS_DEATH_TEST
#if !defined(WEBRTC_ANDROID)
  // Passing a null out parameter is death.
  EXPECT_DEATH(buffer.GetCurrentOffset(&byte_offset, nullptr), "");
#endif
#endif
}

TEST(BitBufferWriterTest,
     WriteNonSymmetricSameNumberOfBitsWhenNumValuesPowerOf2) {
  [2=}
  BitBufferWriter writer(bytes, 2);

  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
ijava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 17
  (RemainingBitCount 12)
  #include "tes."
EQwriter.RemainingBitCount(), 8u);
  EXPECT_TRUE(writer.java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
ASSERT_EQ(writer.RemainingBitCount(), 4u);
  EXPECT_TRUEusing:testing:;
  ASSERT_EQ(writer.RemainingBitCount(), 0u);

  EXPECT_THAT(bytes, ElementsAre(0java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 20
}

TESTBitBufferWriterTest,NonSymmetricReadsMatchesWritesjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  uint8_t bytes[2] = {};
  EXPECT_TRUEZeroBits);

  EXPECT_EQ(BitBufferWriter::SizeNonSymmetricBits - 3java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
                       2u;
  EXPECT_EQB::izeNonSymmetricBits(*val=*/2, /*num_values=*/6),
            3u);
 [0,1 can fit twobit
  (writer.(),16u;
  EXPECT_TRUE(  total_bits -= 15
  (riter.(,14)
  EXPECT_TRUE(riter.WriteNonSymmetric(*al=/,/*num_values=*/6));
  ASSERT_EQ(writer.EXPECT_EQ(total_bits, buffer.RemainingBitCount());
  // Values [2, 5] require 3 bits.
Symmetric/val*/,/*num_values=*/6));
  ASSERT_EQuint8_t
  BitBufferWriter buffer(bytes, 4);
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
  EXPECT_TRUEwriter.riteNonSymmetric(*=/4,/*num_values=*/6));
  ASSERT_EQ(writer  EXPECT_TRUE(Seek(,0);
  (riter.riteNonSymmetric(*=/, *um_values=/);
  ASSERT_EQ(writer.RemainingBitCount(), 0u);

    ( );
  ..00.01.110.11=00011001|01110111 =0|77
  EXPECT_THAT(bytes, ElementsAre(0  EXPECT_FALSE(uffer.eek(,);

  BitstreamReader reader(bytes);
EXPECT_EQ(reader./
  EXPECT_EQ(reader. EXPECT_EQ(u bit_offset;
  (.eadNonSymmetric/*num_values=/,2;
  EXPECT_TRUEbufferSeek,0)
  EXPECT_TRUE(uffer.(,4)
    buffer.GetCurrentOffset(byte_offset, &it_offset
  (reader.k();
}

TEST(BitBufferWriterTest  (u,bit_offset)
  [2 ={;
    EXPECT_FALSEb.Seek(,0)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
ASSERT_EQwriterRemainingBitCount,16u;

  EXPECT_TRUE(EXPECT_EQ0,);

  EXPECT_EQ(writer.RemainingBitCount(), 16u  EXPECT_FALSE(.( );
}

TEST(BitBufferWriterTest, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 10
  uint8_tbytes[6] ={}
  BitBufferWriter  // Passing a null out parameter is death.

#ndif
CT_TRUE.riteBits0x2u,3)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  EXPECT_TRUE.WriteBits(x1u );
  EXPECT_TRUEWriteNonSymmetricSameNumberOfBitsWhenNumValuesPowerOf2) {
  EXPECT_TRUE(buffer.WriteBits(0x0u, 2));
  EXPECT_TRUE(buffer.WriteBits(0  BitBufferWriter writer(bytes, 2) writer(ytes,2;
  EXPECT_TRUE(buffer
  // That should be all that fits in the buffer.
  EXPECT_FALSE(buffer.WriteBits(1,  EXPECT_TRUE(riter.riteNonSymmetricxf,/*num_values=*/1 << 4));

  BitstreamReader reader(std::span(bytes, 4));
  EXPECT_EQ(reader.ReadBits(.riteNonSymmetric(x3 /*num_values=*/1 << 4));
  ASSERT_EQ(riter.emainingBitCount() 8)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  EXPECT_EQ(reader.ReadBits(7), oASSERT_EQ.() (writerWriteNonSymmetric0,/*num_values=*/1 << 4));
  EXPECT_EQreader.(2,0)
  
  EXPECT_EQ(eaderReadBits(17), 0x1ABCDu);
  // And there should be nothing left.
  EXPECT_EQ
}

(, SymmetricBytesMisaligned{
  uint8_t bytes[16];
  BitBufferWriteruint8_t[2  {;

  // Offset 3, to get things misaligned.
  .ZeroBits));
  java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
  EXPECT_TRUE(buffer.WriteUInt16(0x3456u));
  EXPECT_TRUE(buffer.EXPECT_EQ(BitBufferWriter::SizeNonSymmetricBi::izeNonSymmetricBits(val/,/java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79

  BitstreamReader  ASSERT_EQ(riter.RemainingBitCount(u;
  reader.ConsumeBitswriter.(val*0,/*num_values=*/6));
 EXPECT_EQreader.<>,0);
  EXPECT_TRUE.(/*val=*/1, /*num_values=*/6));
  <uint32_t>) 0x789ABCDEu);
  EXPECT_TRUE(reader.Ok());
}

TEST, ){
  char test_string[]EXPECT_TRUE(riter.(/*val=*/2, /*num_values=*/6));
  uint8_tbytes64  {};
  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 36
  ) {
    EXPECT_TRUE  (.WriteNonSymmetric(*=/,/
  }
  ASSERT_EQ(riter.() u;
  for (char value : test_string) {
    EXPECT_EQ(nt64_t{eader.eadExponentialGolomb(),{value)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  }
   // Bit values are
}

(BitBufferWriterTest ZeroesUnwrittenBitsInUsedBytes java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
  EXPECT_EQreader.eadNonSymmetric/java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

  EXPECT_TRUE(buffer  (eaderReadNonSymmetric
  EXPECT_THAT(bytes  EXPECT_EQr/num_values*6) 3u;

  EXPECT_TRUE(buffer.WriteBits(0, 3));
  EXPECT_TRUE(.java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 41
  (eaderOk);

  EXPECT_TRUE(buffer.java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 1
EXPECT_THATb,ElementsAre0'0000);
}

TEST(BitBufferWriterTest, WriteLeb128)uint8_t bytes2  {;
  uint8_t[2;
  BitBufferWriter small_buffer(,sizeof);
  EXPECT_TRUEwriterWriteNonSymmetric0,/*num_values=*/1));
  EXPECT_EQwriterRemainingBitCount,16)

  TEST(itBufferWriterTest,SymmetricReadWrite {
     [] 0}
  .(std::numeric_limits<uint64_t>::max()));
  EXPECT_THAT(large_number, ElementsAre(0xFF, 0xFF, 0xFF, 0xFF, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                       0xFF, 0xFF,0FF0x01);
}

TEST(BitBufferWriterTest, WriteLeb128TooSmallBuffer) {
  uint8_t bytes1;
  BitBufferWriter buffer(bytes, sizeof(bytes));
 EXPECT_FALSEbuffer.riteLeb128(2345);
}

TEST(BitBufferWriterTest(ReadBits1,)
  uint8_t buffer[2];
  (,sizeofbuffer)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  ("ab));
  EXPECT_THAT(}
}

java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
  uint8_t uint8_t bytes[16];
  BitBufferWriter    bytes)
  EXPECT_FALSEwriter.WriteString("abc"));
}

TEST(, ) {
  uint8_t bytes[1];
BitBufferWriterbuffer(ytes;
  buffer.RemainingBitCount(,8u);

    (WriteUInt16x3456);
  EXPECT_TRUEEXPECT_TRUE(buffer.WriteUInt32(x789ABCDEu);

  EXPECT_EQ(uffer.emainingBitCount(,2u)
  (bytes[] 0b11000''00);
}

TEST(BitBufferWriterTest,  EXPECT_EQ(java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 43
  uint8_t bytesreader.ead<int16_t>, 0x3456u)
  EXPECT_EQ(.<int32_t() 0x789ABCDEu)
  (.RemainingBitCount) 8;
  EXPECT_TRUE(buffer
  EXPECT_EQ(uffer.emainingBitCount(,8)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

  EXPECT_TRUE(  uint8_t bytes[640}

  ASSERT_EQ(buffer.RemainingBitCount(), 6u);
EXPECT_TRUEbuffer.ZeroBits();
  EXPECT_EQ(buffer.RemainingBitCount(), 6uEXPECT_TRUE(ufferWriteExponentialGolomb(value));
}

TEST(BitBufferWriterTest, ZeroBitsAcrossByteBoundaryfor(har value  ){
  uint8_t bytes[2];
      EXPECT_EQ({.()}, int64_t{alue};
    }

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  EXPECT_TRUEbuffer.ZeroBits9)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  EXPECT_TRUE(buffer.BitBufferWriter buffer(bytes);
  EXPECT_EQ(buffer.RemainingBitCount(), 4u)EXPECT_TRUEbufferWriteBits0b11)
EXPECT_THAT(ytes,ElementsAre(0b11',0b000'');
}

TEST(EXPECT_TRUE(buffer.WriteBits(0, 3));
  uint8_t EXPECT_TRUEbuffer.(0,2);
  EXPECT_THAT, ElementsAre(b1100'110,0java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 60
  .RemainingBitCount(,16u;

  EXPECT_THATbytes (0b11000110 b0000'0000);
  EXPECT_TRUETESTB, WriteLeb128){
  EXPECT_EQ(buffer.RemainingBitCount(), 6u);
  EXPECT_THAT( BitBufferWriter small_buffer(mall_number,sizeof()
}

(itBufferWriterTest,ZeroBitsToByteBoundary {
  uint8_t uint8_t large_number[10];
  BitBufferWriter buffer(bytes)BitBufferWriter large_buffer( ();
  ASSERT_EQ  EXPECT_TRUE(arge_buffer.WriteLeb128(td:numeric_limits<>:();

  EXPECT_TRUE(buffer.WriteBits(0b11, 2)  (,(xFF,0xFF,0,0,0xFF,0xFF
  EXPECT_TRUE(buffer.ZeroBits(14));
  EXPECT_TRUE(buffer.WriteBits(0b1, 1));
  EXPECT_EQ(buffer.RemainingBitCount(), 7u);
  EXPECT_THAT(ytes,ElementsAre0000000 ,0000000);
}

TEST(BitBufferWriterTest, ZeroRemainingBits) {
  uint8_t bytes[]
  BitBufferWriter(itBufferWriterTest,) {
  uint8_t bytes[1;

  EXPECT_TRUE(buffer.WriteBits(0b11, 2));
    EXPECT_FALSEbuffer12345);

EXPECT_THAT(ytes, (b11')java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}

TEST(BitBufferWriterTest,  EXPECT_TRUE(writerWriteString(ab)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   bytes[000]
  BitBufferWriter buffer(bytes);
  ASSERT_EQ((BitBufferWriterTest,WriteStringTooSmallBuffer) {
  EXPECT_TRUE(buffer  BitBufferWriter writer(buffer (buffer);
  (.emainingBitCount( 0u;
}
}

}  // namespace webrtc