mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-28 21:46:06 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/llvm/unittests/Support/AddressRangeTest.cpp
Alexey Lapshin 1e72920c88 [dsymutil] dsymutil produces broken lines info (probably) with LTO on mac 
This patch fixes #60307 issue. The 8bb4451 introduces the possibility
to unite overlapped or adjacent address ranges to keep address ranges
in an unambiguous state. The AddressRangesMap is used to normalize
address ranges. The AddressRangesMap keeps address ranges and the value
of the relocated address. For intersected range, it creates a united
range that keeps the last inserted mapping value. The same for adjusted ranges.
While it is OK to use the last inserted mapping value for intersected ranges
(as there is no way how to resolve ambiguity) It is not OK to use the
last inserted value for adjacent address ranges. Currently, two following
address ranges are united into a single one:

{0,24,17e685c} {24,d8,55afe20} -> {0,d8,55afe20}

To avoid the problem, the AddressRangesMap should not unite adjacent address ranges
with different relocated addresses. Instead, it should leave adjacent address ranges
as separate ranges. So, the ranges should look like this:

{0,24,17e685c} {24,d8,55afe20}

Differential Revision: https://reviews.llvm.org/D142936
2023-02-03 11:09:50 +01:00

432 lines
17 KiB
C++
Raw Blame History

//===- llvm/unittest/Support/AddresRangeTest.cpp --------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/ADT/AddressRanges.h"
#include "llvm/Testing/Support/Error.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <string>
using namespace llvm;
TEST(AddressRangeTest, TestRanges) {
// test llvm::AddressRange.
const uint64_t StartAddr = 0x1000;
const uint64_t EndAddr = 0x2000;
// Verify constructor and API to ensure it takes start and end address.
const AddressRange Range(StartAddr, EndAddr);
EXPECT_EQ(Range.size(), EndAddr - StartAddr);
// Verify llvm::AddressRange::contains().
EXPECT_FALSE(Range.contains(0));
EXPECT_FALSE(Range.contains(StartAddr - 1));
EXPECT_TRUE(Range.contains(StartAddr));
EXPECT_TRUE(Range.contains(EndAddr - 1));
EXPECT_FALSE(Range.contains(EndAddr));
EXPECT_FALSE(Range.contains(UINT64_MAX));
const AddressRange RangeSame(StartAddr, EndAddr);
const AddressRange RangeDifferentStart(StartAddr + 1, EndAddr);
const AddressRange RangeDifferentEnd(StartAddr, EndAddr + 1);
const AddressRange RangeDifferentStartEnd(StartAddr + 1, EndAddr + 1);
// Test == and != with values that are the same
EXPECT_EQ(Range, RangeSame);
EXPECT_FALSE(Range != RangeSame);
// Test == and != with values that are the different
EXPECT_NE(Range, RangeDifferentStart);
EXPECT_NE(Range, RangeDifferentEnd);
EXPECT_NE(Range, RangeDifferentStartEnd);
EXPECT_FALSE(Range == RangeDifferentStart);
EXPECT_FALSE(Range == RangeDifferentEnd);
EXPECT_FALSE(Range == RangeDifferentStartEnd);
// Test "bool operator<(const AddressRange &, const AddressRange &)".
EXPECT_FALSE(Range < RangeSame);
EXPECT_FALSE(RangeSame < Range);
EXPECT_LT(Range, RangeDifferentStart);
EXPECT_LT(Range, RangeDifferentEnd);
EXPECT_LT(Range, RangeDifferentStartEnd);
// Test "bool operator<(const AddressRange &, uint64_t)"
EXPECT_LT(Range.start(), StartAddr + 1);
// Test "bool operator<(uint64_t, const AddressRange &)"
EXPECT_LT(StartAddr - 1, Range.start());
// Verify llvm::AddressRange::isContiguousWith() and
// llvm::AddressRange::intersects().
const AddressRange EndsBeforeRangeStart(0, StartAddr - 1);
const AddressRange EndsAtRangeStart(0, StartAddr);
const AddressRange OverlapsRangeStart(StartAddr - 1, StartAddr + 1);
const AddressRange InsideRange(StartAddr + 1, EndAddr - 1);
const AddressRange OverlapsRangeEnd(EndAddr - 1, EndAddr + 1);
const AddressRange StartsAtRangeEnd(EndAddr, EndAddr + 0x100);
const AddressRange StartsAfterRangeEnd(EndAddr + 1, EndAddr + 0x100);
EXPECT_FALSE(Range.intersects(EndsBeforeRangeStart));
EXPECT_FALSE(Range.intersects(EndsAtRangeStart));
EXPECT_TRUE(Range.intersects(OverlapsRangeStart));
EXPECT_TRUE(Range.intersects(InsideRange));
EXPECT_TRUE(Range.intersects(OverlapsRangeEnd));
EXPECT_FALSE(Range.intersects(StartsAtRangeEnd));
EXPECT_FALSE(Range.intersects(StartsAfterRangeEnd));
// Test the functions that maintain address ranges:
// "bool AddressRange::contains(uint64_t Addr) const;"
// "void AddressRanges::insert(const AddressRange &R);"
AddressRanges Ranges;
Ranges.insert(AddressRange(0x1000, 0x2000));
Ranges.insert(AddressRange(0x2000, 0x3000));
Ranges.insert(AddressRange(0x4000, 0x5000));
EXPECT_FALSE(Ranges.contains(0));
EXPECT_FALSE(Ranges.contains(0x1000 - 1));
EXPECT_TRUE(Ranges.contains(0x1000));
EXPECT_TRUE(Ranges.contains(0x2000));
EXPECT_TRUE(Ranges.contains(0x4000));
EXPECT_TRUE(Ranges.contains(0x2000 - 1));
EXPECT_TRUE(Ranges.contains(0x3000 - 1));
EXPECT_FALSE(Ranges.contains(0x3000 + 1));
EXPECT_TRUE(Ranges.contains(0x5000 - 1));
EXPECT_FALSE(Ranges.contains(0x5000 + 1));
EXPECT_FALSE(Ranges.contains(UINT64_MAX));
EXPECT_FALSE(Ranges.contains(AddressRange()));
EXPECT_FALSE(Ranges.contains(AddressRange(0x1000 - 1, 0x1000)));
EXPECT_FALSE(Ranges.contains(AddressRange(0x1000, 0x1000)));
EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x1000 + 1)));
EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x2000)));
EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x2001)));
EXPECT_TRUE(Ranges.contains(AddressRange(0x2000, 0x3000)));
EXPECT_FALSE(Ranges.contains(AddressRange(0x2000, 0x3001)));
EXPECT_FALSE(Ranges.contains(AddressRange(0x3000, 0x3001)));
EXPECT_FALSE(Ranges.contains(AddressRange(0x1500, 0x4500)));
EXPECT_FALSE(Ranges.contains(AddressRange(0x5000, 0x5001)));
// Verify that intersecting ranges get combined
Ranges.clear();
Ranges.insert(AddressRange(0x1100, 0x1F00));
// Verify a wholy contained range that is added doesn't do anything.
Ranges.insert(AddressRange(0x1500, 0x1F00));
EXPECT_EQ(Ranges.size(), 1u);
EXPECT_EQ(Ranges[0], AddressRange(0x1100, 0x1F00));
// Verify a range that starts before and intersects gets combined.
Ranges.insert(AddressRange(0x1000, Ranges[0].start() + 1));
EXPECT_EQ(Ranges.size(), 1u);
EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x1F00));
// Verify a range that starts inside and extends ranges gets combined.
Ranges.insert(AddressRange(Ranges[0].end() - 1, 0x2000));
EXPECT_EQ(Ranges.size(), 1u);
EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x2000));
// Verify that adjacent ranges get combined
Ranges.insert(AddressRange(0x2000, 0x2fff));
EXPECT_EQ(Ranges.size(), 1u);
EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x2fff));
// Verify that ranges having 1 byte gap do not get combined
Ranges.insert(AddressRange(0x3000, 0x4000));
EXPECT_EQ(Ranges.size(), 2u);
EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x2fff));
EXPECT_EQ(Ranges[1], AddressRange(0x3000, 0x4000));
// Verify if we add an address range that intersects two ranges
// that they get combined
Ranges.insert(AddressRange(Ranges[0].end() - 1, Ranges[1].start() + 1));
EXPECT_EQ(Ranges.size(), 1u);
EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x4000));
Ranges.insert(AddressRange(0x3000, 0x4000));
Ranges.insert(AddressRange(0x4000, 0x5000));
Ranges.insert(AddressRange(0x2000, 0x4500));
EXPECT_EQ(Ranges.size(), 1u);
EXPECT_EQ(Ranges[0], AddressRange(0x1000, 0x5000));
}
TEST(AddressRangeTest, TestRangesRandom) {
AddressRanges Ranges;
size_t NumElements = 100;
std::srand(std::time(nullptr));
// Fill ranges.
for (size_t Idx = 0; Idx < NumElements; Idx++) {
uint64_t Start = static_cast<uint64_t>(std::rand() % 1000);
uint64_t End = Start + static_cast<uint64_t>(std::rand() % 1000);
Ranges.insert({Start, End});
}
// Check ranges.
for (size_t Idx = 0; Idx + 1 < Ranges.size(); Idx++) {
// Check that ranges are not intersected.
EXPECT_FALSE(Ranges[Idx].intersects(Ranges[Idx + 1]));
// Check that ranges are sorted and not adjusted.
EXPECT_TRUE(Ranges[Idx].end() < Ranges[Idx + 1].start());
}
}
TEST(AddressRangeTest, TestRangesMap) {
AddressRangesMap Ranges;
EXPECT_EQ(Ranges.size(), 0u);
EXPECT_TRUE(Ranges.empty());
// Add single range.
Ranges.insert(AddressRange(0x1000, 0x2000), 0xfe);
EXPECT_EQ(Ranges.size(), 1u);
EXPECT_FALSE(Ranges.empty());
EXPECT_TRUE(Ranges.contains(0x1500));
EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x2000)));
///////////////////////////////////////
/// Check ranges with the same mapped value.
// Clear ranges.
Ranges.clear();
EXPECT_EQ(Ranges.size(), 0u);
EXPECT_TRUE(Ranges.empty());
// Add range and check mapped value.
Ranges.insert(AddressRange(0x1000, 0x2000), 0x11);
EXPECT_EQ(Ranges.size(), 1u);
EXPECT_EQ(Ranges.getRangeThatContains(0x1000)->Value, 0x11);
// Add adjacent range and check mapped value.
Ranges.insert(AddressRange(0x2000, 0x3000), 0x11);
EXPECT_EQ(Ranges.size(), 2u);
EXPECT_EQ(Ranges.getRangeThatContains(0x1000)->Value, 0x11);
EXPECT_EQ(Ranges.getRangeThatContains(0x2000)->Value, 0x11);
EXPECT_EQ(Ranges.getRangeThatContains(0x2900)->Value, 0x11);
EXPECT_FALSE(Ranges.getRangeThatContains(0x3000));
// Add intersecting range and check mapped value.
Ranges.insert(AddressRange(0x1000, 0x3000), 0x11);
EXPECT_EQ(Ranges.size(), 2u);
EXPECT_EQ(Ranges.getRangeThatContains(0x1000)->Value, 0x11);
// Add second range and check mapped values.
Ranges.insert(AddressRange(0x4000, 0x5000), 0x11);
EXPECT_EQ(Ranges.size(), 3u);
EXPECT_EQ(Ranges[0].Range, AddressRange(0x1000, 0x2000));
EXPECT_EQ(Ranges[0].Value, 0x11);
EXPECT_EQ(Ranges[1].Range, AddressRange(0x2000, 0x3000));
EXPECT_EQ(Ranges[1].Value, 0x11);
EXPECT_EQ(Ranges[2].Range, AddressRange(0x4000, 0x5000));
EXPECT_EQ(Ranges[2].Value, 0x11);
EXPECT_EQ(Ranges.getRangeThatContains(0x1000)->Value, 0x11);
EXPECT_EQ(Ranges.getRangeThatContains(0x4000)->Value, 0x11);
// Add intersecting range and check mapped value.
Ranges.insert(AddressRange(0x0, 0x6000), 0x11);
EXPECT_EQ(Ranges.size(), 6u);
EXPECT_EQ(Ranges.getRangeThatContains(0x1000)->Value, 0x11);
// Check that mapped values are correctly preserved for combined ranges.
Ranges.clear();
Ranges.insert(AddressRange(0x0, 0xff), 0x11);
Ranges.insert(AddressRange(0x100, 0x1ff), 0x11);
Ranges.insert(AddressRange(0x200, 0x2ff), 0x11);
Ranges.insert(AddressRange(0x500, 0x5ff), 0x11);
Ranges.insert(AddressRange(0x300, 0x3ff), 0x11);
Ranges.insert(AddressRange(0x400, 0x4ff), 0x11);
Ranges.insert(AddressRange(0x600, 0x6ff), 0x11);
EXPECT_EQ(Ranges.size(), 7u);
Ranges.insert(AddressRange(0x150, 0x350), 0x11);
EXPECT_EQ(Ranges.size(), 9u);
EXPECT_EQ(Ranges[0].Range, AddressRange(0x0, 0xff));
EXPECT_EQ(Ranges[0].Value, 0x11);
EXPECT_EQ(Ranges[1].Range, AddressRange(0x100, 0x1ff));
EXPECT_EQ(Ranges[1].Value, 0x11);
EXPECT_EQ(Ranges[2].Range, AddressRange(0x1ff, 0x200));
EXPECT_EQ(Ranges[2].Value, 0x11);
EXPECT_EQ(Ranges[3].Range, AddressRange(0x200, 0x2ff));
EXPECT_EQ(Ranges[3].Value, 0x11);
EXPECT_EQ(Ranges[4].Range, AddressRange(0x2ff, 0x300));
EXPECT_EQ(Ranges[4].Value, 0x11);
EXPECT_EQ(Ranges[5].Range, AddressRange(0x300, 0x3ff));
EXPECT_EQ(Ranges[5].Value, 0x11);
EXPECT_EQ(Ranges[6].Range, AddressRange(0x400, 0x4ff));
EXPECT_EQ(Ranges[6].Value, 0x11);
EXPECT_EQ(Ranges[7].Range, AddressRange(0x500, 0x5ff));
EXPECT_EQ(Ranges[7].Value, 0x11);
EXPECT_EQ(Ranges[8].Range, AddressRange(0x600, 0x6ff));
EXPECT_EQ(Ranges[8].Value, 0x11);
Ranges.insert(AddressRange(0x3ff, 0x400), 0x11);
EXPECT_EQ(Ranges.size(), 10u);
EXPECT_EQ(Ranges[0].Range, AddressRange(0x0, 0xff));
EXPECT_EQ(Ranges[0].Value, 0x11);
EXPECT_EQ(Ranges[1].Range, AddressRange(0x100, 0x1ff));
EXPECT_EQ(Ranges[1].Value, 0x11);
EXPECT_EQ(Ranges[2].Range, AddressRange(0x1ff, 0x200));
EXPECT_EQ(Ranges[2].Value, 0x11);
EXPECT_EQ(Ranges[3].Range, AddressRange(0x200, 0x2ff));
EXPECT_EQ(Ranges[3].Value, 0x11);
EXPECT_EQ(Ranges[4].Range, AddressRange(0x2ff, 0x300));
EXPECT_EQ(Ranges[4].Value, 0x11);
EXPECT_EQ(Ranges[5].Range, AddressRange(0x300, 0x3ff));
EXPECT_EQ(Ranges[5].Value, 0x11);
EXPECT_EQ(Ranges[6].Range, AddressRange(0x3ff, 0x400));
EXPECT_EQ(Ranges[6].Value, 0x11);
EXPECT_EQ(Ranges[7].Range, AddressRange(0x400, 0x4ff));
EXPECT_EQ(Ranges[7].Value, 0x11);
EXPECT_EQ(Ranges[8].Range, AddressRange(0x500, 0x5ff));
EXPECT_EQ(Ranges[8].Value, 0x11);
EXPECT_EQ(Ranges[9].Range, AddressRange(0x600, 0x6ff));
EXPECT_EQ(Ranges[9].Value, 0x11);
/////////////////////////////////////////////
/// Check ranges with various mapped values.
// Clear ranges.
Ranges.clear();
EXPECT_EQ(Ranges.size(), 0u);
EXPECT_TRUE(Ranges.empty());
// Add range and check mapped value.
Ranges.insert(AddressRange(0x1000, 0x2000), 0xfe);
EXPECT_EQ(Ranges.size(), 1u);
EXPECT_EQ(Ranges.getRangeThatContains(0x1000)->Value, 0xfe);
// Add adjacent range and check mapped value.
Ranges.insert(AddressRange(0x2000, 0x3000), 0xfc);
EXPECT_EQ(Ranges.size(), 2u);
EXPECT_EQ(Ranges.getRangeThatContains(0x1000)->Value, 0xfe);
EXPECT_EQ(Ranges.getRangeThatContains(0x2000)->Value, 0xfc);
EXPECT_EQ(Ranges.getRangeThatContains(0x2900)->Value, 0xfc);
EXPECT_FALSE(Ranges.getRangeThatContains(0x3000));
// Add intersecting range and check mapped value.
Ranges.insert(AddressRange(0x1000, 0x3000), 0xff);
EXPECT_EQ(Ranges.size(), 2u);
EXPECT_EQ(Ranges.getRangeThatContains(0x1000)->Value, 0xfe);
// Add one more range and check mapped values.
Ranges.insert(AddressRange(0x4000, 0x5000), 0x0);
EXPECT_EQ(Ranges.size(), 3u);
EXPECT_EQ(Ranges[0].Value, 0xfe);
EXPECT_EQ(Ranges[1].Value, 0xfc);
EXPECT_EQ(Ranges[2].Value, 0x0);
EXPECT_EQ(Ranges.getRangeThatContains(0x1000)->Value, 0xfe);
EXPECT_EQ(Ranges.getRangeThatContains(0x4000)->Value, 0x0);
// Add intersecting range and check mapped value.
Ranges.insert(AddressRange(0x0, 0x6000), 0x1);
EXPECT_EQ(Ranges.size(), 6u);
EXPECT_EQ(Ranges[0].Value, 0x1);
EXPECT_EQ(Ranges[1].Value, 0xfe);
EXPECT_EQ(Ranges[2].Value, 0xfc);
EXPECT_EQ(Ranges[3].Value, 0x1);
EXPECT_EQ(Ranges[4].Value, 0x0);
EXPECT_EQ(Ranges[5].Value, 0x1);
EXPECT_EQ(Ranges.getRangeThatContains(0x1000)->Value, 0xfe);
// Check that mapped values are correctly preserved for combined ranges.
Ranges.clear();
Ranges.insert(AddressRange(0x0, 0xff), 0x1);
Ranges.insert(AddressRange(0x100, 0x1ff), 0x2);
Ranges.insert(AddressRange(0x200, 0x2ff), 0x3);
Ranges.insert(AddressRange(0x300, 0x3ff), 0x4);
Ranges.insert(AddressRange(0x500, 0x5ff), 0x6);
Ranges.insert(AddressRange(0x400, 0x4ff), 0x5);
Ranges.insert(AddressRange(0x600, 0x6ff), 0x7);
EXPECT_EQ(Ranges.size(), 7u);
Ranges.insert(AddressRange(0x150, 0x350), 0xff);
EXPECT_EQ(Ranges.size(), 9u);
EXPECT_EQ(Ranges[0].Range, AddressRange(0x0, 0xff));
EXPECT_EQ(Ranges[0].Value, 0x1);
EXPECT_EQ(Ranges[1].Range, AddressRange(0x100, 0x1ff));
EXPECT_EQ(Ranges[1].Value, 0x2);
EXPECT_EQ(Ranges[2].Range, AddressRange(0x1ff, 0x200));
EXPECT_EQ(Ranges[2].Value, 0xff);
EXPECT_EQ(Ranges[3].Range, AddressRange(0x200, 0x2ff));
EXPECT_EQ(Ranges[3].Value, 0x3);
EXPECT_EQ(Ranges[4].Range, AddressRange(0x2ff, 0x300));
EXPECT_EQ(Ranges[4].Value, 0xff);
EXPECT_EQ(Ranges[5].Range, AddressRange(0x300, 0x3ff));
EXPECT_EQ(Ranges[5].Value, 0x4);
EXPECT_EQ(Ranges[6].Range, AddressRange(0x400, 0x4ff));
EXPECT_EQ(Ranges[6].Value, 0x5);
EXPECT_EQ(Ranges[7].Range, AddressRange(0x500, 0x5ff));
EXPECT_EQ(Ranges[7].Value, 0x6);
EXPECT_EQ(Ranges[8].Range, AddressRange(0x600, 0x6ff));
EXPECT_EQ(Ranges[8].Value, 0x7);
Ranges.insert(AddressRange(0x650, 0x700), 0x8);
Ranges.insert(AddressRange(0x3ff, 0x400), 0x5);
Ranges.insert(AddressRange(0x0, 0x40), 0xee);
EXPECT_EQ(Ranges.size(), 11u);
EXPECT_EQ(Ranges[0].Range, AddressRange(0x0, 0xff));
EXPECT_EQ(Ranges[0].Value, 0x1);
EXPECT_EQ(Ranges[1].Range, AddressRange(0x100, 0x1ff));
EXPECT_EQ(Ranges[1].Value, 0x2);
EXPECT_EQ(Ranges[2].Range, AddressRange(0x1ff, 0x200));
EXPECT_EQ(Ranges[2].Value, 0xff);
EXPECT_EQ(Ranges[3].Range, AddressRange(0x200, 0x2ff));
EXPECT_EQ(Ranges[3].Value, 0x3);
EXPECT_EQ(Ranges[4].Range, AddressRange(0x2ff, 0x300));
EXPECT_EQ(Ranges[4].Value, 0xff);
EXPECT_EQ(Ranges[5].Range, AddressRange(0x300, 0x3ff));
EXPECT_EQ(Ranges[5].Value, 0x4);
EXPECT_EQ(Ranges[6].Range, AddressRange(0x3ff, 0x400));
EXPECT_EQ(Ranges[6].Value, 0x5);
EXPECT_EQ(Ranges[7].Range, AddressRange(0x400, 0x4ff));
EXPECT_EQ(Ranges[7].Value, 0x5);
EXPECT_EQ(Ranges[8].Range, AddressRange(0x500, 0x5ff));
EXPECT_EQ(Ranges[8].Value, 0x6);
EXPECT_EQ(Ranges[9].Range, AddressRange(0x600, 0x6ff));
EXPECT_EQ(Ranges[9].Value, 0x7);
EXPECT_EQ(Ranges[10].Range, AddressRange(0x6ff, 0x700));
EXPECT_EQ(Ranges[10].Value, 0x8);
}
TEST(AddressRangeTest, TestRangesMapRandom) {
AddressRangesMap Ranges;
size_t NumElements = 100;
std::srand(std::time(nullptr));
// Fill ranges. Use the same mapped value.
for (size_t Idx = 0; Idx < NumElements; Idx++) {
uint64_t Start = static_cast<uint64_t>(std::rand() % 1000);
uint64_t End = Start + static_cast<uint64_t>(std::rand() % 1000);
Ranges.insert({Start, End}, 0xffLL);
}
// Check ranges.
for (size_t Idx = 0; Idx + 1 < Ranges.size(); Idx++) {
// Check that ranges are not intersected.
EXPECT_FALSE(Ranges[Idx].Range.intersects(Ranges[Idx + 1].Range));
// Check that ranges are sorted and not adjusted.
EXPECT_TRUE(Ranges[Idx].Range.end() <= Ranges[Idx + 1].Range.start());
}
Ranges.clear();
// Fill ranges. Use the various mapped value.
for (size_t Idx = 0; Idx < NumElements; Idx++) {
uint64_t Start = static_cast<uint64_t>(std::rand() % 1000);
uint64_t End = Start + static_cast<uint64_t>(std::rand() % 1000);
int64_t Value = static_cast<int64_t>(std::rand() % 10);
Ranges.insert({Start, End}, Value);
}
// Check ranges.
for (size_t Idx = 0; Idx + 1 < Ranges.size(); Idx++) {
// Check that ranges are not intersected.
EXPECT_FALSE(Ranges[Idx].Range.intersects(Ranges[Idx + 1].Range));
// Check that ranges are sorted and not adjusted.
EXPECT_TRUE(Ranges[Idx].Range.end() <= Ranges[Idx + 1].Range.start());
}
}
Reference in New Issue View Git Blame Copy Permalink