Remove mock_ffmpeg and update media unittests.

media/filters/bitstream_converter_unittest.cc

Index: media/filters/bitstream_converter_unittest.cc
diff --git a/media/filters/bitstream_converter_unittest.cc b/media/filters/bitstream_converter_unittest.cc
index 1e8434113f65aaa7e246625c6d0e63d6c1af4912..6f3628bde5b1f009a19d2bcc23ba35617306a8cc 100644
--- a/media/filters/bitstream_converter_unittest.cc
+++ b/media/filters/bitstream_converter_unittest.cc
@@ -4,73 +4,111 @@
 
 #include <deque>
 
-#include "media/base/mock_ffmpeg.h"
+#include "base/file_util.h"
+#include "base/path_service.h"
+#include "media/base/media.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/bitstream_converter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using ::testing::DoAll;
-using ::testing::Mock;
-using ::testing::Return;
-using ::testing::ReturnNull;
-using ::testing::SetArgumentPointee;
-using ::testing::StrEq;
-using ::testing::StrictMock;
-using ::testing::_;
-
 namespace media {
 
 class BitstreamConverterTest : public testing::Test {
+ public:
+  static int DoFilter(AVBitStreamFilterContext *bsfc,

[scherkus (not reviewing), 2011/08/11 01:26:29]

nit: instead of having everything be a static inside the test class, perhaps
just make it all static and do away with the BitstreamConverterTest:: mess and
prototype decls

[acolwell GONE FROM CHROMIUM, 2011/08/11 23:54:40]

Done.

+                      AVCodecContext *avctx,
+                      const char *args,
+                      uint8_t **poutbuf,
+                      int *poutbuf_size,
+                      const uint8_t *buf,
+                      int buf_size,
+                      int keyframe);
+
+  static void DoClose(AVBitStreamFilterContext *bsfc);
+
  protected:
   BitstreamConverterTest() {
     memset(&test_stream_context_, 0, sizeof(test_stream_context_));
-    memset(&test_filter_, 0, sizeof(test_filter_));
     memset(&test_packet_, 0, sizeof(test_packet_));
-    test_packet_.data = kData1;
-    test_packet_.size = kTestSize1;
+    test_packet_.data = kFailData;
+    test_packet_.size = kFailSize;
+
+    FilePath file_path;
+    EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
+    InitializeMediaLibrary(file_path);

[scherkus (not reviewing), 2011/08/11 01:26:29]

InitializeMediaLibraryForTest() ?

[acolwell GONE FROM CHROMIUM, 2011/08/11 23:54:40]

Done.

+
+    if (!stream_filter_.next)
+      av_register_bitstream_filter(&stream_filter_);

[scherkus (not reviewing), 2011/08/11 01:26:29]

does this prevent duplicate registration?

perhaps you want SetUpTestCase():
http://code.google.com/p/googletest/wiki/AdvancedGuide#Sharing_Resources_Betw...

[acolwell GONE FROM CHROMIUM, 2011/08/11 23:54:40]

Done.

   }
 
   virtual ~BitstreamConverterTest() {}
 
   AVCodecContext test_stream_context_;
-  AVBitStreamFilterContext test_filter_;
   AVPacket test_packet_;
 
-  StrictMock<MockFFmpeg> mock_ffmpeg_;
-
   static const char kTestFilterName[];
-  static uint8_t kData1[];
-  static uint8_t kData2[];
-  static const int kTestSize1;
-  static const int kTestSize2;
+  static uint8_t kFailData[];
+  static uint8_t kNewBufferData[];
+  static uint8_t kInPlaceData[];
+  static const int kFailSize;
+  static const int kNewBufferSize;
+  static const int kInPlaceSize;
+  static AVBitStreamFilter stream_filter_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BitstreamConverterTest);
 };
 
 const char BitstreamConverterTest::kTestFilterName[] = "test_filter";
-uint8_t BitstreamConverterTest::kData1[] = { 1 };
-uint8_t BitstreamConverterTest::kData2[] = { 2 };
-const int BitstreamConverterTest::kTestSize1 = 1;
-const int BitstreamConverterTest::kTestSize2 = 2;
+uint8_t BitstreamConverterTest::kFailData[] = { 3, 2, 1 };
+uint8_t BitstreamConverterTest::kNewBufferData[] = { 2, 1 };
+uint8_t BitstreamConverterTest::kInPlaceData[] = { 1 };
+const int BitstreamConverterTest::kFailSize = 3;
+const int BitstreamConverterTest::kNewBufferSize = 2;
+const int BitstreamConverterTest::kInPlaceSize = 1;
+AVBitStreamFilter BitstreamConverterTest::stream_filter_ = {
+  BitstreamConverterTest::kTestFilterName,
+  0, // Private Data Size
+  BitstreamConverterTest::DoFilter,
+  BitstreamConverterTest::DoClose,
+  0,
+};
 
-TEST_F(BitstreamConverterTest, Initialize) {
-  FFmpegBitstreamConverter converter(kTestFilterName, &test_stream_context_);
+//static

[scherkus (not reviewing), 2011/08/11 01:26:29]

// static

[acolwell GONE FROM CHROMIUM, 2011/08/11 23:54:40]

Done.

+int BitstreamConverterTest::DoFilter(AVBitStreamFilterContext *bsfc,

[scherkus (not reviewing), 2011/08/11 01:26:29]

pointers w/ types + docs on what this test filter does

[acolwell GONE FROM CHROMIUM, 2011/08/11 23:54:40]

Done.

+                                     AVCodecContext *avctx,
+                                     const char *args,
+                                     uint8_t **poutbuf,
+                                     int *poutbuf_size,
+                                     const uint8_t *buf,
+                                     int buf_size,
+                                     int keyframe) {
+  if (buf_size == kNewBufferSize &&
+      !memcmp(buf, kNewBufferData, kNewBufferSize)) {
+    *poutbuf_size = buf_size + 1;
+    *poutbuf = static_cast<uint8*>(av_malloc(*poutbuf_size));
+    *poutbuf[0] = 0;
+    memcpy((*poutbuf) + 1, buf, buf_size);
+    return 0;
+  } else if (buf_size == kInPlaceSize &&
+             !memcmp(buf, kInPlaceData, kInPlaceSize)) {
+    return 0;
+  }
 
-  // Test Initialize returns false on a bad initialization, and cleanup is not
-  // done.
-  EXPECT_CALL(mock_ffmpeg_, AVBitstreamFilterInit(StrEq(kTestFilterName)))
-      .WillOnce(ReturnNull());
-  EXPECT_FALSE(converter.Initialize());
+  return -1;
+}
+
+//static

[scherkus (not reviewing), 2011/08/11 01:26:29]

// static

[acolwell GONE FROM CHROMIUM, 2011/08/11 23:54:40]

Done.

+void BitstreamConverterTest::DoClose(AVBitStreamFilterContext *bsfc) {}
 
-  EXPECT_TRUE(Mock::VerifyAndClearExpectations(&mock_ffmpeg_));
+TEST_F(BitstreamConverterTest, InitializeFailed) {
+  FFmpegBitstreamConverter converter("BAD_FILTER_NAME", &test_stream_context_);
 
-  // Test Initialize returns true on successful initialization, and cleanup is
-  // done. The cleanup will be activated when the converter object goes out of
-  // scope.
-  EXPECT_CALL(mock_ffmpeg_, AVBitstreamFilterInit(StrEq(kTestFilterName)))
-      .WillOnce(Return(&test_filter_));
-  EXPECT_CALL(mock_ffmpeg_, AVBitstreamFilterClose(&test_filter_));
+  EXPECT_FALSE(converter.Initialize());
+}
+
+TEST_F(BitstreamConverterTest, InitializeSuccess) {
+  FFmpegBitstreamConverter converter(kTestFilterName, &test_stream_context_);
   EXPECT_TRUE(converter.Initialize());
 }
 
@@ -83,81 +121,42 @@ TEST_F(BitstreamConverterTest, ConvertPacket_NotInitialized) {
 TEST_F(BitstreamConverterTest, ConvertPacket_FailedFilter) {
   FFmpegBitstreamConverter converter(kTestFilterName, &test_stream_context_);
 
-  // Inject mock filter instance.
-  converter.stream_filter_ = &test_filter_;
-
-  // Simulate a successful filter call, that allocates a new data buffer.
-  EXPECT_CALL(mock_ffmpeg_,
-              AVBitstreamFilterFilter(&test_filter_, &test_stream_context_,
-                                      NULL, _, _,
-                                      test_packet_.data, test_packet_.size, _))
-      .WillOnce(Return(AVERROR(EINVAL)));
+  EXPECT_TRUE(converter.Initialize());
 
   EXPECT_FALSE(converter.ConvertPacket(&test_packet_));
-
-  // Uninject mock filter instance to avoid cleanup code on destruction of
-  // converter.
-  converter.stream_filter_ = NULL;
 }
 
 TEST_F(BitstreamConverterTest, ConvertPacket_Success) {
   FFmpegBitstreamConverter converter(kTestFilterName, &test_stream_context_);
 
-  // Inject mock filter instance.
-  converter.stream_filter_ = &test_filter_;
+  EXPECT_TRUE(converter.Initialize());
 
   // Ensure our packet doesn't already have a destructor.
   ASSERT_TRUE(test_packet_.destruct == NULL);
 
-  // Simulate a successful filter call, that allocates a new data buffer.
-  EXPECT_CALL(mock_ffmpeg_,
-              AVBitstreamFilterFilter(&test_filter_, &test_stream_context_,
-                                      NULL, _, _,
-                                      test_packet_.data, test_packet_.size, _))
-      .WillOnce(DoAll(SetArgumentPointee<3>(&kData2[0]),
-                      SetArgumentPointee<4>(kTestSize2),
-                      Return(0)));
-  EXPECT_CALL(mock_ffmpeg_, AVFreePacket(&test_packet_));
+  test_packet_.data = kNewBufferData;
+  test_packet_.size = kNewBufferSize;
 
   EXPECT_TRUE(converter.ConvertPacket(&test_packet_));
-  EXPECT_EQ(kData2, test_packet_.data);
-  EXPECT_EQ(kTestSize2, test_packet_.size);
+  EXPECT_NE(kNewBufferData, test_packet_.data);
+  EXPECT_EQ(kNewBufferSize + 1, test_packet_.size);
   EXPECT_TRUE(test_packet_.destruct != NULL);
-
-  // Uninject mock filter instance to avoid cleanup code on destruction of
-  // converter.
-  converter.stream_filter_ = NULL;
 }
 
 TEST_F(BitstreamConverterTest, ConvertPacket_SuccessInPlace) {
   FFmpegBitstreamConverter converter(kTestFilterName, &test_stream_context_);
 
-  // Inject mock filter instance.
-  converter.stream_filter_ = &test_filter_;
+  EXPECT_TRUE(converter.Initialize());
 
   // Ensure our packet is in a sane start state.
   ASSERT_TRUE(test_packet_.destruct == NULL);
-  ASSERT_EQ(kData1, test_packet_.data);
-  ASSERT_EQ(kTestSize1, test_packet_.size);
-
-  // Simulate a successful filter call, that reuses the input buffer.  We should
-  // not free the packet here or alter the packet's destructor.
-  EXPECT_CALL(mock_ffmpeg_,
-              AVBitstreamFilterFilter(&test_filter_, &test_stream_context_,
-                                      NULL, _, _,
-                                      test_packet_.data, test_packet_.size, _))
-      .WillOnce(DoAll(SetArgumentPointee<3>(test_packet_.data),
-                      SetArgumentPointee<4>(test_packet_.size),
-                      Return(0)));
+  test_packet_.data = kInPlaceData;
+  test_packet_.size = kInPlaceSize;
 
   EXPECT_TRUE(converter.ConvertPacket(&test_packet_));
-  EXPECT_EQ(kData1, test_packet_.data);
-  EXPECT_EQ(kTestSize1, test_packet_.size);
+  EXPECT_EQ(kInPlaceData, test_packet_.data);
+  EXPECT_EQ(kInPlaceSize, test_packet_.size);
   EXPECT_TRUE(test_packet_.destruct == NULL);
-
-  // Uninject mock filter instance to avoid cleanup code on destruction of
-  // converter.
-  converter.stream_filter_ = NULL;
 }
 
 }  // namespace media