Added test for Core/Range class.

[teemperor]

Summary

We can optimize and refactor some of the classes in RangeMap.h, but first
we should have some tests for all the data structures in there. This adds a first
batch of tests for the Range class itself.

There are some unexpected results happening when mixing invalid and valid ranges, so
I added some FIXME's for that in the tests.

[teemperor]

(Also we maybe might want to merge the functionalities of Range and VMRange in the future).

[teemperor]

• Fixed typo in CMakeLists

[vsk]

Thanks, looks good with nitpicks.

unittests/Core/RangeTest.cpp

139

Yeah, this looks wrong.

177

Yep, the first two results are at least inconsistent with the third, and look wrong to me.

250

Drop this comment?

253

Might help to have a helper lambda here, like expectOrderedLessThan = [](r1, r2) { expect_true(r1 < r2); expect_false(r2 < r1); }.

[teemperor]

• Addressed Vedant's comments (thanks!)

unittests/Core/CMakeLists.txt

 add_lldb_unittest(LLDBCoreTests
   BroadcasterTest.cpp
   DataExtractorTest.cpp
   EventTest.cpp
   ListenerTest.cpp
   MangledTest.cpp
+  RangeTest.cpp
   RichManglingContextTest.cpp
   StreamCallbackTest.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbSymbol
     lldbPluginObjectFileELF

unittests/Core/RangeTest.cpp

+//===-- RangeTest.cpp ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/RangeMap.h"
+
+#include <cstdint>
+#include <type_traits>
+
+#include "gtest/gtest.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+TEST(RangeTest, SizeTypes) {
+  Range<lldb::addr_t, uint32_t> r;
+  static_assert(std::is_same<lldb::addr_t, decltype(r.GetRangeBase())>::value,
+                "RangeBase type is not equal to the given one.");
+  static_assert(std::is_same<lldb::addr_t, decltype(r.GetRangeEnd())>::value,
+                "RangeEnd type is not equal to the given one.");
+  static_assert(std::is_same<uint32_t, decltype(r.GetByteSize())>::value,
+                "Size type is not equal to the given one.");
+}
+
+typedef Range<lldb::addr_t, uint32_t> RangeT;
+
+TEST(RangeTest, DefaultConstructor) {
+  RangeT r;
+  EXPECT_FALSE(r.IsValid());
+  EXPECT_EQ(0U, r.GetByteSize());
+  EXPECT_EQ(0U, r.GetRangeBase());
+  EXPECT_EQ(0U, r.GetRangeEnd());
+}
+
+TEST(RangeTest, Constructor) {
+  RangeT r(3, 5);
+  EXPECT_TRUE(r.IsValid());
+  EXPECT_EQ(5U, r.GetByteSize());
+  EXPECT_EQ(3U, r.GetRangeBase());
+  EXPECT_EQ(8U, r.GetRangeEnd());
+}
+
+TEST(RangeTest, Copy) {
+  RangeT orig(3, 5);
+  RangeT r = orig;
+  EXPECT_TRUE(r.IsValid());
+  EXPECT_EQ(5U, r.GetByteSize());
+  EXPECT_EQ(3U, r.GetRangeBase());
+  EXPECT_EQ(8U, r.GetRangeEnd());
+}
+
+TEST(RangeTest, Clear) {
+  RangeT r(3, 5);
+  r.Clear();
+  EXPECT_TRUE(r == RangeT());
+}
+
+TEST(RangeTest, ClearWithStarAddress) {
+  RangeT r(3, 5);
+  r.Clear(4);
+  EXPECT_TRUE(r == RangeT(4, 0));
+}
+
+TEST(RangeTest, SetRangeBase) {
+  RangeT r(3, 5);
+  r.SetRangeBase(6);
+  EXPECT_EQ(6U, r.GetRangeBase());
+  EXPECT_EQ(11U, r.GetRangeEnd());
+  EXPECT_EQ(5U, r.GetByteSize());
+}
+
+TEST(RangeTest, Slide) {
+  RangeT r(3, 5);
+  r.Slide(1);
+  EXPECT_EQ(4U, r.GetRangeBase());
+  EXPECT_EQ(9U, r.GetRangeEnd());
+  EXPECT_EQ(5U, r.GetByteSize());
+
+  r.Slide(2);
+  EXPECT_EQ(6U, r.GetRangeBase());
+  EXPECT_EQ(11U, r.GetRangeEnd());
+  EXPECT_EQ(5U, r.GetByteSize());
+}
+
+TEST(RangeTest, SlideZero) {
+  RangeT r(3, 5);
+  r.Slide(0);
+  EXPECT_EQ(3U, r.GetRangeBase());
+  EXPECT_EQ(8U, r.GetRangeEnd());
+  EXPECT_EQ(5U, r.GetByteSize());
+}
+
+TEST(RangeTest, ContainsAddr) {
+  RangeT r(3, 5);
+  EXPECT_FALSE(r.Contains(0));
+  EXPECT_FALSE(r.Contains(1));
+  EXPECT_FALSE(r.Contains(2));
+  EXPECT_TRUE(r.Contains(3));
+  EXPECT_TRUE(r.Contains(4));
+  EXPECT_TRUE(r.Contains(5));
+  EXPECT_TRUE(r.Contains(6));
+  EXPECT_TRUE(r.Contains(7));
+  EXPECT_FALSE(r.Contains(8));
+  EXPECT_FALSE(r.Contains(9));
+  EXPECT_FALSE(r.Contains(10));
+}
+
+TEST(RangeTest, ContainsAddrInvalid) {
+  RangeT r;
+  EXPECT_FALSE(r.Contains(0));
+  EXPECT_FALSE(r.Contains(1));
+  EXPECT_FALSE(r.Contains(2));
+  EXPECT_FALSE(r.Contains(3));
+  EXPECT_FALSE(r.Contains(4));
+}
+
+TEST(RangeTest, ContainsEndInclusive) {
+  RangeT r(3, 5);
+  EXPECT_FALSE(r.ContainsEndInclusive(0));
+  EXPECT_FALSE(r.ContainsEndInclusive(1));
+  EXPECT_FALSE(r.ContainsEndInclusive(2));
+  EXPECT_TRUE(r.ContainsEndInclusive(3));
+  EXPECT_TRUE(r.ContainsEndInclusive(4));
+  EXPECT_TRUE(r.ContainsEndInclusive(5));
+  EXPECT_TRUE(r.ContainsEndInclusive(6));
+  EXPECT_TRUE(r.ContainsEndInclusive(7));
+  EXPECT_TRUE(r.ContainsEndInclusive(8));
+  EXPECT_FALSE(r.ContainsEndInclusive(9));
+  EXPECT_FALSE(r.ContainsEndInclusive(10));
+}
+
+TEST(RangeTest, ContainsEndInclusiveInvalid) {
+  RangeT r;
+  // FIXME: This is probably not intended.
+  EXPECT_TRUE(r.ContainsEndInclusive(0));
+
+  EXPECT_FALSE(r.ContainsEndInclusive(1));
+  EXPECT_FALSE(r.ContainsEndInclusive(2));
+}
+
+TEST(RangeTest, ContainsRange) {
+  RangeT r(3, 5);
+
+  // Range always contains itself.
+  EXPECT_TRUE(r.Contains(r));
+  // Invalid range.
+  EXPECT_FALSE(r.Contains(RangeT()));
+  // Range starts and ends before.
+  EXPECT_FALSE(r.Contains(RangeT(0, 3)));
+  // Range starts before but contains beginning.
+  EXPECT_FALSE(r.Contains(RangeT(0, 4)));
+  // Range starts before but contains beginning and more.
+  EXPECT_FALSE(r.Contains(RangeT(0, 5)));
+  // Range starts before and contains the other.
+  EXPECT_FALSE(r.Contains(RangeT(0, 9)));
+  // Range is fully inside.
+  EXPECT_TRUE(r.Contains(RangeT(4, 3)));
+  // Range has same start, but not as large.
+  EXPECT_TRUE(r.Contains(RangeT(3, 4)));
+  // Range has same end, but starts earlier.
+  EXPECT_TRUE(r.Contains(RangeT(4, 4)));
+  // Range starts inside, but stops after the end of r.
+  EXPECT_FALSE(r.Contains(RangeT(4, 5)));
+  // Range starts directly after r.
+  EXPECT_FALSE(r.Contains(RangeT(8, 2)));
+  // Range starts directly after r.
+  EXPECT_FALSE(r.Contains(RangeT(9, 2)));
+
+  // Invalid range with different start.
+  // FIXME: The first two probably not intended.
+  EXPECT_TRUE(r.Contains(RangeT(3, 0)));
+  EXPECT_TRUE(r.Contains(RangeT(4, 0)));
+  EXPECT_FALSE(r.Contains(RangeT(8, 0)));
+}
+
+TEST(RangeTest, ContainsRangeStartingFromZero) {
+  RangeT r(0, 3);
+  EXPECT_TRUE(r.Contains(r));
+
+  // FIXME: This is probably not intended.
+  EXPECT_TRUE(r.Contains(RangeT()));
+}
+
+TEST(RangeTest, Union) {
+  RangeT r(3, 5);
+
+  // Ranges that we can't merge because it's not adjoin/intersecting.
+  EXPECT_FALSE(r.Union(RangeT(9, 1)));
+  // Check that we didn't modify our range.
+  EXPECT_EQ(r, RangeT(3, 5));
+
+  // Another range we can't merge, but before r.
+  EXPECT_FALSE(r.Union(RangeT(1, 1)));
+  EXPECT_EQ(r, RangeT(3, 5));
+
+  // Merge an adjoin range after.
+  EXPECT_TRUE(r.Union(RangeT(8, 2)));
+  EXPECT_EQ(r, RangeT(3, 7));
+
+  // Merge an adjoin range before.
+  EXPECT_TRUE(r.Union(RangeT(1, 2)));
+  EXPECT_EQ(r, RangeT(1, 9));
+
+  // Merge an intersecting range after.
+  EXPECT_TRUE(r.Union(RangeT(8, 3)));
+  EXPECT_EQ(r, RangeT(1, 10));
+
+  // Merge an intersecting range before.
+  EXPECT_TRUE(r.Union(RangeT(0, 1)));
+  EXPECT_EQ(r, RangeT(0, 11));
+
+  // Merge a few ranges inside that shouldn't do anything.
+  EXPECT_TRUE(r.Union(RangeT(0, 3)));
+  EXPECT_EQ(r, RangeT(0, 11));
+  EXPECT_TRUE(r.Union(RangeT(5, 1)));
+  EXPECT_EQ(r, RangeT(0, 11));
+  EXPECT_TRUE(r.Union(RangeT(9, 2)));
+  EXPECT_EQ(r, RangeT(0, 11));
+}
+
+TEST(RangeTest, DoesAdjoinOrIntersect) {
+  RangeT r(3, 4);
+
+  EXPECT_FALSE(r.DoesAdjoinOrIntersect(RangeT(1, 1)));
+  EXPECT_TRUE(r.DoesAdjoinOrIntersect(RangeT(1, 2)));
+  EXPECT_TRUE(r.DoesAdjoinOrIntersect(RangeT(2, 2)));
+  EXPECT_TRUE(r.DoesAdjoinOrIntersect(RangeT(4, 2)));
+  EXPECT_TRUE(r.DoesAdjoinOrIntersect(RangeT(6, 2)));
+  EXPECT_TRUE(r.DoesAdjoinOrIntersect(RangeT(7, 2)));
+  EXPECT_FALSE(r.DoesAdjoinOrIntersect(RangeT(8, 2)));
+}
+
+TEST(RangeTest, DoesIntersect) {
+  RangeT r(3, 4);
+
+  EXPECT_FALSE(r.DoesIntersect(RangeT(1, 1)));
+  EXPECT_FALSE(r.DoesIntersect(RangeT(1, 2)));
+  EXPECT_TRUE(r.DoesIntersect(RangeT(2, 2)));
+  EXPECT_TRUE(r.DoesIntersect(RangeT(4, 2)));
+  EXPECT_TRUE(r.DoesIntersect(RangeT(6, 2)));
+  EXPECT_FALSE(r.DoesIntersect(RangeT(7, 2)));
+  EXPECT_FALSE(r.DoesIntersect(RangeT(8, 2)));
+}
+
+// For less than, we should
+TEST(RangeTest, LessThan) {
+  RangeT r(10, 20);
+
+  // Equal range.
+  EXPECT_FALSE(r < RangeT(10, 20));
+  EXPECT_FALSE(RangeT(10, 20) < r);
+
+  // Same start, but bigger size.
+  EXPECT_TRUE(r < RangeT(10, 21));
+  EXPECT_FALSE(RangeT(10, 21) < r);
+
+  // Start before, but ends before.
+  EXPECT_FALSE(r < RangeT(9, 20));
+  EXPECT_TRUE(RangeT(9, 20) < r);
+
+  // Start before, but equal size.
+  EXPECT_FALSE(r < RangeT(9, 21));
+  EXPECT_TRUE(RangeT(9, 21) < r);
+
+  // Start before, but bigger size.
+  EXPECT_FALSE(r < RangeT(9, 22));
+  EXPECT_TRUE(RangeT(9, 22) < r);
+
+  // Start after, but ends before.
+  EXPECT_TRUE(r < RangeT(11, 18));
+  EXPECT_FALSE(RangeT(11, 18) < r);
+
+  // Start after, but equal size.
+  EXPECT_TRUE(r < RangeT(11, 19));
+  EXPECT_FALSE(RangeT(11, 19) < r);
+
+  // Start after, but bigger size.
+  EXPECT_TRUE(r < RangeT(11, 20));
+  EXPECT_FALSE(RangeT(11, 20) < r);
+}
+
+TEST(RangeTest, Equal) {
+  RangeT r(10, 20);
+
+  // Equal range.
+  EXPECT_TRUE(r == RangeT(10, 20));
+
+  // Same start, different size.
+  EXPECT_FALSE(r == RangeT(10, 21));
+
+  // Different start, same size.
+  EXPECT_FALSE(r == RangeT(9, 20));
+
+  // Different start, different size.
+  EXPECT_FALSE(r == RangeT(9, 21));
+  EXPECT_FALSE(r == RangeT(11, 19));
+}
+
+TEST(RangeTest, NotEqual) {
+  RangeT r(10, 20);
+
+  EXPECT_FALSE(r != RangeT(10, 20));
+
+  EXPECT_TRUE(r != RangeT(10, 21));
+  EXPECT_TRUE(r != RangeT(9, 20));
+  EXPECT_TRUE(r != RangeT(9, 21));
+}
+
+// Comparison tests for invalid ranges (size == 0).
+
+TEST(RangeTest, LessThanInvalid) {
+  EXPECT_TRUE(RangeT() < RangeT(1, 0));
+  EXPECT_TRUE(RangeT() < RangeT(2, 0));
+  EXPECT_TRUE(RangeT(1, 0) < RangeT(2, 0));
+}
+
+TEST(RangeTest, EqualInvalid) {
+  RangeT r;
+  EXPECT_TRUE(r == RangeT());
+  // Another invalid range, but with a different start.
+  EXPECT_FALSE(r == RangeT(3, 0));
+}
+
+TEST(RangeTest, NotEqualInvalid) {
+  RangeT r;
+  EXPECT_FALSE(r != RangeT());
+  EXPECT_FALSE(r == RangeT(3, 0));
+}