Export Test - Do Not Merge

Get rid of gmock-generated-matchers.h and gmock-generated-matchers.h.pump.

Stop using pump for MATCHER* macroses generation.

PiperOrigin-RevId: 293878808

CMakeLists.txt

@@ -10,7 +10,11 @@ endif (POLICY CMP0048)
 project(googletest-distribution)
 set(GOOGLETEST_VERSION 1.10.0)
 
-if (CMAKE_VERSION VERSION_GREATER "3.0.2")
+if (CMAKE_VERSION VERSION_LESS "3.1")
+  add_definitions(-std=c++11)
+else()
+  set(CMAKE_CXX_STANDARD 11)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
   if(NOT CYGWIN AND NOT MSYS)
     set(CMAKE_CXX_EXTENSIONS OFF)
   endif()

googlemock/docs/cook_book.md

@@ -421,7 +421,7 @@ sadly they are side effects of C++'s limitations):
     `NiceMock<StrictMock<MockFoo> >`) is **not** supported.
 2.  `NiceMock<MockFoo>` and `StrictMock<MockFoo>` may not work correctly if the
     destructor of `MockFoo` is not virtual. We would like to fix this, but it
-    requires cleaning up existing tests.
+    requires cleaning up existing tests. http://b/28934720 tracks the issue.
 3.  During the constructor or destructor of `MockFoo`, the mock object is *not*
     nice or strict. This may cause surprises if the constructor or destructor
     calls a mock method on `this` object. (This behavior, however, is consistent
@@ -2174,7 +2174,7 @@ own precedence order distinct from the `ON_CALL` precedence order.
 ### Using Functions/Methods/Functors/Lambdas as Actions {#FunctionsAsActions}
 
 If the built-in actions don't suit you, you can use an existing callable
-(function, `std::function`, method, functor, lambda) as an action.
+(function, `std::function`, method, functor, lambda as an action.
 
 <!-- GOOGLETEST_CM0024 DO NOT DELETE -->
 
@@ -2203,7 +2203,6 @@ class Helper {
       .WillRepeatedly(Invoke(NewPermanentCallback(Sum3, 1)));
   EXPECT_CALL(foo, ComplexJob(_))
       .WillOnce(Invoke(&helper, &Helper::ComplexJob))
-      .WillOnce([] { return true; })
       .WillRepeatedly([](int x) { return x > 0; });
 
   foo.Sum(5, 6);         // Invokes CalculateSum(5, 6).
@@ -2213,11 +2212,11 @@ class Helper {
 ```
 
 The only requirement is that the type of the function, etc must be *compatible*
-with the signature of the mock function, meaning that the latter's arguments (if
+with the signature of the mock function, meaning that the latter's arguments can
-it takes any) can be implicitly converted to the corresponding arguments of the
+be implicitly converted to the corresponding arguments of the former, and the
-former, and the former's return type can be implicitly converted to that of the
+former's return type can be implicitly converted to that of the latter. So, you
-latter. So, you can invoke something whose type is *not* exactly the same as the
+can invoke something whose type is *not* exactly the same as the mock function,
-mock function, as long as it's safe to do so - nice, huh?
+as long as it's safe to do so - nice, huh?
 
 **`Note:`{.escaped}**
 
@@ -2268,20 +2267,19 @@ TEST_F(FooTest, Test) {
 
 ### Invoking a Function/Method/Functor/Lambda/Callback Without Arguments
 
-`Invoke()` passes the mock function's arguments to the function, etc being
+`Invoke()` is very useful for doing actions that are more complex. It passes the
-invoked such that the callee has the full context of the call to work with. If
+mock function's arguments to the function, etc being invoked such that the
-the invoked function is not interested in some or all of the arguments, it can
+callee has the full context of the call to work with. If the invoked function is
-simply ignore them.
+not interested in some or all of the arguments, it can simply ignore them.
 
 Yet, a common pattern is that a test author wants to invoke a function without
-the arguments of the mock function. She could do that using a wrapper function
+the arguments of the mock function. `Invoke()` allows her to do that using a
-that throws away the arguments before invoking an underlining nullary function.
+wrapper function that throws away the arguments before invoking an underlining
-Needless to say, this can be tedious and obscures the intent of the test.
+nullary function. Needless to say, this can be tedious and obscures the intent
+of the test.
 
-There are two solutions to this problem. First, you can pass any callable of
+`InvokeWithoutArgs()` solves this problem. It's like `Invoke()` except that it
-zero args as an action. Alternatively, use `InvokeWithoutArgs()`, which is like
+doesn't pass the mock function's arguments to the callee. Here's an example:
-`Invoke()` except that it doesn't pass the mock function's arguments to the
-callee. Here's an example of each:
 
 ```cpp
 using ::testing::_;
@@ -2298,7 +2296,7 @@ bool Job2(int n, char c) { ... }
 ...
   MockFoo foo;
   EXPECT_CALL(foo, ComplexJob(_))
-      .WillOnce([] { Job1(); });
+      .WillOnce(InvokeWithoutArgs(Job1))
       .WillOnce(InvokeWithoutArgs(NewPermanentCallback(Job2, 5, 'a')));
 
   foo.ComplexJob(10);  // Invokes Job1().

googlemock/docs/for_dummies.md

@@ -374,7 +374,7 @@ convenient way of saying "any value".
 In the above examples, `100` and `50` are also matchers; implicitly, they are
 the same as `Eq(100)` and `Eq(50)`, which specify that the argument must be
 equal (using `operator==`) to the matcher argument. There are many
-[built-in matchers](cheat_sheet.md#MatcherList) for common types (as well as
+[built-in matchers](#MatcherList) for common types (as well as
 [custom matchers](cook_book.md#NewMatchers)); for example:
 
 ```cpp

googlemock/include/gmock/gmock-actions.h

@@ -263,10 +263,6 @@ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
 
 #undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
 
-// Simple two-arg form of std::disjunction.
-template <typename P, typename Q>
-using disjunction = typename ::std::conditional<P::value, P, Q>::type;
-
 }  // namespace internal
 
 // When an unexpected function call is encountered, Google Mock will
@@ -460,15 +456,9 @@ class Action {
   // This cannot take std::function directly, because then Action would not be
   // directly constructible from lambda (it would require two conversions).
   template <typename G,
-            typename IsCompatibleFunctor =
+            typename = typename ::std::enable_if<
-                ::std::is_constructible<::std::function<F>, G>,
+                ::std::is_constructible<::std::function<F>, G>::value>::type>
-            typename IsNoArgsFunctor =
+  Action(G&& fun) : fun_(::std::forward<G>(fun)) {}  // NOLINT
-                ::std::is_constructible<::std::function<Result()>, G>,
-            typename = typename ::std::enable_if<internal::disjunction<
-                IsCompatibleFunctor, IsNoArgsFunctor>::value>::type>
-  Action(G&& fun) {  // NOLINT
-    Init(::std::forward<G>(fun), IsCompatibleFunctor());
-  }
 
   // Constructs an Action from its implementation.
   explicit Action(ActionInterface<F>* impl)
@@ -500,26 +490,6 @@ class Action {
   template <typename G>
   friend class Action;
 
-  template <typename G>
-  void Init(G&& g, ::std::true_type) {
-    fun_ = ::std::forward<G>(g);
-  }
-
-  template <typename G>
-  void Init(G&& g, ::std::false_type) {
-    fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)};
-  }
-
-  template <typename FunctionImpl>
-  struct IgnoreArgs {
-    template <typename... Args>
-    Result operator()(const Args&...) const {
-      return function_impl();
-    }
-
-    FunctionImpl function_impl;
-  };
-
   // fun_ is an empty function if and only if this is the DoDefault() action.
   ::std::function<F> fun_;
 };

googlemock/include/gmock/gmock-matchers.h

@@ -424,14 +424,7 @@ class MatcherCastImpl<T, Matcher<U> > {
               !std::is_base_of<FromType, ToType>::value,
           "Can't implicitly convert from <base> to <derived>");
 
-      // Do the cast to `U` explicitly if necessary.
+      return source_matcher_.MatchAndExplain(static_cast<U>(x), listener);
-      // Otherwise, let implicit conversions do the trick.
-      using CastType =
-          typename std::conditional<std::is_convertible<T&, const U&>::value,
-                                    T&, U>::type;
-
-      return source_matcher_.MatchAndExplain(static_cast<CastType>(x),
-                                             listener);
     }
 
     void DescribeTo(::std::ostream* os) const override {
@@ -531,8 +524,8 @@ inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) {
 template <typename T, typename U>
 inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) {
   // Enforce that T can be implicitly converted to U.
-  static_assert(std::is_convertible<const T&, const U&>::value,
+  GTEST_COMPILE_ASSERT_((std::is_convertible<T, U>::value),
-                "T must be implicitly convertible to U");
+                        "T must be implicitly convertible to U");
   // Enforce that we are not converting a non-reference type T to a reference
   // type U.
   GTEST_COMPILE_ASSERT_(
@@ -913,15 +906,15 @@ class StrEqualityMatcher {
                      bool case_sensitive)
       : string_(str), expect_eq_(expect_eq), case_sensitive_(case_sensitive) {}
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  bool MatchAndExplain(const internal::StringView& s,
+  bool MatchAndExplain(const absl::string_view& s,
                        MatchResultListener* listener) const {
-    // This should fail to compile if StringView is used with wide
+    // This should fail to compile if absl::string_view is used with wide
     // strings.
     const StringType& str = std::string(s);
     return MatchAndExplain(str, listener);
   }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
   // Accepts pointer types, particularly:
   //   const char*
@@ -939,7 +932,7 @@ class StrEqualityMatcher {
   // Matches anything that can convert to StringType.
   //
   // This is a template, not just a plain function with const StringType&,
-  // because StringView has some interfering non-explicit constructors.
+  // because absl::string_view has some interfering non-explicit constructors.
   template <typename MatcheeStringType>
   bool MatchAndExplain(const MatcheeStringType& s,
                        MatchResultListener* /* listener */) const {
@@ -983,15 +976,15 @@ class HasSubstrMatcher {
   explicit HasSubstrMatcher(const StringType& substring)
       : substring_(substring) {}
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  bool MatchAndExplain(const internal::StringView& s,
+  bool MatchAndExplain(const absl::string_view& s,
                        MatchResultListener* listener) const {
-    // This should fail to compile if StringView is used with wide
+    // This should fail to compile if absl::string_view is used with wide
     // strings.
     const StringType& str = std::string(s);
     return MatchAndExplain(str, listener);
   }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
   // Accepts pointer types, particularly:
   //   const char*
@@ -1006,7 +999,7 @@ class HasSubstrMatcher {
   // Matches anything that can convert to StringType.
   //
   // This is a template, not just a plain function with const StringType&,
-  // because StringView has some interfering non-explicit constructors.
+  // because absl::string_view has some interfering non-explicit constructors.
   template <typename MatcheeStringType>
   bool MatchAndExplain(const MatcheeStringType& s,
                        MatchResultListener* /* listener */) const {
@@ -1039,15 +1032,15 @@ class StartsWithMatcher {
   explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
   }
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  bool MatchAndExplain(const internal::StringView& s,
+  bool MatchAndExplain(const absl::string_view& s,
                        MatchResultListener* listener) const {
-    // This should fail to compile if StringView is used with wide
+    // This should fail to compile if absl::string_view is used with wide
     // strings.
     const StringType& str = std::string(s);
     return MatchAndExplain(str, listener);
   }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
   // Accepts pointer types, particularly:
   //   const char*
@@ -1062,7 +1055,7 @@ class StartsWithMatcher {
   // Matches anything that can convert to StringType.
   //
   // This is a template, not just a plain function with const StringType&,
-  // because StringView has some interfering non-explicit constructors.
+  // because absl::string_view has some interfering non-explicit constructors.
   template <typename MatcheeStringType>
   bool MatchAndExplain(const MatcheeStringType& s,
                        MatchResultListener* /* listener */) const {
@@ -1095,15 +1088,15 @@ class EndsWithMatcher {
  public:
   explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  bool MatchAndExplain(const internal::StringView& s,
+  bool MatchAndExplain(const absl::string_view& s,
                        MatchResultListener* listener) const {
-    // This should fail to compile if StringView is used with wide
+    // This should fail to compile if absl::string_view is used with wide
     // strings.
     const StringType& str = std::string(s);
     return MatchAndExplain(str, listener);
   }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
   // Accepts pointer types, particularly:
   //   const char*
@@ -1118,7 +1111,7 @@ class EndsWithMatcher {
   // Matches anything that can convert to StringType.
   //
   // This is a template, not just a plain function with const StringType&,
-  // because StringView has some interfering non-explicit constructors.
+  // because absl::string_view has some interfering non-explicit constructors.
   template <typename MatcheeStringType>
   bool MatchAndExplain(const MatcheeStringType& s,
                        MatchResultListener* /* listener */) const {

googlemock/include/gmock/gmock-spec-builders.h

@@ -1786,79 +1786,10 @@ void ReportUninterestingCall(CallReaction reaction, const std::string& msg);
 
 }  // namespace internal
 
-namespace internal {
+// A MockFunction<F> class has one mock method whose type is F.  It is
-
+// useful when you just want your test code to emit some messages and
-template <typename F>
+// have Google Mock verify the right messages are sent (and perhaps at
-class MockFunction;
+// the right times).  For example, if you are exercising code:
-
-template <typename R, typename... Args>
-class MockFunction<R(Args...)> {
- public:
-  MockFunction(const MockFunction&) = delete;
-  MockFunction& operator=(const MockFunction&) = delete;
-
-  std::function<R(Args...)> AsStdFunction() {
-    return [this](Args... args) -> R {
-      return this->Call(std::forward<Args>(args)...);
-    };
-  }
-
-  // Implementation detail: the expansion of the MOCK_METHOD macro.
-  R Call(Args... args) {
-    mock_.SetOwnerAndName(this, "Call");
-    return mock_.Invoke(std::forward<Args>(args)...);
-  }
-
-  MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) {
-    mock_.RegisterOwner(this);
-    return mock_.With(std::move(m)...);
-  }
-
-  MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) {
-    return this->gmock_Call(::testing::A<Args>()...);
-  }
-
- protected:
-  MockFunction() = default;
-  ~MockFunction() = default;
-
- private:
-  FunctionMocker<R(Args...)> mock_;
-};
-
-/*
-The SignatureOf<F> struct is a meta-function returning function signature
-corresponding to the provided F argument.
-
-It makes use of MockFunction easier by allowing it to accept more F arguments
-than just function signatures.
-
-Specializations provided here cover only a signature type itself and
-std::function. However, if need be it can be easily extended to cover also other
-types (like for example boost::function).
-*/
-
-template <typename F>
-struct SignatureOf;
-
-template <typename R, typename... Args>
-struct SignatureOf<R(Args...)> {
-  using type = R(Args...);
-};
-
-template <typename F>
-struct SignatureOf<std::function<F>> : SignatureOf<F> {};
-
-template <typename F>
-using SignatureOfT = typename SignatureOf<F>::type;
-
-}  // namespace internal
-
-// A MockFunction<F> type has one mock method whose type is
-// internal::SignatureOfT<F>.  It is useful when you just want your
-// test code to emit some messages and have Google Mock verify the
-// right messages are sent (and perhaps at the right times).  For
-// example, if you are exercising code:
 //
 //   Foo(1);
 //   Foo(2);
@@ -1892,34 +1823,49 @@ using SignatureOfT = typename SignatureOf<F>::type;
 // Bar("a") is called by which call to Foo().
 //
 // MockFunction<F> can also be used to exercise code that accepts
-// std::function<internal::SignatureOfT<F>> callbacks. To do so, use
+// std::function<F> callbacks. To do so, use AsStdFunction() method
-// AsStdFunction() method to create std::function proxy forwarding to
+// to create std::function proxy forwarding to original object's Call.
-// original object's Call. Example:
+// Example:
 //
 // TEST(FooTest, RunsCallbackWithBarArgument) {
 //   MockFunction<int(string)> callback;
 //   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
 //   Foo(callback.AsStdFunction());
 // }
-//
-// The internal::SignatureOfT<F> indirection allows to use other types
-// than just function signature type. This is typically useful when
-// providing a mock for a predefined std::function type. Example:
-//
-// using FilterPredicate = std::function<bool(string)>;
-// void MyFilterAlgorithm(FilterPredicate predicate);
-//
-// TEST(FooTest, FilterPredicateAlwaysAccepts) {
-//   MockFunction<FilterPredicate> predicateMock;
-//   EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true));
-//   MyFilterAlgorithm(predicateMock.AsStdFunction());
-// }
 template <typename F>
-class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> {
+class MockFunction;
-  using Base = internal::MockFunction<internal::SignatureOfT<F>>;
 
+template <typename R, typename... Args>
+class MockFunction<R(Args...)> {
  public:
-  using Base::Base;
+  MockFunction() {}
+  MockFunction(const MockFunction&) = delete;
+  MockFunction& operator=(const MockFunction&) = delete;
+
+  std::function<R(Args...)> AsStdFunction() {
+    return [this](Args... args) -> R {
+      return this->Call(std::forward<Args>(args)...);
+    };
+  }
+
+  // Implementation detail: the expansion of the MOCK_METHOD macro.
+  R Call(Args... args) {
+    mock_.SetOwnerAndName(this, "Call");
+    return mock_.Invoke(std::forward<Args>(args)...);
+  }
+
+  internal::MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) {
+    mock_.RegisterOwner(this);
+    return mock_.With(std::move(m)...);
+  }
+
+  internal::MockSpec<R(Args...)> gmock_Call(const internal::WithoutMatchers&,
+                                            R (*)(Args...)) {
+    return this->gmock_Call(::testing::A<Args>()...);
+  }
+
+ private:
+  internal::FunctionMocker<R(Args...)> mock_;
 };
 
 // The style guide prohibits "using" statements in a namespace scope

googlemock/scripts/generator/cpp/gmock_class.py

@@ -35,11 +35,11 @@ from cpp import utils
 
 # Preserve compatibility with Python 2.3.
 try:
-  _dummy = set
+    _dummy = set
 except NameError:
-  import sets
+    import sets
 
-  set = sets.Set
+    set = sets.Set
 
 _VERSION = (1, 0, 1)  # The version of this script.
 # How many spaces to indent.  Can set me with the INDENT environment variable.
@@ -47,199 +47,202 @@ _INDENT = 2
 
 
 def _RenderType(ast_type):
-  """Renders the potentially recursively templated type into a string.
+    """Renders the potentially recursively templated type into a string.
 
   Args:
     ast_type: The AST of the type.
 
   Returns:
-    Rendered string of the type.
+    Rendered string and a boolean to indicate whether we have multiple args
+    (which is not handled correctly).
   """
-  # Add modifiers like 'const'.
+    has_multiarg_error = False
-  modifiers = ''
+    # Add modifiers like 'const'.
-  if ast_type.modifiers:
+    modifiers = ''
-    modifiers = ' '.join(ast_type.modifiers) + ' '
+    if ast_type.modifiers:
-  return_type = modifiers + ast_type.name
+        modifiers = ' '.join(ast_type.modifiers) + ' '
-  if ast_type.templated_types:
+    return_type = modifiers + ast_type.name
-    # Collect template args.
+    if ast_type.templated_types:
-    template_args = []
+        # Collect template args.
-    for arg in ast_type.templated_types:
+        template_args = []
-      rendered_arg = _RenderType(arg)
+        for arg in ast_type.templated_types:
-      template_args.append(rendered_arg)
+            rendered_arg, e = _RenderType(arg)
-    return_type += '<' + ', '.join(template_args) + '>'
+            if e: has_multiarg_error = True
-  if ast_type.pointer:
+            template_args.append(rendered_arg)
-    return_type += '*'
+        return_type += '<' + ', '.join(template_args) + '>'
-  if ast_type.reference:
+        # We are actually not handling multi-template-args correctly. So mark it.
-    return_type += '&'
+        if len(template_args) > 1:
-  return return_type
+            has_multiarg_error = True
+    if ast_type.pointer:
+        return_type += '*'
+    if ast_type.reference:
+        return_type += '&'
+    return return_type, has_multiarg_error
 
 
-def _GenerateArg(source):
+def _GetNumParameters(parameters, source):
-  """Strips out comments, default arguments, and redundant spaces from a single argument.
+    num_parameters = len(parameters)
-
+    if num_parameters == 1:
-  Args:
+        first_param = parameters[0]
-    source: A string for a single argument.
+        if source[first_param.start:first_param.end].strip() == 'void':
-
+            # We must treat T(void) as a function with no parameters.
-  Returns:
+            return 0
-    Rendered string of the argument.
+    return num_parameters
-  """
-  # Remove end of line comments before eliminating newlines.
-  arg = re.sub(r'//.*', '', source)
-
-  # Remove c-style comments.
-  arg = re.sub(r'/\*.*\*/', '', arg)
-
-  # Remove default arguments.
-  arg = re.sub(r'=.*', '', arg)
-
-  # Collapse spaces and newlines into a single space.
-  arg = re.sub(r'\s+', ' ', arg)
-  return arg.strip()
-
-
-def _EscapeForMacro(s):
-  """Escapes a string for use as an argument to a C++ macro."""
-  paren_count = 0
-  for c in s:
-    if c == '(':
-      paren_count += 1
-    elif c == ')':
-      paren_count -= 1
-    elif c == ',' and paren_count == 0:
-      return '(' + s + ')'
-  return s
 
 
 def _GenerateMethods(output_lines, source, class_node):
-  function_type = (
+    function_type = (ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL |
-      ast.FUNCTION_VIRTUAL | ast.FUNCTION_PURE_VIRTUAL | ast.FUNCTION_OVERRIDE)
+                     ast.FUNCTION_OVERRIDE)
-  ctor_or_dtor = ast.FUNCTION_CTOR | ast.FUNCTION_DTOR
+    ctor_or_dtor = ast.FUNCTION_CTOR | ast.FUNCTION_DTOR
-  indent = ' ' * _INDENT
+    indent = ' ' * _INDENT
 
-  for node in class_node.body:
+    for node in class_node.body:
-    # We only care about virtual functions.
+        # We only care about virtual functions.
-    if (isinstance(node, ast.Function) and node.modifiers & function_type and
+        if (isinstance(node, ast.Function) and
-        not node.modifiers & ctor_or_dtor):
+                node.modifiers & function_type and
-      # Pick out all the elements we need from the original function.
+                not node.modifiers & ctor_or_dtor):
-      modifiers = 'override'
+            # Pick out all the elements we need from the original function.
-      if node.modifiers & ast.FUNCTION_CONST:
+            const = ''
-        modifiers = 'const, ' + modifiers
+            if node.modifiers & ast.FUNCTION_CONST:
+                const = 'CONST_'
+            num_parameters = _GetNumParameters(node.parameters, source)
+            return_type = 'void'
+            if node.return_type:
+                return_type, has_multiarg_error = _RenderType(node.return_type)
+                if has_multiarg_error:
+                    for line in [
+                        '// The following line won\'t really compile, as the return',
+                        '// type has multiple template arguments.  To fix it, use a',
+                        '// typedef for the return type.']:
+                        output_lines.append(indent + line)
+            tmpl = ''
+            if class_node.templated_types:
+                tmpl = '_T'
+            mock_method_macro = 'MOCK_%sMETHOD%d%s' % (const, num_parameters, tmpl)
 
-      return_type = 'void'
+            args = ''
-      if node.return_type:
+            if node.parameters:
-        return_type = _EscapeForMacro(_RenderType(node.return_type))
+                # Get the full text of the parameters from the start
+                # of the first parameter to the end of the last parameter.
+                start = node.parameters[0].start
+                end = node.parameters[-1].end
+                # Remove // comments.
+                args_strings = re.sub(r'//.*', '', source[start:end])
+                # Remove /* comments */.
+                args_strings = re.sub(r'/\*.*\*/', '', args_strings)
+                # Remove default arguments.
+                args_strings = re.sub(r'=.*,', ',', args_strings)
+                args_strings = re.sub(r'=.*', '', args_strings)
+                # Condense multiple spaces and eliminate newlines putting the
+                # parameters together on a single line.  Ensure there is a
+                # space in an argument which is split by a newline without
+                # intervening whitespace, e.g.: int\nBar
+                args = re.sub('  +', ' ', args_strings.replace('\n', ' '))
 
-      args = []
+            # Create the mock method definition.
-      for p in node.parameters:
+            output_lines.extend(['%s%s(%s,' % (indent, mock_method_macro, node.name),
-        arg = _GenerateArg(source[p.start:p.end])
+                                 '%s%s(%s));' % (indent * 3, return_type, args)])
-        args.append(_EscapeForMacro(arg))
-
-      # Create the mock method definition.
-      output_lines.extend([
-          '%sMOCK_METHOD(%s, %s, (%s), (%s));' %
-          (indent, return_type, node.name, ', '.join(args), modifiers)
-      ])
 
 
 def _GenerateMocks(filename, source, ast_list, desired_class_names):
-  processed_class_names = set()
+    processed_class_names = set()
-  lines = []
+    lines = []
-  for node in ast_list:
+    for node in ast_list:
-    if (isinstance(node, ast.Class) and node.body and
+        if (isinstance(node, ast.Class) and node.body and
-        # desired_class_names being None means that all classes are selected.
+                # desired_class_names being None means that all classes are selected.
-        (not desired_class_names or node.name in desired_class_names)):
+                (not desired_class_names or node.name in desired_class_names)):
-      class_name = node.name
+            class_name = node.name
-      parent_name = class_name
+            parent_name = class_name
-      processed_class_names.add(class_name)
+            processed_class_names.add(class_name)
-      class_node = node
+            class_node = node
-      # Add namespace before the class.
+            # Add namespace before the class.
-      if class_node.namespace:
+            if class_node.namespace:
-        lines.extend(['namespace %s {' % n for n in class_node.namespace])  # }
+                lines.extend(['namespace %s {' % n for n in class_node.namespace])  # }
-        lines.append('')
+                lines.append('')
 
-      # Add template args for templated classes.
+            # Add template args for templated classes.
-      if class_node.templated_types:
+            if class_node.templated_types:
-        # TODO(paulchang): The AST doesn't preserve template argument order,
+                # TODO(paulchang): The AST doesn't preserve template argument order,
-        # so we have to make up names here.
+                # so we have to make up names here.
-        # TODO(paulchang): Handle non-type template arguments (e.g.
+                # TODO(paulchang): Handle non-type template arguments (e.g.
-        # template<typename T, int N>).
+                # template<typename T, int N>).
-        template_arg_count = len(class_node.templated_types.keys())
+                template_arg_count = len(class_node.templated_types.keys())
-        template_args = ['T%d' % n for n in range(template_arg_count)]
+                template_args = ['T%d' % n for n in range(template_arg_count)]
-        template_decls = ['typename ' + arg for arg in template_args]
+                template_decls = ['typename ' + arg for arg in template_args]
-        lines.append('template <' + ', '.join(template_decls) + '>')
+                lines.append('template <' + ', '.join(template_decls) + '>')
-        parent_name += '<' + ', '.join(template_args) + '>'
+                parent_name += '<' + ', '.join(template_args) + '>'
 
-      # Add the class prolog.
+            # Add the class prolog.
-      lines.append('class Mock%s : public %s {'  # }
+            lines.append('class Mock%s : public %s {'  # }
-                   % (class_name, parent_name))
+                         % (class_name, parent_name))
-      lines.append('%spublic:' % (' ' * (_INDENT // 2)))
+            lines.append('%spublic:' % (' ' * (_INDENT // 2)))
 
-      # Add all the methods.
+            # Add all the methods.
-      _GenerateMethods(lines, source, class_node)
+            _GenerateMethods(lines, source, class_node)
 
-      # Close the class.
+            # Close the class.
-      if lines:
+            if lines:
-        # If there are no virtual methods, no need for a public label.
+                # If there are no virtual methods, no need for a public label.
-        if len(lines) == 2:
+                if len(lines) == 2:
-          del lines[-1]
+                    del lines[-1]
 
-        # Only close the class if there really is a class.
+                # Only close the class if there really is a class.
-        lines.append('};')
+                lines.append('};')
-        lines.append('')  # Add an extra newline.
+                lines.append('')  # Add an extra newline.
 
-      # Close the namespace.
+            # Close the namespace.
-      if class_node.namespace:
+            if class_node.namespace:
-        for i in range(len(class_node.namespace) - 1, -1, -1):
+                for i in range(len(class_node.namespace) - 1, -1, -1):
-          lines.append('}  // namespace %s' % class_node.namespace[i])
+                    lines.append('}  // namespace %s' % class_node.namespace[i])
-        lines.append('')  # Add an extra newline.
+                lines.append('')  # Add an extra newline.
 
-  if desired_class_names:
+    if desired_class_names:
-    missing_class_name_list = list(desired_class_names - processed_class_names)
+        missing_class_name_list = list(desired_class_names - processed_class_names)
-    if missing_class_name_list:
+        if missing_class_name_list:
-      missing_class_name_list.sort()
+            missing_class_name_list.sort()
-      sys.stderr.write('Class(es) not found in %s: %s\n' %
+            sys.stderr.write('Class(es) not found in %s: %s\n' %
-                       (filename, ', '.join(missing_class_name_list)))
+                             (filename, ', '.join(missing_class_name_list)))
-  elif not processed_class_names:
+    elif not processed_class_names:
-    sys.stderr.write('No class found in %s\n' % filename)
+        sys.stderr.write('No class found in %s\n' % filename)
 
-  return lines
+    return lines
 
 
 def main(argv=sys.argv):
-  if len(argv) < 2:
+    if len(argv) < 2:
-    sys.stderr.write('Google Mock Class Generator v%s\n\n' %
+        sys.stderr.write('Google Mock Class Generator v%s\n\n' %
-                     '.'.join(map(str, _VERSION)))
+                         '.'.join(map(str, _VERSION)))
-    sys.stderr.write(__doc__)
+        sys.stderr.write(__doc__)
-    return 1
+        return 1
 
-  global _INDENT
+    global _INDENT
-  try:
+    try:
-    _INDENT = int(os.environ['INDENT'])
+        _INDENT = int(os.environ['INDENT'])
-  except KeyError:
+    except KeyError:
-    pass
+        pass
-  except:
+    except:
-    sys.stderr.write('Unable to use indent of %s\n' % os.environ.get('INDENT'))
+        sys.stderr.write('Unable to use indent of %s\n' % os.environ.get('INDENT'))
 
-  filename = argv[1]
+    filename = argv[1]
-  desired_class_names = None  # None means all classes in the source file.
+    desired_class_names = None  # None means all classes in the source file.
-  if len(argv) >= 3:
+    if len(argv) >= 3:
-    desired_class_names = set(argv[2:])
+        desired_class_names = set(argv[2:])
-  source = utils.ReadFile(filename)
+    source = utils.ReadFile(filename)
-  if source is None:
+    if source is None:
-    return 1
+        return 1
 
-  builder = ast.BuilderFromSource(source, filename)
+    builder = ast.BuilderFromSource(source, filename)
-  try:
+    try:
-    entire_ast = filter(None, builder.Generate())
+        entire_ast = filter(None, builder.Generate())
-  except KeyboardInterrupt:
+    except KeyboardInterrupt:
-    return
+        return
-  except:
+    except:
-    # An error message was already printed since we couldn't parse.
+        # An error message was already printed since we couldn't parse.
-    sys.exit(1)
+        sys.exit(1)
-  else:
+    else:
-    lines = _GenerateMocks(filename, source, entire_ast, desired_class_names)
+        lines = _GenerateMocks(filename, source, entire_ast, desired_class_names)
-    sys.stdout.write('\n'.join(lines))
+        sys.stdout.write('\n'.join(lines))
 
 
 if __name__ == '__main__':
-  main(sys.argv)
+    main(sys.argv)

googlemock/scripts/generator/cpp/gmock_class_test.py

@@ -29,43 +29,43 @@ from cpp import gmock_class
 
 
 class TestCase(unittest.TestCase):
-  """Helper class that adds assert methods."""
+    """Helper class that adds assert methods."""
 
-  @staticmethod
+    @staticmethod
-  def StripLeadingWhitespace(lines):
+    def StripLeadingWhitespace(lines):
-    """Strip leading whitespace in each line in 'lines'."""
+        """Strip leading whitespace in each line in 'lines'."""
-    return '\n'.join([s.lstrip() for s in lines.split('\n')])
+        return '\n'.join([s.lstrip() for s in lines.split('\n')])
 
-  def assertEqualIgnoreLeadingWhitespace(self, expected_lines, lines):
+    def assertEqualIgnoreLeadingWhitespace(self, expected_lines, lines):
-    """Specialized assert that ignores the indent level."""
+        """Specialized assert that ignores the indent level."""
-    self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines))
+        self.assertEqual(expected_lines, self.StripLeadingWhitespace(lines))
 
 
 class GenerateMethodsTest(TestCase):
 
-  @staticmethod
+    @staticmethod
-  def GenerateMethodSource(cpp_source):
+    def GenerateMethodSource(cpp_source):
-    """Convert C++ source to Google Mock output source lines."""
+        """Convert C++ source to Google Mock output source lines."""
-    method_source_lines = []
+        method_source_lines = []
-    # <test> is a pseudo-filename, it is not read or written.
+        # <test> is a pseudo-filename, it is not read or written.
-    builder = ast.BuilderFromSource(cpp_source, '<test>')
+        builder = ast.BuilderFromSource(cpp_source, '<test>')
-    ast_list = list(builder.Generate())
+        ast_list = list(builder.Generate())
-    gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0])
+        gmock_class._GenerateMethods(method_source_lines, cpp_source, ast_list[0])
-    return '\n'.join(method_source_lines)
+        return '\n'.join(method_source_lines)
 
-  def testSimpleMethod(self):
+    def testSimpleMethod(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual int Bar();
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (), (override));',
+            'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testSimpleConstructorsAndDestructor(self):
+    def testSimpleConstructorsAndDestructor(self):
-    source = """
+        source = """
 class Foo {
  public:
   Foo();
@@ -76,26 +76,26 @@ class Foo {
   virtual int Bar() = 0;
 };
 """
-    # The constructors and destructor should be ignored.
+        # The constructors and destructor should be ignored.
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (), (override));',
+            'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testVirtualDestructor(self):
+    def testVirtualDestructor(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual ~Foo();
   virtual int Bar() = 0;
 };
 """
-    # The destructor should be ignored.
+        # The destructor should be ignored.
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (), (override));',
+            'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testExplicitlyDefaultedConstructorsAndDestructor(self):
+    def testExplicitlyDefaultedConstructorsAndDestructor(self):
-    source = """
+        source = """
 class Foo {
  public:
   Foo() = default;
@@ -105,13 +105,13 @@ class Foo {
   virtual int Bar() = 0;
 };
 """
-    # The constructors and destructor should be ignored.
+        # The constructors and destructor should be ignored.
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (), (override));',
+            'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testExplicitlyDeletedConstructorsAndDestructor(self):
+    def testExplicitlyDeletedConstructorsAndDestructor(self):
-    source = """
+        source = """
 class Foo {
  public:
   Foo() = delete;
@@ -121,69 +121,69 @@ class Foo {
   virtual int Bar() = 0;
 };
 """
-    # The constructors and destructor should be ignored.
+        # The constructors and destructor should be ignored.
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (), (override));',
+            'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testSimpleOverrideMethod(self):
+    def testSimpleOverrideMethod(self):
-    source = """
+        source = """
 class Foo {
  public:
   int Bar() override;
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (), (override));',
+            'MOCK_METHOD0(Bar,\nint());',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testSimpleConstMethod(self):
+    def testSimpleConstMethod(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual void Bar(bool flag) const;
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(void, Bar, (bool flag), (const, override));',
+            'MOCK_CONST_METHOD1(Bar,\nvoid(bool flag));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testExplicitVoid(self):
+    def testExplicitVoid(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual int Bar(void);
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (void), (override));',
+            'MOCK_METHOD0(Bar,\nint(void));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testStrangeNewlineInParameter(self):
+    def testStrangeNewlineInParameter(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual void Bar(int
 a) = 0;
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(void, Bar, (int a), (override));',
+            'MOCK_METHOD1(Bar,\nvoid(int a));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testDefaultParameters(self):
+    def testDefaultParameters(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual void Bar(int a, char c = 'x') = 0;
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(void, Bar, (int a, char c), (override));',
+            'MOCK_METHOD2(Bar,\nvoid(int a, char c ));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testMultipleDefaultParameters(self):
+    def testMultipleDefaultParameters(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual void Bar(
@@ -195,58 +195,47 @@ class Foo {
         int const *& rp = aDefaultPointer) = 0;
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(void, Bar, '
+            "MOCK_METHOD7(Bar,\n"
-        '(int a, char c, const int* const p, const std::string& s, char tab[], int const *& rp), '
+            "void(int a , char c , const int* const p , const std::string& s , char tab[] , int const *& rp ));",
-        '(override));', self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testMultipleSingleLineDefaultParameters(self):
+    def testConstDefaultParameter(self):
-    source = """
+        source = """
-class Foo {
- public:
-  virtual void Bar(int a = 42, int b = 43, int c = 44) = 0;
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(void, Bar, (int a, int b, int c), (override));',
-        self.GenerateMethodSource(source))
-
-  def testConstDefaultParameter(self):
-    source = """
 class Test {
  public:
   virtual bool Bar(const int test_arg = 42) = 0;
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        expected = 'MOCK_METHOD1(Bar,\nbool(const int test_arg ));'
-        'MOCK_METHOD(bool, Bar, (const int test_arg), (override));',
+        self.assertEqualIgnoreLeadingWhitespace(
-        self.GenerateMethodSource(source))
+            expected, self.GenerateMethodSource(source))
 
-  def testConstRefDefaultParameter(self):
+    def testConstRefDefaultParameter(self):
-    source = """
+        source = """
 class Test {
  public:
   virtual bool Bar(const std::string& test_arg = "42" ) = 0;
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        expected = 'MOCK_METHOD1(Bar,\nbool(const std::string& test_arg ));'
-        'MOCK_METHOD(bool, Bar, (const std::string& test_arg), (override));',
+        self.assertEqualIgnoreLeadingWhitespace(
-        self.GenerateMethodSource(source))
+            expected, self.GenerateMethodSource(source))
 
-  def testRemovesCommentsWhenDefaultsArePresent(self):
+    def testRemovesCommentsWhenDefaultsArePresent(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual void Bar(int a = 42 /* a comment */,
                    char /* other comment */ c= 'x') = 0;
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(void, Bar, (int a, char c), (override));',
+            'MOCK_METHOD2(Bar,\nvoid(int a , char c));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testDoubleSlashCommentsInParameterListAreRemoved(self):
+    def testDoubleSlashCommentsInParameterListAreRemoved(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual void Bar(int a,  // inline comments should be elided.
@@ -254,111 +243,117 @@ class Foo {
                    ) const = 0;
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(void, Bar, (int a, int b), (const, override));',
+            'MOCK_CONST_METHOD2(Bar,\nvoid(int a, int b));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testCStyleCommentsInParameterListAreNotRemoved(self):
+    def testCStyleCommentsInParameterListAreNotRemoved(self):
-    # NOTE(nnorwitz): I'm not sure if it's the best behavior to keep these
+        # NOTE(nnorwitz): I'm not sure if it's the best behavior to keep these
-    # comments.  Also note that C style comments after the last parameter
+        # comments.  Also note that C style comments after the last parameter
-    # are still elided.
+        # are still elided.
-    source = """
+        source = """
 class Foo {
  public:
   virtual const string& Bar(int /* keeper */, int b);
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(const string&, Bar, (int, int b), (override));',
+            'MOCK_METHOD2(Bar,\nconst string&(int , int b));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testArgsOfTemplateTypes(self):
+    def testArgsOfTemplateTypes(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual int Bar(const vector<int>& v, map<int, string>* output);
 };"""
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (const vector<int>& v, (map<int, string>* output)), (override));',
+            'MOCK_METHOD2(Bar,\n'
-        self.GenerateMethodSource(source))
+            'int(const vector<int>& v, map<int, string>* output));',
+            self.GenerateMethodSource(source))
 
-  def testReturnTypeWithOneTemplateArg(self):
+    def testReturnTypeWithOneTemplateArg(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual vector<int>* Bar(int n);
 };"""
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(vector<int>*, Bar, (int n), (override));',
+            'MOCK_METHOD1(Bar,\nvector<int>*(int n));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testReturnTypeWithManyTemplateArgs(self):
+    def testReturnTypeWithManyTemplateArgs(self):
-    source = """
+        source = """
 class Foo {
  public:
   virtual map<int, string> Bar();
 };"""
-    self.assertEqualIgnoreLeadingWhitespace(
+        # Comparing the comment text is brittle - we'll think of something
-        'MOCK_METHOD((map<int, string>), Bar, (), (override));',
+        # better in case this gets annoying, but for now let's keep it simple.
-        self.GenerateMethodSource(source))
+        self.assertEqualIgnoreLeadingWhitespace(
+            '// The following line won\'t really compile, as the return\n'
+            '// type has multiple template arguments.  To fix it, use a\n'
+            '// typedef for the return type.\n'
+            'MOCK_METHOD0(Bar,\nmap<int, string>());',
+            self.GenerateMethodSource(source))
 
-  def testSimpleMethodInTemplatedClass(self):
+    def testSimpleMethodInTemplatedClass(self):
-    source = """
+        source = """
 template<class T>
 class Foo {
  public:
   virtual int Bar();
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (), (override));',
+            'MOCK_METHOD0_T(Bar,\nint());',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testPointerArgWithoutNames(self):
+    def testPointerArgWithoutNames(self):
-    source = """
+        source = """
 class Foo {
   virtual int Bar(C*);
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (C*), (override));',
+            'MOCK_METHOD1(Bar,\nint(C*));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testReferenceArgWithoutNames(self):
+    def testReferenceArgWithoutNames(self):
-    source = """
+        source = """
 class Foo {
   virtual int Bar(C&);
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (C&), (override));',
+            'MOCK_METHOD1(Bar,\nint(C&));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
-  def testArrayArgWithoutNames(self):
+    def testArrayArgWithoutNames(self):
-    source = """
+        source = """
 class Foo {
   virtual int Bar(C[]);
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(
+        self.assertEqualIgnoreLeadingWhitespace(
-        'MOCK_METHOD(int, Bar, (C[]), (override));',
+            'MOCK_METHOD1(Bar,\nint(C[]));',
-        self.GenerateMethodSource(source))
+            self.GenerateMethodSource(source))
 
 
 class GenerateMocksTest(TestCase):
 
-  @staticmethod
+    @staticmethod
-  def GenerateMocks(cpp_source):
+    def GenerateMocks(cpp_source):
-    """Convert C++ source to complete Google Mock output source."""
+        """Convert C++ source to complete Google Mock output source."""
-    # <test> is a pseudo-filename, it is not read or written.
+        # <test> is a pseudo-filename, it is not read or written.
-    filename = '<test>'
+        filename = '<test>'
-    builder = ast.BuilderFromSource(cpp_source, filename)
+        builder = ast.BuilderFromSource(cpp_source, filename)
-    ast_list = list(builder.Generate())
+        ast_list = list(builder.Generate())
-    lines = gmock_class._GenerateMocks(filename, cpp_source, ast_list, None)
+        lines = gmock_class._GenerateMocks(filename, cpp_source, ast_list, None)
-    return '\n'.join(lines)
+        return '\n'.join(lines)
 
-  def testNamespaces(self):
+    def testNamespaces(self):
-    source = """
+        source = """
 namespace Foo {
 namespace Bar { class Forward; }
 namespace Baz {
@@ -371,91 +366,96 @@ class Test {
 }  // namespace Baz
 }  // namespace Foo
 """
-    expected = """\
+        expected = """\
 namespace Foo {
 namespace Baz {
 
 class MockTest : public Test {
 public:
-MOCK_METHOD(void, Foo, (), (override));
+MOCK_METHOD0(Foo,
+void());
 };
 
 }  // namespace Baz
 }  // namespace Foo
 """
-    self.assertEqualIgnoreLeadingWhitespace(expected,
+        self.assertEqualIgnoreLeadingWhitespace(
-                                            self.GenerateMocks(source))
+            expected, self.GenerateMocks(source))
 
-  def testClassWithStorageSpecifierMacro(self):
+    def testClassWithStorageSpecifierMacro(self):
-    source = """
+        source = """
 class STORAGE_SPECIFIER Test {
  public:
   virtual void Foo();
 };
 """
-    expected = """\
+        expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD(void, Foo, (), (override));
+MOCK_METHOD0(Foo,
+void());
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(expected,
+        self.assertEqualIgnoreLeadingWhitespace(
-                                            self.GenerateMocks(source))
+            expected, self.GenerateMocks(source))
 
-  def testTemplatedForwardDeclaration(self):
+    def testTemplatedForwardDeclaration(self):
-    source = """
+        source = """
 template <class T> class Forward;  // Forward declaration should be ignored.
 class Test {
  public:
   virtual void Foo();
 };
 """
-    expected = """\
+        expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD(void, Foo, (), (override));
+MOCK_METHOD0(Foo,
+void());
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(expected,
+        self.assertEqualIgnoreLeadingWhitespace(
-                                            self.GenerateMocks(source))
+            expected, self.GenerateMocks(source))
 
-  def testTemplatedClass(self):
+    def testTemplatedClass(self):
-    source = """
+        source = """
 template <typename S, typename T>
 class Test {
  public:
   virtual void Foo();
 };
 """
-    expected = """\
+        expected = """\
 template <typename T0, typename T1>
 class MockTest : public Test<T0, T1> {
 public:
-MOCK_METHOD(void, Foo, (), (override));
+MOCK_METHOD0_T(Foo,
+void());
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(expected,
+        self.assertEqualIgnoreLeadingWhitespace(
-                                            self.GenerateMocks(source))
+            expected, self.GenerateMocks(source))
 
-  def testTemplateInATemplateTypedef(self):
+    def testTemplateInATemplateTypedef(self):
-    source = """
+        source = """
 class Test {
  public:
   typedef std::vector<std::list<int>> FooType;
   virtual void Bar(const FooType& test_arg);
 };
 """
-    expected = """\
+        expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD(void, Bar, (const FooType& test_arg), (override));
+MOCK_METHOD1(Bar,
+void(const FooType& test_arg));
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(expected,
+        self.assertEqualIgnoreLeadingWhitespace(
-                                            self.GenerateMocks(source))
+            expected, self.GenerateMocks(source))
 
-  def testTemplateInATemplateTypedefWithComma(self):
+    def testTemplateInATemplateTypedefWithComma(self):
-    source = """
+        source = """
 class Test {
  public:
   typedef std::function<void(
@@ -463,33 +463,18 @@ class Test {
   virtual void Bar(const FooType& test_arg);
 };
 """
-    expected = """\
+        expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD(void, Bar, (const FooType& test_arg), (override));
+MOCK_METHOD1(Bar,
+void(const FooType& test_arg));
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(expected,
+        self.assertEqualIgnoreLeadingWhitespace(
-                                            self.GenerateMocks(source))
+            expected, self.GenerateMocks(source))
 
-  def testParenthesizedCommaInArg(self):
+    def testEnumType(self):
-    source = """
+        source = """
-class Test {
- public:
-   virtual void Bar(std::function<void(int, int)> f);
-};
-"""
-    expected = """\
-class MockTest : public Test {
-public:
-MOCK_METHOD(void, Bar, (std::function<void(int, int)> f), (override));
-};
-"""
-    self.assertEqualIgnoreLeadingWhitespace(expected,
-                                            self.GenerateMocks(source))
-
-  def testEnumType(self):
-    source = """
 class Test {
  public:
   enum Bar {
@@ -498,17 +483,18 @@ class Test {
   virtual void Foo();
 };
 """
-    expected = """\
+        expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD(void, Foo, (), (override));
+MOCK_METHOD0(Foo,
+void());
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(expected,
+        self.assertEqualIgnoreLeadingWhitespace(
-                                            self.GenerateMocks(source))
+            expected, self.GenerateMocks(source))
 
-  def testEnumClassType(self):
+    def testEnumClassType(self):
-    source = """
+        source = """
 class Test {
  public:
   enum class Bar {
@@ -517,17 +503,18 @@ class Test {
   virtual void Foo();
 };
 """
-    expected = """\
+        expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD(void, Foo, (), (override));
+MOCK_METHOD0(Foo,
+void());
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(expected,
+        self.assertEqualIgnoreLeadingWhitespace(
-                                            self.GenerateMocks(source))
+            expected, self.GenerateMocks(source))
 
-  def testStdFunction(self):
+    def testStdFunction(self):
-    source = """
+        source = """
 class Test {
  public:
   Test(std::function<int(std::string)> foo) : foo_(foo) {}
@@ -538,15 +525,16 @@ class Test {
   std::function<int(std::string)> foo_;
 };
 """
-    expected = """\
+        expected = """\
 class MockTest : public Test {
 public:
-MOCK_METHOD(std::function<int (std::string)>, foo, (), (override));
+MOCK_METHOD0(foo,
+std::function<int (std::string)>());
 };
 """
-    self.assertEqualIgnoreLeadingWhitespace(expected,
+        self.assertEqualIgnoreLeadingWhitespace(
-                                            self.GenerateMocks(source))
+            expected, self.GenerateMocks(source))
 
 
 if __name__ == '__main__':
-  unittest.main()
+    unittest.main()

googlemock/test/BUILD.bazel

@@ -28,6 +28,8 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+# Author: misterg@google.com (Gennadiy Civil)
+#
 #   Bazel Build for Google C++ Testing Framework(Google Test)-googlemock
 
 load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_test")

googlemock/test/gmock-actions_test.cc

@@ -1470,19 +1470,8 @@ TEST(FunctorActionTest, TypeConversion) {
   EXPECT_EQ(1, s2.Perform(std::make_tuple("hello")));
 
   // Also between the lambda and the action itself.
-  const Action<bool(std::string)> x1 = [](Unused) { return 42; };
+  const Action<bool(std::string)> x = [](Unused) { return 42; };
-  const Action<bool(std::string)> x2 = [] { return 42; };
+  EXPECT_TRUE(x.Perform(std::make_tuple("hello")));
-  EXPECT_TRUE(x1.Perform(std::make_tuple("hello")));
-  EXPECT_TRUE(x2.Perform(std::make_tuple("hello")));
-
-  // Ensure decay occurs where required.
-  std::function<int()> f = [] { return 7; };
-  Action<int(int)> d = f;
-  f = nullptr;
-  EXPECT_EQ(7, d.Perform(std::make_tuple(1)));
-
-  // Ensure creation of an empty action succeeds.
-  Action<void(int)>(nullptr);
 }
 
 TEST(FunctorActionTest, UnusedArguments) {

googlemock/test/gmock-function-mocker_test.cc

@@ -40,7 +40,6 @@
 # include <objbase.h>
 #endif  // GTEST_OS_WINDOWS
 
-#include <functional>
 #include <map>
 #include <string>
 #include <type_traits>
@@ -779,56 +778,6 @@ TEST(MockMethodMockFunctionTest, AsStdFunctionWithReferenceParameter) {
   EXPECT_EQ(-1, call(foo.AsStdFunction(), i));
 }
 
-namespace {
-
-template <typename Expected, typename F>
-static constexpr bool IsMockFunctionTemplateArgumentDeducedTo(
-    const MockFunction<F>&) {
-  return std::is_same<F, Expected>::value;
-}
-
-}  // namespace
-
-template <typename F>
-class MockMethodMockFunctionSignatureTest : public Test {};
-
-using MockMethodMockFunctionSignatureTypes =
-    Types<void(), int(), void(int), int(int), int(bool, int),
-          int(bool, char, int, int, int, int, int, char, int, bool)>;
-TYPED_TEST_SUITE(MockMethodMockFunctionSignatureTest,
-                 MockMethodMockFunctionSignatureTypes);
-
-TYPED_TEST(MockMethodMockFunctionSignatureTest,
-           IsMockFunctionTemplateArgumentDeducedForRawSignature) {
-  using Argument = TypeParam;
-  MockFunction<Argument> foo;
-  EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<Argument>(foo));
-}
-
-TYPED_TEST(MockMethodMockFunctionSignatureTest,
-           IsMockFunctionTemplateArgumentDeducedForStdFunction) {
-  using Argument = std::function<TypeParam>;
-  MockFunction<Argument> foo;
-  EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<Argument>(foo));
-}
-
-TYPED_TEST(
-    MockMethodMockFunctionSignatureTest,
-    IsMockFunctionCallMethodSignatureTheSameForRawSignatureAndStdFunction) {
-  using ForRawSignature = decltype(&MockFunction<TypeParam>::Call);
-  using ForStdFunction =
-      decltype(&MockFunction<std::function<TypeParam>>::Call);
-  EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
-}
-
-TYPED_TEST(
-    MockMethodMockFunctionSignatureTest,
-    IsMockFunctionAsStdFunctionMethodSignatureTheSameForRawSignatureAndStdFunction) {
-  using ForRawSignature = decltype(&MockFunction<TypeParam>::AsStdFunction);
-  using ForStdFunction =
-      decltype(&MockFunction<std::function<TypeParam>>::AsStdFunction);
-  EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
-}
 
 struct MockMethodSizes0 {
   MOCK_METHOD(void, func, ());

googlemock/test/gmock-matchers_test.cc

@@ -351,43 +351,43 @@ TEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) {
   EXPECT_FALSE(m2.Matches("hello"));
 }
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
 // Tests that a C-string literal can be implicitly converted to a
-// Matcher<StringView> or Matcher<const StringView&>.
+// Matcher<absl::string_view> or Matcher<const absl::string_view&>.
 TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
-  Matcher<internal::StringView> m1 = "cats";
+  Matcher<absl::string_view> m1 = "cats";
   EXPECT_TRUE(m1.Matches("cats"));
   EXPECT_FALSE(m1.Matches("dogs"));
 
-  Matcher<const internal::StringView&> m2 = "cats";
+  Matcher<const absl::string_view&> m2 = "cats";
   EXPECT_TRUE(m2.Matches("cats"));
   EXPECT_FALSE(m2.Matches("dogs"));
 }
 
 // Tests that a std::string object can be implicitly converted to a
-// Matcher<StringView> or Matcher<const StringView&>.
+// Matcher<absl::string_view> or Matcher<const absl::string_view&>.
 TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromString) {
-  Matcher<internal::StringView> m1 = std::string("cats");
+  Matcher<absl::string_view> m1 = std::string("cats");
   EXPECT_TRUE(m1.Matches("cats"));
   EXPECT_FALSE(m1.Matches("dogs"));
 
-  Matcher<const internal::StringView&> m2 = std::string("cats");
+  Matcher<const absl::string_view&> m2 = std::string("cats");
   EXPECT_TRUE(m2.Matches("cats"));
   EXPECT_FALSE(m2.Matches("dogs"));
 }
 
-// Tests that a StringView object can be implicitly converted to a
+// Tests that a absl::string_view object can be implicitly converted to a
-// Matcher<StringView> or Matcher<const StringView&>.
+// Matcher<absl::string_view> or Matcher<const absl::string_view&>.
 TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromStringView) {
-  Matcher<internal::StringView> m1 = internal::StringView("cats");
+  Matcher<absl::string_view> m1 = absl::string_view("cats");
   EXPECT_TRUE(m1.Matches("cats"));
   EXPECT_FALSE(m1.Matches("dogs"));
 
-  Matcher<const internal::StringView&> m2 = internal::StringView("cats");
+  Matcher<const absl::string_view&> m2 = absl::string_view("cats");
   EXPECT_TRUE(m2.Matches("cats"));
   EXPECT_FALSE(m2.Matches("dogs"));
 }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
 // Tests that a std::reference_wrapper<std::string> object can be implicitly
 // converted to a Matcher<std::string> or Matcher<const std::string&> via Eq().
@@ -765,11 +765,10 @@ TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
 
 // Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
 TEST(SafeMatcherCastTest, FromNonReferenceToConstReference) {
-  Matcher<std::unique_ptr<int>> m1 = IsNull();
+  Matcher<int> m1 = Eq(0);
-  Matcher<const std::unique_ptr<int>&> m2 =
+  Matcher<const int&> m2 = SafeMatcherCast<const int&>(m1);
-      SafeMatcherCast<const std::unique_ptr<int>&>(m1);
+  EXPECT_TRUE(m2.Matches(0));
-  EXPECT_TRUE(m2.Matches(std::unique_ptr<int>()));
+  EXPECT_FALSE(m2.Matches(1));
-  EXPECT_FALSE(m2.Matches(std::unique_ptr<int>(new int)));
 }
 
 // Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<T>.
@@ -1236,17 +1235,17 @@ TEST(StrEqTest, MatchesEqualString) {
   EXPECT_TRUE(m2.Matches("Hello"));
   EXPECT_FALSE(m2.Matches("Hi"));
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  Matcher<const internal::StringView&> m3 = StrEq("Hello");
+  Matcher<const absl::string_view&> m3 = StrEq("Hello");
-  EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
+  EXPECT_TRUE(m3.Matches(absl::string_view("Hello")));
-  EXPECT_FALSE(m3.Matches(internal::StringView("hello")));
+  EXPECT_FALSE(m3.Matches(absl::string_view("hello")));
-  EXPECT_FALSE(m3.Matches(internal::StringView()));
+  EXPECT_FALSE(m3.Matches(absl::string_view()));
 
-  Matcher<const internal::StringView&> m_empty = StrEq("");
+  Matcher<const absl::string_view&> m_empty = StrEq("");
-  EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
+  EXPECT_TRUE(m_empty.Matches(absl::string_view("")));
-  EXPECT_TRUE(m_empty.Matches(internal::StringView()));
+  EXPECT_TRUE(m_empty.Matches(absl::string_view()));
-  EXPECT_FALSE(m_empty.Matches(internal::StringView("hello")));
+  EXPECT_FALSE(m_empty.Matches(absl::string_view("hello")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 }
 
 TEST(StrEqTest, CanDescribeSelf) {
@@ -1273,12 +1272,12 @@ TEST(StrNeTest, MatchesUnequalString) {
   EXPECT_TRUE(m2.Matches("hello"));
   EXPECT_FALSE(m2.Matches("Hello"));
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  Matcher<const internal::StringView> m3 = StrNe("Hello");
+  Matcher<const absl::string_view> m3 = StrNe("Hello");
-  EXPECT_TRUE(m3.Matches(internal::StringView("")));
+  EXPECT_TRUE(m3.Matches(absl::string_view("")));
-  EXPECT_TRUE(m3.Matches(internal::StringView()));
+  EXPECT_TRUE(m3.Matches(absl::string_view()));
-  EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
+  EXPECT_FALSE(m3.Matches(absl::string_view("Hello")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 }
 
 TEST(StrNeTest, CanDescribeSelf) {
@@ -1297,13 +1296,13 @@ TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
   EXPECT_TRUE(m2.Matches("hello"));
   EXPECT_FALSE(m2.Matches("Hi"));
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  Matcher<const internal::StringView&> m3 = StrCaseEq(std::string("Hello"));
+  Matcher<const absl::string_view&> m3 = StrCaseEq(std::string("Hello"));
-  EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
+  EXPECT_TRUE(m3.Matches(absl::string_view("Hello")));
-  EXPECT_TRUE(m3.Matches(internal::StringView("hello")));
+  EXPECT_TRUE(m3.Matches(absl::string_view("hello")));
-  EXPECT_FALSE(m3.Matches(internal::StringView("Hi")));
+  EXPECT_FALSE(m3.Matches(absl::string_view("Hi")));
-  EXPECT_FALSE(m3.Matches(internal::StringView()));
+  EXPECT_FALSE(m3.Matches(absl::string_view()));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 }
 
 TEST(StrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
@@ -1347,13 +1346,13 @@ TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) {
   EXPECT_TRUE(m2.Matches(""));
   EXPECT_FALSE(m2.Matches("Hello"));
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  Matcher<const internal::StringView> m3 = StrCaseNe("Hello");
+  Matcher<const absl::string_view> m3 = StrCaseNe("Hello");
-  EXPECT_TRUE(m3.Matches(internal::StringView("Hi")));
+  EXPECT_TRUE(m3.Matches(absl::string_view("Hi")));
-  EXPECT_TRUE(m3.Matches(internal::StringView()));
+  EXPECT_TRUE(m3.Matches(absl::string_view()));
-  EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
+  EXPECT_FALSE(m3.Matches(absl::string_view("Hello")));
-  EXPECT_FALSE(m3.Matches(internal::StringView("hello")));
+  EXPECT_FALSE(m3.Matches(absl::string_view("hello")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 }
 
 TEST(StrCaseNeTest, CanDescribeSelf) {
@@ -1394,25 +1393,25 @@ TEST(HasSubstrTest, WorksForCStrings) {
   EXPECT_FALSE(m_empty.Matches(nullptr));
 }
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-// Tests that HasSubstr() works for matching StringView-typed values.
+// Tests that HasSubstr() works for matching absl::string_view-typed values.
 TEST(HasSubstrTest, WorksForStringViewClasses) {
-  const Matcher<internal::StringView> m1 = HasSubstr("foo");
+  const Matcher<absl::string_view> m1 = HasSubstr("foo");
-  EXPECT_TRUE(m1.Matches(internal::StringView("I love food.")));
+  EXPECT_TRUE(m1.Matches(absl::string_view("I love food.")));
-  EXPECT_FALSE(m1.Matches(internal::StringView("tofo")));
+  EXPECT_FALSE(m1.Matches(absl::string_view("tofo")));
-  EXPECT_FALSE(m1.Matches(internal::StringView()));
+  EXPECT_FALSE(m1.Matches(absl::string_view()));
 
-  const Matcher<const internal::StringView&> m2 = HasSubstr("foo");
+  const Matcher<const absl::string_view&> m2 = HasSubstr("foo");
-  EXPECT_TRUE(m2.Matches(internal::StringView("I love food.")));
+  EXPECT_TRUE(m2.Matches(absl::string_view("I love food.")));
-  EXPECT_FALSE(m2.Matches(internal::StringView("tofo")));
+  EXPECT_FALSE(m2.Matches(absl::string_view("tofo")));
-  EXPECT_FALSE(m2.Matches(internal::StringView()));
+  EXPECT_FALSE(m2.Matches(absl::string_view()));
 
-  const Matcher<const internal::StringView&> m3 = HasSubstr("");
+  const Matcher<const absl::string_view&> m3 = HasSubstr("");
-  EXPECT_TRUE(m3.Matches(internal::StringView("foo")));
+  EXPECT_TRUE(m3.Matches(absl::string_view("foo")));
-  EXPECT_TRUE(m3.Matches(internal::StringView("")));
+  EXPECT_TRUE(m3.Matches(absl::string_view("")));
-  EXPECT_TRUE(m3.Matches(internal::StringView()));
+  EXPECT_TRUE(m3.Matches(absl::string_view()));
 }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
 // Tests that HasSubstr(s) describes itself properly.
 TEST(HasSubstrTest, CanDescribeSelf) {
@@ -1649,12 +1648,12 @@ TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
   EXPECT_FALSE(m2.Matches("H"));
   EXPECT_FALSE(m2.Matches(" Hi"));
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  const Matcher<internal::StringView> m_empty = StartsWith("");
+  const Matcher<absl::string_view> m_empty = StartsWith("");
-  EXPECT_TRUE(m_empty.Matches(internal::StringView()));
+  EXPECT_TRUE(m_empty.Matches(absl::string_view()));
-  EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
+  EXPECT_TRUE(m_empty.Matches(absl::string_view("")));
-  EXPECT_TRUE(m_empty.Matches(internal::StringView("not empty")));
+  EXPECT_TRUE(m_empty.Matches(absl::string_view("not empty")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 }
 
 TEST(StartsWithTest, CanDescribeSelf) {
@@ -1677,13 +1676,13 @@ TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
   EXPECT_FALSE(m2.Matches("i"));
   EXPECT_FALSE(m2.Matches("Hi "));
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  const Matcher<const internal::StringView&> m4 = EndsWith("");
+  const Matcher<const absl::string_view&> m4 = EndsWith("");
   EXPECT_TRUE(m4.Matches("Hi"));
   EXPECT_TRUE(m4.Matches(""));
-  EXPECT_TRUE(m4.Matches(internal::StringView()));
+  EXPECT_TRUE(m4.Matches(absl::string_view()));
-  EXPECT_TRUE(m4.Matches(internal::StringView("")));
+  EXPECT_TRUE(m4.Matches(absl::string_view("")));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 }
 
 TEST(EndsWithTest, CanDescribeSelf) {
@@ -1704,16 +1703,16 @@ TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
   EXPECT_FALSE(m2.Matches("az1"));
   EXPECT_FALSE(m2.Matches("1az"));
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  const Matcher<const internal::StringView&> m3 = MatchesRegex("a.*z");
+  const Matcher<const absl::string_view&> m3 = MatchesRegex("a.*z");
-  EXPECT_TRUE(m3.Matches(internal::StringView("az")));
+  EXPECT_TRUE(m3.Matches(absl::string_view("az")));
-  EXPECT_TRUE(m3.Matches(internal::StringView("abcz")));
+  EXPECT_TRUE(m3.Matches(absl::string_view("abcz")));
-  EXPECT_FALSE(m3.Matches(internal::StringView("1az")));
+  EXPECT_FALSE(m3.Matches(absl::string_view("1az")));
-  EXPECT_FALSE(m3.Matches(internal::StringView()));
+  EXPECT_FALSE(m3.Matches(absl::string_view()));
-  const Matcher<const internal::StringView&> m4 = MatchesRegex("");
+  const Matcher<const absl::string_view&> m4 = MatchesRegex("");
-  EXPECT_TRUE(m4.Matches(internal::StringView("")));
+  EXPECT_TRUE(m4.Matches(absl::string_view("")));
-  EXPECT_TRUE(m4.Matches(internal::StringView()));
+  EXPECT_TRUE(m4.Matches(absl::string_view()));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 }
 
 TEST(MatchesRegexTest, CanDescribeSelf) {
@@ -1723,10 +1722,10 @@ TEST(MatchesRegexTest, CanDescribeSelf) {
   Matcher<const char*> m2 = MatchesRegex(new RE("a.*"));
   EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2));
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  Matcher<const internal::StringView> m3 = MatchesRegex(new RE("0.*"));
+  Matcher<const absl::string_view> m3 = MatchesRegex(new RE("0.*"));
   EXPECT_EQ("matches regular expression \"0.*\"", Describe(m3));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 }
 
 // Tests ContainsRegex().
@@ -1742,17 +1741,16 @@ TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
   EXPECT_TRUE(m2.Matches("az1"));
   EXPECT_FALSE(m2.Matches("1a"));
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  const Matcher<const internal::StringView&> m3 =
+  const Matcher<const absl::string_view&> m3 = ContainsRegex(new RE("a.*z"));
-      ContainsRegex(new RE("a.*z"));
+  EXPECT_TRUE(m3.Matches(absl::string_view("azbz")));
-  EXPECT_TRUE(m3.Matches(internal::StringView("azbz")));
+  EXPECT_TRUE(m3.Matches(absl::string_view("az1")));
-  EXPECT_TRUE(m3.Matches(internal::StringView("az1")));
+  EXPECT_FALSE(m3.Matches(absl::string_view("1a")));
-  EXPECT_FALSE(m3.Matches(internal::StringView("1a")));
+  EXPECT_FALSE(m3.Matches(absl::string_view()));
-  EXPECT_FALSE(m3.Matches(internal::StringView()));
+  const Matcher<const absl::string_view&> m4 = ContainsRegex("");
-  const Matcher<const internal::StringView&> m4 = ContainsRegex("");
+  EXPECT_TRUE(m4.Matches(absl::string_view("")));
-  EXPECT_TRUE(m4.Matches(internal::StringView("")));
+  EXPECT_TRUE(m4.Matches(absl::string_view()));
-  EXPECT_TRUE(m4.Matches(internal::StringView()));
+#endif  // GTEST_HAS_ABSL
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 
 TEST(ContainsRegexTest, CanDescribeSelf) {
@@ -1762,10 +1760,10 @@ TEST(ContainsRegexTest, CanDescribeSelf) {
   Matcher<const char*> m2 = ContainsRegex(new RE("a.*"));
   EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2));
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  Matcher<const internal::StringView> m3 = ContainsRegex(new RE("0.*"));
+  Matcher<const absl::string_view> m3 = ContainsRegex(new RE("0.*"));
   EXPECT_EQ("contains regular expression \"0.*\"", Describe(m3));
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 }
 
 // Tests for wide strings.
@@ -4726,18 +4724,20 @@ TEST(SizeIsTest, ExplainsResult) {
   Matcher<vector<int> > m1 = SizeIs(2);
   Matcher<vector<int> > m2 = SizeIs(Lt(2u));
   Matcher<vector<int> > m3 = SizeIs(AnyOf(0, 3));
-  Matcher<vector<int> > m4 = SizeIs(Gt(1u));
+  Matcher<vector<int> > m4 = SizeIs(GreaterThan(1));
   vector<int> container;
   EXPECT_EQ("whose size 0 doesn't match", Explain(m1, container));
   EXPECT_EQ("whose size 0 matches", Explain(m2, container));
   EXPECT_EQ("whose size 0 matches", Explain(m3, container));
-  EXPECT_EQ("whose size 0 doesn't match", Explain(m4, container));
+  EXPECT_EQ("whose size 0 doesn't match, which is 1 less than 1",
+            Explain(m4, container));
   container.push_back(0);
   container.push_back(0);
   EXPECT_EQ("whose size 2 matches", Explain(m1, container));
   EXPECT_EQ("whose size 2 doesn't match", Explain(m2, container));
   EXPECT_EQ("whose size 2 doesn't match", Explain(m3, container));
-  EXPECT_EQ("whose size 2 matches", Explain(m4, container));
+  EXPECT_EQ("whose size 2 matches, which is 1 more than 1",
+            Explain(m4, container));
 }
 
 #if GTEST_HAS_TYPED_TEST

googletest/README.md

@@ -189,9 +189,9 @@ or
 
 When Google Test uses pthread, you may need to add flags to your compiler and/or
 linker to select the pthread library, or you'll get link errors. If you use the
-CMake script, this is taken care of for you. If you use your own build script,
+CMake script or the deprecated Autotools script, this is taken care of for you.
-you'll need to read your compiler and linker's manual to figure out what flags
+If you use your own build script, you'll need to read your compiler and linker's
-to add.
+manual to figure out what flags to add.
 
 ### As a Shared Library (DLL)
 

googletest/docs/advanced.md

@@ -2116,15 +2116,6 @@ For example:
     everything in test suite `FooTest` except `FooTest.Bar` and everything in
     test suite `BarTest` except `BarTest.Foo`.
 
-#### Stop test execution upon first failure
-
-By default, a googletest program runs all tests the user has defined. In some
-cases (e.g. iterative test development & execution) it may be desirable stop
-test execution upon first failure (trading improved latency for completeness).
-If `GTEST_FAIL_FAST` environment variable or `--gtest_fail_fast` flag is set,
-the test runner will stop execution as soon as the first test failure is
-found.
-
 #### Temporarily Disabling Tests
 
 If you have a broken test that you cannot fix right away, you can add the

googletest/include/gtest/gtest-matchers.h

@@ -384,18 +384,18 @@ class GTEST_API_ Matcher<std::string>
   Matcher(const char* s);  // NOLINT
 };
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
 // The following two specializations allow the user to write str
 // instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view
 // matcher is expected.
 template <>
-class GTEST_API_ Matcher<const internal::StringView&>
+class GTEST_API_ Matcher<const absl::string_view&>
-    : public internal::MatcherBase<const internal::StringView&> {
+    : public internal::MatcherBase<const absl::string_view&> {
  public:
   Matcher() {}
 
-  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
+  explicit Matcher(const MatcherInterface<const absl::string_view&>* impl)
-      : internal::MatcherBase<const internal::StringView&>(impl) {}
+      : internal::MatcherBase<const absl::string_view&>(impl) {}
 
   // Allows the user to write str instead of Eq(str) sometimes, where
   // str is a std::string object.
@@ -404,20 +404,20 @@ class GTEST_API_ Matcher<const internal::StringView&>
   // Allows the user to write "foo" instead of Eq("foo") sometimes.
   Matcher(const char* s);  // NOLINT
 
-  // Allows the user to pass absl::string_views or std::string_views directly.
+  // Allows the user to pass absl::string_views directly.
-  Matcher(internal::StringView s);  // NOLINT
+  Matcher(absl::string_view s);  // NOLINT
 };
 
 template <>
-class GTEST_API_ Matcher<internal::StringView>
+class GTEST_API_ Matcher<absl::string_view>
-    : public internal::MatcherBase<internal::StringView> {
+    : public internal::MatcherBase<absl::string_view> {
  public:
   Matcher() {}
 
-  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
+  explicit Matcher(const MatcherInterface<const absl::string_view&>* impl)
-      : internal::MatcherBase<internal::StringView>(impl) {}
+      : internal::MatcherBase<absl::string_view>(impl) {}
-  explicit Matcher(const MatcherInterface<internal::StringView>* impl)
+  explicit Matcher(const MatcherInterface<absl::string_view>* impl)
-      : internal::MatcherBase<internal::StringView>(impl) {}
+      : internal::MatcherBase<absl::string_view>(impl) {}
 
   // Allows the user to write str instead of Eq(str) sometimes, where
   // str is a std::string object.
@@ -426,10 +426,10 @@ class GTEST_API_ Matcher<internal::StringView>
   // Allows the user to write "foo" instead of Eq("foo") sometimes.
   Matcher(const char* s);  // NOLINT
 
-  // Allows the user to pass absl::string_views or std::string_views directly.
+  // Allows the user to pass absl::string_views directly.
-  Matcher(internal::StringView s);  // NOLINT
+  Matcher(absl::string_view s);  // NOLINT
 };
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
 // Prints a matcher in a human-readable format.
 template <typename T>
@@ -620,12 +620,12 @@ class MatchesRegexMatcher {
   MatchesRegexMatcher(const RE* regex, bool full_match)
       : regex_(regex), full_match_(full_match) {}
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-  bool MatchAndExplain(const internal::StringView& s,
+  bool MatchAndExplain(const absl::string_view& s,
                        MatchResultListener* listener) const {
     return MatchAndExplain(std::string(s), listener);
   }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
   // Accepts pointer types, particularly:
   //   const char*

googletest/include/gtest/gtest-printers.h

@@ -119,91 +119,105 @@
 
 namespace testing {
 
-// Definitions in the internal* namespaces are subject to change without notice.
+// Definitions in the 'internal' and 'internal2' name spaces are
-// DO NOT USE THEM IN USER CODE!
+// subject to change without notice.  DO NOT USE THEM IN USER CODE!
-namespace internal {
+namespace internal2 {
+
+// Prints the given number of bytes in the given object to the given
+// ostream.
+GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
+                                     size_t count,
+                                     ::std::ostream* os);
+
+// For selecting which printer to use when a given type has neither <<
+// nor PrintTo().
+enum TypeKind {
+  kProtobuf,              // a protobuf type
+  kConvertibleToInteger,  // a type implicitly convertible to BiggestInt
+                          // (e.g. a named or unnamed enum type)
+#if GTEST_HAS_ABSL
+  kConvertibleToStringView,  // a type implicitly convertible to
+                             // absl::string_view
+#endif
+  kOtherType  // anything else
+};
+
+// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
+// by the universal printer to print a value of type T when neither
+// operator<< nor PrintTo() is defined for T, where kTypeKind is the
+// "kind" of T as defined by enum TypeKind.
+template <typename T, TypeKind kTypeKind>
+class TypeWithoutFormatter {
+ public:
+  // This default version is called when kTypeKind is kOtherType.
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    PrintBytesInObjectTo(
+        static_cast<const unsigned char*>(
+            reinterpret_cast<const void*>(std::addressof(value))),
+        sizeof(value), os);
+  }
+};
+
+// We print a protobuf using its ShortDebugString() when the string
+// doesn't exceed this many characters; otherwise we print it using
+// DebugString() for better readability.
+const size_t kProtobufOneLinerMaxLength = 50;
 
 template <typename T>
-void UniversalPrint(const T& value, ::std::ostream* os);
+class TypeWithoutFormatter<T, kProtobuf> {
-
+ public:
-// Used to print an STL-style container when the user doesn't define
+  static void PrintValue(const T& value, ::std::ostream* os) {
-// a PrintTo() for it.
+    std::string pretty_str = value.ShortDebugString();
-struct ContainerPrinter {
+    if (pretty_str.length() > kProtobufOneLinerMaxLength) {
-  template <typename T,
+      pretty_str = "\n" + value.DebugString();
-            typename = typename std::enable_if<
-                (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
-                !IsRecursiveContainer<T>::value>::type>
-  static void PrintValue(const T& container, std::ostream* os) {
-    const size_t kMaxCount = 32;  // The maximum number of elements to print.
-    *os << '{';
-    size_t count = 0;
-    for (auto&& elem : container) {
-      if (count > 0) {
-        *os << ',';
-        if (count == kMaxCount) {  // Enough has been printed.
-          *os << " ...";
-          break;
-        }
-      }
-      *os << ' ';
-      // We cannot call PrintTo(elem, os) here as PrintTo() doesn't
-      // handle `elem` being a native array.
-      internal::UniversalPrint(elem, os);
-      ++count;
     }
-
+    *os << ("<" + pretty_str + ">");
-    if (count > 0) {
-      *os << ' ';
-    }
-    *os << '}';
   }
 };
 
-// Used to print a pointer that is neither a char pointer nor a member
+template <typename T>
-// pointer, when the user doesn't define PrintTo() for it.  (A member
+class TypeWithoutFormatter<T, kConvertibleToInteger> {
-// variable pointer or member function pointer doesn't really point to
+ public:
-// a location in the address space.  Their representation is
+  // Since T has no << operator or PrintTo() but can be implicitly
-// implementation-defined.  Therefore they will be printed as raw
+  // converted to BiggestInt, we print it as a BiggestInt.
-// bytes.)
+  //
-struct FunctionPointerPrinter {
+  // Most likely T is an enum type (either named or unnamed), in which
-  template <typename T, typename = typename std::enable_if<
+  // case printing it as an integer is the desired behavior.  In case
-                            std::is_function<T>::value>::type>
+  // T is not an enum, printing it as an integer is the best we can do
-  static void PrintValue(T* p, ::std::ostream* os) {
+  // given that it has no user-defined printer.
-    if (p == nullptr) {
+  static void PrintValue(const T& value, ::std::ostream* os) {
-      *os << "NULL";
+    const internal::BiggestInt kBigInt = value;
-    } else {
+    *os << kBigInt;
-      // T is a function type, so '*os << p' doesn't do what we want
-      // (it just prints p as bool).  We want to print p as a const
-      // void*.
-      *os << reinterpret_cast<const void*>(p);
-    }
   }
 };
 
-struct PointerPrinter {
+#if GTEST_HAS_ABSL
-  template <typename T>
+template <typename T>
-  static void PrintValue(T* p, ::std::ostream* os) {
+class TypeWithoutFormatter<T, kConvertibleToStringView> {
-    if (p == nullptr) {
+ public:
-      *os << "NULL";
+  // Since T has neither operator<< nor PrintTo() but can be implicitly
-    } else {
+  // converted to absl::string_view, we print it as a absl::string_view.
-      // T is not a function type.  We just call << to print p,
+  //
-      // relying on ADL to pick up user-defined << for their pointer
+  // Note: the implementation is further below, as it depends on
-      // types, if any.
+  // internal::PrintTo symbol which is defined later in the file.
-      *os << p;
+  static void PrintValue(const T& value, ::std::ostream* os);
-    }
-  }
 };
+#endif
 
-namespace internal_stream {
+// Prints the given value to the given ostream.  If the value is a
-
+// protocol message, its debug string is printed; if it's an enum or
-struct Sentinel;
+// of a type implicitly convertible to BiggestInt, it's printed as an
-template <typename Char, typename CharTraits, typename T>
+// integer; otherwise the bytes in the value are printed.  This is
-Sentinel* operator<<(::std::basic_ostream<Char, CharTraits>& os, const T& x);
+// what UniversalPrinter<T>::Print() does when it knows nothing about
-
+// type T and T has neither << operator nor PrintTo().
-// Check if the user has a user-defined operator<< for their type.
 //
-// We put this in its own namespace to inject a custom operator<< that allows us
+// A user can override this behavior for a class type Foo by defining
-// to probe the type's operator.
+// a << operator in the namespace where Foo is defined.
+//
+// We put this operator in namespace 'internal2' instead of 'internal'
+// to simplify the implementation, as much code in 'internal' needs to
+// use << in STL, which would conflict with our own << were it defined
+// in 'internal'.
 //
 // Note that this operator<< takes a generic std::basic_ostream<Char,
 // CharTraits> type instead of the more restricted std::ostream.  If
@@ -214,106 +228,68 @@ Sentinel* operator<<(::std::basic_ostream<Char, CharTraits>& os, const T& x);
 // operator<<(std::ostream&, const T&) or
 // operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
 // specific.
-template <typename T>
+template <typename Char, typename CharTraits, typename T>
-constexpr bool UseStreamOperator() {
+::std::basic_ostream<Char, CharTraits>& operator<<(
-  return !std::is_same<decltype(std::declval<std::ostream&>()
+    ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
-                                << std::declval<const T&>()),
+  TypeWithoutFormatter<T, (internal::IsAProtocolMessage<T>::value
-                       Sentinel*>::value;
+                               ? kProtobuf
-}
+                               : std::is_convertible<
-
+                                     const T&, internal::BiggestInt>::value
-}  // namespace internal_stream
+                                     ? kConvertibleToInteger
-
+                                     :
-struct StreamPrinter {
+#if GTEST_HAS_ABSL
-  template <typename T, typename = typename std::enable_if<
+                                     std::is_convertible<
-                            internal_stream::UseStreamOperator<T>()>::type>
+                                         const T&, absl::string_view>::value
-  static void PrintValue(const T& value, ::std::ostream* os) {
+                                         ? kConvertibleToStringView
-    *os << value;
+                                         :
-  }
-};
-
-struct ProtobufPrinter {
-  // We print a protobuf using its ShortDebugString() when the string
-  // doesn't exceed this many characters; otherwise we print it using
-  // DebugString() for better readability.
-  static const size_t kProtobufOneLinerMaxLength = 50;
-
-  template <typename T, typename = typename std::enable_if<
-                            internal::IsAProtocolMessage<T>::value>::type>
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    std::string pretty_str = value.ShortDebugString();
-    if (pretty_str.length() > kProtobufOneLinerMaxLength) {
-      pretty_str = "\n" + value.DebugString();
-    }
-    *os << ("<" + pretty_str + ">");
-  }
-};
-
-struct ConvertibleToIntegerPrinter {
-  // Since T has no << operator or PrintTo() but can be implicitly
-  // converted to BiggestInt, we print it as a BiggestInt.
-  //
-  // Most likely T is an enum type (either named or unnamed), in which
-  // case printing it as an integer is the desired behavior.  In case
-  // T is not an enum, printing it as an integer is the best we can do
-  // given that it has no user-defined printer.
-  static void PrintValue(internal::BiggestInt value, ::std::ostream* os) {
-    *os << value;
-  }
-};
-
-struct ConvertibleToStringViewPrinter {
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  static void PrintValue(internal::StringView value, ::std::ostream* os) {
-    internal::UniversalPrint(value, os);
-  }
 #endif
-};
+                                         kOtherType)>::PrintValue(x, &os);
-
+  return os;
-
-// Prints the given number of bytes in the given object to the given
-// ostream.
-GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
-                                     size_t count,
-                                     ::std::ostream* os);
-struct FallbackPrinter {
-  template <typename T>
-  static void PrintValue(const T& value, ::std::ostream* os) {
-    PrintBytesInObjectTo(
-        static_cast<const unsigned char*>(
-            reinterpret_cast<const void*>(std::addressof(value))),
-        sizeof(value), os);
-  }
-};
-
-// Try every printer in order and return the first one that works.
-template <typename T, typename E, typename Printer, typename... Printers>
-struct FindFirstPrinter : FindFirstPrinter<T, E, Printers...> {};
-
-template <typename T, typename Printer, typename... Printers>
-struct FindFirstPrinter<
-    T, decltype(Printer::PrintValue(std::declval<const T&>(), nullptr)),
-    Printer, Printers...> {
-  using type = Printer;
-};
-
-// Select the best printer in the following order:
-//  - Print containers (they have begin/end/etc).
-//  - Print function pointers.
-//  - Print object pointers.
-//  - Use the stream operator, if available.
-//  - Print protocol buffers.
-//  - Print types convertible to BiggestInt.
-//  - Print types convertible to StringView, if available.
-//  - Fallback to printing the raw bytes of the object.
-template <typename T>
-void PrintWithFallback(const T& value, ::std::ostream* os) {
-  using Printer = typename FindFirstPrinter<
-      T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
-      StreamPrinter, ProtobufPrinter, ConvertibleToIntegerPrinter,
-      ConvertibleToStringViewPrinter, FallbackPrinter>::type;
-  Printer::PrintValue(value, os);
 }
 
+}  // namespace internal2
+}  // namespace testing
+
+// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
+// magic needed for implementing UniversalPrinter won't work.
+namespace testing_internal {
+
+// Used to print a value that is not an STL-style container when the
+// user doesn't define PrintTo() for it.
+template <typename T>
+void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
+  // With the following statement, during unqualified name lookup,
+  // testing::internal2::operator<< appears as if it was declared in
+  // the nearest enclosing namespace that contains both
+  // ::testing_internal and ::testing::internal2, i.e. the global
+  // namespace.  For more details, refer to the C++ Standard section
+  // 7.3.4-1 [namespace.udir].  This allows us to fall back onto
+  // testing::internal2::operator<< in case T doesn't come with a <<
+  // operator.
+
+  using ::testing::internal2::operator<<;
+
+  // Assuming T is defined in namespace foo, in the next statement,
+  // the compiler will consider all of:
+  //
+  //   1. foo::operator<< (thanks to Koenig look-up),
+  //   2. ::operator<< (as the current namespace is enclosed in ::),
+  //   3. testing::internal2::operator<< (thanks to the using statement above).
+  //
+  // The operator<< whose type matches T best will be picked.
+  //
+  // We deliberately allow #2 to be a candidate, as sometimes it's
+  // impossible to define #1 (e.g. when foo is ::std, defining
+  // anything in it is undefined behavior unless you are a compiler
+  // vendor.).
+  *os << value;
+}
+
+}  // namespace testing_internal
+
+namespace testing {
+namespace internal {
+
 // FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
 // value of type ToPrint that is an operand of a comparison assertion
 // (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
@@ -411,6 +387,85 @@ std::string FormatForComparisonFailureMessage(
 template <typename T>
 class UniversalPrinter;
 
+template <typename T>
+void UniversalPrint(const T& value, ::std::ostream* os);
+
+enum DefaultPrinterType {
+  kPrintContainer,
+  kPrintPointer,
+  kPrintFunctionPointer,
+  kPrintOther,
+};
+template <DefaultPrinterType type> struct WrapPrinterType {};
+
+// Used to print an STL-style container when the user doesn't define
+// a PrintTo() for it.
+template <typename C>
+void DefaultPrintTo(WrapPrinterType<kPrintContainer> /* dummy */,
+                    const C& container, ::std::ostream* os) {
+  const size_t kMaxCount = 32;  // The maximum number of elements to print.
+  *os << '{';
+  size_t count = 0;
+  for (typename C::const_iterator it = container.begin();
+       it != container.end(); ++it, ++count) {
+    if (count > 0) {
+      *os << ',';
+      if (count == kMaxCount) {  // Enough has been printed.
+        *os << " ...";
+        break;
+      }
+    }
+    *os << ' ';
+    // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
+    // handle *it being a native array.
+    internal::UniversalPrint(*it, os);
+  }
+
+  if (count > 0) {
+    *os << ' ';
+  }
+  *os << '}';
+}
+
+// Used to print a pointer that is neither a char pointer nor a member
+// pointer, when the user doesn't define PrintTo() for it.  (A member
+// variable pointer or member function pointer doesn't really point to
+// a location in the address space.  Their representation is
+// implementation-defined.  Therefore they will be printed as raw
+// bytes.)
+template <typename T>
+void DefaultPrintTo(WrapPrinterType<kPrintPointer> /* dummy */,
+                    T* p, ::std::ostream* os) {
+  if (p == nullptr) {
+    *os << "NULL";
+  } else {
+    // T is not a function type.  We just call << to print p,
+    // relying on ADL to pick up user-defined << for their pointer
+    // types, if any.
+    *os << p;
+  }
+}
+template <typename T>
+void DefaultPrintTo(WrapPrinterType<kPrintFunctionPointer> /* dummy */,
+                    T* p, ::std::ostream* os) {
+  if (p == nullptr) {
+    *os << "NULL";
+  } else {
+    // T is a function type, so '*os << p' doesn't do what we want
+    // (it just prints p as bool).  We want to print p as a const
+    // void*.
+    *os << reinterpret_cast<const void*>(p);
+  }
+}
+
+// Used to print a non-container, non-pointer value when the user
+// doesn't define PrintTo() for it.
+template <typename T>
+void DefaultPrintTo(WrapPrinterType<kPrintOther> /* dummy */,
+                    const T& value, ::std::ostream* os) {
+  ::testing_internal::DefaultPrintNonContainerTo(value, os);
+}
+
 // Prints the given value using the << operator if it has one;
 // otherwise prints the bytes in it.  This is what
 // UniversalPrinter<T>::Print() does when PrintTo() is not specialized
@@ -424,7 +479,36 @@ class UniversalPrinter;
 // wants).
 template <typename T>
 void PrintTo(const T& value, ::std::ostream* os) {
-  internal::PrintWithFallback(value, os);
+  // DefaultPrintTo() is overloaded.  The type of its first argument
+  // determines which version will be picked.
+  //
+  // Note that we check for container types here, prior to we check
+  // for protocol message types in our operator<<.  The rationale is:
+  //
+  // For protocol messages, we want to give people a chance to
+  // override Google Mock's format by defining a PrintTo() or
+  // operator<<.  For STL containers, other formats can be
+  // incompatible with Google Mock's format for the container
+  // elements; therefore we check for container types here to ensure
+  // that our format is used.
+  //
+  // Note that MSVC and clang-cl do allow an implicit conversion from
+  // pointer-to-function to pointer-to-object, but clang-cl warns on it.
+  // So don't use ImplicitlyConvertible if it can be helped since it will
+  // cause this warning, and use a separate overload of DefaultPrintTo for
+  // function pointers so that the `*os << p` in the object pointer overload
+  // doesn't cause that warning either.
+  DefaultPrintTo(
+      WrapPrinterType <
+                  (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
+              !IsRecursiveContainer<T>::value
+          ? kPrintContainer
+          : !std::is_pointer<T>::value
+                ? kPrintOther
+                : std::is_function<typename std::remove_pointer<T>::type>::value
+                      ? kPrintFunctionPointer
+                      : kPrintPointer > (),
+      value, os);
 }
 
 // The following list of PrintTo() overloads tells
@@ -517,12 +601,12 @@ inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
 }
 #endif  // GTEST_HAS_STD_WSTRING
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-// Overload for internal::StringView.
+// Overload for absl::string_view.
-inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
+inline void PrintTo(absl::string_view sp, ::std::ostream* os) {
   PrintTo(::std::string(sp), os);
 }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
 inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
 
@@ -815,6 +899,16 @@ Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
 
 }  // namespace internal
 
+#if GTEST_HAS_ABSL
+namespace internal2 {
+template <typename T>
+void TypeWithoutFormatter<T, kConvertibleToStringView>::PrintValue(
+    const T& value, ::std::ostream* os) {
+  internal::PrintTo(absl::string_view(value), os);
+}
+}  // namespace internal2
+#endif
+
 template <typename T>
 ::std::string PrintToString(const T& value) {
   ::std::stringstream ss;

googletest/include/gtest/gtest.h

@@ -101,10 +101,6 @@ GTEST_DECLARE_bool_(catch_exceptions);
 // to let Google Test decide.
 GTEST_DECLARE_string_(color);
 
-// This flag controls whether the test runner should continue execution past
-// first failure.
-GTEST_DECLARE_bool_(fail_fast);
-
 // This flag sets up the filter to select by name using a glob pattern
 // the tests to run. If the filter is not given all tests are executed.
 GTEST_DECLARE_string_(filter);
@@ -799,9 +795,6 @@ class GTEST_API_ TestInfo {
   // deletes it.
   void Run();
 
-  // Skip and records the test result for this object.
-  void Skip();
-
   static void ClearTestResult(TestInfo* test_info) {
     test_info->result_.Clear();
   }
@@ -950,9 +943,6 @@ class GTEST_API_ TestSuite {
   // Runs every test in this TestSuite.
   void Run();
 
-  // Skips the execution of tests under this TestSuite
-  void Skip();
-
   // Runs SetUpTestSuite() for this TestSuite.  This wrapper is needed
   // for catching exceptions thrown from SetUpTestSuite().
   void RunSetUpTestSuite() {
@@ -1817,6 +1807,12 @@ class GTEST_API_ AssertHelper {
   GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
 };
 
+enum GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW };
+
+GTEST_API_ GTEST_ATTRIBUTE_PRINTF_(2, 3) void ColoredPrintf(GTestColor color,
+                                                            const char* fmt,
+                                                            ...);
+
 }  // namespace internal
 
 // The pure interface class that all value-parameterized tests inherit from.

googletest/include/gtest/internal/gtest-port.h

@@ -199,9 +199,6 @@
 //                                        suppressed (constant conditional).
 //   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
 //                                        is suppressed.
-//   GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or
-//                                    Matcher<absl::string_view>
-//                                    specializations.
 //
 // Synchronization:
 //   Mutex, MutexLock, ThreadLocal, GetThreadCount()
@@ -252,8 +249,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-
-#include <cerrno>
 #include <cstdint>
 #include <limits>
 #include <type_traits>
@@ -1962,16 +1957,16 @@ namespace posix {
 typedef struct _stat StatStruct;
 
 # ifdef __BORLANDC__
-inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int IsATTY(int fd) { return isatty(fd); }
 inline int StrCaseCmp(const char* s1, const char* s2) {
   return stricmp(s1, s2);
 }
 inline char* StrDup(const char* src) { return strdup(src); }
 # else  // !__BORLANDC__
 #  if GTEST_OS_WINDOWS_MOBILE
-inline int DoIsATTY(int /* fd */) { return 0; }
+inline int IsATTY(int /* fd */) { return 0; }
 #  else
-inline int DoIsATTY(int fd) { return _isatty(fd); }
+inline int IsATTY(int fd) { return _isatty(fd); }
 #  endif  // GTEST_OS_WINDOWS_MOBILE
 inline int StrCaseCmp(const char* s1, const char* s2) {
   return _stricmp(s1, s2);
@@ -1996,7 +1991,7 @@ inline bool IsDir(const StatStruct& st) {
 typedef struct stat StatStruct;
 
 inline int FileNo(FILE* file) { return fileno(file); }
-inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int IsATTY(int fd) { return isatty(fd); }
 inline int Stat(const char* path, StatStruct* buf) {
   // stat function not implemented on ESP8266
   return 0;
@@ -2013,7 +2008,7 @@ inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
 typedef struct stat StatStruct;
 
 inline int FileNo(FILE* file) { return fileno(file); }
-inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int IsATTY(int fd) { return isatty(fd); }
 inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
 inline int StrCaseCmp(const char* s1, const char* s2) {
   return strcasecmp(s1, s2);
@@ -2024,17 +2019,6 @@ inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
 
 #endif  // GTEST_OS_WINDOWS
 
-inline int IsATTY(int fd) {
-  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout
-  // to a file on Linux), which is unexpected, so save the previous value, and
-  // restore it after the call.
-  int savedErrno = errno;
-  int isAttyValue = DoIsATTY(fd);
-  errno = savedErrno;
-
-  return isAttyValue;
-}
-
 // Functions deprecated by MSVC 8.0.
 
 GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
@@ -2236,32 +2220,4 @@ const char* StringFromGTestEnv(const char* flag, const char* default_val);
 
 #endif  // !defined(GTEST_INTERNAL_DEPRECATED)
 
-#if GTEST_HAS_ABSL
-// Always use absl::string_view for Matcher<> specializations if googletest
-// is built with absl support.
-# define GTEST_INTERNAL_HAS_STRING_VIEW 1
-#include "absl/strings/string_view.h"
-namespace testing {
-namespace internal {
-using StringView = ::absl::string_view;
-}  // namespace internal
-}  // namespace testing
-#else
-# ifdef __has_include
-#   if __has_include(<string_view>) && __cplusplus >= 201703L
-// Otherwise for C++17 and higher use std::string_view for Matcher<>
-// specializations.
-#   define GTEST_INTERNAL_HAS_STRING_VIEW 1
-#include <string_view>
-namespace testing {
-namespace internal {
-using StringView = ::std::string_view;
-}  // namespace internal
-}  // namespace testing
-// The case where absl is configured NOT to alias std::string_view is not
-// supported.
-#  endif  // __has_include(<string_view>) && __cplusplus >= 201703L
-# endif  // __has_include
-#endif  // GTEST_HAS_ABSL
-
 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

googletest/samples/prime_tables.h

@@ -66,11 +66,11 @@ class OnTheFlyPrimeTable : public PrimeTable {
   }
 
   int GetNextPrime(int p) const override {
-    if (p < 0) return -1;
+    for (int n = p + 1; n > 0; n++) {
-
-    for (int n = p + 1;; n++) {
       if (IsPrime(n)) return n;
     }
+
+    return -1;
   }
 };
 

googletest/src/gtest-internal-inl.h

@@ -84,7 +84,6 @@ const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
 const char kBreakOnFailureFlag[] = "break_on_failure";
 const char kCatchExceptionsFlag[] = "catch_exceptions";
 const char kColorFlag[] = "color";
-const char kFailFast[] = "fail_fast";
 const char kFilterFlag[] = "filter";
 const char kListTestsFlag[] = "list_tests";
 const char kOutputFlag[] = "output";
@@ -165,7 +164,6 @@ class GTestFlagSaver {
     color_ = GTEST_FLAG(color);
     death_test_style_ = GTEST_FLAG(death_test_style);
     death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
-    fail_fast_ = GTEST_FLAG(fail_fast);
     filter_ = GTEST_FLAG(filter);
     internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
     list_tests_ = GTEST_FLAG(list_tests);
@@ -189,7 +187,6 @@ class GTestFlagSaver {
     GTEST_FLAG(death_test_style) = death_test_style_;
     GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
     GTEST_FLAG(filter) = filter_;
-    GTEST_FLAG(fail_fast) = fail_fast_;
     GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
     GTEST_FLAG(list_tests) = list_tests_;
     GTEST_FLAG(output) = output_;
@@ -211,7 +208,6 @@ class GTestFlagSaver {
   std::string color_;
   std::string death_test_style_;
   bool death_test_use_fork_;
-  bool fail_fast_;
   std::string filter_;
   std::string internal_run_death_test_;
   bool list_tests_;

googletest/src/gtest-matchers.cc

@@ -58,40 +58,40 @@ Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); }
 // s.
 Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); }
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
-// Constructs a matcher that matches a const StringView& whose value is
+// Constructs a matcher that matches a const absl::string_view& whose value is
 // equal to s.
-Matcher<const internal::StringView&>::Matcher(const std::string& s) {
+Matcher<const absl::string_view&>::Matcher(const std::string& s) {
   *this = Eq(s);
 }
 
-// Constructs a matcher that matches a const StringView& whose value is
+// Constructs a matcher that matches a const absl::string_view& whose value is
 // equal to s.
-Matcher<const internal::StringView&>::Matcher(const char* s) {
+Matcher<const absl::string_view&>::Matcher(const char* s) {
   *this = Eq(std::string(s));
 }
 
-// Constructs a matcher that matches a const StringView& whose value is
+// Constructs a matcher that matches a const absl::string_view& whose value is
 // equal to s.
-Matcher<const internal::StringView&>::Matcher(internal::StringView s) {
+Matcher<const absl::string_view&>::Matcher(absl::string_view s) {
   *this = Eq(std::string(s));
 }
 
-// Constructs a matcher that matches a StringView whose value is equal to
+// Constructs a matcher that matches a absl::string_view whose value is equal to
 // s.
-Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); }
+Matcher<absl::string_view>::Matcher(const std::string& s) { *this = Eq(s); }
 
-// Constructs a matcher that matches a StringView whose value is equal to
+// Constructs a matcher that matches a absl::string_view whose value is equal to
 // s.
-Matcher<internal::StringView>::Matcher(const char* s) {
+Matcher<absl::string_view>::Matcher(const char* s) {
   *this = Eq(std::string(s));
 }
 
-// Constructs a matcher that matches a StringView whose value is equal to
+// Constructs a matcher that matches a absl::string_view whose value is equal to
 // s.
-Matcher<internal::StringView>::Matcher(internal::StringView s) {
+Matcher<absl::string_view>::Matcher(absl::string_view s) {
   *this = Eq(std::string(s));
 }
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
 }  // namespace testing

googletest/src/gtest-printers.cc

@@ -104,7 +104,7 @@ void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
 
 }  // namespace
 
-namespace internal {
+namespace internal2 {
 
 // Delegates to PrintBytesInObjectToImpl() to print the bytes in the
 // given object.  The delegation simplifies the implementation, which
@@ -116,6 +116,10 @@ void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
   PrintBytesInObjectToImpl(obj_bytes, count, os);
 }
 
+}  // namespace internal2
+
+namespace internal {
+
 // Depending on the value of a char (or wchar_t), we print it in one
 // of three formats:
 //   - as is if it's a printable ASCII (e.g. 'a', '2', ' '),

googletest/src/gtest.cc

@@ -213,21 +213,6 @@ static const char* GetDefaultFilter() {
   return kUniversalFilter;
 }
 
-// Bazel passes in the argument to '--test_runner_fail_fast' via the
-// TESTBRIDGE_TEST_RUNNER_FAIL_FAST environment variable.
-static bool GetDefaultFailFast() {
-  const char* const testbridge_test_runner_fail_fast =
-      internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
-  if (testbridge_test_runner_fail_fast != nullptr) {
-    return strcmp(testbridge_test_runner_fail_fast, "1") == 0;
-  }
-  return false;
-}
-
-GTEST_DEFINE_bool_(
-    fail_fast, internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast()),
-    "True if and only if a test failure should stop further test execution.");
-
 GTEST_DEFINE_bool_(
     also_run_disabled_tests,
     internal::BoolFromGTestEnv("also_run_disabled_tests", false),
@@ -2283,7 +2268,7 @@ static const char* const kReservedOutputTestCaseAttributes[] = {
     "classname",   "name", "status", "time",   "type_param",
     "value_param", "file", "line",   "result", "timestamp"};
 
-template <size_t kSize>
+template <int kSize>
 std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
   return std::vector<std::string>(array, array + kSize);
 }
@@ -2878,28 +2863,6 @@ void TestInfo::Run() {
   impl->set_current_test_info(nullptr);
 }
 
-// Skip and records a skipped test result for this object.
-void TestInfo::Skip() {
-  if (!should_run_) return;
-
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->set_current_test_info(this);
-
-  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
-
-  // Notifies the unit test event listeners that a test is about to start.
-  repeater->OnTestStart(*this);
-
-  const TestPartResult test_part_result =
-      TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
-  impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
-      test_part_result);
-
-  // Notifies the unit test event listener that a test has just finished.
-  repeater->OnTestEnd(*this);
-  impl->set_current_test_info(nullptr);
-}
-
 // class TestSuite
 
 // Gets the number of successful tests in this test suite.
@@ -3012,12 +2975,6 @@ void TestSuite::Run() {
   start_timestamp_ = internal::GetTimeInMillis();
   for (int i = 0; i < total_test_count(); i++) {
     GetMutableTestInfo(i)->Run();
-    if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) {
-      for (int j = i + 1; j < total_test_count(); j++) {
-        GetMutableTestInfo(j)->Skip();
-      }
-      break;
-    }
   }
   elapsed_time_ = internal::GetTimeInMillis() - start_timestamp_;
 
@@ -3035,36 +2992,6 @@ void TestSuite::Run() {
   impl->set_current_test_suite(nullptr);
 }
 
-// Skips all tests under this TestSuite.
-void TestSuite::Skip() {
-  if (!should_run_) return;
-
-  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
-  impl->set_current_test_suite(this);
-
-  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
-
-  // Call both legacy and the new API
-  repeater->OnTestSuiteStart(*this);
-//  Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI
-  repeater->OnTestCaseStart(*this);
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI
-
-  for (int i = 0; i < total_test_count(); i++) {
-    GetMutableTestInfo(i)->Skip();
-  }
-
-  // Call both legacy and the new API
-  repeater->OnTestSuiteEnd(*this);
-  // Legacy API is deprecated but still available
-#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI
-  repeater->OnTestCaseEnd(*this);
-#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI
-
-  impl->set_current_test_suite(nullptr);
-}
-
 // Clears the results of all tests in this test suite.
 void TestSuite::ClearResult() {
   ad_hoc_test_result_.Clear();
@@ -3129,9 +3056,6 @@ static const char * TestPartResultTypeToString(TestPartResult::Type type) {
 }
 
 namespace internal {
-namespace {
-enum class GTestColor { kDefault, kRed, kGreen, kYellow };
-}  // namespace
 
 // Prints a TestPartResult to an std::string.
 static std::string PrintTestPartResultToString(
@@ -3169,12 +3093,9 @@ static void PrintTestPartResult(const TestPartResult& test_part_result) {
 // Returns the character attribute for the given color.
 static WORD GetColorAttribute(GTestColor color) {
   switch (color) {
-    case GTestColor::kRed:
+    case COLOR_RED:    return FOREGROUND_RED;
-      return FOREGROUND_RED;
+    case COLOR_GREEN:  return FOREGROUND_GREEN;
-    case GTestColor::kGreen:
+    case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN;
-      return FOREGROUND_GREEN;
-    case GTestColor::kYellow:
-      return FOREGROUND_RED | FOREGROUND_GREEN;
     default:           return 0;
   }
 }
@@ -3212,16 +3133,13 @@ static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
 
 #else
 
-// Returns the ANSI color code for the given color. GTestColor::kDefault is
+// Returns the ANSI color code for the given color.  COLOR_DEFAULT is
 // an invalid input.
 static const char* GetAnsiColorCode(GTestColor color) {
   switch (color) {
-    case GTestColor::kRed:
+    case COLOR_RED:     return "1";
-      return "1";
+    case COLOR_GREEN:   return "2";
-    case GTestColor::kGreen:
+    case COLOR_YELLOW:  return "3";
-      return "2";
-    case GTestColor::kYellow:
-      return "3";
     default:
       return nullptr;
   }
@@ -3270,7 +3188,6 @@ bool ShouldUseColor(bool stdout_is_tty) {
 // cannot simply emit special characters and have the terminal change colors.
 // This routine must actually emit the characters rather than return a string
 // that would be colored when printed, as can be done on Linux.
-
 void ColoredPrintf(GTestColor color, const char* fmt, ...) {
   va_list args;
   va_start(args, fmt);
@@ -3281,7 +3198,7 @@ void ColoredPrintf(GTestColor color, const char* fmt, ...) {
 #else
   static const bool in_color_mode =
       ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
-  const bool use_color = in_color_mode && (color != GTestColor::kDefault);
+  const bool use_color = in_color_mode && (color != COLOR_DEFAULT);
 #endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
 
   if (!use_color) {
@@ -3393,24 +3310,25 @@ void PrettyUnitTestResultPrinter::OnTestIterationStart(
   // Prints the filter if it's not *.  This reminds the user that some
   // tests may be skipped.
   if (!String::CStringEquals(filter, kUniversalFilter)) {
-    ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
+    ColoredPrintf(COLOR_YELLOW,
-                  filter);
+                  "Note: %s filter = %s\n", GTEST_NAME_, filter);
   }
 
   if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
     const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
-    ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
+    ColoredPrintf(COLOR_YELLOW,
+                  "Note: This is test shard %d of %s.\n",
                   static_cast<int>(shard_index) + 1,
                   internal::posix::GetEnv(kTestTotalShards));
   }
 
   if (GTEST_FLAG(shuffle)) {
-    ColoredPrintf(GTestColor::kYellow,
+    ColoredPrintf(COLOR_YELLOW,
                   "Note: Randomizing tests' orders with a seed of %d .\n",
                   unit_test.random_seed());
   }
 
-  ColoredPrintf(GTestColor::kGreen, "[==========] ");
+  ColoredPrintf(COLOR_GREEN,  "[==========] ");
   printf("Running %s from %s.\n",
          FormatTestCount(unit_test.test_to_run_count()).c_str(),
          FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
@@ -3419,7 +3337,7 @@ void PrettyUnitTestResultPrinter::OnTestIterationStart(
 
 void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
     const UnitTest& /*unit_test*/) {
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  ColoredPrintf(COLOR_GREEN,  "[----------] ");
   printf("Global test environment set-up.\n");
   fflush(stdout);
 }
@@ -3428,7 +3346,7 @@ void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
 void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
   const std::string counts =
       FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  ColoredPrintf(COLOR_GREEN, "[----------] ");
   printf("%s from %s", counts.c_str(), test_case.name());
   if (test_case.type_param() == nullptr) {
     printf("\n");
@@ -3442,7 +3360,7 @@ void PrettyUnitTestResultPrinter::OnTestSuiteStart(
     const TestSuite& test_suite) {
   const std::string counts =
       FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  ColoredPrintf(COLOR_GREEN, "[----------] ");
   printf("%s from %s", counts.c_str(), test_suite.name());
   if (test_suite.type_param() == nullptr) {
     printf("\n");
@@ -3454,7 +3372,7 @@ void PrettyUnitTestResultPrinter::OnTestSuiteStart(
 #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 
 void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
-  ColoredPrintf(GTestColor::kGreen, "[ RUN      ] ");
+  ColoredPrintf(COLOR_GREEN,  "[ RUN      ] ");
   PrintTestName(test_info.test_suite_name(), test_info.name());
   printf("\n");
   fflush(stdout);
@@ -3477,11 +3395,11 @@ void PrettyUnitTestResultPrinter::OnTestPartResult(
 
 void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
   if (test_info.result()->Passed()) {
-    ColoredPrintf(GTestColor::kGreen, "[       OK ] ");
+    ColoredPrintf(COLOR_GREEN, "[       OK ] ");
   } else if (test_info.result()->Skipped()) {
-    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+    ColoredPrintf(COLOR_GREEN, "[  SKIPPED ] ");
   } else {
-    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+    ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
   }
   PrintTestName(test_info.test_suite_name(), test_info.name());
   if (test_info.result()->Failed())
@@ -3502,7 +3420,7 @@ void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
 
   const std::string counts =
       FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  ColoredPrintf(COLOR_GREEN, "[----------] ");
   printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(),
          internal::StreamableToString(test_case.elapsed_time()).c_str());
   fflush(stdout);
@@ -3513,7 +3431,7 @@ void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) {
 
   const std::string counts =
       FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  ColoredPrintf(COLOR_GREEN, "[----------] ");
   printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(),
          internal::StreamableToString(test_suite.elapsed_time()).c_str());
   fflush(stdout);
@@ -3522,7 +3440,7 @@ void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) {
 
 void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
     const UnitTest& /*unit_test*/) {
-  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  ColoredPrintf(COLOR_GREEN,  "[----------] ");
   printf("Global test environment tear-down\n");
   fflush(stdout);
 }
@@ -3530,7 +3448,7 @@ void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
 // Internal helper for printing the list of failed tests.
 void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
   const int failed_test_count = unit_test.failed_test_count();
-  ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+  ColoredPrintf(COLOR_RED,  "[  FAILED  ] ");
   printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
 
   for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
@@ -3543,7 +3461,7 @@ void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
       if (!test_info.should_run() || !test_info.result()->Failed()) {
         continue;
       }
-      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
       printf("%s.%s", test_suite.name(), test_info.name());
       PrintFullTestCommentIfPresent(test_info);
       printf("\n");
@@ -3564,7 +3482,7 @@ void PrettyUnitTestResultPrinter::PrintFailedTestSuites(
       continue;
     }
     if (test_suite.ad_hoc_test_result().Failed()) {
-      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+      ColoredPrintf(COLOR_RED, "[  FAILED  ] ");
       printf("%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name());
       ++suite_failure_count;
     }
@@ -3592,7 +3510,7 @@ void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
       if (!test_info.should_run() || !test_info.result()->Skipped()) {
         continue;
       }
-      ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+      ColoredPrintf(COLOR_GREEN, "[  SKIPPED ] ");
       printf("%s.%s", test_suite.name(), test_info.name());
       printf("\n");
     }
@@ -3601,7 +3519,7 @@ void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
 
 void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
                                                      int /*iteration*/) {
-  ColoredPrintf(GTestColor::kGreen, "[==========] ");
+  ColoredPrintf(COLOR_GREEN,  "[==========] ");
   printf("%s from %s ran.",
          FormatTestCount(unit_test.test_to_run_count()).c_str(),
          FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
@@ -3610,12 +3528,12 @@ void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
            internal::StreamableToString(unit_test.elapsed_time()).c_str());
   }
   printf("\n");
-  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] ");
+  ColoredPrintf(COLOR_GREEN,  "[  PASSED  ] ");
   printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
 
   const int skipped_test_count = unit_test.skipped_test_count();
   if (skipped_test_count > 0) {
-    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+    ColoredPrintf(COLOR_GREEN, "[  SKIPPED ] ");
     printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
     PrintSkippedTests(unit_test);
   }
@@ -3630,8 +3548,10 @@ void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
     if (unit_test.Passed()) {
       printf("\n");  // Add a spacer if no FAILURE banner is displayed.
     }
-    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n",
+    ColoredPrintf(COLOR_YELLOW,
-                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
+                  "  YOU HAVE %d DISABLED %s\n\n",
+                  num_disabled,
+                  num_disabled == 1 ? "TEST" : "TESTS");
   }
   // Ensure that Google Test output is printed before, e.g., heapchecker output.
   fflush(stdout);
@@ -5596,13 +5516,6 @@ bool UnitTestImpl::RunAllTests() {
         for (int test_index = 0; test_index < total_test_suite_count();
              test_index++) {
           GetMutableSuiteCase(test_index)->Run();
-          if (GTEST_FLAG(fail_fast) &&
-              GetMutableSuiteCase(test_index)->Failed()) {
-            for (int j = test_index + 1; j < total_test_suite_count(); j++) {
-              GetMutableSuiteCase(j)->Skip();
-            }
-            break;
-          }
         }
       }
 
@@ -5641,14 +5554,14 @@ bool UnitTestImpl::RunAllTests() {
 
   if (!gtest_is_initialized_before_run_all_tests) {
     ColoredPrintf(
-        GTestColor::kRed,
+        COLOR_RED,
         "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
         "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
         "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
         " will start to enforce the valid usage. "
         "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT
 #if GTEST_FOR_GOOGLE_
-    ColoredPrintf(GTestColor::kRed,
+    ColoredPrintf(COLOR_RED,
                   "For more details, see http://wiki/Main/ValidGUnitMain.\n");
 #endif  // GTEST_FOR_GOOGLE_
   }
@@ -5665,7 +5578,7 @@ void WriteToShardStatusFileIfNeeded() {
   if (test_shard_file != nullptr) {
     FILE* const file = posix::FOpen(test_shard_file, "w");
     if (file == nullptr) {
-      ColoredPrintf(GTestColor::kRed,
+      ColoredPrintf(COLOR_RED,
                     "Could not write to the test shard status file \"%s\" "
                     "specified by the %s environment variable.\n",
                     test_shard_file, kTestShardStatusFile);
@@ -5699,7 +5612,7 @@ bool ShouldShard(const char* total_shards_env,
       << "Invalid environment variables: you have "
       << kTestShardIndex << " = " << shard_index
       << ", but have left " << kTestTotalShards << " unset.\n";
-    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
     fflush(stdout);
     exit(EXIT_FAILURE);
   } else if (total_shards != -1 && shard_index == -1) {
@@ -5707,7 +5620,7 @@ bool ShouldShard(const char* total_shards_env,
       << "Invalid environment variables: you have "
       << kTestTotalShards << " = " << total_shards
       << ", but have left " << kTestShardIndex << " unset.\n";
-    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
     fflush(stdout);
     exit(EXIT_FAILURE);
   } else if (shard_index < 0 || shard_index >= total_shards) {
@@ -5716,7 +5629,7 @@ bool ShouldShard(const char* total_shards_env,
       << kTestShardIndex << " < " << kTestTotalShards
       << ", but you have " << kTestShardIndex << "=" << shard_index
       << ", " << kTestTotalShards << "=" << total_shards << ".\n";
-    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    ColoredPrintf(COLOR_RED, "%s", msg.GetString().c_str());
     fflush(stdout);
     exit(EXIT_FAILURE);
   }
@@ -6106,7 +6019,7 @@ static bool HasGoogleTestFlagPrefix(const char* str) {
 //   @D    changes to the default terminal text color.
 //
 static void PrintColorEncoded(const char* str) {
-  GTestColor color = GTestColor::kDefault;  // The current color.
+  GTestColor color = COLOR_DEFAULT;  // The current color.
 
   // Conceptually, we split the string into segments divided by escape
   // sequences.  Then we print one segment at a time.  At the end of
@@ -6126,13 +6039,13 @@ static void PrintColorEncoded(const char* str) {
     if (ch == '@') {
       ColoredPrintf(color, "@");
     } else if (ch == 'D') {
-      color = GTestColor::kDefault;
+      color = COLOR_DEFAULT;
     } else if (ch == 'R') {
-      color = GTestColor::kRed;
+      color = COLOR_RED;
     } else if (ch == 'G') {
-      color = GTestColor::kGreen;
+      color = COLOR_GREEN;
     } else if (ch == 'Y') {
-      color = GTestColor::kYellow;
+      color = COLOR_YELLOW;
     } else {
       --str;
     }
@@ -6207,31 +6120,31 @@ static const char kColorEncodedHelpMessage[] =
 static bool ParseGoogleTestFlag(const char* const arg) {
   return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
                        &GTEST_FLAG(also_run_disabled_tests)) ||
-         ParseBoolFlag(arg, kBreakOnFailureFlag,
+      ParseBoolFlag(arg, kBreakOnFailureFlag,
-                       &GTEST_FLAG(break_on_failure)) ||
+                    &GTEST_FLAG(break_on_failure)) ||
-         ParseBoolFlag(arg, kCatchExceptionsFlag,
+      ParseBoolFlag(arg, kCatchExceptionsFlag,
-                       &GTEST_FLAG(catch_exceptions)) ||
+                    &GTEST_FLAG(catch_exceptions)) ||
-         ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
+      ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
-         ParseStringFlag(arg, kDeathTestStyleFlag,
+      ParseStringFlag(arg, kDeathTestStyleFlag,
-                         &GTEST_FLAG(death_test_style)) ||
+                      &GTEST_FLAG(death_test_style)) ||
-         ParseBoolFlag(arg, kDeathTestUseFork,
+      ParseBoolFlag(arg, kDeathTestUseFork,
-                       &GTEST_FLAG(death_test_use_fork)) ||
+                    &GTEST_FLAG(death_test_use_fork)) ||
-         ParseBoolFlag(arg, kFailFast, &GTEST_FLAG(fail_fast)) ||
+      ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
-         ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
+      ParseStringFlag(arg, kInternalRunDeathTestFlag,
-         ParseStringFlag(arg, kInternalRunDeathTestFlag,
+                      &GTEST_FLAG(internal_run_death_test)) ||
-                         &GTEST_FLAG(internal_run_death_test)) ||
+      ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
-         ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
+      ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
-         ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
+      ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
-         ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
+      ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) ||
-         ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) ||
+      ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
-         ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
+      ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
-         ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
+      ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
-         ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
+      ParseInt32Flag(arg, kStackTraceDepthFlag,
-         ParseInt32Flag(arg, kStackTraceDepthFlag,
+                     &GTEST_FLAG(stack_trace_depth)) ||
-                        &GTEST_FLAG(stack_trace_depth)) ||
+      ParseStringFlag(arg, kStreamResultToFlag,
-         ParseStringFlag(arg, kStreamResultToFlag,
+                      &GTEST_FLAG(stream_result_to)) ||
-                         &GTEST_FLAG(stream_result_to)) ||
+      ParseBoolFlag(arg, kThrowOnFailureFlag,
-         ParseBoolFlag(arg, kThrowOnFailureFlag, &GTEST_FLAG(throw_on_failure));
+                    &GTEST_FLAG(throw_on_failure));
 }
 
 #if GTEST_USE_OWN_FLAGFILE_FLAG_

googletest/test/BUILD.bazel

@@ -28,6 +28,8 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
+# Author: misterg@google.com (Gennadiy Civil)
+#
 # Bazel BUILD for The Google C++ Testing Framework (Google Test)
 
 load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_test")
@@ -58,7 +60,6 @@ cc_test(
             "googletest-catch-exceptions-test_.cc",
             "googletest-color-test_.cc",
             "googletest-env-var-test_.cc",
-            "googletest-failfast-unittest_.cc",
             "googletest-filter-unittest_.cc",
             "googletest-break-on-failure-unittest_.cc",
             "googletest-listener-test.cc",
@@ -223,21 +224,6 @@ py_test(
     deps = [":gtest_test_utils"],
 )
 
-cc_binary(
-    name = "googletest-failfast-unittest_",
-    testonly = 1,
-    srcs = ["googletest-failfast-unittest_.cc"],
-    deps = ["//:gtest"],
-)
-
-py_test(
-    name = "googletest-failfast-unittest",
-    size = "medium",
-    srcs = ["googletest-failfast-unittest.py"],
-    data = [":googletest-failfast-unittest_"],
-    deps = [":gtest_test_utils"],
-)
-
 cc_binary(
     name = "googletest-filter-unittest_",
     testonly = 1,

googletest/test/googletest-env-var-test.py

@@ -85,8 +85,6 @@ class GTestEnvVarTest(gtest_test_utils.TestCase):
 
     TestFlag('break_on_failure', '1', '0')
     TestFlag('color', 'yes', 'auto')
-    SetEnvVar('TESTBRIDGE_TEST_RUNNER_FAIL_FAST', None)  # For 'fail_fast' test
-    TestFlag('fail_fast', '1', '0')
     TestFlag('filter', 'FooTest.Bar', '*')
     SetEnvVar('XML_OUTPUT_FILE', None)  # For 'output' test
     TestFlag('output', 'xml:tmp/foo.xml', '')

googletest/test/googletest-env-var-test_.cc

@@ -72,11 +72,6 @@ void PrintFlag(const char* flag) {
     return;
   }
 
-  if (strcmp(flag, "fail_fast") == 0) {
-    cout << GTEST_FLAG(fail_fast);
-    return;
-  }
-
   if (strcmp(flag, "filter") == 0) {
     cout << GTEST_FLAG(filter);
     return;

googletest/test/googletest-failfast-unittest.py

@@ -1,410 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2020 Google Inc. All Rights Reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-"""Unit test for Google Test fail_fast.
-
-A user can specify if a Google Test program should continue test execution
-after a test failure via the GTEST_FAIL_FAST environment variable or the
---gtest_fail_fast flag. The default value of the flag can also be changed
-by Bazel fail fast environment variable TESTBRIDGE_TEST_RUNNER_FAIL_FAST.
-
-This script tests such functionality by invoking googletest-failfast-unittest_
-(a program written with Google Test) with different environments and command
-line flags.
-"""
-
-import os
-import gtest_test_utils
-
-# Constants.
-
-# Bazel testbridge environment variable for fail fast
-BAZEL_FAIL_FAST_ENV_VAR = 'TESTBRIDGE_TEST_RUNNER_FAIL_FAST'
-
-# The environment variable for specifying fail fast.
-FAIL_FAST_ENV_VAR = 'GTEST_FAIL_FAST'
-
-# The command line flag for specifying fail fast.
-FAIL_FAST_FLAG = 'gtest_fail_fast'
-
-# The command line flag to run disabled tests.
-RUN_DISABLED_FLAG = 'gtest_also_run_disabled_tests'
-
-# The command line flag for specifying a filter.
-FILTER_FLAG = 'gtest_filter'
-
-# Command to run the googletest-failfast-unittest_ program.
-COMMAND = gtest_test_utils.GetTestExecutablePath(
-    'googletest-failfast-unittest_')
-
-# The command line flag to tell Google Test to output the list of tests it
-# will run.
-LIST_TESTS_FLAG = '--gtest_list_tests'
-
-# Indicates whether Google Test supports death tests.
-SUPPORTS_DEATH_TESTS = 'HasDeathTest' in gtest_test_utils.Subprocess(
-    [COMMAND, LIST_TESTS_FLAG]).output
-
-# Utilities.
-
-environ = os.environ.copy()
-
-
-def SetEnvVar(env_var, value):
-  """Sets the env variable to 'value'; unsets it when 'value' is None."""
-
-  if value is not None:
-    environ[env_var] = value
-  elif env_var in environ:
-    del environ[env_var]
-
-
-def RunAndReturnOutput(test_suite=None, fail_fast=None, run_disabled=False):
-  """Runs the test program and returns its output."""
-
-  args = []
-  xml_path = os.path.join(gtest_test_utils.GetTempDir(),
-                          '.GTestFailFastUnitTest.xml')
-  args += ['--gtest_output=xml:' + xml_path]
-  if fail_fast is not None:
-    if isinstance(fail_fast, str):
-      args += ['--%s=%s' % (FAIL_FAST_FLAG, fail_fast)]
-    elif fail_fast:
-      args += ['--%s' % FAIL_FAST_FLAG]
-    else:
-      args += ['--no%s' % FAIL_FAST_FLAG]
-  if test_suite:
-    args += ['--%s=%s.*' % (FILTER_FLAG, test_suite)]
-  if run_disabled:
-    args += ['--%s' % RUN_DISABLED_FLAG]
-  txt_out = gtest_test_utils.Subprocess([COMMAND] + args, env=environ).output
-  with open(xml_path) as xml_file:
-    return txt_out, xml_file.read()
-
-
-# The unit test.
-class GTestFailFastUnitTest(gtest_test_utils.TestCase):
-  """Tests the env variable or the command line flag for fail_fast."""
-
-  def testDefaultBehavior(self):
-    """Tests the behavior of not specifying the fail_fast."""
-
-    txt, _ = RunAndReturnOutput()
-    self.assertIn('22 FAILED TEST', txt)
-
-  def testGoogletestFlag(self):
-    txt, _ = RunAndReturnOutput(test_suite='HasSimpleTest', fail_fast=True)
-    self.assertIn('1 FAILED TEST', txt)
-    self.assertIn('[  SKIPPED ] 3 tests', txt)
-
-    txt, _ = RunAndReturnOutput(test_suite='HasSimpleTest', fail_fast=False)
-    self.assertIn('4 FAILED TEST', txt)
-    self.assertNotIn('[  SKIPPED ]', txt)
-
-  def testGoogletestEnvVar(self):
-    """Tests the behavior of specifying fail_fast via Googletest env var."""
-
-    try:
-      SetEnvVar(FAIL_FAST_ENV_VAR, '1')
-      txt, _ = RunAndReturnOutput('HasSimpleTest')
-      self.assertIn('1 FAILED TEST', txt)
-      self.assertIn('[  SKIPPED ] 3 tests', txt)
-
-      SetEnvVar(FAIL_FAST_ENV_VAR, '0')
-      txt, _ = RunAndReturnOutput('HasSimpleTest')
-      self.assertIn('4 FAILED TEST', txt)
-      self.assertNotIn('[  SKIPPED ]', txt)
-    finally:
-      SetEnvVar(FAIL_FAST_ENV_VAR, None)
-
-  def testBazelEnvVar(self):
-    """Tests the behavior of specifying fail_fast via Bazel testbridge."""
-
-    try:
-      SetEnvVar(BAZEL_FAIL_FAST_ENV_VAR, '1')
-      txt, _ = RunAndReturnOutput('HasSimpleTest')
-      self.assertIn('1 FAILED TEST', txt)
-      self.assertIn('[  SKIPPED ] 3 tests', txt)
-
-      SetEnvVar(BAZEL_FAIL_FAST_ENV_VAR, '0')
-      txt, _ = RunAndReturnOutput('HasSimpleTest')
-      self.assertIn('4 FAILED TEST', txt)
-      self.assertNotIn('[  SKIPPED ]', txt)
-    finally:
-      SetEnvVar(BAZEL_FAIL_FAST_ENV_VAR, None)
-
-  def testFlagOverridesEnvVar(self):
-    """Tests precedence of flag over env var."""
-
-    try:
-      SetEnvVar(FAIL_FAST_ENV_VAR, '0')
-      txt, _ = RunAndReturnOutput('HasSimpleTest', True)
-      self.assertIn('1 FAILED TEST', txt)
-      self.assertIn('[  SKIPPED ] 3 tests', txt)
-    finally:
-      SetEnvVar(FAIL_FAST_ENV_VAR, None)
-
-  def testGoogletestEnvVarOverridesBazelEnvVar(self):
-    """Tests that the Googletest native env var over Bazel testbridge."""
-
-    try:
-      SetEnvVar(BAZEL_FAIL_FAST_ENV_VAR, '0')
-      SetEnvVar(FAIL_FAST_ENV_VAR, '1')
-      txt, _ = RunAndReturnOutput('HasSimpleTest')
-      self.assertIn('1 FAILED TEST', txt)
-      self.assertIn('[  SKIPPED ] 3 tests', txt)
-    finally:
-      SetEnvVar(FAIL_FAST_ENV_VAR, None)
-      SetEnvVar(BAZEL_FAIL_FAST_ENV_VAR, None)
-
-  def testEventListener(self):
-    txt, _ = RunAndReturnOutput(test_suite='HasSkipTest', fail_fast=True)
-    self.assertIn('1 FAILED TEST', txt)
-    self.assertIn('[  SKIPPED ] 3 tests', txt)
-    for expected_count, callback in [(1, 'OnTestSuiteStart'),
-                                     (5, 'OnTestStart'),
-                                     (5, 'OnTestEnd'),
-                                     (5, 'OnTestPartResult'),
-                                     (1, 'OnTestSuiteEnd')]:
-      self.assertEqual(
-          expected_count, txt.count(callback),
-          'Expected %d calls to callback %s match count on output: %s ' %
-          (expected_count, callback, txt))
-
-    txt, _ = RunAndReturnOutput(test_suite='HasSkipTest', fail_fast=False)
-    self.assertIn('3 FAILED TEST', txt)
-    self.assertIn('[  SKIPPED ] 1 test', txt)
-    for expected_count, callback in [(1, 'OnTestSuiteStart'),
-                                     (5, 'OnTestStart'),
-                                     (5, 'OnTestEnd'),
-                                     (5, 'OnTestPartResult'),
-                                     (1, 'OnTestSuiteEnd')]:
-      self.assertEqual(
-          expected_count, txt.count(callback),
-          'Expected %d calls to callback %s match count on output: %s ' %
-          (expected_count, callback, txt))
-
-  def assertXmlResultCount(self, result, count, xml):
-    self.assertEqual(
-        count, xml.count('result="%s"' % result),
-        'Expected \'result="%s"\' match count of %s: %s ' %
-        (result, count, xml))
-
-  def assertXmlStatusCount(self, status, count, xml):
-    self.assertEqual(
-        count, xml.count('status="%s"' % status),
-        'Expected \'status="%s"\' match count of %s: %s ' %
-        (status, count, xml))
-
-  def assertFailFastXmlAndTxtOutput(self,
-                                    fail_fast,
-                                    test_suite,
-                                    passed_count,
-                                    failure_count,
-                                    skipped_count,
-                                    suppressed_count,
-                                    run_disabled=False):
-    """Assert XML and text output of a test execution."""
-
-    txt, xml = RunAndReturnOutput(test_suite, fail_fast, run_disabled)
-    if failure_count > 0:
-      self.assertIn('%s FAILED TEST' % failure_count, txt)
-    if suppressed_count > 0:
-      self.assertIn('%s DISABLED TEST' % suppressed_count, txt)
-    if skipped_count > 0:
-      self.assertIn('[  SKIPPED ] %s tests' % skipped_count, txt)
-    self.assertXmlStatusCount('run',
-                              passed_count + failure_count + skipped_count, xml)
-    self.assertXmlStatusCount('notrun', suppressed_count, xml)
-    self.assertXmlResultCount('completed', passed_count + failure_count, xml)
-    self.assertXmlResultCount('skipped', skipped_count, xml)
-    self.assertXmlResultCount('suppressed', suppressed_count, xml)
-
-  def assertFailFastBehavior(self,
-                             test_suite,
-                             passed_count,
-                             failure_count,
-                             skipped_count,
-                             suppressed_count,
-                             run_disabled=False):
-    """Assert --fail_fast via flag."""
-
-    for fail_fast in ('true', '1', 't', True):
-      self.assertFailFastXmlAndTxtOutput(fail_fast, test_suite, passed_count,
-                                         failure_count, skipped_count,
-                                         suppressed_count, run_disabled)
-
-  def assertNotFailFastBehavior(self,
-                                test_suite,
-                                passed_count,
-                                failure_count,
-                                skipped_count,
-                                suppressed_count,
-                                run_disabled=False):
-    """Assert --nofail_fast via flag."""
-
-    for fail_fast in ('false', '0', 'f', False):
-      self.assertFailFastXmlAndTxtOutput(fail_fast, test_suite, passed_count,
-                                         failure_count, skipped_count,
-                                         suppressed_count, run_disabled)
-
-  def testFlag_HasFixtureTest(self):
-    """Tests the behavior of fail_fast and TEST_F."""
-    self.assertFailFastBehavior(
-        test_suite='HasFixtureTest',
-        passed_count=1,
-        failure_count=1,
-        skipped_count=3,
-        suppressed_count=0)
-    self.assertNotFailFastBehavior(
-        test_suite='HasFixtureTest',
-        passed_count=1,
-        failure_count=4,
-        skipped_count=0,
-        suppressed_count=0)
-
-  def testFlag_HasSimpleTest(self):
-    """Tests the behavior of fail_fast and TEST."""
-    self.assertFailFastBehavior(
-        test_suite='HasSimpleTest',
-        passed_count=1,
-        failure_count=1,
-        skipped_count=3,
-        suppressed_count=0)
-    self.assertNotFailFastBehavior(
-        test_suite='HasSimpleTest',
-        passed_count=1,
-        failure_count=4,
-        skipped_count=0,
-        suppressed_count=0)
-
-  def testFlag_HasParametersTest(self):
-    """Tests the behavior of fail_fast and TEST_P."""
-    self.assertFailFastBehavior(
-        test_suite='HasParametersSuite/HasParametersTest',
-        passed_count=0,
-        failure_count=1,
-        skipped_count=3,
-        suppressed_count=0)
-    self.assertNotFailFastBehavior(
-        test_suite='HasParametersSuite/HasParametersTest',
-        passed_count=0,
-        failure_count=4,
-        skipped_count=0,
-        suppressed_count=0)
-
-  def testFlag_HasDisabledTest(self):
-    """Tests the behavior of fail_fast and Disabled test cases."""
-    self.assertFailFastBehavior(
-        test_suite='HasDisabledTest',
-        passed_count=1,
-        failure_count=1,
-        skipped_count=2,
-        suppressed_count=1,
-        run_disabled=False)
-    self.assertNotFailFastBehavior(
-        test_suite='HasDisabledTest',
-        passed_count=1,
-        failure_count=3,
-        skipped_count=0,
-        suppressed_count=1,
-        run_disabled=False)
-
-  def testFlag_HasDisabledRunDisabledTest(self):
-    """Tests the behavior of fail_fast and Disabled test cases enabled."""
-    self.assertFailFastBehavior(
-        test_suite='HasDisabledTest',
-        passed_count=1,
-        failure_count=1,
-        skipped_count=3,
-        suppressed_count=0,
-        run_disabled=True)
-    self.assertNotFailFastBehavior(
-        test_suite='HasDisabledTest',
-        passed_count=1,
-        failure_count=4,
-        skipped_count=0,
-        suppressed_count=0,
-        run_disabled=True)
-
-  def testFlag_HasDisabledSuiteTest(self):
-    """Tests the behavior of fail_fast and Disabled test suites."""
-    self.assertFailFastBehavior(
-        test_suite='DISABLED_HasDisabledSuite',
-        passed_count=0,
-        failure_count=0,
-        skipped_count=0,
-        suppressed_count=5,
-        run_disabled=False)
-    self.assertNotFailFastBehavior(
-        test_suite='DISABLED_HasDisabledSuite',
-        passed_count=0,
-        failure_count=0,
-        skipped_count=0,
-        suppressed_count=5,
-        run_disabled=False)
-
-  def testFlag_HasDisabledSuiteRunDisabledTest(self):
-    """Tests the behavior of fail_fast and Disabled test suites enabled."""
-    self.assertFailFastBehavior(
-        test_suite='DISABLED_HasDisabledSuite',
-        passed_count=1,
-        failure_count=1,
-        skipped_count=3,
-        suppressed_count=0,
-        run_disabled=True)
-    self.assertNotFailFastBehavior(
-        test_suite='DISABLED_HasDisabledSuite',
-        passed_count=1,
-        failure_count=4,
-        skipped_count=0,
-        suppressed_count=0,
-        run_disabled=True)
-
-  if SUPPORTS_DEATH_TESTS:
-
-    def testFlag_HasDeathTest(self):
-      """Tests the behavior of fail_fast and death tests."""
-      self.assertFailFastBehavior(
-          test_suite='HasDeathTest',
-          passed_count=1,
-          failure_count=1,
-          skipped_count=3,
-          suppressed_count=0)
-      self.assertNotFailFastBehavior(
-          test_suite='HasDeathTest',
-          passed_count=1,
-          failure_count=4,
-          skipped_count=0,
-          suppressed_count=0)
-
-
-if __name__ == '__main__':
-  gtest_test_utils.Main()

googletest/test/googletest-failfast-unittest_.cc

@@ -1,167 +0,0 @@
-// Copyright 2005, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-// Unit test for Google Test test filters.
-//
-// A user can specify which test(s) in a Google Test program to run via
-// either the GTEST_FILTER environment variable or the --gtest_filter
-// flag.  This is used for testing such functionality.
-//
-// The program will be invoked from a Python unit test.  Don't run it
-// directly.
-
-#include "gtest/gtest.h"
-
-namespace {
-
-// Test HasFixtureTest.
-
-class HasFixtureTest : public testing::Test {};
-
-TEST_F(HasFixtureTest, Test0) {}
-
-TEST_F(HasFixtureTest, Test1) { FAIL() << "Expected failure."; }
-
-TEST_F(HasFixtureTest, Test2) { FAIL() << "Expected failure."; }
-
-TEST_F(HasFixtureTest, Test3) { FAIL() << "Expected failure."; }
-
-TEST_F(HasFixtureTest, Test4) { FAIL() << "Expected failure."; }
-
-// Test HasSimpleTest.
-
-TEST(HasSimpleTest, Test0) {}
-
-TEST(HasSimpleTest, Test1) { FAIL() << "Expected failure."; }
-
-TEST(HasSimpleTest, Test2) { FAIL() << "Expected failure."; }
-
-TEST(HasSimpleTest, Test3) { FAIL() << "Expected failure."; }
-
-TEST(HasSimpleTest, Test4) { FAIL() << "Expected failure."; }
-
-// Test HasDisabledTest.
-
-TEST(HasDisabledTest, Test0) {}
-
-TEST(HasDisabledTest, DISABLED_Test1) { FAIL() << "Expected failure."; }
-
-TEST(HasDisabledTest, Test2) { FAIL() << "Expected failure."; }
-
-TEST(HasDisabledTest, Test3) { FAIL() << "Expected failure."; }
-
-TEST(HasDisabledTest, Test4) { FAIL() << "Expected failure."; }
-
-// Test HasDeathTest
-
-TEST(HasDeathTest, Test0) { EXPECT_DEATH_IF_SUPPORTED(exit(1), ".*"); }
-
-TEST(HasDeathTest, Test1) {
-  EXPECT_DEATH_IF_SUPPORTED(FAIL() << "Expected failure.", ".*");
-}
-
-TEST(HasDeathTest, Test2) {
-  EXPECT_DEATH_IF_SUPPORTED(FAIL() << "Expected failure.", ".*");
-}
-
-TEST(HasDeathTest, Test3) {
-  EXPECT_DEATH_IF_SUPPORTED(FAIL() << "Expected failure.", ".*");
-}
-
-TEST(HasDeathTest, Test4) {
-  EXPECT_DEATH_IF_SUPPORTED(FAIL() << "Expected failure.", ".*");
-}
-
-// Test DISABLED_HasDisabledSuite
-
-TEST(DISABLED_HasDisabledSuite, Test0) {}
-
-TEST(DISABLED_HasDisabledSuite, Test1) { FAIL() << "Expected failure."; }
-
-TEST(DISABLED_HasDisabledSuite, Test2) { FAIL() << "Expected failure."; }
-
-TEST(DISABLED_HasDisabledSuite, Test3) { FAIL() << "Expected failure."; }
-
-TEST(DISABLED_HasDisabledSuite, Test4) { FAIL() << "Expected failure."; }
-
-// Test HasParametersTest
-
-class HasParametersTest : public testing::TestWithParam<int> {};
-
-TEST_P(HasParametersTest, Test1) { FAIL() << "Expected failure."; }
-
-TEST_P(HasParametersTest, Test2) { FAIL() << "Expected failure."; }
-
-INSTANTIATE_TEST_SUITE_P(HasParametersSuite, HasParametersTest,
-                         testing::Values(1, 2));
-
-class MyTestListener : public ::testing::EmptyTestEventListener {
-  void OnTestSuiteStart(const ::testing::TestSuite& test_suite) override {
-    printf("We are in OnTestSuiteStart of %s.\n", test_suite.name());
-  }
-
-  void OnTestStart(const ::testing::TestInfo& test_info) override {
-    printf("We are in OnTestStart of %s.%s.\n", test_info.test_suite_name(),
-           test_info.name());
-  }
-
-  void OnTestPartResult(
-      const ::testing::TestPartResult& test_part_result) override {
-    printf("We are in OnTestPartResult %s:%d.\n", test_part_result.file_name(),
-           test_part_result.line_number());
-  }
-
-  void OnTestEnd(const ::testing::TestInfo& test_info) override {
-    printf("We are in OnTestEnd of %s.%s.\n", test_info.test_suite_name(),
-           test_info.name());
-  }
-
-  void OnTestSuiteEnd(const ::testing::TestSuite& test_suite) override {
-    printf("We are in OnTestSuiteEnd of %s.\n", test_suite.name());
-  }
-};
-
-TEST(HasSkipTest, Test0) { SUCCEED() << "Expected success."; }
-
-TEST(HasSkipTest, Test1) { GTEST_SKIP() << "Expected skip."; }
-
-TEST(HasSkipTest, Test2) { FAIL() << "Expected failure."; }
-
-TEST(HasSkipTest, Test3) { FAIL() << "Expected failure."; }
-
-TEST(HasSkipTest, Test4) { FAIL() << "Expected failure."; }
-
-}  // namespace
-
-int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  ::testing::UnitTest::GetInstance()->listeners().Append(new MyTestListener());
-  return RUN_ALL_TESTS();
-}

googletest/test/googletest-printers-test.cc

@@ -760,22 +760,22 @@ TEST(PrintTypeWithGenericStreamingTest, TypeImplicitlyConvertible) {
   EXPECT_EQ("AllowsGenericStreamingAndImplicitConversionTemplate", Print(a));
 }
 
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_ABSL
 
-// Tests printing internal::StringView.
+// Tests printing ::absl::string_view.
 
 TEST(PrintStringViewTest, SimpleStringView) {
-  const internal::StringView sp = "Hello";
+  const ::absl::string_view sp = "Hello";
   EXPECT_EQ("\"Hello\"", Print(sp));
 }
 
 TEST(PrintStringViewTest, UnprintableCharacters) {
   const char str[] = "NUL (\0) and \r\t";
-  const internal::StringView sp(str, sizeof(str) - 1);
+  const ::absl::string_view sp(str, sizeof(str) - 1);
   EXPECT_EQ("\"NUL (\\0) and \\r\\t\"", Print(sp));
 }
 
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#endif  // GTEST_HAS_ABSL
 
 // Tests printing STL containers.
 

googletest/test/gtest_unittest.cc

@@ -37,22 +37,21 @@
 // code once "gtest.h" has been #included.
 // Do not move it after other gtest #includes.
 TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
-  bool dummy = testing::GTEST_FLAG(also_run_disabled_tests) ||
+  bool dummy = testing::GTEST_FLAG(also_run_disabled_tests)
-               testing::GTEST_FLAG(break_on_failure) ||
+      || testing::GTEST_FLAG(break_on_failure)
-               testing::GTEST_FLAG(catch_exceptions) ||
+      || testing::GTEST_FLAG(catch_exceptions)
-               testing::GTEST_FLAG(color) != "unknown" ||
+      || testing::GTEST_FLAG(color) != "unknown"
-               testing::GTEST_FLAG(fail_fast) ||
+      || testing::GTEST_FLAG(filter) != "unknown"
-               testing::GTEST_FLAG(filter) != "unknown" ||
+      || testing::GTEST_FLAG(list_tests)
-               testing::GTEST_FLAG(list_tests) ||
+      || testing::GTEST_FLAG(output) != "unknown"
-               testing::GTEST_FLAG(output) != "unknown" ||
+      || testing::GTEST_FLAG(print_time)
-               testing::GTEST_FLAG(print_time) ||
+      || testing::GTEST_FLAG(random_seed)
-               testing::GTEST_FLAG(random_seed) ||
+      || testing::GTEST_FLAG(repeat) > 0
-               testing::GTEST_FLAG(repeat) > 0 ||
+      || testing::GTEST_FLAG(show_internal_stack_frames)
-               testing::GTEST_FLAG(show_internal_stack_frames) ||
+      || testing::GTEST_FLAG(shuffle)
-               testing::GTEST_FLAG(shuffle) ||
+      || testing::GTEST_FLAG(stack_trace_depth) > 0
-               testing::GTEST_FLAG(stack_trace_depth) > 0 ||
+      || testing::GTEST_FLAG(stream_result_to) != "unknown"
-               testing::GTEST_FLAG(stream_result_to) != "unknown" ||
+      || testing::GTEST_FLAG(throw_on_failure);
-               testing::GTEST_FLAG(throw_on_failure);
   EXPECT_TRUE(dummy || !dummy);  // Suppresses warning that dummy is unused.
 }
 
@@ -203,7 +202,6 @@ using testing::GTEST_FLAG(break_on_failure);
 using testing::GTEST_FLAG(catch_exceptions);
 using testing::GTEST_FLAG(color);
 using testing::GTEST_FLAG(death_test_use_fork);
-using testing::GTEST_FLAG(fail_fast);
 using testing::GTEST_FLAG(filter);
 using testing::GTEST_FLAG(list_tests);
 using testing::GTEST_FLAG(output);
@@ -1600,7 +1598,6 @@ class GTestFlagSaverTest : public Test {
     GTEST_FLAG(catch_exceptions) = false;
     GTEST_FLAG(death_test_use_fork) = false;
     GTEST_FLAG(color) = "auto";
-    GTEST_FLAG(fail_fast) = false;
     GTEST_FLAG(filter) = "";
     GTEST_FLAG(list_tests) = false;
     GTEST_FLAG(output) = "";
@@ -1628,7 +1625,6 @@ class GTestFlagSaverTest : public Test {
     EXPECT_FALSE(GTEST_FLAG(catch_exceptions));
     EXPECT_STREQ("auto", GTEST_FLAG(color).c_str());
     EXPECT_FALSE(GTEST_FLAG(death_test_use_fork));
-    EXPECT_FALSE(GTEST_FLAG(fail_fast));
     EXPECT_STREQ("", GTEST_FLAG(filter).c_str());
     EXPECT_FALSE(GTEST_FLAG(list_tests));
     EXPECT_STREQ("", GTEST_FLAG(output).c_str());
@@ -1645,7 +1641,6 @@ class GTestFlagSaverTest : public Test {
     GTEST_FLAG(catch_exceptions) = true;
     GTEST_FLAG(color) = "no";
     GTEST_FLAG(death_test_use_fork) = true;
-    GTEST_FLAG(fail_fast) = true;
     GTEST_FLAG(filter) = "abc";
     GTEST_FLAG(list_tests) = true;
     GTEST_FLAG(output) = "xml:foo.xml";
@@ -5500,22 +5495,20 @@ TEST_F(SetUpTestSuiteTest, TestSetupTestSuite2) {
 // The Flags struct stores a copy of all Google Test flags.
 struct Flags {
   // Constructs a Flags struct where each flag has its default value.
-  Flags()
+  Flags() : also_run_disabled_tests(false),
-      : also_run_disabled_tests(false),
+            break_on_failure(false),
-        break_on_failure(false),
+            catch_exceptions(false),
-        catch_exceptions(false),
+            death_test_use_fork(false),
-        death_test_use_fork(false),
+            filter(""),
-        fail_fast(false),
+            list_tests(false),
-        filter(""),
+            output(""),
-        list_tests(false),
+            print_time(true),
-        output(""),
+            random_seed(0),
-        print_time(true),
+            repeat(1),
-        random_seed(0),
+            shuffle(false),
-        repeat(1),
+            stack_trace_depth(kMaxStackTraceDepth),
-        shuffle(false),
+            stream_result_to(""),
-        stack_trace_depth(kMaxStackTraceDepth),
+            throw_on_failure(false) {}
-        stream_result_to(""),
-        throw_on_failure(false) {}
 
   // Factory methods.
 
@@ -5551,14 +5544,6 @@ struct Flags {
     return flags;
   }
 
-  // Creates a Flags struct where the gtest_fail_fast flag has
-  // the given value.
-  static Flags FailFast(bool fail_fast) {
-    Flags flags;
-    flags.fail_fast = fail_fast;
-    return flags;
-  }
-
   // Creates a Flags struct where the gtest_filter flag has the given
   // value.
   static Flags Filter(const char* filter) {
@@ -5644,7 +5629,6 @@ struct Flags {
   bool break_on_failure;
   bool catch_exceptions;
   bool death_test_use_fork;
-  bool fail_fast;
   const char* filter;
   bool list_tests;
   const char* output;
@@ -5666,7 +5650,6 @@ class ParseFlagsTest : public Test {
     GTEST_FLAG(break_on_failure) = false;
     GTEST_FLAG(catch_exceptions) = false;
     GTEST_FLAG(death_test_use_fork) = false;
-    GTEST_FLAG(fail_fast) = false;
     GTEST_FLAG(filter) = "";
     GTEST_FLAG(list_tests) = false;
     GTEST_FLAG(output) = "";
@@ -5697,7 +5680,6 @@ class ParseFlagsTest : public Test {
     EXPECT_EQ(expected.break_on_failure, GTEST_FLAG(break_on_failure));
     EXPECT_EQ(expected.catch_exceptions, GTEST_FLAG(catch_exceptions));
     EXPECT_EQ(expected.death_test_use_fork, GTEST_FLAG(death_test_use_fork));
-    EXPECT_EQ(expected.fail_fast, GTEST_FLAG(fail_fast));
     EXPECT_STREQ(expected.filter, GTEST_FLAG(filter).c_str());
     EXPECT_EQ(expected.list_tests, GTEST_FLAG(list_tests));
     EXPECT_STREQ(expected.output, GTEST_FLAG(output).c_str());
@@ -5784,15 +5766,6 @@ TEST_F(ParseFlagsTest, NoFlag) {
   GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), false);
 }
 
-// Tests parsing --gtest_fail_fast.
-TEST_F(ParseFlagsTest, FailFast) {
-  const char* argv[] = {"foo.exe", "--gtest_fail_fast", nullptr};
-
-  const char* argv2[] = {"foo.exe", nullptr};
-
-  GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::FailFast(true), false);
-}
-
 // Tests parsing a bad --gtest_filter flag.
 TEST_F(ParseFlagsTest, FilterBad) {
   const char* argv[] = {"foo.exe", "--gtest_filter", nullptr};