MSE: Verify MediaLog events created by existing WebM unit tests

media/formats/webm/webm_content_encodings_client_unittest.cc

 // Copyright 2014 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 "media/formats/webm/webm_content_encodings_client.h"
+
+#include <string>
+
 #include "base/bind.h"
+#include "base/strings/string_number_conversions.h"
+#include "media/base/mock_media_log.h"
 #include "media/formats/webm/webm_constants.h"
-#include "media/formats/webm/webm_content_encodings_client.h"
 #include "media/formats/webm/webm_parser.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::StrictMock;
+
 namespace media {
 
+// Matchers for verifying common media log entry strings.
+#define CONTAINS_STRING(arg, x) (std::string::npos != (arg).find(x))
+
+MATCHER(MissingContentEncoding, "") {
+  return CONTAINS_STRING(arg, "Missing ContentEncoding.");
+}
+
+MATCHER(UnexpectedContentEncodingOrder, "") {
+  return CONTAINS_STRING(arg, "Unexpected ContentEncodingOrder.");
+}
+
+MATCHER(UnexpectedContentEncodingScope, "") {
+  return CONTAINS_STRING(arg, "Unexpected ContentEncodingScope.");
+}
+
+MATCHER(ContentCompressionNotSupported, "") {
+  return CONTAINS_STRING(arg, "ContentCompression not supported.");
+}
+
+MATCHER(MissingContentEncryption, "") {
+  return CONTAINS_STRING(
+      arg,
+      "ContentEncodingType is encryption but ContentEncryption is missing.");
+}
+
+MATCHER_P(UnexpectedContentEncAlgo, algo, "") {
+  return CONTAINS_STRING(
+      arg, "Unexpected ContentEncAlgo " + base::IntToString(algo) + ".");
+}
+
 class WebMContentEncodingsClientTest : public testing::Test {
  public:
   WebMContentEncodingsClientTest()
-      : client_(new MediaLog()), parser_(kWebMIdContentEncodings, &client_) {}
+      : media_log_(new StrictMock<MockMediaLog>()),
+        client_(media_log_),
+        parser_(kWebMIdContentEncodings, &client_) {}
 
   void ParseAndExpectToFail(const uint8* buf, int size) {
     int result = parser_.Parse(buf, size);
     EXPECT_EQ(-1, result);
   }
 
  protected:
+  scoped_refptr<StrictMock<MockMediaLog>> media_log_;
   WebMContentEncodingsClient client_;
   WebMListParser parser_;
 };
 
 TEST_F(WebMContentEncodingsClientTest, EmptyContentEncodings) {
   const uint8 kContentEncodings[] = {
     0x6D, 0x80, 0x80,  // ContentEncodings (size = 0)
   };
   int size = sizeof(kContentEncodings);
+  EXPECT_MEDIA_LOG_STRING(MissingContentEncoding());

[xhwang, 2015/08/19 00:25:05]

nit: hmm, can we just use EXPECT_MEDIA_LOG() which is shorter?

[wolenetz, 2015/08/24 19:34:02]

SGTM. Done.
In this CL, I also responded to dependent CL's comment by chcunningham@
(https://codereview.chromium.org/1300013002/diff/1/media/formats/mp4/aac_unitt...)
and have moved CONTAINS_STRING macro definition into mock_media_log. Different
redefinition of macros causes precompilation errors, so if somehow
"CONTAINS_STRING" becomes redefined elsewhere later in scope of the same
compilation target, that will cause compile error. Before I confirmed this, I
was uncomfortable putting such a generically named macro into a wider scope,
even if test-only.

   ParseAndExpectToFail(kContentEncodings, size);
 }
 
 TEST_F(WebMContentEncodingsClientTest, EmptyContentEncoding) {
   const uint8 kContentEncodings[] = {
     0x6D, 0x80, 0x83,  // ContentEncodings (size = 3)
     0x63, 0x40, 0x80,  //   ContentEncoding (size = 0)
   };
   int size = sizeof(kContentEncodings);
   ParseAndExpectToFail(kContentEncodings, size);
@@ skipping 132 matching lines @@
 
 TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingOrder) {
   const uint8 kContentEncodings[] = {
     0x6D, 0x80, 0x8E,        // ContentEncodings (size = 14)
     0x62, 0x40, 0x8B,        //   ContentEncoding (size = 11)
     0x50, 0x31, 0x81, 0xEE,  //     ContentEncodingOrder (size = 1), invalid
     0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
     0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
   };
   int size = sizeof(kContentEncodings);
+  EXPECT_MEDIA_LOG_STRING(UnexpectedContentEncodingOrder());
   ParseAndExpectToFail(kContentEncodings, size);
 }
 
 TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingScope) {
   const uint8 kContentEncodings[] = {
     0x6D, 0x80, 0x8E,        // ContentEncodings (size = 14)
     0x62, 0x40, 0x8B,        //   ContentEncoding (size = 11)
     0x50, 0x32, 0x81, 0xEE,  //     ContentEncodingScope (size = 1), invalid
     0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
     0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
   };
   int size = sizeof(kContentEncodings);
+  EXPECT_MEDIA_LOG_STRING(UnexpectedContentEncodingScope());
   ParseAndExpectToFail(kContentEncodings, size);
 }
 
 TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingType) {
   const uint8 kContentEncodings[] = {
     0x6D, 0x80, 0x8E,        // ContentEncodings (size = 14)
     0x62, 0x40, 0x8B,        //   ContentEncoding (size = 11)
     0x50, 0x33, 0x81, 0x00,  //     ContentEncodingType (size = 1), invalid
     0x50, 0x35, 0x80,        //     ContentEncryption (size = 0)
   };
   int size = sizeof(kContentEncodings);
+  EXPECT_MEDIA_LOG_STRING(ContentCompressionNotSupported());
   ParseAndExpectToFail(kContentEncodings, size);
 }
 
 // ContentEncodingType is encryption but no ContentEncryption present.
 TEST_F(WebMContentEncodingsClientTest, MissingContentEncryption) {
   const uint8 kContentEncodings[] = {
     0x6D, 0x80, 0x87,        // ContentEncodings (size = 7)
     0x62, 0x40, 0x84,        //   ContentEncoding (size = 4)
     0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
                              //     ContentEncryption missing
   };
   int size = sizeof(kContentEncodings);
+  EXPECT_MEDIA_LOG_STRING(MissingContentEncryption());
   ParseAndExpectToFail(kContentEncodings, size);
 }
 
 TEST_F(WebMContentEncodingsClientTest, InvalidContentEncAlgo) {
   const uint8 kContentEncodings[] = {
     0x6D, 0x80, 0x99,        // ContentEncodings (size = 25)
     0x62, 0x40, 0x96,        //   ContentEncoding (size = 22)
     0x50, 0x33, 0x81, 0x01,  //     ContentEncodingType (size = 1)
     0x50, 0x35, 0x8F,        //     ContentEncryption (size = 15)
     0x47, 0xE1, 0x81, 0xEE,  //       ContentEncAlgo (size = 1), invalid
     0x47, 0xE2, 0x88,        //       ContentEncKeyID (size = 8)
     0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
   };
   int size = sizeof(kContentEncodings);
+  EXPECT_MEDIA_LOG_STRING(UnexpectedContentEncAlgo(0xEE));
   ParseAndExpectToFail(kContentEncodings, size);
 }
 
 }  // namespace media