win: Some %zu to PRIuS

util/stdlib/strlcpy_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/stdlib/strlcpy.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "base/basictypes.h"
+#include "base/format_macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 TEST(strlcpy, c16lcpy) {
   // Use a destination buffer that’s larger than the length passed to c16lcpy.
   // The unused portion is a guard area that must not be written to.
   struct TestBuffer {
     base::char16 lead_guard[64];
     base::char16 data[128];
     base::char16 trail_guard[64];
   };
   TestBuffer expected_untouched;
   memset(&expected_untouched, 0xa5, sizeof(expected_untouched));
 
   // Test with M, é, Ā, ő, and Ḙ. This is a mix of characters that have zero and
   // nonzero low and high bytes.
   const base::char16 test_characters[] = {0x4d, 0xe9, 0x100, 0x151, 0x1e18};
 
   for (size_t index = 0; index < arraysize(test_characters); ++index) {
     base::char16 test_character = test_characters[index];
     SCOPED_TRACE(base::StringPrintf(
-        "character index %zu, character 0x%x", index, test_character));
+        "character index %" PRIuS ", character 0x%x", index, test_character));
     for (size_t length = 0; length < 256; ++length) {
-      SCOPED_TRACE(base::StringPrintf("index %zu", length));
+      SCOPED_TRACE(
+          base::StringPrintf("index %" PRIuS, length));
       base::string16 test_string(length, test_character);
 
       TestBuffer destination;
       memset(&destination, 0xa5, sizeof(destination));
 
       EXPECT_EQ(length,
                 c16lcpy(destination.data,
                         test_string.c_str(),
                         arraysize(destination.data)));
 
@@ skipping 23 matching lines @@
       EXPECT_TRUE(base::c16memcmp(expected_untouched.trail_guard,
                                   destination.trail_guard,
                                   arraysize(destination.trail_guard)) == 0);
     }
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad