Merge pull request #2453 from kuzkry:gtest-port-clean-up_kMaxBiggestInt

googletest/include/gtest/gtest-printers.h

@@ -133,7 +133,7 @@ GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
 // nor PrintTo().
 enum TypeKind {
   kProtobuf,              // a protobuf type
-  kConvertibleToInteger,  // a type implicitly convertible to std::intmax_t
+  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
@@ -179,14 +179,14 @@ template <typename T>
 class TypeWithoutFormatter<T, kConvertibleToInteger> {
  public:
   // Since T has no << operator or PrintTo() but can be implicitly
-  // converted to the maximum width integer, we print it as a std::intmax_t.
+  // 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
+  // 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(const T& value, ::std::ostream* os) {
-    const std::intmax_t kBigInt = value;
+    const internal::BiggestInt kBigInt = value;
     *os << kBigInt;
   }
 };
@@ -204,10 +204,10 @@ class TypeWithoutFormatter<T, kConvertibleToStringView> {
 };
 #endif
 
-// Prints the given value to the given ostream. If the value is a
+// 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
-// of a type implicitly convertible to std::intmax_t, it's printed as an
-// integer; otherwise the bytes in the value are printed. This is
+// of a type implicitly convertible to BiggestInt, it's printed as an
+// integer; otherwise the bytes in the value are printed.  This is
 // what UniversalPrinter<T>::Print() does when it knows nothing about
 // type T and T has neither << operator nor PrintTo().
 //
@@ -231,18 +231,19 @@ class TypeWithoutFormatter<T, kConvertibleToStringView> {
 template <typename Char, typename CharTraits, typename T>
 ::std::basic_ostream<Char, CharTraits>& operator<<(
     ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
-  TypeWithoutFormatter<
-      T, (internal::IsAProtocolMessage<T>::value
-              ? kProtobuf
-              : std::is_convertible<const T&, std::intmax_t>::value
-                    ? kConvertibleToInteger
-                    :
+  TypeWithoutFormatter<T, (internal::IsAProtocolMessage<T>::value
+                               ? kProtobuf
+                               : std::is_convertible<
+                                     const T&, internal::BiggestInt>::value
+                                     ? kConvertibleToInteger
+                                     :
 #if GTEST_HAS_ABSL
-                    std::is_convertible<const T&, absl::string_view>::value
-                        ? kConvertibleToStringView
-                        :
+                                     std::is_convertible<
+                                         const T&, absl::string_view>::value
+                                         ? kConvertibleToStringView
+                                         :
 #endif
-                        kOtherType)>::PrintValue(x, &os);
+                                         kOtherType)>::PrintValue(x, &os);
   return os;
 }
 

googletest/include/gtest/gtest.h

@@ -1531,11 +1531,13 @@ AssertionResult CmpHelperEQ(const char* lhs_expression,
   return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
 }
 
-// With this overloaded version, we allow anonymous enums to be used in
-// {ASSERT|EXPECT}_EQ as anonymous enums can be implicitly cast to integers.
+// With this overloaded version, we allow anonymous enums to be used
+// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
+// can be implicitly cast to BiggestInt.
 GTEST_API_ AssertionResult CmpHelperEQ(const char* lhs_expression,
                                        const char* rhs_expression,
-                                       std::intmax_t lhs, std::intmax_t rhs);
+                                       BiggestInt lhs,
+                                       BiggestInt rhs);
 
 class EqHelper {
  public:
@@ -1552,14 +1554,16 @@ class EqHelper {
     return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
   }
 
-  // With this overloaded version, we allow anonymous enums to be used in
-  // {ASSERT|EXPECT}_EQ as anonymous enums can be implicitly cast to integers.
+  // With this overloaded version, we allow anonymous enums to be used
+  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
+  // enums can be implicitly cast to BiggestInt.
   //
   // Even though its body looks the same as the above version, we
   // cannot merge the two, as it will make anonymous enums unhappy.
   static AssertionResult Compare(const char* lhs_expression,
-                                 const char* rhs_expression, std::intmax_t lhs,
-                                 std::intmax_t rhs) {
+                                 const char* rhs_expression,
+                                 BiggestInt lhs,
+                                 BiggestInt rhs) {
     return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
   }
 
@@ -1592,24 +1596,24 @@ AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
 // of similar code.
 //
 // For each templatized helper function, we also define an overloaded
-// version for std::intmax_t in order to reduce code bloat and allow
-// anonymous enums to be used with {ASSERT|EXPECT}_??.
+// version for BiggestInt in order to reduce code bloat and allow
+// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
+// with gcc 4.
 //
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 
-#define GTEST_IMPL_CMP_HELPER_(op_name, op)                                \
-  template <typename T1, typename T2>                                      \
-  AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
-                                     const T1& val1, const T2& val2) {     \
-    if (val1 op val2) {                                                    \
-      return AssertionSuccess();                                           \
-    } else {                                                               \
-      return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);            \
-    }                                                                      \
-  }                                                                        \
-  GTEST_API_ AssertionResult CmpHelper##op_name(                           \
-      const char* expr1, const char* expr2, std::intmax_t val1,            \
-      std::intmax_t val2)
+#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
+template <typename T1, typename T2>\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   const T1& val1, const T2& val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
+  }\
+}\
+GTEST_API_ AssertionResult CmpHelper##op_name(\
+    const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
 
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
 

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

@@ -225,6 +225,7 @@
 //   TypeWithSize   - maps an integer to a int type.
 //   Int32, UInt32, Int64, UInt64, TimeInMillis
 //                  - integers of known sizes.
+//   BiggestInt     - the biggest signed integer type.
 //
 // Command-line utilities:
 //   GTEST_DECLARE_*()  - declares a flag.
@@ -1875,9 +1876,12 @@ GTEST_API_ size_t GetThreadCount();
 #if GTEST_OS_WINDOWS
 # define GTEST_PATH_SEP_ "\\"
 # define GTEST_HAS_ALT_PATH_SEP_ 1
+// The biggest signed integer type the compiler supports.
+typedef __int64 BiggestInt;
 #else
 # define GTEST_PATH_SEP_ "/"
 # define GTEST_HAS_ALT_PATH_SEP_ 0
+typedef long long BiggestInt;  // NOLINT
 #endif  // GTEST_OS_WINDOWS
 
 // Utilities for char.
@@ -2080,6 +2084,16 @@ GTEST_DISABLE_MSC_DEPRECATED_POP_()
 # define GTEST_SNPRINTF_ snprintf
 #endif
 
+// The maximum number a BiggestInt can represent.  This definition
+// works no matter BiggestInt is represented in one's complement or
+// two's complement.
+//
+// We cannot rely on numeric_limits in STL, as __int64 and long long
+// are not part of standard C++ and numeric_limits doesn't need to be
+// defined for them.
+const BiggestInt kMaxBiggestInt =
+    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
+
 // This template class serves as a compile-time function from size to
 // type.  It maps a size in bytes to a primitive type with that
 // size. e.g.

googletest/src/gtest.cc

@@ -1442,8 +1442,9 @@ namespace internal {
 // The helper function for {ASSERT|EXPECT}_EQ with int or enum
 // arguments.
 AssertionResult CmpHelperEQ(const char* lhs_expression,
-                            const char* rhs_expression, std::intmax_t lhs,
-                            std::intmax_t rhs) {
+                            const char* rhs_expression,
+                            BiggestInt lhs,
+                            BiggestInt rhs) {
   if (lhs == rhs) {
     return AssertionSuccess();
   }
@@ -1456,20 +1457,20 @@ AssertionResult CmpHelperEQ(const char* lhs_expression,
 }
 
 // A macro for implementing the helper functions needed to implement
-// ASSERT_?? and EXPECT_?? with integer or enum arguments. It is here
+// ASSERT_?? and EXPECT_?? with integer or enum arguments.  It is here
 // just to avoid copy-and-paste of similar code.
-#define GTEST_IMPL_CMP_HELPER_(op_name, op)                                    \
-  AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2,     \
-                                     std::intmax_t val1, std::intmax_t val2) { \
-    if (val1 op val2) {                                                        \
-      return AssertionSuccess();                                               \
-    } else {                                                                   \
-      return AssertionFailure()                                                \
-             << "Expected: (" << expr1 << ") " #op " (" << expr2               \
-             << "), actual: " << FormatForComparisonFailureMessage(val1, val2) \
-             << " vs " << FormatForComparisonFailureMessage(val2, val1);       \
-    }                                                                          \
-  }
+#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   BiggestInt val1, BiggestInt val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    return AssertionFailure() \
+        << "Expected: (" << expr1 << ") " #op " (" << expr2\
+        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
+        << " vs " << FormatForComparisonFailureMessage(val2, val1);\
+  }\
+}
 
 // Implements the helper function for {ASSERT|EXPECT}_NE with int or
 // enum arguments.

googletest/test/googletest-printers-test.cc

@@ -83,12 +83,10 @@ void PrintTo(EnumWithPrintTo e, std::ostream* os) {
   *os << (e == kEWPT1 ? "kEWPT1" : "invalid");
 }
 
-// A class implicitly convertible to std::intmax_t.
-class IntMaxConvertible {
+// A class implicitly convertible to BiggestInt.
+class BiggestIntConvertible {
  public:
-  constexpr operator std::intmax_t() const {  // NOLINT(runtime/explicit)
-    return 42;
-  }
+  operator ::testing::internal::BiggestInt() const { return 42; }
 };
 
 // A user-defined unprintable class template in the global namespace.
@@ -269,10 +267,10 @@ TEST(PrintEnumTest, EnumWithPrintTo) {
   EXPECT_EQ("invalid", Print(static_cast<EnumWithPrintTo>(0)));
 }
 
-// Tests printing a class implicitly convertible to std::intmax_t.
+// Tests printing a class implicitly convertible to BiggestInt.
 
-TEST(PrintClassTest, IntMaxConvertible) {
-  EXPECT_EQ("42", Print(IntMaxConvertible()));
+TEST(PrintClassTest, BiggestIntConvertible) {
+  EXPECT_EQ("42", Print(BiggestIntConvertible()));
 }
 
 // Tests printing various char types.
@@ -527,9 +525,10 @@ TEST(PrintPointerTest, NonMemberFunctionPointer) {
   // standard disallows casting between pointers to functions and
   // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
   // this limitation.
-  EXPECT_EQ(PrintPointer(reinterpret_cast<const void*>(
-                reinterpret_cast<std::intptr_t>(&MyFunction))),
-            Print(&MyFunction));
+  EXPECT_EQ(
+      PrintPointer(reinterpret_cast<const void*>(
+          reinterpret_cast<internal::BiggestInt>(&MyFunction))),
+      Print(&MyFunction));
   int (*p)(bool) = NULL;  // NOLINT
   EXPECT_EQ("NULL", Print(p));
 }
@@ -1121,8 +1120,8 @@ TEST(PrintReferenceTest, HandlesFunctionPointer) {
   // standard disallows casting between pointers to functions and
   // pointers to objects, and some compilers (e.g. GCC 3.4) enforce
   // this limitation.
-  const std::string fp_string = PrintPointer(
-      reinterpret_cast<const void*>(reinterpret_cast<std::intptr_t>(fp)));
+  const std::string fp_string = PrintPointer(reinterpret_cast<const void*>(
+      reinterpret_cast<internal::BiggestInt>(fp)));
   EXPECT_EQ("@" + fp_pointer_string + " " + fp_string,
             PrintByRef(fp));
 }

googletest/test/gtest_unittest.cc

@@ -55,11 +55,11 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
   EXPECT_TRUE(dummy || !dummy);  // Suppresses warning that dummy is unused.
 }
 
+#include <limits.h>  // For INT_MAX.
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
-#include <limits>
 #include <map>
 #include <ostream>
 #include <type_traits>
@@ -3952,11 +3952,11 @@ enum {
   // On Linux, kCaseB and kCaseA have the same value when truncated to
   // int size.  We want to test whether this will confuse the
   // assertions.
-  kCaseB = (std::numeric_limits<std::intmax_t>::max)(),
+  kCaseB = testing::internal::kMaxBiggestInt,
 
 # else
 
-  kCaseB = (std::numeric_limits<int>::max)(),
+  kCaseB = INT_MAX,
 
 # endif  // GTEST_OS_LINUX