From: Simon Marchi Date: Mon, 9 Apr 2018 19:45:39 +0000 (-0400) Subject: Add selftests for range_contains and insert_into_bit_range_vector X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=d5f4488f09b811b0ca44e687da2acbc286d84d4a;p=binutils-gdb.git Add selftests for range_contains and insert_into_bit_range_vector Add some selftests for these two functions. To to make it easier to compare sequences of ranges, add operator== and operator!= to compare two gdb::array_view, and add operator== in struct range. gdb/ChangeLog: * value.c: Include "selftest.h" and "common/array-view.h". (struct range) : New. (test_ranges_contain): New. (check_ranges_vector): New. (test_insert_into_bit_range_vector): New. (_initialize_values): Register selftests. * common/array-view.h (operator==, operator!=): New. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 87b22e85b46..09d8db479ab 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,14 @@ +2018-04-09 Simon Marchi + Pedro Alves + + * value.c: Include "selftest.h" and "common/array-view.h". + (struct range) : New. + (test_ranges_contain): New. + (check_ranges_vector): New. + (test_insert_into_bit_range_vector): New. + (_initialize_values): Register selftests. + * common/array-view.h (operator==, operator!=): New. + 2018-04-09 Simon Marchi * common/gdb_vecs.h (unordered_remove): Add overload that takes diff --git a/gdb/common/array-view.h b/gdb/common/array-view.h index 3a09ec720cc..319ea99468d 100644 --- a/gdb/common/array-view.h +++ b/gdb/common/array-view.h @@ -174,6 +174,33 @@ private: size_type m_size; }; +/* Compare LHS and RHS for (deep) equality. That is, whether LHS and + RHS have the same sizes, and whether each pair of elements of LHS + and RHS at the same position compares equal. */ + +template +bool +operator== (const gdb::array_view &lhs, const gdb::array_view &rhs) +{ + if (lhs.size () != rhs.size ()) + return false; + + for (size_t i = 0; i < lhs.size (); i++) + if (!(lhs[i] == rhs[i])) + return false; + + return true; +} + +/* Compare two array_views for inequality. */ + +template +bool +operator!= (const gdb::array_view &lhs, const gdb::array_view &rhs) +{ + return !(lhs == rhs); +} + } /* namespace gdb */ #endif diff --git a/gdb/value.c b/gdb/value.c index 3d6595f9509..12aa2b8bb46 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -41,6 +41,8 @@ #include "user-regs.h" #include #include "completer.h" +#include "selftest.h" +#include "common/array-view.h" /* Definition of a user function. */ struct internal_function @@ -76,6 +78,12 @@ struct range { return offset < other.offset; } + + /* Returns true if THIS is equal to OTHER. */ + bool operator== (const range &other) const + { + return offset == other.offset && length == other.length; + } }; /* Returns true if the ranges defined by [offset1, offset1+len1) and @@ -3903,6 +3911,148 @@ isvoid_internal_fn (struct gdbarch *gdbarch, return value_from_longest (builtin_type (gdbarch)->builtin_int, ret); } +#if GDB_SELF_TEST +namespace selftests +{ + +/* Test the ranges_contain function. */ + +static void +test_ranges_contain () +{ + std::vector ranges; + range r; + + /* [10, 14] */ + r.offset = 10; + r.length = 5; + ranges.push_back (r); + + /* [20, 24] */ + r.offset = 20; + r.length = 5; + ranges.push_back (r); + + /* [2, 6] */ + SELF_CHECK (!ranges_contain (ranges, 2, 5)); + /* [9, 13] */ + SELF_CHECK (ranges_contain (ranges, 9, 5)); + /* [10, 11] */ + SELF_CHECK (ranges_contain (ranges, 10, 2)); + /* [10, 14] */ + SELF_CHECK (ranges_contain (ranges, 10, 5)); + /* [13, 18] */ + SELF_CHECK (ranges_contain (ranges, 13, 6)); + /* [14, 18] */ + SELF_CHECK (ranges_contain (ranges, 14, 5)); + /* [15, 18] */ + SELF_CHECK (!ranges_contain (ranges, 15, 4)); + /* [16, 19] */ + SELF_CHECK (!ranges_contain (ranges, 16, 4)); + /* [16, 21] */ + SELF_CHECK (ranges_contain (ranges, 16, 6)); + /* [21, 21] */ + SELF_CHECK (ranges_contain (ranges, 21, 1)); + /* [21, 25] */ + SELF_CHECK (ranges_contain (ranges, 21, 5)); + /* [26, 28] */ + SELF_CHECK (!ranges_contain (ranges, 26, 3)); +} + +/* Check that RANGES contains the same ranges as EXPECTED. */ + +static bool +check_ranges_vector (gdb::array_view ranges, + gdb::array_view expected) +{ + return ranges == expected; +} + +/* Test the insert_into_bit_range_vector function. */ + +static void +test_insert_into_bit_range_vector () +{ + std::vector ranges; + + /* [10, 14] */ + { + insert_into_bit_range_vector (&ranges, 10, 5); + static const range expected[] = { + {10, 5} + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [10, 14] */ + { + insert_into_bit_range_vector (&ranges, 11, 4); + static const range expected = {10, 5}; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [10, 14] [20, 24] */ + { + insert_into_bit_range_vector (&ranges, 20, 5); + static const range expected[] = { + {10, 5}, + {20, 5}, + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [10, 14] [17, 24] */ + { + insert_into_bit_range_vector (&ranges, 17, 5); + static const range expected[] = { + {10, 5}, + {17, 8}, + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [2, 8] [10, 14] [17, 24] */ + { + insert_into_bit_range_vector (&ranges, 2, 7); + static const range expected[] = { + {2, 7}, + {10, 5}, + {17, 8}, + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [2, 14] [17, 24] */ + { + insert_into_bit_range_vector (&ranges, 9, 1); + static const range expected[] = { + {2, 13}, + {17, 8}, + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [2, 14] [17, 24] */ + { + insert_into_bit_range_vector (&ranges, 9, 1); + static const range expected[] = { + {2, 13}, + {17, 8}, + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [2, 33] */ + { + insert_into_bit_range_vector (&ranges, 4, 30); + static const range expected = {2, 32}; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } +} + +} /* namespace selftests */ +#endif /* GDB_SELF_TEST */ + void _initialize_values (void) { @@ -3954,4 +4104,9 @@ prevents future values, larger than this size, from being allocated."), set_max_value_size, show_max_value_size, &setlist, &showlist); +#if GDB_SELF_TEST + selftests::register_test ("ranges_contain", selftests::test_ranges_contain); + selftests::register_test ("insert_into_bit_range_vector", + selftests::test_insert_into_bit_range_vector); +#endif }