win: Add memory map range intersection helper

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,
@@ skipping 137 matching lines @@
                                     testcase.size));
 
     CheckedRange<int32_t, uint32_t> range(testcase.base, testcase.size);
     EXPECT_EQ(testcase.valid, range.IsValid());
   }
 }
 
 TEST(CheckedRange, ContainsValue) {
   const struct TestData {
     uint32_t value;
-    bool valid;
+    bool contains;
   } kTestData[] = {
       {0, false},
       {1, false},
       {0x1fff, false},
       {0x2000, true},
       {0x2001, true},
       {0x2ffe, true},
       {0x2fff, true},
       {0x3000, false},
       {0x3001, false},
@@ skipping 14 matching lines @@
   };
 
   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 %" PRIuS ", value 0x%x", index, testcase.value));
 
-    EXPECT_EQ(testcase.valid, parent_range.ContainsValue(testcase.value));
+    EXPECT_EQ(testcase.contains, parent_range.ContainsValue(testcase.value));
   }
 }
 
 TEST(CheckedRange, ContainsRange) {
   const struct TestData {
     uint32_t base;
     uint32_t size;
-    bool valid;
+    bool contains;
   } 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},
       {0x2800, 0x800, true},
@@ skipping 23 matching lines @@
 
   for (size_t index = 0; index < arraysize(kTestData); ++index) {
     const TestData& testcase = kTestData[index];
     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));
+    EXPECT_EQ(testcase.contains, parent_range.ContainsRange(child_range));
   }
 }
 
+TEST(CheckedRange, OverlapsRange) {
+  const struct TestData {
+    uint32_t base;
+    uint32_t size;
+    bool overlaps;
+  } kTestData[] = {
+      {0, 0, false},
+      {0, 1, false},
+      {0x2000, 0x1000, true},
+      {0, 0x2000, false},
+      {0x3000, 0x1000, false},
+      {0x1800, 0x1000, true},
+      {0x1800, 0x2000, true},
+      {0x2800, 0x1000, true},
+      {0x2000, 0x800, true},
+      {0x2800, 0x800, true},
+      {0x2400, 0x800, true},
+      {0x2800, 0, false},
+      {0x2000, 0xffffdfff, true},
+      {0x2800, 0xffffd7ff, true},
+      {0x3000, 0xffffcfff, false},
+      {0xfffffffe, 1, false},
+      {0xffffffff, 0, false},
+      {0x1fff, 0, false},
+      {0x2000, 0, false},
+      {0x2001, 0, false},
+      {0x2fff, 0, false},
+      {0x3000, 0, false},
+      {0x3001, 0, false},
+      {0x1fff, 1, false},
+      {0x2000, 1, true},
+      {0x2001, 1, true},
+      {0x2fff, 1, true},
+      {0x3000, 1, false},
+      {0x3001, 1, false},
+  };
+
+  CheckedRange<uint32_t> first_range(0x2000, 0x1000);
+  ASSERT_TRUE(first_range.IsValid());
+
+  for (size_t index = 0; index < arraysize(kTestData); ++index) {
+    const TestData& testcase = kTestData[index];
+    SCOPED_TRACE(base::StringPrintf("index %" PRIuS ", base 0x%x, size 0x%x",
+                                    index,
+                                    testcase.base,
+                                    testcase.size));
+
+    CheckedRange<uint32_t> second_range(testcase.base, testcase.size);
+    ASSERT_TRUE(second_range.IsValid());
+    EXPECT_EQ(testcase.overlaps, first_range.OverlapsRange(second_range));
+  }
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace crashpad