Add unittest for H264BitReader.

content/common/gpu/media/h264_parser_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
@@ skipping 54 matching lines @@
         break;
 
       default:
         // Skip unsupported NALU.
         DVLOG(4) << "Skipping unsupported NALU";
         break;
     }
   }
 }
 
+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);
 
   const CommandLine::SwitchMap& switches =
       CommandLine::ForCurrentProcess()->GetSwitches();
   for (CommandLine::SwitchMap::const_iterator it = switches.begin();
        it != switches.end(); ++it) {
     if (it->first == "test_stream") {
       test_stream_filename = it->second.c_str();
     } else if (it->first == "num_nalus") {
       CHECK(base::StringToInt(it->second, &num_nalus));
     } else {
       LOG(FATAL) << "Unexpected switch: " << it->first << ":" << it->second;
     }
   }
 
   return RUN_ALL_TESTS();
 }
-