win: Some %zu to PRIuS

util/numeric/checked_range_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/numeric/checked_range.h"
 
 #include <stdint.h>
 
 #include <limits>
 
 #include "base/basictypes.h"
+#include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "gtest/gtest.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 TEST(CheckedRange, IsValid) {
   const struct UnsignedTestData {
     uint32_t base;
@@ skipping 39 matching lines @@
       {0xffffffff, 1, false},
       {0xffffffff, 2, false},
       {0xffffffff, 0x7fffffff, false},
       {0xffffffff, 0x80000000, false},
       {0xffffffff, 0xfffffffe, false},
       {0xffffffff, 0xffffffff, false},
   };
 
   for (size_t index = 0; index < arraysize(kUnsignedTestData); ++index) {
     const UnsignedTestData& testcase = kUnsignedTestData[index];
-    SCOPED_TRACE(base::StringPrintf("unsigned index %zu, base 0x%x, size 0x%x",
+    SCOPED_TRACE(base::StringPrintf("unsigned index %" PRIuS
+                                    ", base 0x%x, size 0x%x",
                                     index,
                                     testcase.base,
                                     testcase.size));
 
     CheckedRange<uint32_t> range(testcase.base, testcase.size);
     EXPECT_EQ(testcase.valid, range.IsValid());
   }
 
   const int32_t kMinInt32 = std::numeric_limits<int32_t>::min();
   const struct SignedTestData {
@@ skipping 40 matching lines @@
       {-1, 1, true},
       {-1, 2, true},
       {-1, 0x7fffffff, true},
       {-1, 0x80000000, false},
       {-1, 0xfffffffe, false},
       {-1, 0xffffffff, false},
   };
 
   for (size_t index = 0; index < arraysize(kSignedTestData); ++index) {
     const SignedTestData& testcase = kSignedTestData[index];
-    SCOPED_TRACE(base::StringPrintf("signed index %zu, base 0x%x, size 0x%x",
+    SCOPED_TRACE(base::StringPrintf("signed index %" PRIuS
+                                    ", base 0x%x, size 0x%x",
                                     index,
                                     testcase.base,
                                     testcase.size));
 
     CheckedRange<int32_t, uint32_t> range(testcase.base, testcase.size);
     EXPECT_EQ(testcase.valid, range.IsValid());
   }
 }
 
 TEST(CheckedRange, ContainsValue) {
@@ skipping 24 matching lines @@
       {0xffffdfff, false},
       {0xffffefff, false},
       {0xffffffff, false},
   };
 
   CheckedRange<uint32_t> parent_range(0x2000, 0x1000);
   ASSERT_TRUE(parent_range.IsValid());
 
   for (size_t index = 0; index < arraysize(kTestData); ++index) {
     const TestData& testcase = kTestData[index];
-    SCOPED_TRACE(
-        base::StringPrintf("index %zu, value 0x%x", index, testcase.value));
+    SCOPED_TRACE(base::StringPrintf(
+        "index %" PRIuS ", value 0x%x", index, testcase.value));
 
     EXPECT_EQ(testcase.valid, parent_range.ContainsValue(testcase.value));
   }
 }
 
 TEST(CheckedRange, ContainsRange) {
   const struct TestData {
     uint32_t base;
     uint32_t size;
     bool valid;
@@ skipping 26 matching lines @@
       {0x2fff, 1, true},
       {0x3000, 1, false},
       {0x3001, 1, false},
   };
 
   CheckedRange<uint32_t> parent_range(0x2000, 0x1000);
   ASSERT_TRUE(parent_range.IsValid());
 
   for (size_t index = 0; index < arraysize(kTestData); ++index) {
     const TestData& testcase = kTestData[index];
-    SCOPED_TRACE(base::StringPrintf("index %zu, base 0x%x, size 0x%x",
+    SCOPED_TRACE(base::StringPrintf("index %" PRIuS ", base 0x%x, size 0x%x",
                                     index,
                                     testcase.base,
                                     testcase.size));
 
     CheckedRange<uint32_t> child_range(testcase.base, testcase.size);
     ASSERT_TRUE(child_range.IsValid());
     EXPECT_EQ(testcase.valid, parent_range.ContainsRange(child_range));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad