Really fix tests broken at 9778206.

core/src/fxcrt/fx_system_unittest.cpp

 // Copyright 2015 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "../../../testing/fx_string_testhelpers.h"
 #include "../../include/fxcrt/fx_system.h"
 
@@ skipping 52 matching lines @@
   const size_t kBufLen = 67;  // "-" + 64 digits + NUL + sentinel.
   FX_CHAR buf[kBufLen];
   buf[kBufLen - 1] = kSentinel;
   FXSYS_i64toa(input, buf, 2);
   EXPECT_EQ(std::string(expected_output), buf);
   EXPECT_EQ(kSentinel, buf[kBufLen - 1]);
 }
 
 }  // namespace
 
+#if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
+
 TEST(fxcrt, FXSYS_itoa_InvalidRadix) {
   FX_CHAR buf[32];
 
-#if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
   FXSYS_itoa(42, buf, 17);  // Ours stops at 16.
-#else
-  FXSYS_itoa(42, buf, 37);  // Theirs goes up to 36.
-#endif
   EXPECT_EQ(std::string(""), buf);
 
   FXSYS_itoa(42, buf, 1);
   EXPECT_EQ(std::string(""), buf);
 
   FXSYS_itoa(42, buf, 0);
   EXPECT_EQ(std::string(""), buf);
 
   FXSYS_itoa(42, buf, -1);
   EXPECT_EQ(std::string(""), buf);
 }
 
+#endif  // _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
+
 TEST(fxcrt, FXSYS_itoa) {
   Check32BitBase16Itoa(std::numeric_limits<int32_t>::min(), "-80000000");
   Check32BitBase10Itoa(std::numeric_limits<int32_t>::min(), "-2147483648");
   Check32BitBase2Itoa(std::numeric_limits<int32_t>::min(),
                       "-10000000000000000000000000000000");
 
   Check32BitBase16Itoa(-1, "-1");
   Check32BitBase10Itoa(-1, "-1");
   Check32BitBase2Itoa(-1, "-1");
 
   Check32BitBase16Itoa(0, "0");
   Check32BitBase10Itoa(0, "0");
   Check32BitBase2Itoa(0, "0");
 
   Check32BitBase16Itoa(42, "2a");
   Check32BitBase10Itoa(42, "42");
   Check32BitBase2Itoa(42, "101010");
 
   Check32BitBase16Itoa(std::numeric_limits<int32_t>::max(), "7fffffff");
   Check32BitBase10Itoa(std::numeric_limits<int32_t>::max(), "2147483647");
   Check32BitBase2Itoa(std::numeric_limits<int32_t>::max(),
                       "1111111111111111111111111111111");
 }
 
+#if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
 
 TEST(fxcrt, FXSYS_i64toa_InvalidRadix) {
   FX_CHAR buf[32];
 
-#if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
   FXSYS_i64toa(42, buf, 17);  // Ours stops at 16.
-#else
-  FXSYS_i64toa(42, buf, 37);  // Theirs goes up to 36.
-#endif
   EXPECT_EQ(std::string(""), buf);
 
   FXSYS_i64toa(42, buf, 1);
   EXPECT_EQ(std::string(""), buf);
 
   FXSYS_i64toa(42, buf, 0);
   EXPECT_EQ(std::string(""), buf);
 
   FXSYS_i64toa(42, buf, -1);
   EXPECT_EQ(std::string(""), buf);
 };
 
+#endif  // _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
+
 TEST(fxcrt, FXSYS_i64toa) {
   Check64BitBase16Itoa(
       std::numeric_limits<int64_t>::min(), "-8000000000000000");
   Check64BitBase10Itoa(
       std::numeric_limits<int64_t>::min(), "-9223372036854775808");
   Check64BitBase2Itoa(
       std::numeric_limits<int64_t>::min(),
       "-1000000000000000000000000000000000000000000000000000000000000000");
 
   Check64BitBase16Itoa(-1, "-1");
   Check64BitBase10Itoa(-1, "-1");
   Check64BitBase2Itoa(-1, "-1");
 
   Check64BitBase16Itoa(0, "0");
   Check64BitBase10Itoa(0, "0");
   Check64BitBase2Itoa(0, "0");
 
   Check64BitBase16Itoa(42, "2a");
   Check64BitBase10Itoa(42, "42");
   Check64BitBase2Itoa(42, "101010");
 
   Check64BitBase16Itoa(
       std::numeric_limits<int64_t>::max(), "7fffffffffffffff");
   Check64BitBase10Itoa(
       std::numeric_limits<int64_t>::max(), "9223372036854775807");
   Check64BitBase2Itoa(
       std::numeric_limits<int64_t>::max(),
       "111111111111111111111111111111111111111111111111111111111111111");
 }