Update Crashpad to b47bf6c250c6b825dee1c5fbad9152c2c962e828

third_party/crashpad/crashpad/util/numeric/checked_address_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,
@@ skipping 104 matching lines @@
       {0xfffffffffffffffe, 0, kValid64Invalid32},
       {0xfffffffffffffffe, 1, kValid64Invalid32},
       {0xfffffffffffffffe, 2, kInvalid},
       {0xffffffffffffffff, 0, kValid64Invalid32},
       {0xffffffffffffffff, 1, kInvalid},
   };
 
   for (size_t index = 0; index < arraysize(kTestData); ++index) {
     const TestData& testcase = kTestData[index];
     SCOPED_TRACE(base::StringPrintf("index %" PRIuS
-                                    ", base 0x%llx, size 0x%llx",
+                                    ", base 0x%" PRIx64 ", size 0x%" PRIx64,
                                     index,
                                     testcase.base,
                                     testcase.size));
 
     CheckedAddressRange range_32(false, testcase.base, testcase.size);
     EXPECT_EQ(ExpectationForValidity32(testcase.validity), range_32.IsValid());
 
     CheckedAddressRange range_64(true, testcase.base, testcase.size);
     EXPECT_EQ(ExpectationForValidity64(testcase.validity), range_64.IsValid());
   }
@@ skipping 30 matching lines @@
       {0x100000000, false},
       {0xffffffffffffffff, false},
   };
 
   CheckedAddressRange parent_range_32(false, 0x2000, 0x1000);
   ASSERT_TRUE(parent_range_32.IsValid());
 
   for (size_t index = 0; index < arraysize(kTestData); ++index) {
     const TestData& testcase = kTestData[index];
     SCOPED_TRACE(base::StringPrintf(
-        "index %" PRIuS ", value 0x%llx", index, testcase.value));
+        "index %" PRIuS ", value 0x%" PRIx64, index, testcase.value));
 
     EXPECT_EQ(testcase.expectation,
               parent_range_32.ContainsValue(testcase.value));
   }
 
   CheckedAddressRange parent_range_64(true, 0x100000000, 0x1000);
   ASSERT_TRUE(parent_range_64.IsValid());
   EXPECT_FALSE(parent_range_64.ContainsValue(0xffffffff));
   EXPECT_TRUE(parent_range_64.ContainsValue(0x100000000));
   EXPECT_TRUE(parent_range_64.ContainsValue(0x100000001));
@@ skipping 36 matching lines @@
       {0x3000, 1, false},
       {0x3001, 1, false},
   };
 
   CheckedAddressRange parent_range_32(false, 0x2000, 0x1000);
   ASSERT_TRUE(parent_range_32.IsValid());
 
   for (size_t index = 0; index < arraysize(kTestData); ++index) {
     const TestData& testcase = kTestData[index];
     SCOPED_TRACE(base::StringPrintf("index %" PRIuS
-                                    ", base 0x%llx, size 0x%llx",
+                                    ", base 0x%" PRIx64 ", size 0x%" PRIx64,
                                     index,
                                     testcase.base,
                                     testcase.size));
 
     CheckedAddressRange child_range_32(false, testcase.base, testcase.size);
     ASSERT_TRUE(child_range_32.IsValid());
     EXPECT_EQ(testcase.expectation,
               parent_range_32.ContainsRange(child_range_32));
   }
 
   CheckedAddressRange parent_range_64(true, 0x100000000, 0x1000);
   ASSERT_TRUE(parent_range_64.IsValid());
 
   CheckedAddressRange child_range_64(true, 0xffffffff, 2);
   EXPECT_FALSE(parent_range_64.ContainsRange(child_range_64));
 
   child_range_64.SetRange(true, 0x100000000, 2);
   EXPECT_TRUE(parent_range_64.ContainsRange(child_range_64));
 
   child_range_64.SetRange(true, 0x100000ffe, 2);
   EXPECT_TRUE(parent_range_64.ContainsRange(child_range_64));
 
   child_range_64.SetRange(true, 0x100000fff, 2);
   EXPECT_FALSE(parent_range_64.ContainsRange(child_range_64));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad