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

base/strings/safe_sprintf_unittest.cc

 // Copyright 2013 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 "base/strings/safe_sprintf.h"
 
 #include <stdio.h>
 #include <string.h>
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Death tests on Android are currently very flaky. No need to add more flaky
 // tests, as they just make it hard to spot real problems.
 // TODO(markus): See if the restrictions on Android can eventually be lifted.
 #if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
 #define ALLOW_DEATH_TEST
 #endif
 
 namespace base {
 namespace strings {
 
 TEST(SafeSPrintfTest, Empty) {
   char buf[2] = { 'X', 'X' };
 
   // Negative buffer size should always result in an error.
-  EXPECT_EQ(-1, SafeSNPrintf(buf, -1, ""));
+  EXPECT_EQ(-1, SafeSNPrintf(buf, static_cast<size_t>(-1), ""));
   EXPECT_EQ('X', buf[0]);
   EXPECT_EQ('X', buf[1]);
 
   // Zero buffer size should always result in an error.
   EXPECT_EQ(-1, SafeSNPrintf(buf, 0, ""));
   EXPECT_EQ('X', buf[0]);
   EXPECT_EQ('X', buf[1]);
 
   // A one-byte buffer should always print a single NUL byte.
   EXPECT_EQ(0, SafeSNPrintf(buf, 1, ""));
@@ skipping 17 matching lines @@
 TEST(SafeSPrintfTest, NoArguments) {
   // Output a text message that doesn't require any substitutions. This
   // is roughly equivalent to calling strncpy() (but unlike strncpy(), it does
   // always add a trailing NUL; it always deduplicates '%' characters).
   static const char text[] = "hello world";
   char ref[20], buf[20];
   memset(ref, 'X', sizeof(char) * arraysize(buf));
   memcpy(buf, ref, sizeof(buf));
 
   // A negative buffer size should always result in an error.
-  EXPECT_EQ(-1, SafeSNPrintf(buf, -1, text));
+  EXPECT_EQ(-1, SafeSNPrintf(buf, static_cast<size_t>(-1), text));
   EXPECT_TRUE(!memcmp(buf, ref, sizeof(buf)));
 
   // Zero buffer size should always result in an error.
   EXPECT_EQ(-1, SafeSNPrintf(buf, 0, text));
   EXPECT_TRUE(!memcmp(buf, ref, sizeof(buf)));
 
   // A one-byte buffer should always print a single NUL byte.
   EXPECT_EQ(static_cast<ssize_t>(sizeof(text))-1, SafeSNPrintf(buf, 1, text));
   EXPECT_EQ(0, buf[0]);
   EXPECT_TRUE(!memcmp(buf+1, ref+1, sizeof(buf)-1));
@@ skipping 43 matching lines @@
 
 TEST(SafeSPrintfTest, OneArgument) {
   // Test basic single-argument single-character substitution.
   const char text[] = "hello world";
   const char fmt[]  = "hello%cworld";
   char ref[20], buf[20];
   memset(ref, 'X', sizeof(buf));
   memcpy(buf, ref, sizeof(buf));
 
   // A negative buffer size should always result in an error.
-  EXPECT_EQ(-1, SafeSNPrintf(buf, -1, fmt, ' '));
+  EXPECT_EQ(-1, SafeSNPrintf(buf, static_cast<size_t>(-1), fmt, ' '));
   EXPECT_TRUE(!memcmp(buf, ref, sizeof(buf)));
 
   // Zero buffer size should always result in an error.
   EXPECT_EQ(-1, SafeSNPrintf(buf, 0, fmt, ' '));
   EXPECT_TRUE(!memcmp(buf, ref, sizeof(buf)));
 
   // A one-byte buffer should always print a single NUL byte.
   EXPECT_EQ(static_cast<ssize_t>(sizeof(text))-1,
             SafeSNPrintf(buf, 1, fmt, ' '));
   EXPECT_EQ(0, buf[0]);
@@ skipping 600 matching lines @@
   void *ptr = str;
   char buf[40];
   EXPECT_EQ(10, SafeSPrintf(buf, "%p", str));
   EXPECT_EQ("0x80000000", std::string(buf));
   EXPECT_EQ(10, SafeSPrintf(buf, "%p", ptr));
   EXPECT_EQ("0x80000000", std::string(buf));
 }
 
 }  // namespace strings
 }  // namespace base