Add unittest for H264BitReader.

content/common/gpu/media/h264_parser_unittest.cc

Index: content/common/gpu/media/h264_parser_unittest.cc
diff --git a/content/common/gpu/media/h264_parser_unittest.cc b/content/common/gpu/media/h264_parser_unittest.cc
index 53d1b3565223c92d1f21aa5634f6c2d0cd9dc3a0..9822af44fbb93ec7ff7e133e50efd82418e8bb16 100644
--- a/content/common/gpu/media/h264_parser_unittest.cc
+++ b/content/common/gpu/media/h264_parser_unittest.cc
@@ -72,6 +72,158 @@ TEST(H264ParserTest, StreamFileParsing) {
   }
 }
 
+class H264BitReaderTest : public ::testing::Test {

[Ami GONE FROM CHROMIUM, 2012/07/31 17:24:15]

AFAICT this class's sole purpose is to forward calls to reader_.  Why not just
declare the reader_ in each TEST() and elide this class entirely?

(in case you're unfamiliar with the difference between TEST_F and TEST, the
latter doesn't require an explicit testing::Test-derived base class).

[xiaomings, 2012/07/31 19:24:32]

The class H264BitReader is a private nested class of H264Parser. So I have to
make the test class friend of H264Parser in order to access methods of
H264BitReader. If I use TEST(), the result class name is composed.
On 2012/07/31 17:24:15, Ami Fischman wrote:

[Ami GONE FROM CHROMIUM, 2012/07/31 20:30:25]

Any reason not to extract the bitreader outside of the parser?  (possibly either
in the same file or in a new file trio)

+ public:
+  bool Initialize(const uint8* data, off_t size) {
+    return reader_.Initialize(data, size);
+  }
+
+  bool ReadBits(int num_bits, int *out) {
+    return reader_.ReadBits(num_bits, out);
+  }
+
+  off_t NumBitsLeft() {
+    return reader_.NumBitsLeft();
+  }
+
+  bool HasMoreRBSPData() {
+    return reader_.HasMoreRBSPData();
+  }
+
+ private:
+  H264Parser::H264BitReader reader_;
+};
+
+TEST_F(H264BitReaderTest, ReadStreamWithoutEscapeAndTrailingZeroBytes) {
+  const unsigned char rbsp[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xa0};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+
+  EXPECT_TRUE(ReadBits(1, &dummy));
+  EXPECT_EQ(dummy, 0x00);
+  EXPECT_EQ(NumBitsLeft(), 47);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(8, &dummy));
+  EXPECT_EQ(dummy, 0x02);
+  EXPECT_EQ(NumBitsLeft(), 39);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(31, &dummy));
+  EXPECT_EQ(dummy, 0x23456789);
+  EXPECT_EQ(NumBitsLeft(), 8);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(1, &dummy));
+  EXPECT_EQ(dummy, 1);
+  EXPECT_EQ(NumBitsLeft(), 7);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(1, &dummy));
+  EXPECT_EQ(dummy, 0);
+  EXPECT_EQ(NumBitsLeft(), 6);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
+TEST_F(H264BitReaderTest, EmptyStream) {
+  const unsigned char rbsp[] = {0x80, 0x00, 0x00};
+
+  EXPECT_FALSE(Initialize(rbsp, 0));
+  EXPECT_FALSE(Initialize(rbsp, 1));
+  EXPECT_FALSE(Initialize(rbsp, sizeof(rbsp)));
+}
+
+TEST_F(H264BitReaderTest, SingleByteStream) {
+  const unsigned char rbsp[] = {0x18};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+  EXPECT_EQ(NumBitsLeft(), 8);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(4, &dummy));
+  EXPECT_EQ(dummy, 0x01);
+  EXPECT_EQ(NumBitsLeft(), 4);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
+TEST_F(H264BitReaderTest, StopBitOccupyFullByte) {
+  const unsigned char rbsp[] = {0xab, 0x80};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+  EXPECT_EQ(NumBitsLeft(), 16);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(8, &dummy));
+  EXPECT_EQ(dummy, 0xab);
+  EXPECT_EQ(NumBitsLeft(), 8);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
+TEST_F(H264BitReaderTest, ReadFailure) {
+  const unsigned char rbsp[] = {0x18};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, 1));
+  EXPECT_FALSE(ReadBits(5, &dummy));
+}
+
+TEST_F(H264BitReaderTest, MalformedStream) {
+  const unsigned char rbsp[] = {0x00, 0x00, 0x03, 0x00, 0x00};
+
+  EXPECT_FALSE(Initialize(rbsp, 1));
+  EXPECT_FALSE(Initialize(rbsp, sizeof(rbsp)));
+}
+
+TEST_F(H264BitReaderTest, EscapeSequence) {
+  const unsigned char rbsp[] =
+      {0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x03, 0x03, 0x00, 0x00, 0x03};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+
+  EXPECT_TRUE(ReadBits(8, &dummy));
+  EXPECT_EQ(dummy, 0x00);
+  EXPECT_EQ(NumBitsLeft(), 80);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(24, &dummy));
+  EXPECT_EQ(dummy, 0x00);
+  EXPECT_EQ(NumBitsLeft(), 48);
+  EXPECT_TRUE(HasMoreRBSPData());
+
+  EXPECT_TRUE(ReadBits(15, &dummy));
+  EXPECT_EQ(dummy, 0x01);
+  EXPECT_EQ(NumBitsLeft(), 25);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
+TEST_F(H264BitReaderTest, NonEscapeFollowedByStopBit) {
+  const unsigned char rbsp[] = {0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+  EXPECT_TRUE(ReadBits(23, &dummy));
+  EXPECT_EQ(dummy, 0x03);
+  EXPECT_EQ(NumBitsLeft(), 33);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
+TEST_F(H264BitReaderTest, TrailingZero) {
+  const unsigned char rbsp[] = {0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00};
+  int dummy = 0;
+
+  EXPECT_TRUE(Initialize(rbsp, sizeof(rbsp)));
+  EXPECT_TRUE(ReadBits(8, &dummy));
+  EXPECT_EQ(dummy, 0x01);
+  EXPECT_TRUE(HasMoreRBSPData());
+  EXPECT_TRUE(ReadBits(15, &dummy));
+  EXPECT_EQ(dummy, 0x01);
+  EXPECT_FALSE(HasMoreRBSPData());
+}
+
 int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   CommandLine::Init(argc, argv);
@@ -91,4 +243,3 @@ int main(int argc, char **argv) {
 
   return RUN_ALL_TESTS();
 }
-