Moves the universal printer from gmock to gtest (by Vlad Losev).

Makefile.am

@@ -38,7 +38,6 @@ pkginclude_HEADERS = include/gmock/gmock.h \
                      include/gmock/gmock-generated-nice-strict.h \
                      include/gmock/gmock-matchers.h \
                      include/gmock/gmock-more-actions.h \
-                     include/gmock/gmock-printers.h \
                      include/gmock/gmock-spec-builders.h
 
 pkginclude_internaldir = $(pkgincludedir)/internal
@@ -92,7 +91,6 @@ GMOCK_SOURCE_INGLUDES = \
   src/gmock-cardinalities.cc \
   src/gmock-internal-utils.cc \
   src/gmock-matchers.cc \
-  src/gmock-printers.cc \
   src/gmock-spec-builders.cc
 
 EXTRA_DIST += $(GMOCK_SOURCE_INGLUDES)
@@ -110,8 +108,7 @@ EXTRA_DIST += \
   test/gmock-matchers_test.cc \
   test/gmock-more-actions_test.cc \
   test/gmock-nice-strict_test.cc \
-  test/gmock-port_test.cc \
-  test/gmock-printers_test.cc
+  test/gmock-port_test.cc
 
 # Python tests, which we don't run using autotools.
 EXTRA_DIST += \

include/gmock/gmock-actions.h

@@ -43,7 +43,6 @@
 #include <errno.h>
 #endif
 
-#include <gmock/gmock-printers.h>
 #include <gmock/internal/gmock-internal-utils.h>
 #include <gmock/internal/gmock-port.h>
 
@@ -477,7 +476,7 @@ class ReturnAction {
     // and put the typedef both here (for use in assert statement) and
     // in the Impl class. But both definitions must be the same.
     typedef typename Function<F>::Result Result;
-    GMOCK_COMPILE_ASSERT_(
+    GTEST_COMPILE_ASSERT_(
         !internal::is_reference<Result>::value,
         use_ReturnRef_instead_of_Return_to_return_a_reference);
     return Action<F>(new Impl<F>(value_));
@@ -504,7 +503,7 @@ class ReturnAction {
     virtual Result Perform(const ArgumentTuple&) { return value_; }
 
    private:
-    GMOCK_COMPILE_ASSERT_(!internal::is_reference<Result>::value,
+    GTEST_COMPILE_ASSERT_(!internal::is_reference<Result>::value,
                           Result_cannot_be_a_reference_type);
     Result value_;
 
@@ -522,7 +521,7 @@ class ReturnNullAction {
   // Allows ReturnNull() to be used in any pointer-returning function.
   template <typename Result, typename ArgumentTuple>
   static Result Perform(const ArgumentTuple&) {
-    GMOCK_COMPILE_ASSERT_(internal::is_pointer<Result>::value,
+    GTEST_COMPILE_ASSERT_(internal::is_pointer<Result>::value,
                           ReturnNull_can_be_used_to_return_a_pointer_only);
     return NULL;
   }
@@ -555,7 +554,7 @@ class ReturnRefAction {
     // Asserts that the function return type is a reference.  This
     // catches the user error of using ReturnRef(x) when Return(x)
     // should be used, and generates some helpful error message.
-    GMOCK_COMPILE_ASSERT_(internal::is_reference<Result>::value,
+    GTEST_COMPILE_ASSERT_(internal::is_reference<Result>::value,
                           use_Return_instead_of_ReturnRef_to_return_a_value);
     return Action<F>(new Impl<F>(ref_));
   }

include/gmock/gmock-generated-function-mockers.h

@@ -344,7 +344,7 @@ using internal::FunctionMocker;
 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 #define GMOCK_METHOD0_(tn, constness, ct, Method, F) \
   GMOCK_RESULT_(tn, F) ct Method() constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 0, \
         this_method_does_not_take_0_arguments); \
     GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \
@@ -359,7 +359,7 @@ using internal::FunctionMocker;
 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 #define GMOCK_METHOD1_(tn, constness, ct, Method, F) \
   GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 1, \
         this_method_does_not_take_1_argument); \
     GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \
@@ -376,7 +376,7 @@ using internal::FunctionMocker;
 #define GMOCK_METHOD2_(tn, constness, ct, Method, F) \
   GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                  GMOCK_ARG_(tn, F, 2) gmock_a2) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 2, \
         this_method_does_not_take_2_arguments); \
     GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \
@@ -395,7 +395,7 @@ using internal::FunctionMocker;
   GMOCK_RESULT_(tn, F) ct Method(GMOCK_ARG_(tn, F, 1) gmock_a1, \
                                  GMOCK_ARG_(tn, F, 2) gmock_a2, \
                                  GMOCK_ARG_(tn, F, 3) gmock_a3) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 3, \
         this_method_does_not_take_3_arguments); \
     GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \
@@ -417,7 +417,7 @@ using internal::FunctionMocker;
                                  GMOCK_ARG_(tn, F, 2) gmock_a2, \
                                  GMOCK_ARG_(tn, F, 3) gmock_a3, \
                                  GMOCK_ARG_(tn, F, 4) gmock_a4) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 4, \
         this_method_does_not_take_4_arguments); \
     GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \
@@ -442,7 +442,7 @@ using internal::FunctionMocker;
                                  GMOCK_ARG_(tn, F, 3) gmock_a3, \
                                  GMOCK_ARG_(tn, F, 4) gmock_a4, \
                                  GMOCK_ARG_(tn, F, 5) gmock_a5) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 5, \
         this_method_does_not_take_5_arguments); \
     GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \
@@ -469,7 +469,7 @@ using internal::FunctionMocker;
                                  GMOCK_ARG_(tn, F, 4) gmock_a4, \
                                  GMOCK_ARG_(tn, F, 5) gmock_a5, \
                                  GMOCK_ARG_(tn, F, 6) gmock_a6) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 6, \
         this_method_does_not_take_6_arguments); \
     GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \
@@ -498,7 +498,7 @@ using internal::FunctionMocker;
                                  GMOCK_ARG_(tn, F, 5) gmock_a5, \
                                  GMOCK_ARG_(tn, F, 6) gmock_a6, \
                                  GMOCK_ARG_(tn, F, 7) gmock_a7) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 7, \
         this_method_does_not_take_7_arguments); \
     GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \
@@ -529,7 +529,7 @@ using internal::FunctionMocker;
                                  GMOCK_ARG_(tn, F, 6) gmock_a6, \
                                  GMOCK_ARG_(tn, F, 7) gmock_a7, \
                                  GMOCK_ARG_(tn, F, 8) gmock_a8) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 8, \
         this_method_does_not_take_8_arguments); \
     GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \
@@ -562,7 +562,7 @@ using internal::FunctionMocker;
                                  GMOCK_ARG_(tn, F, 7) gmock_a7, \
                                  GMOCK_ARG_(tn, F, 8) gmock_a8, \
                                  GMOCK_ARG_(tn, F, 9) gmock_a9) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 9, \
         this_method_does_not_take_9_arguments); \
     GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \
@@ -598,7 +598,7 @@ using internal::FunctionMocker;
                                  GMOCK_ARG_(tn, F, 8) gmock_a8, \
                                  GMOCK_ARG_(tn, F, 9) gmock_a9, \
                                  GMOCK_ARG_(tn, F, 10) gmock_a10) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == 10, \
         this_method_does_not_take_10_arguments); \
     GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \

include/gmock/gmock-generated-function-mockers.h.pump

@@ -132,7 +132,7 @@ $var matcher_as = [[$for j, \
 // INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!!
 #define GMOCK_METHOD$i[[]]_(tn, constness, ct, Method, F) \
   GMOCK_RESULT_(tn, F) ct Method($arg_as) constness { \
-    GMOCK_COMPILE_ASSERT_(::std::tr1::tuple_size< \
+    GTEST_COMPILE_ASSERT_(::std::tr1::tuple_size< \
         tn ::testing::internal::Function<F>::ArgumentTuple>::value == $i, \
         this_method_does_not_take_$i[[]]_argument[[$if i != 1 [[s]]]]); \
     GMOCK_MOCKER_($i, constness, Method).SetOwnerAndName(this, #Method); \

include/gmock/gmock-generated-matchers.h

@@ -42,7 +42,6 @@
 #include <string>
 #include <vector>
 #include <gmock/gmock-matchers.h>
-#include <gmock/gmock-printers.h>
 
 namespace testing {
 namespace internal {
@@ -222,7 +221,7 @@ template <class ArgsTuple, int k0 = -1, int k1 = -1, int k2 = -1, int k3 = -1,
 class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
  public:
   // ArgsTuple may have top-level const or reference modifiers.
-  typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(ArgsTuple)) RawArgsTuple;
+  typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(ArgsTuple)) RawArgsTuple;
   typedef typename internal::TupleFields<RawArgsTuple, k0, k1, k2, k3, k4, k5,
       k6, k7, k8, k9>::type SelectedArgs;
   typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
@@ -315,7 +314,7 @@ class ElementsAreMatcher1 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -344,7 +343,7 @@ class ElementsAreMatcher2 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -372,7 +371,7 @@ class ElementsAreMatcher3 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -402,7 +401,7 @@ class ElementsAreMatcher4 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -434,7 +433,7 @@ class ElementsAreMatcher5 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -470,7 +469,7 @@ class ElementsAreMatcher6 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -508,7 +507,7 @@ class ElementsAreMatcher7 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -548,7 +547,7 @@ class ElementsAreMatcher8 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -591,7 +590,7 @@ class ElementsAreMatcher9 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -636,7 +635,7 @@ class ElementsAreMatcher10 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;

include/gmock/gmock-generated-matchers.h.pump

@@ -44,7 +44,6 @@ $$ }} This line fixes auto-indentation of the following code in Emacs.
 #include <string>
 #include <vector>
 #include <gmock/gmock-matchers.h>
-#include <gmock/gmock-printers.h>
 
 namespace testing {
 namespace internal {
@@ -108,7 +107,7 @@ template <class ArgsTuple$for i [[, int k$i = -1]]>
 class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
  public:
   // ArgsTuple may have top-level const or reference modifiers.
-  typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(ArgsTuple)) RawArgsTuple;
+  typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(ArgsTuple)) RawArgsTuple;
   typedef typename internal::TupleFields<RawArgsTuple, $ks>::type SelectedArgs;
   typedef Matcher<const SelectedArgs&> MonomorphicInnerMatcher;
 
@@ -201,7 +200,7 @@ class ElementsAreMatcher$i {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;

include/gmock/gmock-matchers.h

@@ -45,7 +45,6 @@
 #include <string>
 #include <vector>
 
-#include <gmock/gmock-printers.h>
 #include <gmock/internal/gmock-internal-utils.h>
 #include <gmock/internal/gmock-port.h>
 #include <gtest/gtest.h>
@@ -419,20 +418,20 @@ class SafeMatcherCastImpl {
   template <typename U>
   static inline Matcher<T> Cast(const Matcher<U>& matcher) {
     // Enforce that T can be implicitly converted to U.
-    GMOCK_COMPILE_ASSERT_((internal::ImplicitlyConvertible<T, U>::value),
+    GTEST_COMPILE_ASSERT_((internal::ImplicitlyConvertible<T, U>::value),
                           T_must_be_implicitly_convertible_to_U);
     // Enforce that we are not converting a non-reference type T to a reference
     // type U.
-    GMOCK_COMPILE_ASSERT_(
+    GTEST_COMPILE_ASSERT_(
         internal::is_reference<T>::value || !internal::is_reference<U>::value,
         cannot_convert_non_referentce_arg_to_reference);
     // In case both T and U are arithmetic types, enforce that the
     // conversion is not lossy.
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(T)) RawT;
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(U)) RawU;
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T)) RawT;
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(U)) RawU;
     const bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
     const bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
-    GMOCK_COMPILE_ASSERT_(
+    GTEST_COMPILE_ASSERT_(
         kTIsOther || kUIsOther ||
         (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
         conversion_of_arithmetic_types_must_be_lossless);
@@ -566,7 +565,7 @@ bool TupleMatches(const MatcherTuple& matcher_tuple,
   using ::std::tr1::tuple_size;
   // Makes sure that matcher_tuple and value_tuple have the same
   // number of fields.
-  GMOCK_COMPILE_ASSERT_(tuple_size<MatcherTuple>::value ==
+  GTEST_COMPILE_ASSERT_(tuple_size<MatcherTuple>::value ==
                         tuple_size<ValueTuple>::value,
                         matcher_and_value_have_different_numbers_of_fields);
   return TuplePrefix<tuple_size<ValueTuple>::value>::
@@ -1604,8 +1603,8 @@ class PointeeMatcher {
   template <typename Pointer>
   class Impl : public MatcherInterface<Pointer> {
    public:
-    typedef typename PointeeOf<GMOCK_REMOVE_CONST_(  // NOLINT
-        GMOCK_REMOVE_REFERENCE_(Pointer))>::type Pointee;
+    typedef typename PointeeOf<GTEST_REMOVE_CONST_(  // NOLINT
+        GTEST_REMOVE_REFERENCE_(Pointer))>::type Pointee;
 
     explicit Impl(const InnerMatcher& matcher)
         : matcher_(MatcherCast<const Pointee&>(matcher)) {}
@@ -1663,7 +1662,7 @@ class FieldMatcher {
   bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
     return MatchAndExplainImpl(
         typename ::testing::internal::
-            is_pointer<GMOCK_REMOVE_CONST_(T)>::type(),
+            is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
         value, listener);
   }
 
@@ -1702,9 +1701,9 @@ class PropertyMatcher {
  public:
   // The property may have a reference type, so 'const PropertyType&'
   // may cause double references and fail to compile.  That's why we
-  // need GMOCK_REFERENCE_TO_CONST, which works regardless of
+  // need GTEST_REFERENCE_TO_CONST, which works regardless of
   // PropertyType being a reference or not.
-  typedef GMOCK_REFERENCE_TO_CONST_(PropertyType) RefToConstProperty;
+  typedef GTEST_REFERENCE_TO_CONST_(PropertyType) RefToConstProperty;
 
   PropertyMatcher(PropertyType (Class::*property)() const,
                   const Matcher<RefToConstProperty>& matcher)
@@ -1724,7 +1723,7 @@ class PropertyMatcher {
   bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
     return MatchAndExplainImpl(
         typename ::testing::internal::
-            is_pointer<GMOCK_REMOVE_CONST_(T)>::type(),
+            is_pointer<GTEST_REMOVE_CONST_(T)>::type(),
         value, listener);
   }
 
@@ -1875,7 +1874,7 @@ class ContainerEqMatcher {
     // Makes sure the user doesn't instantiate this class template
     // with a const or reference type.
     testing::StaticAssertTypeEq<Container,
-        GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))>();
+        GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))>();
   }
 
   void DescribeTo(::std::ostream* os) const {
@@ -1890,9 +1889,9 @@ class ContainerEqMatcher {
   template <typename LhsContainer>
   bool MatchAndExplain(const LhsContainer& lhs,
                        MatchResultListener* listener) const {
-    // GMOCK_REMOVE_CONST_() is needed to work around an MSVC 8.0 bug
+    // GTEST_REMOVE_CONST_() is needed to work around an MSVC 8.0 bug
     // that causes LhsContainer to be a const type sometimes.
-    typedef internal::StlContainerView<GMOCK_REMOVE_CONST_(LhsContainer)>
+    typedef internal::StlContainerView<GTEST_REMOVE_CONST_(LhsContainer)>
         LhsView;
     typedef typename LhsView::type LhsStlContainer;
     StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
@@ -1951,7 +1950,7 @@ class ContainerEqMatcher {
 template <typename Container>
 class QuantifierMatcherImpl : public MatcherInterface<Container> {
  public:
-  typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container)) RawContainer;
+  typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container)) RawContainer;
   typedef StlContainerView<RawContainer> View;
   typedef typename View::type StlContainer;
   typedef typename View::const_reference StlContainerReference;
@@ -2090,7 +2089,7 @@ class EachMatcher {
 template <typename PairType>
 class KeyMatcherImpl : public MatcherInterface<PairType> {
  public:
-  typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(PairType)) RawPairType;
+  typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(PairType)) RawPairType;
   typedef typename RawPairType::first_type KeyType;
 
   template <typename InnerMatcher>
@@ -2152,7 +2151,7 @@ class KeyMatcher {
 template <typename PairType>
 class PairMatcherImpl : public MatcherInterface<PairType> {
  public:
-  typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(PairType)) RawPairType;
+  typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(PairType)) RawPairType;
   typedef typename RawPairType::first_type FirstType;
   typedef typename RawPairType::second_type SecondType;
 
@@ -2259,7 +2258,7 @@ class PairMatcher {
 template <typename Container>
 class ElementsAreMatcherImpl : public MatcherInterface<Container> {
  public:
-  typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container)) RawContainer;
+  typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container)) RawContainer;
   typedef internal::StlContainerView<RawContainer> View;
   typedef typename View::type StlContainer;
   typedef typename View::const_reference StlContainerReference;
@@ -2378,7 +2377,7 @@ class ElementsAreMatcher0 {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -2397,7 +2396,7 @@ class ElementsAreArrayMatcher {
 
   template <typename Container>
   operator Matcher<Container>() const {
-    typedef GMOCK_REMOVE_CONST_(GMOCK_REMOVE_REFERENCE_(Container))
+    typedef GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(Container))
         RawContainer;
     typedef typename internal::StlContainerView<RawContainer>::type::value_type
         Element;
@@ -2609,7 +2608,7 @@ inline PolymorphicMatcher<
   return MakePolymorphicMatcher(
       internal::PropertyMatcher<Class, PropertyType>(
           property,
-          MatcherCast<GMOCK_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
+          MatcherCast<GTEST_REFERENCE_TO_CONST_(PropertyType)>(matcher)));
   // The call to MatcherCast() is required for supporting inner
   // matchers of compatible types.  For example, it allows
   //   Property(&Foo::bar, m)
@@ -2893,11 +2892,11 @@ Truly(Predicate pred) {
 // values and order differences are not explained.)
 template <typename Container>
 inline PolymorphicMatcher<internal::ContainerEqMatcher<  // NOLINT
-                            GMOCK_REMOVE_CONST_(Container)> >
+                            GTEST_REMOVE_CONST_(Container)> >
     ContainerEq(const Container& rhs) {
   // This following line is for working around a bug in MSVC 8.0,
   // which causes Container to be a const type sometimes.
-  typedef GMOCK_REMOVE_CONST_(Container) RawContainer;
+  typedef GTEST_REMOVE_CONST_(Container) RawContainer;
   return MakePolymorphicMatcher(
       internal::ContainerEqMatcher<RawContainer>(rhs));
 }

include/gmock/gmock-more-actions.h

@@ -162,7 +162,7 @@ ACTION_TEMPLATE(SetArgReferee,
   // Ensures that argument #k is a reference.  If you get a compiler
   // error on the next line, you are using SetArgReferee<k>(value) in
   // a mock function whose k-th (0-based) argument is not a reference.
-  GMOCK_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
+  GTEST_COMPILE_ASSERT_(internal::is_reference<argk_type>::value,
                         SetArgReferee_must_be_used_with_a_reference_argument);
   ::std::tr1::get<k>(args) = value;
 }

include/gmock/gmock-spec-builders.h

@@ -69,7 +69,6 @@
 #include <gmock/gmock-actions.h>
 #include <gmock/gmock-cardinalities.h>
 #include <gmock/gmock-matchers.h>
-#include <gmock/gmock-printers.h>
 #include <gmock/internal/gmock-internal-utils.h>
 #include <gmock/internal/gmock-port.h>
 #include <gtest/gtest.h>

include/gmock/gmock.h

@@ -63,7 +63,6 @@
 #include <gmock/gmock-more-actions.h>
 #include <gmock/gmock-generated-nice-strict.h>
 #include <gmock/gmock-matchers.h>
-#include <gmock/gmock-printers.h>
 #include <gmock/internal/gmock-internal-utils.h>
 
 namespace testing {

include/gmock/internal/gmock-port.h

@@ -50,149 +50,12 @@
 // tr1/tuple.  gmock-port.h does this via gtest-port.h, which is
 // guaranteed to pull in the tuple header.
 
-#if GTEST_OS_LINUX
-
-#endif  // GTEST_OS_LINUX
-
-namespace testing {
-namespace internal {
-
 // For MS Visual C++, check the compiler version. At least VS 2003 is
 // required to compile Google Mock.
 #if defined(_MSC_VER) && _MSC_VER < 1310
 #error "At least Visual C++ 2003 (7.1) is required to compile Google Mock."
 #endif
 
-// Use implicit_cast as a safe version of static_cast for upcasting in
-// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
-// const Foo*).  When you use implicit_cast, the compiler checks that
-// the cast is safe.  Such explicit implicit_casts are necessary in
-// surprisingly many situations where C++ demands an exact type match
-// instead of an argument type convertable to a target type.
-//
-// The syntax for using implicit_cast is the same as for static_cast:
-//
-//   implicit_cast<ToType>(expr)
-//
-// implicit_cast would have been part of the C++ standard library,
-// but the proposal was submitted too late.  It will probably make
-// its way into the language in the future.
-template<typename To>
-inline To implicit_cast(To x) { return x; }
-
-// When you upcast (that is, cast a pointer from type Foo to type
-// SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts
-// always succeed.  When you downcast (that is, cast a pointer from
-// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
-// how do you know the pointer is really of type SubclassOfFoo?  It
-// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
-// when you downcast, you should use this macro.  In debug mode, we
-// use dynamic_cast<> to double-check the downcast is legal (we die
-// if it's not).  In normal mode, we do the efficient static_cast<>
-// instead.  Thus, it's important to test in debug mode to make sure
-// the cast is legal!
-//    This is the only place in the code we should use dynamic_cast<>.
-// In particular, you SHOULDN'T be using dynamic_cast<> in order to
-// do RTTI (eg code like this:
-//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
-//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
-// You should design the code some other way not to need this.
-template<typename To, typename From>  // use like this: down_cast<T*>(foo);
-inline To down_cast(From* f) {  // so we only accept pointers
-  // Ensures that To is a sub-type of From *.  This test is here only
-  // for compile-time type checking, and has no overhead in an
-  // optimized build at run-time, as it will be optimized away
-  // completely.
-  if (false) {
-    const To to = NULL;
-    ::testing::internal::implicit_cast<From*>(to);
-  }
-
-#if GTEST_HAS_RTTI
-  assert(f == NULL || dynamic_cast<To>(f) != NULL);  // RTTI: debug mode only!
-#endif
-  return static_cast<To>(f);
-}
-
-// The GMOCK_COMPILE_ASSERT_ macro can be used to verify that a compile time
-// expression is true. For example, you could use it to verify the
-// size of a static array:
-//
-//   GMOCK_COMPILE_ASSERT_(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
-//                         content_type_names_incorrect_size);
-//
-// or to make sure a struct is smaller than a certain size:
-//
-//   GMOCK_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
-//
-// The second argument to the macro is the name of the variable. If
-// the expression is false, most compilers will issue a warning/error
-// containing the name of the variable.
-
-template <bool>
-struct CompileAssert {
-};
-
-#define GMOCK_COMPILE_ASSERT_(expr, msg) \
-  typedef ::testing::internal::CompileAssert<(bool(expr))> \
-      msg[bool(expr) ? 1 : -1]
-
-// Implementation details of GMOCK_COMPILE_ASSERT_:
-//
-// - GMOCK_COMPILE_ASSERT_ works by defining an array type that has -1
-//   elements (and thus is invalid) when the expression is false.
-//
-// - The simpler definition
-//
-//    #define GMOCK_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
-//
-//   does not work, as gcc supports variable-length arrays whose sizes
-//   are determined at run-time (this is gcc's extension and not part
-//   of the C++ standard).  As a result, gcc fails to reject the
-//   following code with the simple definition:
-//
-//     int foo;
-//     GMOCK_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
-//                                      // not a compile-time constant.
-//
-// - By using the type CompileAssert<(bool(expr))>, we ensures that
-//   expr is a compile-time constant.  (Template arguments must be
-//   determined at compile-time.)
-//
-// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
-//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
-//
-//     CompileAssert<bool(expr)>
-//
-//   instead, these compilers will refuse to compile
-//
-//     GMOCK_COMPILE_ASSERT_(5 > 0, some_message);
-//
-//   (They seem to think the ">" in "5 > 0" marks the end of the
-//   template argument list.)
-//
-// - The array size is (bool(expr) ? 1 : -1), instead of simply
-//
-//     ((expr) ? 1 : -1).
-//
-//   This is to avoid running into a bug in MS VC 7.1, which
-//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
-
-#if GTEST_HAS_GLOBAL_STRING
-typedef ::string string;
-#else
-typedef ::std::string string;
-#endif  // GTEST_HAS_GLOBAL_STRING
-
-#if GTEST_HAS_GLOBAL_WSTRING
-typedef ::wstring wstring;
-#elif GTEST_HAS_STD_WSTRING
-typedef ::std::wstring wstring;
-#endif  // GTEST_HAS_GLOBAL_WSTRING
-
-}  // namespace internal
-}  // namespace testing
-
 // Macro for referencing flags.  This is public as we want the user to
 // use this syntax to reference Google Mock flags.
 #define GMOCK_FLAG(name) FLAGS_gmock_##name

scons/SConscript

@@ -186,7 +186,6 @@ GtestTest(env, 'gmock-matchers_test', [gtest, gmock_main])
 GtestTest(env, 'gmock-more-actions_test', [gtest, gmock_main])
 GtestTest(env, 'gmock-nice-strict_test', [gtest, gmock_main])
 GtestTest(env, 'gmock-port_test', [gtest, gmock_main])
-GtestTest(env, 'gmock-printers_test', [gtest, gmock_main])
 GtestTest(env, 'gmock-spec-builders_test', [gtest, gmock_main])
 GtestTest(env, 'gmock_leak_test_', [gtest, gmock_main])
 GtestTest(env, 'gmock_link_test', [gtest, gmock_main],

scripts/gmock_doctor.py

@@ -203,7 +203,7 @@ def _IncompleteByReferenceArgumentDiagnoser(msg):
   """Diagnoses the IBRA disease, given the error messages by gcc."""
 
   regex = (_FILE_LINE_RE + r'instantiated from here\n'
-           r'.*gmock-printers\.h.*error: invalid application of '
+           r'.*gtest-printers\.h.*error: invalid application of '
            r'\'sizeof\' to incomplete type \'(?P<type>.*)\'')
   diagnosis = """
 In order to mock this function, Google Mock needs to see the definition

src/gmock-all.cc

@@ -43,6 +43,5 @@
 #include "src/gmock-cardinalities.cc"
 #include "src/gmock-internal-utils.cc"
 #include "src/gmock-matchers.cc"
-#include "src/gmock-printers.cc"
 #include "src/gmock-spec-builders.cc"
 #include "src/gmock.cc"

test/gmock-actions_test.cc

@@ -74,9 +74,9 @@ using testing::SetArgumentPointee;
 using testing::SetErrnoAndReturn;
 #endif
 
-#if GMOCK_HAS_PROTOBUF_
+#if GTEST_HAS_PROTOBUF_
 using testing::internal::TestMessage;
-#endif  // GMOCK_HAS_PROTOBUF_
+#endif  // GTEST_HAS_PROTOBUF_
 
 // Tests that BuiltInDefaultValue<T*>::Get() returns NULL.
 TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
@@ -689,7 +689,7 @@ TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
   EXPECT_EQ('a', ch);
 }
 
-#if GMOCK_HAS_PROTOBUF_
+#if GTEST_HAS_PROTOBUF_
 
 // Tests that SetArgumentPointee<N>(proto_buffer) sets the v1 protobuf
 // variable pointed to by the N-th (0-based) argument to proto_buffer.
@@ -786,7 +786,7 @@ TEST(SetArgumentPointeeTest, SetsTheNthPointeeOfProto2BufferBaseType) {
   EXPECT_EQ("hi", dest.string_field());
 }
 
-#endif  // GMOCK_HAS_PROTOBUF_
+#endif  // GTEST_HAS_PROTOBUF_
 
 // Sample functions and functors for testing Invoke() and etc.
 int Nullary() { return 1; }

test/gmock-port_test.cc

@@ -39,126 +39,5 @@
 // NOTE: if this file is left without tests for some reason, put a dummy
 // test here to make references to symbols in the gtest library and avoid
 // 'undefined symbol' linker errors in gmock_main:
-//
-// TEST(DummyTest, Dummy) {}
-
-namespace testing {
-namespace internal {
-// Needed to avoid name collisions in gmock_all_test.cc.
-namespace gmock_port_test {
-
-class Base {
- public:
-  // Copy constructor and assignment operator do exactly what we need, so we
-  // use them.
-  Base() : member_(0) {}
-  explicit Base(int n) : member_(n) {}
-  virtual ~Base() {}
-  int member() { return member_; }
-
- private:
-  int member_;
-};
-
-class Derived : public Base {
- public:
-  explicit Derived(int n) : Base(n) {}
-};
-
-TEST(ImplicitCastTest, ConvertsPointers) {
-  Derived derived(0);
-  EXPECT_TRUE(&derived == ::testing::internal::implicit_cast<Base*>(&derived));
-}
-
-TEST(ImplicitCastTest, CanUseInheritance) {
-  Derived derived(1);
-  Base base = ::testing::internal::implicit_cast<Base>(derived);
-  EXPECT_EQ(derived.member(), base.member());
-}
-
-class Castable {
- public:
-  Castable(bool* converted) : converted_(converted) {}
-  operator Base() {
-    *converted_ = true;
-    return Base();
-  }
-
- private:
-  bool* converted_;
-};
-
-TEST(ImplicitCastTest, CanUseNonConstCastOperator) {
-  bool converted = false;
-  Castable castable(&converted);
-  Base base = ::testing::internal::implicit_cast<Base>(castable);
-  EXPECT_TRUE(converted);
-}
-
-class ConstCastable {
- public:
-  ConstCastable(bool* converted) : converted_(converted) {}
-  operator Base() const {
-    *converted_ = true;
-    return Base();
-  }
-
- private:
-  bool* converted_;
-};
-
-TEST(ImplicitCastTest, CanUseConstCastOperatorOnConstValues) {
-  bool converted = false;
-  const ConstCastable const_castable(&converted);
-  Base base = ::testing::internal::implicit_cast<Base>(const_castable);
-  EXPECT_TRUE(converted);
-}
-
-class ConstAndNonConstCastable {
- public:
-  ConstAndNonConstCastable(bool* converted, bool* const_converted)
-      : converted_(converted), const_converted_(const_converted) {}
-  operator Base() {
-    *converted_ = true;
-    return Base();
-  }
-  operator Base() const {
-    *const_converted_ = true;
-    return Base();
-  }
-
- private:
-  bool* converted_;
-  bool* const_converted_;
-};
-
-TEST(ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately) {
-  bool converted = false;
-  bool const_converted = false;
-  ConstAndNonConstCastable castable(&converted, &const_converted);
-  Base base = ::testing::internal::implicit_cast<Base>(castable);
-  EXPECT_TRUE(converted);
-  EXPECT_FALSE(const_converted);
-
-  converted = false;
-  const_converted = false;
-  const ConstAndNonConstCastable const_castable(&converted, &const_converted);
-  base = ::testing::internal::implicit_cast<Base>(const_castable);
-  EXPECT_FALSE(converted);
-  EXPECT_TRUE(const_converted);
-}
-
-class To {
- public:
-  To(bool* converted) { *converted = true; }  // NOLINT
-};
-
-TEST(ImplicitCastTest, CanUseImplicitConstructor) {
-  bool converted = false;
-  To to = ::testing::internal::implicit_cast<To>(&converted);
-  EXPECT_TRUE(converted);
-}
 
-}  // namespace gmock_port_test
-}  // namespace internal
-}  // namespace testing
+TEST(DummyTest, Dummy) {}

test/gmock_all_test.cc

@@ -44,6 +44,5 @@
 #include "test/gmock-more-actions_test.cc"
 #include "test/gmock-nice-strict_test.cc"
 #include "test/gmock-port_test.cc"
-#include "test/gmock-printers_test.cc"
 #include "test/gmock-spec-builders_test.cc"
 #include "test/gmock_test.cc"