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

PiperOrigin-RevId: 277979766

2 files changed, 16 insertions, 15 deletions

diff --git a/googletest/test/googletest-printers-test.cc b/googletest/test/googletest-printers-test.cc
index 58be7d1c..cebd6ace 100644
--- a/googletest/test/googletest-printers-test.cc
+++ b/googletest/test/googletest-printers-test.cc
@@ -83,10 +83,12 @@ void PrintTo(EnumWithPrintTo e, std::ostream* os) {
   *os << (e == kEWPT1 ? "kEWPT1" : "invalid");
 }
 
-// A class implicitly convertible to BiggestInt.
-class BiggestIntConvertible {
+// A class implicitly convertible to std::intmax_t.
+class IntMaxConvertible {
  public:
-  operator ::testing::internal::BiggestInt() const { return 42; }
+  constexpr operator std::intmax_t() const {  // NOLINT(runtime/explicit)
+    return 42;
+  }
 };
 
 // A user-defined unprintable class template in the global namespace.
@@ -267,10 +269,10 @@ TEST(PrintEnumTest, EnumWithPrintTo) {
   EXPECT_EQ("invalid", Print(static_cast<EnumWithPrintTo>(0)));
 }
 
-// Tests printing a class implicitly convertible to BiggestInt.
+// Tests printing a class implicitly convertible to std::intmax_t.
 
-TEST(PrintClassTest, BiggestIntConvertible) {
-  EXPECT_EQ("42", Print(BiggestIntConvertible()));
+TEST(PrintClassTest, IntMaxConvertible) {
+  EXPECT_EQ("42", Print(IntMaxConvertible()));
 }
 
 // Tests printing various char types.
@@ -525,10 +527,9 @@ 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<internal::BiggestInt>(&MyFunction))),
-      Print(&MyFunction));
+  EXPECT_EQ(PrintPointer(reinterpret_cast<const void*>(
+                reinterpret_cast<std::intptr_t>(&MyFunction))),
+            Print(&MyFunction));
   int (*p)(bool) = NULL;  // NOLINT
   EXPECT_EQ("NULL", Print(p));
 }
@@ -1120,8 +1121,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<internal::BiggestInt>(fp)));
+  const std::string fp_string = PrintPointer(
+      reinterpret_cast<const void*>(reinterpret_cast<std::intptr_t>(fp)));
   EXPECT_EQ("@" + fp_pointer_string + " " + fp_string,
             PrintByRef(fp));
 }
diff --git a/googletest/test/gtest_unittest.cc b/googletest/test/gtest_unittest.cc
index d17a1554..ae8834db 100644
--- a/googletest/test/gtest_unittest.cc
+++ b/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 = testing::internal::kMaxBiggestInt,
+  kCaseB = (std::numeric_limits<std::intmax_t>::max)(),
 
 # else
 
-  kCaseB = INT_MAX,
+  kCaseB = (std::numeric_limits<int>::max)(),
 
 # endif  // GTEST_OS_LINUX