vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
329 lines
8.8 KiB
C++
329 lines
8.8 KiB
C++
//===-- RangeTest.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 "lldb/Utility/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)));
|
|
}
|
|
|
|
TEST(RangeTest, LessThan) {
|
|
RangeT r(10, 20);
|
|
|
|
// Equal range.
|
|
EXPECT_FALSE(r < RangeT(10, 20));
|
|
EXPECT_FALSE(RangeT(10, 20) < r);
|
|
|
|
auto expect_ordered_less_than = [](RangeT r1, RangeT r2) {
|
|
EXPECT_TRUE(r1 < r2);
|
|
EXPECT_FALSE(r2 < r1);
|
|
};
|
|
|
|
// Same start, but bigger size.
|
|
expect_ordered_less_than(r, RangeT(10, 21));
|
|
|
|
// Start before and ends before.
|
|
expect_ordered_less_than(RangeT(9, 20), r);
|
|
|
|
// Start before and equal size.
|
|
expect_ordered_less_than(RangeT(9, 21), r);
|
|
|
|
// Start before and bigger size.
|
|
expect_ordered_less_than(RangeT(9, 22), r);
|
|
|
|
// Start after and ends before.
|
|
expect_ordered_less_than(r, RangeT(11, 18));
|
|
|
|
// Start after and equal size.
|
|
expect_ordered_less_than(r, RangeT(11, 19));
|
|
|
|
// Start after and bigger size.
|
|
expect_ordered_less_than(r, RangeT(11, 20));
|
|
}
|
|
|
|
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));
|
|
}
|