Implement StringPieceHasSubstrMatcher.

net/test/gtest_util.h

 // 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.
 //
 // Testing utilities that extend gtest.
 
 #ifndef NET_TEST_GTEST_UTIL_H_
 #define NET_TEST_GTEST_UTIL_H_
 
+#include <string>
+
+#include "base/macros.h"
+#include "base/strings/string_piece.h"
 #include "base/test/mock_log.h"
 #include "net/base/net_errors.h"
 #include "net/test/scoped_disable_exit_on_dfatal.h"
+#include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 
 // A GMock matcher that checks whether the argument is the expected net::Error.
 // On failure, the expected and actual net::Error names will be printed.
 // Usage: EXPECT_THAT(foo(), IsError(net::ERR_INVALID_ARGUMENT));
 MATCHER_P(IsError,
           expected,
           std::string(negation ? "not " : "") + net::ErrorToString(expected)) {
   if (arg <= 0)
     *result_listener << net::ErrorToString(arg);
   return arg == expected;
 }
 
 // Shorthand for IsError(net::OK).
 // Usage: EXPECT_THAT(foo(), IsOk());
 MATCHER(IsOk,
         std::string(negation ? "not " : "") + net::ErrorToString(net::OK)) {
   if (arg <= 0)
     *result_listener << net::ErrorToString(arg);
   return arg == net::OK;
 }
 
+// A gMock matcher for base::StringPiece arguments.
+// gMock's built-in HasSubstrMatcher does not work,
+// because base::StringPiece cannot be implicitly converted to std::string.
+class StringPieceHasSubstrMatcher {
+ public:
+  explicit StringPieceHasSubstrMatcher(const std::string& substring)
+      : substring_(substring) {}
+
+  bool MatchAndExplain(base::StringPiece s,
+                       ::testing::MatchResultListener* listener) const {
+    return s.as_string().find(substring_) != std::string::npos;
+  }
+
+  // Describe what this matcher matches.
+  void DescribeTo(std::ostream* os) const {
+    *os << "has substring " << substring_;
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "has no substring " << substring_;
+  }
+
+ private:
+  const std::string substring_;
+
+  DISALLOW_ASSIGN(StringPieceHasSubstrMatcher);
+};
+
 // Internal implementation for the EXPECT_DFATAL and ASSERT_DFATAL
 // macros.  Do not use this directly.
 #define GTEST_DFATAL_(statement, severity, matcher, fail)                    \
   do {                                                                       \
     ::base::test::MockLog gtest_log;                                         \
     ::net::test::ScopedDisableExitOnDFatal gtest_disable_exit;               \
     using ::testing::_;                                                      \
     EXPECT_CALL(gtest_log, Log(_, _, _, _, _))                               \
         .WillRepeatedly(::testing::Return(false));                           \
     EXPECT_CALL(gtest_log, Log(::logging::LOG_##severity, _, _, _, matcher)) \
@@ skipping 82 matching lines @@
     (void)(regex);                      \
     statement;                          \
   } while (false)
 
 #endif  // DCHECK_IS_ON()
 
 }  // namespace test
 }  // namespace net
 
 #endif  // NET_TEST_GTEST_UTIL_H_