[libc] Fix various -Wconversion warnings in strto*l test code.

[mcgrathr]

Summary

The Fuchsia build compiles the libc and test code with lots
of warnings enabled, including all the integer conversion warnings.
There was some sloppy type usage here that triggered some of those.

[michaelrj]

libc/test/src/stdlib/strtol_test.cpp

164

If you're changing the types of base and the digits then you also have to add a cast to the appropriate type on each of the ASSERT_EQs in the loops, since if the base types are int then the resulting type will also be int, which won't match the type of the output of the functions.

[mcgrathr]

add more casts

[michaelrj]

LGTM

libc/test/src/stdlib/strtol_test.cpp

TEST(LlvmLibcStrToLTest, MessyBaseTenDecode) {
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - all_together, ptrdiff_t(9));
 }
 
 static char int_to_b36_char(int input) {
   if (input < 0 || input > 36)
     return '0';
   if (input < 10)
-    return '0' + input;
-  return 'A' + input - 10;
+    return static_cast<char>('0' + input);
+  return static_cast<char>('A' + input - 10);
 }
 
 TEST(LlvmLibcStrToLTest, DecodeInOtherBases) {
   char small_string[4] = {'\0', '\0', '\0', '\0'};
-  for (long base = 2; base <= 36; ++base) {
-    for (long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
       if (first_digit < base) {
         errno = 0;
         ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
-                  first_digit);
+                  static_cast<long int>(first_digit));
         ASSERT_EQ(errno, 0);
       } else {
         errno = 0;
         ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base), 0l);
         ASSERT_EQ(errno, 0);
       }
     }
   }
 
-  for (long base = 2; base <= 36; ++base) {
-    for (long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (int second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
         if (first_digit < base && second_digit < base) {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
-                    second_digit + (first_digit * base));
+                    static_cast<long int>(second_digit + (first_digit * base)));
           ASSERT_EQ(errno, 0);
         } else if (first_digit < base) {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
-                    first_digit);
+                    static_cast<long int>(first_digit));
           ASSERT_EQ(errno, 0);
         } else {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base), 0l);
           ASSERT_EQ(errno, 0);
         }
       }
     }
   }
 
-  for (long base = 2; base <= 36; ++base) {
-    for (long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (int second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
-        for (long third_digit = 0; third_digit <= 36; ++third_digit) {
+        for (int third_digit = 0; third_digit <= 36; ++third_digit) {
           small_string[2] = int_to_b36_char(third_digit);
 
           if (first_digit < base && second_digit < base && third_digit < base) {
             errno = 0;
             ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
-                      third_digit + (second_digit * base) +
-                          (first_digit * base * base));
+                      static_cast<long int>(third_digit +
+                                            (second_digit * base) +
+                                            (first_digit * base * base)));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base && second_digit < base) {
             errno = 0;
-            ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
-                      second_digit + (first_digit * base));
+            ASSERT_EQ(
+                __llvm_libc::strtol(small_string, nullptr, base),
+                static_cast<long int>(second_digit + (first_digit * base)));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base) {
             // if the base is 16 there is a special case for the prefix 0X.
             // The number is treated as a one digit hexadecimal.
             if (base == 16 && first_digit == 0 && second_digit == 33) {
               if (third_digit < base) {
                 errno = 0;
                 ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
-                          third_digit);
+                          static_cast<long int>(third_digit));
                 ASSERT_EQ(errno, 0);
               } else {
                 errno = 0;
                 ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base), 0l);
                 ASSERT_EQ(errno, 0);
               }
             } else {
               errno = 0;
               ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base),
-                        first_digit);
+                        static_cast<long int>(first_digit));
               ASSERT_EQ(errno, 0);
             }
           } else {
             errno = 0;
             ASSERT_EQ(__llvm_libc::strtol(small_string, nullptr, base), 0l);
             ASSERT_EQ(errno, 0);
           }
         }

libc/test/src/stdlib/strtoll_test.cpp

TEST(LlvmLibcStrToLLTest, MessyBaseTenDecode) {
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - all_together, ptrdiff_t(9));
 }
 
 static char int_to_b36_char(int input) {
   if (input < 0 || input > 36)
     return '0';
   if (input < 10)
-    return '0' + input;
-  return 'A' + input - 10;
+    return static_cast<char>('0' + input);
+  return static_cast<char>('A' + input - 10);
 }
 
 TEST(LlvmLibcStrToLLTest, DecodeInOtherBases) {
   char small_string[4] = {'\0', '\0', '\0', '\0'};
-  for (long long base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
       if (first_digit < base) {
         errno = 0;
         ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
-                  first_digit);
+                  static_cast<long long int>(first_digit));
         ASSERT_EQ(errno, 0);
       } else {
         errno = 0;
         ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
         ASSERT_EQ(errno, 0);
       }
     }
   }
 
-  for (long long base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (long long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (int second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
         if (first_digit < base && second_digit < base) {
           errno = 0;
-          ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
-                    second_digit + (first_digit * base));
+          ASSERT_EQ(
+              __llvm_libc::strtoll(small_string, nullptr, base),
+              static_cast<long long int>(second_digit + (first_digit * base)));
           ASSERT_EQ(errno, 0);
         } else if (first_digit < base) {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
-                    first_digit);
+                    static_cast<long long int>(first_digit));
           ASSERT_EQ(errno, 0);
         } else {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
           ASSERT_EQ(errno, 0);
         }
       }
     }
   }
 
-  for (long long base = 2; base <= 36; ++base) {
-    for (long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (long long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (int second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
-        for (long long third_digit = 0; third_digit <= 36; ++third_digit) {
+        for (int third_digit = 0; third_digit <= 36; ++third_digit) {
           small_string[2] = int_to_b36_char(third_digit);
 
           if (first_digit < base && second_digit < base && third_digit < base) {
             errno = 0;
             ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
-                      third_digit + (second_digit * base) +
-                          (first_digit * base * base));
+                      static_cast<long long int>(third_digit +
+                                                 (second_digit * base) +
+                                                 (first_digit * base * base)));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base && second_digit < base) {
             errno = 0;
             ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
-                      second_digit + (first_digit * base));
+                      static_cast<long long int>(second_digit +
+                                                 (first_digit * base)));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base) {
             // if the base is 16 there is a special case for the prefix 0X.
             // The number is treated as a one digit hexadecimal.
             if (base == 16 && first_digit == 0 && second_digit == 33) {
               if (third_digit < base) {
                 errno = 0;
                 ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
-                          third_digit);
+                          static_cast<long long int>(third_digit));
                 ASSERT_EQ(errno, 0);
               } else {
                 errno = 0;
                 ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
                           0ll);
                 ASSERT_EQ(errno, 0);
               }
             } else {
               errno = 0;
               ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base),
-                        first_digit);
+                        static_cast<long long int>(first_digit));
               ASSERT_EQ(errno, 0);
             }
           } else {
             errno = 0;
             ASSERT_EQ(__llvm_libc::strtoll(small_string, nullptr, base), 0ll);
             ASSERT_EQ(errno, 0);
           }
         }

libc/test/src/stdlib/strtoul_test.cpp

 //===-- Unittests for strtoul ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/stdlib/strtoul.h"
 
-#include "utils/UnitTest/Test.h"
-
 #include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 
+#include "utils/UnitTest/Test.h"
+
 TEST(LlvmLibcStrToULTest, InvalidBase) {
   const char *ten = "10";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtoul(ten, nullptr, -1), 0ul);
   ASSERT_EQ(errno, EINVAL);
 }
 
 TEST(LlvmLibcStrToULTest, CleanBaseTenDecode) {
TEST(LlvmLibcStrToULTest, MessyBaseTenDecode) {
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - all_together, ptrdiff_t(9));
 }
 
 static char int_to_b36_char(int input) {
   if (input < 0 || input > 36)
     return '0';
   if (input < 10)
-    return '0' + input;
-  return 'A' + input - 10;
+    return static_cast<char>('0' + input);
+  return static_cast<char>('A' + input - 10);
 }
 
 TEST(LlvmLibcStrToULTest, DecodeInOtherBases) {
   char small_string[4] = {'\0', '\0', '\0', '\0'};
-  for (unsigned long base = 2; base <= 36; ++base) {
-    for (unsigned long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
       if (first_digit < base) {
         errno = 0;
         ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
-                  first_digit);
+                  static_cast<unsigned long int>(first_digit));
         ASSERT_EQ(errno, 0);
       } else {
         errno = 0;
         ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base), 0ul);
         ASSERT_EQ(errno, 0);
       }
     }
   }
 
-  for (unsigned long base = 2; base <= 36; ++base) {
-    for (unsigned long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (unsigned long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (int second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
         if (first_digit < base && second_digit < base) {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
-                    second_digit + (first_digit * base));
+                    static_cast<unsigned long int>(second_digit +
+                                                   (first_digit * base)));
           ASSERT_EQ(errno, 0);
         } else if (first_digit < base) {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
-                    first_digit);
+                    static_cast<unsigned long int>(first_digit));
           ASSERT_EQ(errno, 0);
         } else {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base), 0ul);
           ASSERT_EQ(errno, 0);
         }
       }
     }
   }
 
-  for (unsigned long base = 2; base <= 36; ++base) {
-    for (unsigned long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (unsigned long second_digit = 0; second_digit <= 36; ++second_digit) {
+      for (int second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
-        for (unsigned long third_digit = 0; third_digit <= 36; ++third_digit) {
+        for (int third_digit = 0; third_digit <= 36; ++third_digit) {
           small_string[2] = int_to_b36_char(third_digit);
 
           if (first_digit < base && second_digit < base && third_digit < base) {
             errno = 0;
             ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
+                      static_cast<unsigned long int>(
                           third_digit + (second_digit * base) +
-                          (first_digit * base * base));
+                          (first_digit * base * base)));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base && second_digit < base) {
             errno = 0;
             ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
-                      second_digit + (first_digit * base));
+                      static_cast<unsigned long int>(second_digit +
+                                                     (first_digit * base)));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base) {
             // if the base is 16 there is a special case for the prefix 0X.
             // The number is treated as a one digit hexadecimal.
             if (base == 16 && first_digit == 0 && second_digit == 33) {
               if (third_digit < base) {
                 errno = 0;
                 ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
-                          third_digit);
+                          static_cast<unsigned long int>(third_digit));
                 ASSERT_EQ(errno, 0);
               } else {
                 errno = 0;
                 ASSERT_EQ(__llvm_libc::strtoul(small_string, nullptr, base),
                           0ul);
                 ASSERT_EQ(errno, 0);
               }
             } else {

libc/test/src/stdlib/strtoull_test.cpp

 //===-- Unittests for strtoull --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/stdlib/strtoull.h"
 
-#include "utils/UnitTest/Test.h"
-
 #include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 
+#include "utils/UnitTest/Test.h"
+
 TEST(LlvmLibcStrToULLTest, InvalidBase) {
   const char *ten = "10";
   errno = 0;
   ASSERT_EQ(__llvm_libc::strtoull(ten, nullptr, -1), 0ull);
   ASSERT_EQ(errno, EINVAL);
 }
 
 TEST(LlvmLibcStrToULLTest, CleanBaseTenDecode) {
TEST(LlvmLibcStrToULLTest, MessyBaseTenDecode) {
   ASSERT_EQ(errno, 0);
   EXPECT_EQ(str_end - all_together, ptrdiff_t(9));
 }
 
 static char int_to_b36_char(int input) {
   if (input < 0 || input > 36)
     return '0';
   if (input < 10)
-    return '0' + input;
-  return 'A' + input - 10;
+    return static_cast<char>('0' + input);
+  return static_cast<char>('A' + input - 10);
 }
 
 TEST(LlvmLibcStrToULLTest, DecodeInOtherBases) {
   char small_string[4] = {'\0', '\0', '\0', '\0'};
-  for (unsigned long long base = 2; base <= 36; ++base) {
-    for (unsigned long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
       if (first_digit < base) {
         errno = 0;
         ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
-                  first_digit);
+                  static_cast<unsigned long long int>(first_digit));
         ASSERT_EQ(errno, 0);
       } else {
         errno = 0;
         ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base), 0ull);
         ASSERT_EQ(errno, 0);
       }
     }
   }
 
-  for (unsigned long long base = 2; base <= 36; ++base) {
-    for (unsigned long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (unsigned long long second_digit = 0; second_digit <= 36;
-           ++second_digit) {
+      for (int second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
         if (first_digit < base && second_digit < base) {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
-                    second_digit + (first_digit * base));
+                    static_cast<unsigned long long int>(second_digit +
+                                                        (first_digit * base)));
           ASSERT_EQ(errno, 0);
         } else if (first_digit < base) {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
-                    first_digit);
+                    static_cast<unsigned long long int>(first_digit));
           ASSERT_EQ(errno, 0);
         } else {
           errno = 0;
           ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base), 0ull);
           ASSERT_EQ(errno, 0);
         }
       }
     }
   }
 
-  for (unsigned long long base = 2; base <= 36; ++base) {
-    for (unsigned long long first_digit = 0; first_digit <= 36; ++first_digit) {
+  for (int base = 2; base <= 36; ++base) {
+    for (int first_digit = 0; first_digit <= 36; ++first_digit) {
       small_string[0] = int_to_b36_char(first_digit);
-      for (unsigned long long second_digit = 0; second_digit <= 36;
-           ++second_digit) {
+      for (int second_digit = 0; second_digit <= 36; ++second_digit) {
         small_string[1] = int_to_b36_char(second_digit);
-        for (unsigned long long third_digit = 0; third_digit <= 36;
-             ++third_digit) {
+        for (int third_digit = 0; third_digit <= 36; ++third_digit) {
           small_string[2] = int_to_b36_char(third_digit);
 
           if (first_digit < base && second_digit < base && third_digit < base) {
             errno = 0;
             ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
+                      static_cast<unsigned long long int>(
                           third_digit + (second_digit * base) +
-                          (first_digit * base * base));
+                          (first_digit * base * base)));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base && second_digit < base) {
             errno = 0;
             ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
-                      second_digit + (first_digit * base));
+                      static_cast<unsigned long long int>(
+                          second_digit + (first_digit * base)));
             ASSERT_EQ(errno, 0);
           } else if (first_digit < base) {
             // if the base is 16 there is a special case for the prefix 0X.
             // The number is treated as a one digit hexadecimal.
             if (base == 16 && first_digit == 0 && second_digit == 33) {
               if (third_digit < base) {
                 errno = 0;
                 ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
-                          third_digit);
+                          static_cast<unsigned long long int>(third_digit));
                 ASSERT_EQ(errno, 0);
               } else {
                 errno = 0;
                 ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
                           0ull);
                 ASSERT_EQ(errno, 0);
               }
             } else {
               errno = 0;
               ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base),
-                        first_digit);
+                        static_cast<unsigned long long int>(first_digit));
               ASSERT_EQ(errno, 0);
             }
           } else {
             errno = 0;
             ASSERT_EQ(__llvm_libc::strtoull(small_string, nullptr, base), 0ull);
             ASSERT_EQ(errno, 0);
           }
         }