1// Copyright 2007, Google Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8// * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10// * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following disclaimer
12// in the documentation and/or other materials provided with the
13// distribution.
14// * Neither the name of Google Inc. nor the names of its
15// contributors may be used to endorse or promote products derived from
16// this software without specific prior written permission.
17//
18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30// The Google C++ Testing and Mocking Framework (Google Test)
31//
32// This file implements just enough of the matcher interface to allow
33// EXPECT_DEATH and friends to accept a matcher argument.
34
35// IWYU pragma: private, include "testing/base/public/gunit.h"
36// IWYU pragma: friend third_party/googletest/googlemock/.*
37// IWYU pragma: friend third_party/googletest/googletest/.*
38
39#ifndef GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
40#define GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
41
42#include <memory>
43#include <ostream>
44#include <string>
45#include <type_traits>
46
47#include "gtest/gtest-printers.h"
48#include "gtest/internal/gtest-internal.h"
49#include "gtest/internal/gtest-port.h"
50
51// MSVC warning C5046 is new as of VS2017 version 15.8.
52#if defined(_MSC_VER) && _MSC_VER >= 1915
53#define GTEST_MAYBE_5046_ 5046
54#else
55#define GTEST_MAYBE_5046_
56#endif
57
58GTEST_DISABLE_MSC_WARNINGS_PUSH_(
59 4251 GTEST_MAYBE_5046_ /* class A needs to have dll-interface to be used by
60 clients of class B */
61 /* Symbol involving type with internal linkage not defined */)
62
63namespace testing {
64
65// To implement a matcher Foo for type T, define:
66// 1. a class FooMatcherImpl that implements the
67// MatcherInterface<T> interface, and
68// 2. a factory function that creates a Matcher<T> object from a
69// FooMatcherImpl*.
70//
71// The two-level delegation design makes it possible to allow a user
72// to write "v" instead of "Eq(v)" where a Matcher is expected, which
73// is impossible if we pass matchers by pointers. It also eases
74// ownership management as Matcher objects can now be copied like
75// plain values.
76
77// MatchResultListener is an abstract class. Its << operator can be
78// used by a matcher to explain why a value matches or doesn't match.
79//
80class MatchResultListener {
81 public:
82 // Creates a listener object with the given underlying ostream. The
83 // listener does not own the ostream, and does not dereference it
84 // in the constructor or destructor.
85 explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
86 virtual ~MatchResultListener() = 0; // Makes this class abstract.
87
88 // Streams x to the underlying ostream; does nothing if the ostream
89 // is NULL.
90 template <typename T>
91 MatchResultListener& operator<<(const T& x) {
92 if (stream_ != nullptr) *stream_ << x;
93 return *this;
94 }
95
96 // Returns the underlying ostream.
97 ::std::ostream* stream() { return stream_; }
98
99 // Returns true if and only if the listener is interested in an explanation
100 // of the match result. A matcher's MatchAndExplain() method can use
101 // this information to avoid generating the explanation when no one
102 // intends to hear it.
103 bool IsInterested() const { return stream_ != nullptr; }
104
105 private:
106 ::std::ostream* const stream_;
107
108 GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
109};
110
111inline MatchResultListener::~MatchResultListener() {
112}
113
114// An instance of a subclass of this knows how to describe itself as a
115// matcher.
116class MatcherDescriberInterface {
117 public:
118 virtual ~MatcherDescriberInterface() {}
119
120 // Describes this matcher to an ostream. The function should print
121 // a verb phrase that describes the property a value matching this
122 // matcher should have. The subject of the verb phrase is the value
123 // being matched. For example, the DescribeTo() method of the Gt(7)
124 // matcher prints "is greater than 7".
125 virtual void DescribeTo(::std::ostream* os) const = 0;
126
127 // Describes the negation of this matcher to an ostream. For
128 // example, if the description of this matcher is "is greater than
129 // 7", the negated description could be "is not greater than 7".
130 // You are not required to override this when implementing
131 // MatcherInterface, but it is highly advised so that your matcher
132 // can produce good error messages.
133 virtual void DescribeNegationTo(::std::ostream* os) const {
134 *os << "not (";
135 DescribeTo(os);
136 *os << ")";
137 }
138};
139
140// The implementation of a matcher.
141template <typename T>
142class MatcherInterface : public MatcherDescriberInterface {
143 public:
144 // Returns true if and only if the matcher matches x; also explains the
145 // match result to 'listener' if necessary (see the next paragraph), in
146 // the form of a non-restrictive relative clause ("which ...",
147 // "whose ...", etc) that describes x. For example, the
148 // MatchAndExplain() method of the Pointee(...) matcher should
149 // generate an explanation like "which points to ...".
150 //
151 // Implementations of MatchAndExplain() should add an explanation of
152 // the match result *if and only if* they can provide additional
153 // information that's not already present (or not obvious) in the
154 // print-out of x and the matcher's description. Whether the match
155 // succeeds is not a factor in deciding whether an explanation is
156 // needed, as sometimes the caller needs to print a failure message
157 // when the match succeeds (e.g. when the matcher is used inside
158 // Not()).
159 //
160 // For example, a "has at least 10 elements" matcher should explain
161 // what the actual element count is, regardless of the match result,
162 // as it is useful information to the reader; on the other hand, an
163 // "is empty" matcher probably only needs to explain what the actual
164 // size is when the match fails, as it's redundant to say that the
165 // size is 0 when the value is already known to be empty.
166 //
167 // You should override this method when defining a new matcher.
168 //
169 // It's the responsibility of the caller (Google Test) to guarantee
170 // that 'listener' is not NULL. This helps to simplify a matcher's
171 // implementation when it doesn't care about the performance, as it
172 // can talk to 'listener' without checking its validity first.
173 // However, in order to implement dummy listeners efficiently,
174 // listener->stream() may be NULL.
175 virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
176
177 // Inherits these methods from MatcherDescriberInterface:
178 // virtual void DescribeTo(::std::ostream* os) const = 0;
179 // virtual void DescribeNegationTo(::std::ostream* os) const;
180};
181
182namespace internal {
183
184// Converts a MatcherInterface<T> to a MatcherInterface<const T&>.
185template <typename T>
186class MatcherInterfaceAdapter : public MatcherInterface<const T&> {
187 public:
188 explicit MatcherInterfaceAdapter(const MatcherInterface<T>* impl)
189 : impl_(impl) {}
190 ~MatcherInterfaceAdapter() override { delete impl_; }
191
192 void DescribeTo(::std::ostream* os) const override { impl_->DescribeTo(os); }
193
194 void DescribeNegationTo(::std::ostream* os) const override {
195 impl_->DescribeNegationTo(os);
196 }
197
198 bool MatchAndExplain(const T& x,
199 MatchResultListener* listener) const override {
200 return impl_->MatchAndExplain(x, listener);
201 }
202
203 private:
204 const MatcherInterface<T>* const impl_;
205
206 GTEST_DISALLOW_COPY_AND_ASSIGN_(MatcherInterfaceAdapter);
207};
208
209struct AnyEq {
210 template <typename A, typename B>
211 bool operator()(const A& a, const B& b) const { return a == b; }
212};
213struct AnyNe {
214 template <typename A, typename B>
215 bool operator()(const A& a, const B& b) const { return a != b; }
216};
217struct AnyLt {
218 template <typename A, typename B>
219 bool operator()(const A& a, const B& b) const { return a < b; }
220};
221struct AnyGt {
222 template <typename A, typename B>
223 bool operator()(const A& a, const B& b) const { return a > b; }
224};
225struct AnyLe {
226 template <typename A, typename B>
227 bool operator()(const A& a, const B& b) const { return a <= b; }
228};
229struct AnyGe {
230 template <typename A, typename B>
231 bool operator()(const A& a, const B& b) const { return a >= b; }
232};
233
234// A match result listener that ignores the explanation.
235class DummyMatchResultListener : public MatchResultListener {
236 public:
237 DummyMatchResultListener() : MatchResultListener(nullptr) {}
238
239 private:
240 GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
241};
242
243// A match result listener that forwards the explanation to a given
244// ostream. The difference between this and MatchResultListener is
245// that the former is concrete.
246class StreamMatchResultListener : public MatchResultListener {
247 public:
248 explicit StreamMatchResultListener(::std::ostream* os)
249 : MatchResultListener(os) {}
250
251 private:
252 GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
253};
254
255// An internal class for implementing Matcher<T>, which will derive
256// from it. We put functionalities common to all Matcher<T>
257// specializations here to avoid code duplication.
258template <typename T>
259class MatcherBase {
260 public:
261 // Returns true if and only if the matcher matches x; also explains the
262 // match result to 'listener'.
263 bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
264 return impl_->MatchAndExplain(x, listener);
265 }
266
267 // Returns true if and only if this matcher matches x.
268 bool Matches(const T& x) const {
269 DummyMatchResultListener dummy;
270 return MatchAndExplain(x, &dummy);
271 }
272
273 // Describes this matcher to an ostream.
274 void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
275
276 // Describes the negation of this matcher to an ostream.
277 void DescribeNegationTo(::std::ostream* os) const {
278 impl_->DescribeNegationTo(os);
279 }
280
281 // Explains why x matches, or doesn't match, the matcher.
282 void ExplainMatchResultTo(const T& x, ::std::ostream* os) const {
283 StreamMatchResultListener listener(os);
284 MatchAndExplain(x, &listener);
285 }
286
287 // Returns the describer for this matcher object; retains ownership
288 // of the describer, which is only guaranteed to be alive when
289 // this matcher object is alive.
290 const MatcherDescriberInterface* GetDescriber() const {
291 return impl_.get();
292 }
293
294 protected:
295 MatcherBase() {}
296
297 // Constructs a matcher from its implementation.
298 explicit MatcherBase(const MatcherInterface<const T&>* impl) : impl_(impl) {}
299
300 template <typename U>
301 explicit MatcherBase(
302 const MatcherInterface<U>* impl,
303 typename std::enable_if<!std::is_same<U, const U&>::value>::type* =
304 nullptr)
305 : impl_(new internal::MatcherInterfaceAdapter<U>(impl)) {}
306
307 MatcherBase(const MatcherBase&) = default;
308 MatcherBase& operator=(const MatcherBase&) = default;
309 MatcherBase(MatcherBase&&) = default;
310 MatcherBase& operator=(MatcherBase&&) = default;
311
312 virtual ~MatcherBase() {}
313
314 private:
315 std::shared_ptr<const MatcherInterface<const T&>> impl_;
316};
317
318} // namespace internal
319
320// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
321// object that can check whether a value of type T matches. The
322// implementation of Matcher<T> is just a std::shared_ptr to const
323// MatcherInterface<T>. Don't inherit from Matcher!
324template <typename T>
325class Matcher : public internal::MatcherBase<T> {
326 public:
327 // Constructs a null matcher. Needed for storing Matcher objects in STL
328 // containers. A default-constructed matcher is not yet initialized. You
329 // cannot use it until a valid value has been assigned to it.
330 explicit Matcher() {} // NOLINT
331
332 // Constructs a matcher from its implementation.
333 explicit Matcher(const MatcherInterface<const T&>* impl)
334 : internal::MatcherBase<T>(impl) {}
335
336 template <typename U>
337 explicit Matcher(
338 const MatcherInterface<U>* impl,
339 typename std::enable_if<!std::is_same<U, const U&>::value>::type* =
340 nullptr)
341 : internal::MatcherBase<T>(impl) {}
342
343 // Implicit constructor here allows people to write
344 // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
345 Matcher(T value); // NOLINT
346};
347
348// The following two specializations allow the user to write str
349// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string
350// matcher is expected.
351template <>
352class GTEST_API_ Matcher<const std::string&>
353 : public internal::MatcherBase<const std::string&> {
354 public:
355 Matcher() {}
356
357 explicit Matcher(const MatcherInterface<const std::string&>* impl)
358 : internal::MatcherBase<const std::string&>(impl) {}
359
360 // Allows the user to write str instead of Eq(str) sometimes, where
361 // str is a std::string object.
362 Matcher(const std::string& s); // NOLINT
363
364 // Allows the user to write "foo" instead of Eq("foo") sometimes.
365 Matcher(const char* s); // NOLINT
366};
367
368template <>
369class GTEST_API_ Matcher<std::string>
370 : public internal::MatcherBase<std::string> {
371 public:
372 Matcher() {}
373
374 explicit Matcher(const MatcherInterface<const std::string&>* impl)
375 : internal::MatcherBase<std::string>(impl) {}
376 explicit Matcher(const MatcherInterface<std::string>* impl)
377 : internal::MatcherBase<std::string>(impl) {}
378
379 // Allows the user to write str instead of Eq(str) sometimes, where
380 // str is a string object.
381 Matcher(const std::string& s); // NOLINT
382
383 // Allows the user to write "foo" instead of Eq("foo") sometimes.
384 Matcher(const char* s); // NOLINT
385};
386
387#if GTEST_INTERNAL_HAS_STRING_VIEW
388// The following two specializations allow the user to write str
389// instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view
390// matcher is expected.
391template <>
392class GTEST_API_ Matcher<const internal::StringView&>
393 : public internal::MatcherBase<const internal::StringView&> {
394 public:
395 Matcher() {}
396
397 explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
398 : internal::MatcherBase<const internal::StringView&>(impl) {}
399
400 // Allows the user to write str instead of Eq(str) sometimes, where
401 // str is a std::string object.
402 Matcher(const std::string& s); // NOLINT
403
404 // Allows the user to write "foo" instead of Eq("foo") sometimes.
405 Matcher(const char* s); // NOLINT
406
407 // Allows the user to pass absl::string_views or std::string_views directly.
408 Matcher(internal::StringView s); // NOLINT
409};
410
411template <>
412class GTEST_API_ Matcher<internal::StringView>
413 : public internal::MatcherBase<internal::StringView> {
414 public:
415 Matcher() {}
416
417 explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
418 : internal::MatcherBase<internal::StringView>(impl) {}
419 explicit Matcher(const MatcherInterface<internal::StringView>* impl)
420 : internal::MatcherBase<internal::StringView>(impl) {}
421
422 // Allows the user to write str instead of Eq(str) sometimes, where
423 // str is a std::string object.
424 Matcher(const std::string& s); // NOLINT
425
426 // Allows the user to write "foo" instead of Eq("foo") sometimes.
427 Matcher(const char* s); // NOLINT
428
429 // Allows the user to pass absl::string_views or std::string_views directly.
430 Matcher(internal::StringView s); // NOLINT
431};
432#endif // GTEST_INTERNAL_HAS_STRING_VIEW
433
434// Prints a matcher in a human-readable format.
435template <typename T>
436std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) {
437 matcher.DescribeTo(&os);
438 return os;
439}
440
441// The PolymorphicMatcher class template makes it easy to implement a
442// polymorphic matcher (i.e. a matcher that can match values of more
443// than one type, e.g. Eq(n) and NotNull()).
444//
445// To define a polymorphic matcher, a user should provide an Impl
446// class that has a DescribeTo() method and a DescribeNegationTo()
447// method, and define a member function (or member function template)
448//
449// bool MatchAndExplain(const Value& value,
450// MatchResultListener* listener) const;
451//
452// See the definition of NotNull() for a complete example.
453template <class Impl>
454class PolymorphicMatcher {
455 public:
456 explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
457
458 // Returns a mutable reference to the underlying matcher
459 // implementation object.
460 Impl& mutable_impl() { return impl_; }
461
462 // Returns an immutable reference to the underlying matcher
463 // implementation object.
464 const Impl& impl() const { return impl_; }
465
466 template <typename T>
467 operator Matcher<T>() const {
468 return Matcher<T>(new MonomorphicImpl<const T&>(impl_));
469 }
470
471 private:
472 template <typename T>
473 class MonomorphicImpl : public MatcherInterface<T> {
474 public:
475 explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
476
477 void DescribeTo(::std::ostream* os) const override { impl_.DescribeTo(os); }
478
479 void DescribeNegationTo(::std::ostream* os) const override {
480 impl_.DescribeNegationTo(os);
481 }
482
483 bool MatchAndExplain(T x, MatchResultListener* listener) const override {
484 return impl_.MatchAndExplain(x, listener);
485 }
486
487 private:
488 const Impl impl_;
489 };
490
491 Impl impl_;
492};
493
494// Creates a matcher from its implementation.
495// DEPRECATED: Especially in the generic code, prefer:
496// Matcher<T>(new MyMatcherImpl<const T&>(...));
497//
498// MakeMatcher may create a Matcher that accepts its argument by value, which
499// leads to unnecessary copies & lack of support for non-copyable types.
500template <typename T>
501inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
502 return Matcher<T>(impl);
503}
504
505// Creates a polymorphic matcher from its implementation. This is
506// easier to use than the PolymorphicMatcher<Impl> constructor as it
507// doesn't require you to explicitly write the template argument, e.g.
508//
509// MakePolymorphicMatcher(foo);
510// vs
511// PolymorphicMatcher<TypeOfFoo>(foo);
512template <class Impl>
513inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
514 return PolymorphicMatcher<Impl>(impl);
515}
516
517namespace internal {
518// Implements a matcher that compares a given value with a
519// pre-supplied value using one of the ==, <=, <, etc, operators. The
520// two values being compared don't have to have the same type.
521//
522// The matcher defined here is polymorphic (for example, Eq(5) can be
523// used to match an int, a short, a double, etc). Therefore we use
524// a template type conversion operator in the implementation.
525//
526// The following template definition assumes that the Rhs parameter is
527// a "bare" type (i.e. neither 'const T' nor 'T&').
528template <typename D, typename Rhs, typename Op>
529class ComparisonBase {
530 public:
531 explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
532 template <typename Lhs>
533 operator Matcher<Lhs>() const {
534 return Matcher<Lhs>(new Impl<const Lhs&>(rhs_));
535 }
536
537 private:
538 template <typename T>
539 static const T& Unwrap(const T& v) { return v; }
540 template <typename T>
541 static const T& Unwrap(std::reference_wrapper<T> v) { return v; }
542
543 template <typename Lhs, typename = Rhs>
544 class Impl : public MatcherInterface<Lhs> {
545 public:
546 explicit Impl(const Rhs& rhs) : rhs_(rhs) {}
547 bool MatchAndExplain(Lhs lhs,
548 MatchResultListener* /* listener */) const override {
549 return Op()(lhs, Unwrap(rhs_));
550 }
551 void DescribeTo(::std::ostream* os) const override {
552 *os << D::Desc() << " ";
553 UniversalPrint(Unwrap(rhs_), os);
554 }
555 void DescribeNegationTo(::std::ostream* os) const override {
556 *os << D::NegatedDesc() << " ";
557 UniversalPrint(Unwrap(rhs_), os);
558 }
559
560 private:
561 Rhs rhs_;
562 };
563 Rhs rhs_;
564};
565
566template <typename Rhs>
567class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
568 public:
569 explicit EqMatcher(const Rhs& rhs)
570 : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
571 static const char* Desc() { return "is equal to"; }
572 static const char* NegatedDesc() { return "isn't equal to"; }
573};
574template <typename Rhs>
575class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
576 public:
577 explicit NeMatcher(const Rhs& rhs)
578 : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
579 static const char* Desc() { return "isn't equal to"; }
580 static const char* NegatedDesc() { return "is equal to"; }
581};
582template <typename Rhs>
583class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
584 public:
585 explicit LtMatcher(const Rhs& rhs)
586 : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
587 static const char* Desc() { return "is <"; }
588 static const char* NegatedDesc() { return "isn't <"; }
589};
590template <typename Rhs>
591class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
592 public:
593 explicit GtMatcher(const Rhs& rhs)
594 : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
595 static const char* Desc() { return "is >"; }
596 static const char* NegatedDesc() { return "isn't >"; }
597};
598template <typename Rhs>
599class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
600 public:
601 explicit LeMatcher(const Rhs& rhs)
602 : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
603 static const char* Desc() { return "is <="; }
604 static const char* NegatedDesc() { return "isn't <="; }
605};
606template <typename Rhs>
607class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
608 public:
609 explicit GeMatcher(const Rhs& rhs)
610 : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
611 static const char* Desc() { return "is >="; }
612 static const char* NegatedDesc() { return "isn't >="; }
613};
614
615template <typename T, typename = typename std::enable_if<
616 std::is_constructible<std::string, T>::value>::type>
617using StringLike = T;
618
619// Implements polymorphic matchers MatchesRegex(regex) and
620// ContainsRegex(regex), which can be used as a Matcher<T> as long as
621// T can be converted to a string.
622class MatchesRegexMatcher {
623 public:
624 MatchesRegexMatcher(const RE* regex, bool full_match)
625 : regex_(regex), full_match_(full_match) {}
626
627#if GTEST_INTERNAL_HAS_STRING_VIEW
628 bool MatchAndExplain(const internal::StringView& s,
629 MatchResultListener* listener) const {
630 return MatchAndExplain(std::string(s), listener);
631 }
632#endif // GTEST_INTERNAL_HAS_STRING_VIEW
633
634 // Accepts pointer types, particularly:
635 // const char*
636 // char*
637 // const wchar_t*
638 // wchar_t*
639 template <typename CharType>
640 bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
641 return s != nullptr && MatchAndExplain(std::string(s), listener);
642 }
643
644 // Matches anything that can convert to std::string.
645 //
646 // This is a template, not just a plain function with const std::string&,
647 // because absl::string_view has some interfering non-explicit constructors.
648 template <class MatcheeStringType>
649 bool MatchAndExplain(const MatcheeStringType& s,
650 MatchResultListener* /* listener */) const {
651 const std::string& s2(s);
652 return full_match_ ? RE::FullMatch(s2, *regex_)
653 : RE::PartialMatch(s2, *regex_);
654 }
655
656 void DescribeTo(::std::ostream* os) const {
657 *os << (full_match_ ? "matches" : "contains") << " regular expression ";
658 UniversalPrinter<std::string>::Print(regex_->pattern(), os);
659 }
660
661 void DescribeNegationTo(::std::ostream* os) const {
662 *os << "doesn't " << (full_match_ ? "match" : "contain")
663 << " regular expression ";
664 UniversalPrinter<std::string>::Print(regex_->pattern(), os);
665 }
666
667 private:
668 const std::shared_ptr<const RE> regex_;
669 const bool full_match_;
670};
671} // namespace internal
672
673// Matches a string that fully matches regular expression 'regex'.
674// The matcher takes ownership of 'regex'.
675inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
676 const internal::RE* regex) {
677 return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
678}
679template <typename T = std::string>
680PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
681 const internal::StringLike<T>& regex) {
682 return MatchesRegex(new internal::RE(std::string(regex)));
683}
684
685// Matches a string that contains regular expression 'regex'.
686// The matcher takes ownership of 'regex'.
687inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
688 const internal::RE* regex) {
689 return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
690}
691template <typename T = std::string>
692PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
693 const internal::StringLike<T>& regex) {
694 return ContainsRegex(new internal::RE(std::string(regex)));
695}
696
697// Creates a polymorphic matcher that matches anything equal to x.
698// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
699// wouldn't compile.
700template <typename T>
701inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
702
703// Constructs a Matcher<T> from a 'value' of type T. The constructed
704// matcher matches any value that's equal to 'value'.
705template <typename T>
706Matcher<T>::Matcher(T value) { *this = Eq(value); }
707
708// Creates a monomorphic matcher that matches anything with type Lhs
709// and equal to rhs. A user may need to use this instead of Eq(...)
710// in order to resolve an overloading ambiguity.
711//
712// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
713// or Matcher<T>(x), but more readable than the latter.
714//
715// We could define similar monomorphic matchers for other comparison
716// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
717// it yet as those are used much less than Eq() in practice. A user
718// can always write Matcher<T>(Lt(5)) to be explicit about the type,
719// for example.
720template <typename Lhs, typename Rhs>
721inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
722
723// Creates a polymorphic matcher that matches anything >= x.
724template <typename Rhs>
725inline internal::GeMatcher<Rhs> Ge(Rhs x) {
726 return internal::GeMatcher<Rhs>(x);
727}
728
729// Creates a polymorphic matcher that matches anything > x.
730template <typename Rhs>
731inline internal::GtMatcher<Rhs> Gt(Rhs x) {
732 return internal::GtMatcher<Rhs>(x);
733}
734
735// Creates a polymorphic matcher that matches anything <= x.
736template <typename Rhs>
737inline internal::LeMatcher<Rhs> Le(Rhs x) {
738 return internal::LeMatcher<Rhs>(x);
739}
740
741// Creates a polymorphic matcher that matches anything < x.
742template <typename Rhs>
743inline internal::LtMatcher<Rhs> Lt(Rhs x) {
744 return internal::LtMatcher<Rhs>(x);
745}
746
747// Creates a polymorphic matcher that matches anything != x.
748template <typename Rhs>
749inline internal::NeMatcher<Rhs> Ne(Rhs x) {
750 return internal::NeMatcher<Rhs>(x);
751}
752} // namespace testing
753
754GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 5046
755
756#endif // GTEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
757