[libc] fix string conversion tests for windows

There were some copy paste errors as well as some oddities around how
windows handles the difference between long and long long types. This
change fixes those.

Reviewed By: sivachandra

Differential Revision: https://reviews.llvm.org/D108591

Author: michaelrj-google

libc/test/src/stdlib/strtol_test.cpp

@@ -12,6 +12,7 @@
 
 #include <errno.h>
 #include <limits.h>
+#include <stddef.h>
 
 TEST(LlvmLibcStrToLTest, InvalidBase) {
   const char *ten = "10";
@@ -27,7 +28,8 @@ TEST(LlvmLibcStrToLTest, CleanBaseTenDecode) {
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(ten, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - ten, 2l);
+  EXPECT_EQ(str_end - ten, ptrdiff_t(2));
+
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(ten, nullptr, 10), 10l);
   ASSERT_EQ(errno, 0);
@@ -36,47 +38,47 @@ TEST(LlvmLibcStrToLTest, CleanBaseTenDecode) {
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(hundred, &str_end, 10), 100l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - hundred, 3l);
+  EXPECT_EQ(str_end - hundred, ptrdiff_t(3));
 
   const char *negative = "-100";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(negative, &str_end, 10), -100l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - negative, 4l);
+  EXPECT_EQ(str_end - negative, ptrdiff_t(4));
 
   const char *big_number = "123456789012345";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(big_number, &str_end, 10), 123456789012345l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - big_number, 15l);
+  EXPECT_EQ(str_end - big_number, ptrdiff_t(15));
 
   const char *big_negative_number = "-123456789012345";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(big_negative_number, &str_end, 10),
             -123456789012345l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - big_negative_number, 16l);
+  EXPECT_EQ(str_end - big_negative_number, ptrdiff_t(16));
 
   const char *too_big_number = "123456789012345678901";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(too_big_number, &str_end, 10), LONG_MAX);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - too_big_number, 21l);
+  EXPECT_EQ(str_end - too_big_number, ptrdiff_t(21));
 
   const char *too_big_negative_number = "-123456789012345678901";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(too_big_negative_number, &str_end, 10),
             LONG_MIN);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - too_big_negative_number, 22l);
+  EXPECT_EQ(str_end - too_big_negative_number, ptrdiff_t(22));
 
   const char *long_number_range_test =
       "10000000000000000000000000000000000000000000000000";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(long_number_range_test, &str_end, 10),
             LONG_MAX);
   ASSERT_EQ(errno, ERANGE);
-  EXPECT_EQ(str_end - long_number_range_test, 50l);
+  EXPECT_EQ(str_end - long_number_range_test, ptrdiff_t(50));
 }
 
 TEST(LlvmLibcStrToLTest, MessyBaseTenDecode) {
@@ -86,61 +88,61 @@ TEST(LlvmLibcStrToLTest, MessyBaseTenDecode) {
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(spaces_before, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - spaces_before, 7l);
+  EXPECT_EQ(str_end - spaces_before, ptrdiff_t(7));
 
   const char *spaces_after = "10      ";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(spaces_after, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - spaces_after, 2l);
+  EXPECT_EQ(str_end - spaces_after, ptrdiff_t(2));
 
   const char *word_before = "word10";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(word_before, &str_end, 10), 0l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - word_before, 0l);
+  EXPECT_EQ(str_end - word_before, ptrdiff_t(0));
 
   const char *word_after = "10word";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(word_after, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - word_after, 2l);
+  EXPECT_EQ(str_end - word_after, ptrdiff_t(2));
 
   const char *two_numbers = "10 999";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(two_numbers, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - two_numbers, 2l);
+  EXPECT_EQ(str_end - two_numbers, ptrdiff_t(2));
 
   const char *two_signs = "--10 999";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(two_signs, &str_end, 10), 0l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - two_signs, 1l);
+  EXPECT_EQ(str_end - two_signs, ptrdiff_t(1));
 
   const char *sign_before = "+2=4";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(sign_before, &str_end, 10), 2l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - sign_before, 2l);
+  EXPECT_EQ(str_end - sign_before, ptrdiff_t(2));
 
   const char *sign_after = "2+2=4";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(sign_after, &str_end, 10), 2l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - sign_after, 1l);
+  EXPECT_EQ(str_end - sign_after, ptrdiff_t(1));
 
   const char *tab_before = "\t10";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(tab_before, &str_end, 10), 10l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - tab_before, 3l);
+  EXPECT_EQ(str_end - tab_before, ptrdiff_t(3));
 
   const char *all_together = "\t  -12345and+67890";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(all_together, &str_end, 10), -12345l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - all_together, 9l);
+  EXPECT_EQ(str_end - all_together, ptrdiff_t(9));
 }
 
 static char int_to_b36_char(int input) {
@@ -250,13 +252,13 @@ TEST(LlvmLibcStrToLTest, CleanBaseSixteenDecode) {
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(no_prefix, &str_end, 16), 0x123abcl);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - no_prefix, 6l);
+  EXPECT_EQ(str_end - no_prefix, ptrdiff_t(6));
 
   const char *yes_prefix = "0x456def";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(yes_prefix, &str_end, 16), 0x456defl);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - yes_prefix, 8l);
+  EXPECT_EQ(str_end - yes_prefix, ptrdiff_t(8));
 }
 
 TEST(LlvmLibcStrToLTest, AutomaticBaseSelection) {
@@ -266,24 +268,24 @@ TEST(LlvmLibcStrToLTest, AutomaticBaseSelection) {
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(base_ten, &str_end, 0), 12345l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - base_ten, 5l);
+  EXPECT_EQ(str_end - base_ten, ptrdiff_t(5));
 
   const char *base_sixteen_no_prefix = "123abc";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(base_sixteen_no_prefix, &str_end, 0), 123l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - base_sixteen_no_prefix, 3l);
+  EXPECT_EQ(str_end - base_sixteen_no_prefix, ptrdiff_t(3));
 
   const char *base_sixteen_with_prefix = "0x456def";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(base_sixteen_with_prefix, &str_end, 0),
             0x456defl);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - base_sixteen_with_prefix, 8l);
+  EXPECT_EQ(str_end - base_sixteen_with_prefix, ptrdiff_t(8));
 
   const char *base_eight_with_prefix = "012345";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtol(base_eight_with_prefix, &str_end, 0), 012345l);
   ASSERT_EQ(errno, 0);
-  EXPECT_EQ(str_end - base_eight_with_prefix, 6l);
+  EXPECT_EQ(str_end - base_eight_with_prefix, ptrdiff_t(6));
 }