win: make CrashpadInfo retrievable

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,
 // 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/mac/checked_mach_address_range.h"
-
-#include <mach/mach.h>
+#include "util/numeric/checked_address_range.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
+#include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "gtest/gtest.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
+using CheckedAddressRange = CheckedAddressRangeGeneric<uintptr_t, size_t>;
+
 enum Validity {
   kInvalid = false,
   kValid,
   kValid64Invalid32,
 };
 
 bool ExpectationForValidity32(Validity validity) {
   return validity == kValid;
 }
 
 bool ExpectationForValidity64(Validity validity) {
   return validity == kValid || validity == kValid64Invalid32;
 }
 
-TEST(CheckedMachAddressRange, IsValid) {
+TEST(CheckedAddressRange, IsValid) {
   const struct TestData {
-    mach_vm_address_t base;
-    mach_vm_size_t size;
+    uintptr_t base;

[Mark Mentovai, 2015/05/01 19:05:31]

I think these should both be uint64_t or this test will fall apart when run on
32-bit systems. It might even legitimately fail to compile, because many of the
test cases use constants too big to be expressed with 32 bits. Same on lines 29,
136, and 189.

[scottmg, 2015/05/01 19:46:32]

Sorry, that was dumb. Done.

+    size_t size;
     Validity validity;
   } kTestData[] = {
       {0, 0, kValid},
       {0, 1, kValid},
       {0, 2, kValid},
       {0, 0x7fffffff, kValid},
       {0, 0x80000000, kValid},
       {0, 0xfffffffe, kValid},
       {0, 0xffffffff, kValid},
       {0, 0xffffffffffffffff, kValid64Invalid32},
@@ skipping 52 matching lines @@
       {0x8000000000000000, 0xffffffffffffffff, kInvalid},
       {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 %zu, base 0x%llx, size 0x%llx",
+    SCOPED_TRACE(base::StringPrintf("index %" PRIuS ", base 0x%lx, size 0x%lx",
                                     index,
                                     testcase.base,
                                     testcase.size));
 
-    CheckedMachAddressRange range_32(false, testcase.base, testcase.size);
+    CheckedAddressRange range_32(false, testcase.base, testcase.size);
     EXPECT_EQ(ExpectationForValidity32(testcase.validity), range_32.IsValid());
 
-    CheckedMachAddressRange range_64(true, testcase.base, testcase.size);
+    CheckedAddressRange range_64(true, testcase.base, testcase.size);
     EXPECT_EQ(ExpectationForValidity64(testcase.validity), range_64.IsValid());
   }
 }
 
-TEST(CheckedMachAddressRange, ContainsValue) {
+TEST(CheckedAddressRange, ContainsValue) {
   const struct TestData {
-    mach_vm_address_t value;
+    uintptr_t value;
     bool expectation;
   } kTestData[] = {
       {0, false},
       {1, false},
       {0x1fff, false},
       {0x2000, true},
       {0x2001, true},
       {0x2ffe, true},
       {0x2fff, true},
       {0x3000, false},
       {0x3001, false},
       {0x7fffffff, false},
       {0x80000000, false},
       {0x80000001, false},
       {0x80001fff, false},
       {0x80002000, false},
       {0x80002001, false},
       {0x80002ffe, false},
       {0x80002fff, false},
       {0x80003000, false},
       {0x80003001, false},
       {0xffffcfff, false},
       {0xffffdfff, false},
       {0xffffefff, false},
       {0xffffffff, false},
       {0x100000000, false},
       {0xffffffffffffffff, false},
   };
 
-  CheckedMachAddressRange parent_range_32(false, 0x2000, 0x1000);
+  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 %zu, value 0x%llx", index, testcase.value));
+    SCOPED_TRACE(base::StringPrintf(
+        "index %" PRIuS ", value 0x%lx", index, testcase.value));
 
     EXPECT_EQ(testcase.expectation,
               parent_range_32.ContainsValue(testcase.value));
   }
 
-  CheckedMachAddressRange parent_range_64(true, 0x100000000, 0x1000);
+  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));
   EXPECT_TRUE(parent_range_64.ContainsValue(0x100000fff));
   EXPECT_FALSE(parent_range_64.ContainsValue(0x100001000));
 }
 
-TEST(CheckedMachAddressRange, ContainsRange) {
+TEST(CheckedAddressRange, ContainsRange) {
   const struct TestData {
-    mach_vm_address_t base;
-    mach_vm_size_t size;
+    uintptr_t base;
+    size_t size;
     bool expectation;
   } kTestData[] = {
       {0, 0, false},
       {0, 1, false},
       {0x2000, 0x1000, true},
       {0, 0x2000, false},
       {0x3000, 0x1000, false},
       {0x1800, 0x1000, false},
       {0x2800, 0x1000, false},
       {0x2000, 0x800, true},
@@ skipping 12 matching lines @@
       {0x3000, 0, true},
       {0x3001, 0, false},
       {0x1fff, 1, false},
       {0x2000, 1, true},
       {0x2001, 1, true},
       {0x2fff, 1, true},
       {0x3000, 1, false},
       {0x3001, 1, false},
   };
 
-  CheckedMachAddressRange parent_range_32(false, 0x2000, 0x1000);
+  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 %zu, base 0x%llx, size 0x%llx",
+    SCOPED_TRACE(base::StringPrintf("index %" PRIuS ", base 0x%lx, size 0x%lx",
                                     index,
                                     testcase.base,
                                     testcase.size));
 
-    CheckedMachAddressRange child_range_32(false, 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));
   }
 
-  CheckedMachAddressRange parent_range_64(true, 0x100000000, 0x1000);
+  CheckedAddressRange parent_range_64(true, 0x100000000, 0x1000);
   ASSERT_TRUE(parent_range_64.IsValid());
 
-  CheckedMachAddressRange child_range_64(true, 0xffffffff, 2);
+  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