Fixes for re-enabling more MSVC level 4 warnings: base/ edition

base/strings/string_number_conversions_unittest.cc

 // Copyright (c) 2012 The Chromium 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 <errno.h>
 #include <stdint.h>
 #include <stdio.h>
 
 #include <cmath>
 #include <limits>
@@ skipping 455 matching lines @@
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     int output = 0;
     EXPECT_EQ(cases[i].success, HexStringToInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
-  const char input[] = "0xc0ffee\09";
+  const char input[] = "0xc0ffee\0" "9";
   std::string input_string(input, arraysize(input) - 1);
   int output;
   EXPECT_FALSE(HexStringToInt(input_string, &output));
   EXPECT_EQ(0xc0ffee, output);
 }
 
 TEST(StringNumberConversionsTest, HexStringToUInt) {
   static const struct {
     std::string input;
     uint32 output;
@@ skipping 39 matching lines @@
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     uint32 output = 0;
     EXPECT_EQ(cases[i].success, HexStringToUInt(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
-  const char input[] = "0xc0ffee\09";
+  const char input[] = "0xc0ffee\0" "9";
   std::string input_string(input, arraysize(input) - 1);
   uint32 output;
   EXPECT_FALSE(HexStringToUInt(input_string, &output));
   EXPECT_EQ(0xc0ffeeU, output);
 }
 
 TEST(StringNumberConversionsTest, HexStringToInt64) {
   static const struct {
     std::string input;
     int64 output;
@@ skipping 36 matching lines @@
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     int64 output = 0;
     EXPECT_EQ(cases[i].success, HexStringToInt64(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
-  const char input[] = "0xc0ffee\09";
+  const char input[] = "0xc0ffee\0" "9";
   std::string input_string(input, arraysize(input) - 1);
   int64 output;
   EXPECT_FALSE(HexStringToInt64(input_string, &output));
   EXPECT_EQ(0xc0ffee, output);
 }
 
 TEST(StringNumberConversionsTest, HexStringToUInt64) {
   static const struct {
     std::string input;
     uint64 output;
@@ skipping 41 matching lines @@
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     uint64 output = 0;
     EXPECT_EQ(cases[i].success, HexStringToUInt64(cases[i].input, &output));
     EXPECT_EQ(cases[i].output, output);
   }
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
-  const char input[] = "0xc0ffee\09";
+  const char input[] = "0xc0ffee\0" "9";
   std::string input_string(input, arraysize(input) - 1);
   uint64 output;
   EXPECT_FALSE(HexStringToUInt64(input_string, &output));
   EXPECT_EQ(0xc0ffeeU, output);
 }
 
 TEST(StringNumberConversionsTest, HexStringToBytes) {
   static const struct {
     const std::string input;
     const char* output;
@@ skipping 74 matching lines @@
     errno = 1;
     EXPECT_EQ(cases[i].success, StringToDouble(cases[i].input, &output));
     if (cases[i].success)
       EXPECT_EQ(1, errno) << i;  // confirm that errno is unchanged.
     EXPECT_DOUBLE_EQ(cases[i].output, output);
   }
 
   // One additional test to verify that conversion of numbers in strings with
   // embedded NUL characters.  The NUL and extra data after it should be
   // interpreted as junk after the number.
-  const char input[] = "3.14\0159";
+  const char input[] = "3.14\0" "159";
   std::string input_string(input, arraysize(input) - 1);
   double output;
   EXPECT_FALSE(StringToDouble(input_string, &output));
   EXPECT_DOUBLE_EQ(3.14, output);
 }
 
 TEST(StringNumberConversionsTest, DoubleToString) {
   static const struct {
     double input;
     const char* expected;
@@ skipping 25 matching lines @@
 
 TEST(StringNumberConversionsTest, HexEncode) {
   std::string hex(HexEncode(NULL, 0));
   EXPECT_EQ(hex.length(), 0U);
   unsigned char bytes[] = {0x01, 0xff, 0x02, 0xfe, 0x03, 0x80, 0x81};
   hex = HexEncode(bytes, sizeof(bytes));
   EXPECT_EQ(hex.compare("01FF02FE038081"), 0);
 }
 
 }  // namespace base