1526853e34
With the growing number of selftests, I think it would be useful to be
able to run only a subset of the tests. This patch associates a name to
each registered selftest. It then allows doing something like:
(gdb) maintenance selftest aarch64
Running self-tests.
Running selftest aarch64-analyze-prologue.
Running selftest aarch64-process-record.
Ran 2 unit tests, 0 failed
or with gdbserver:
./gdbserver --selftest=aarch64
In both cases, only the tests that contain "aarch64" in their name are
ran. To help validate that the tests you want to run were actually ran,
it also prints a message with the test name before running each test.
Right now, all the arch-dependent tests are registered as a single test
of the selftests. To be able to filter those too, I made them
"first-class citizen" selftests. The selftest type is an interface,
with different implementations for "simple selftests" and "arch
selftests". The run_tests function simply iterates on that an invokes
operator() on each test.
I changed the tests data structure from a vector to a map, because
- it allows iterating in a stable (alphabetical) order
- it allows to easily verify if a test with a given name has been
registered, to avoid duplicates
There's also a new command "maintenance info selftests" that lists the
registered selftests.
gdb/ChangeLog:
* common/selftest.h (selftest): New struct/interface.
(register_test): Add name parameter, add new overload.
(run_tests): Add filter parameter.
(for_each_selftest_ftype): New typedef.
(for_each_selftest): New declaration.
* common/selftest.c (tests): Change type to
map<string, unique_ptr<selftest>>.
(simple_selftest): New struct.
(register_test): New function.
(register_test): Add name parameter and use it.
(run_tests): Add filter parameter and use it. Add prints.
Adjust to vector -> map change.
* aarch64-tdep.c (_initialize_aarch64_tdep): Add names when
registering selftests.
* arm-tdep.c (_initialize_arm_tdep): Likewise.
* disasm-selftests.c (_initialize_disasm_selftests): Likewise.
* dwarf2-frame.c (_initialize_dwarf2_frame): Likewise.
* dwarf2loc.c (_initialize_dwarf2loc): Likewise.
* findvar.c (_initialize_findvar): Likewise.
* gdbarch-selftests.c (_initialize_gdbarch_selftests): Likewise.
* maint.c (maintenance_selftest): Update call to run_tests.
(maintenance_info_selftests): New function.
(_initialize_maint_cmds): Register "maintenance info selftests"
command. Update "maintenance selftest" doc.
* regcache.c (_initialize_regcache): Add names when registering
selftests.
* rust-exp.y (_initialize_rust_exp): Likewise.
* selftest-arch.c (gdbarch_selftest): New struct.
(gdbarch_tests): Remove.
(register_test_foreach_arch): Add name parameter. Call
register_test.
(tests_with_arch): Remove, move most content to
gdbarch_selftest::operator().
(_initialize_selftests_foreach_arch): Remove.
* selftest-arch.h (register_test_foreach_arch): Add name
parameter.
(run_tests_with_arch): New declaration.
* utils-selftests.c (_initialize_utils_selftests): Add names
when registering selftests.
* utils.c (_initialize_utils): Likewise.
* unittests/array-view-selftests.c
(_initialize_array_view_selftests): Likewise.
* unittests/environ-selftests.c (_initialize_environ_selftests):
Likewise.
* unittests/function-view-selftests.c
(_initialize_function_view_selftests): Likewise.
* unittests/offset-type-selftests.c
(_initialize_offset_type_selftests): Likewise.
* unittests/optional-selftests.c
(_initialize_optional_selftests): Likewise.
* unittests/scoped_restore-selftests.c
(_initialize_scoped_restore_selftests): Likewise.
* NEWS: Document "maintenance selftest" and "maint info
selftests".
gdb/gdbserver/ChangeLog:
* server.c (captured_main): Accept argument for --selftest.
Update run_tests call.
* linux-x86-tdesc-selftest.c (initialize_low_tdesc): Add names
when registering selftests.
gdb/doc/ChangeLog:
* gdb.texinfo (Maintenance Commands): Document filter parameter
of "maint selftest". Document "maint info selftests" command.
496 lines
13 KiB
C
496 lines
13 KiB
C
/* Self tests for array_view for GDB, the GNU debugger.
|
|
|
|
Copyright (C) 2017 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "selftest.h"
|
|
#include "common/array-view.h"
|
|
#include <array>
|
|
|
|
namespace selftests {
|
|
namespace array_view_tests {
|
|
|
|
/* Triviality checks. */
|
|
#define CHECK_TRAIT(TRAIT) \
|
|
static_assert (std::TRAIT<gdb::array_view<gdb_byte>>::value, "")
|
|
|
|
#if HAVE_IS_TRIVIALLY_COPYABLE
|
|
|
|
CHECK_TRAIT (is_trivially_copyable);
|
|
CHECK_TRAIT (is_trivially_move_assignable);
|
|
CHECK_TRAIT (is_trivially_move_constructible);
|
|
CHECK_TRAIT (is_trivially_destructible);
|
|
|
|
#endif
|
|
|
|
#undef CHECK_TRAIT
|
|
|
|
/* Wrapper around std::is_convertible to make the code using it a bit
|
|
shorter. (With C++14 we'd use a variable template instead.) */
|
|
|
|
template<typename From, typename To>
|
|
static constexpr bool
|
|
is_convertible ()
|
|
{
|
|
return std::is_convertible<From, To>::value;
|
|
}
|
|
|
|
/* Check for implicit conversion to immutable and mutable views. */
|
|
|
|
static constexpr bool
|
|
check_convertible ()
|
|
{
|
|
using T = gdb_byte;
|
|
using gdb::array_view;
|
|
|
|
return (true
|
|
/* immutable array_view */
|
|
&& is_convertible<const T (&) [1], array_view<const T>> ()
|
|
&& is_convertible<T (&) [1], array_view<const T>> ()
|
|
&& is_convertible<const T, array_view<const T>> ()
|
|
&& is_convertible<T, array_view<const T>> ()
|
|
|
|
/* mutable array_view */
|
|
&& is_convertible<T (&) [1], array_view<T>> ()
|
|
&& !is_convertible<const T (&) [1], array_view<T>> ()
|
|
&& is_convertible<T, array_view<T>> ()
|
|
&& !is_convertible<const T, array_view<T>> ()
|
|
|
|
/* While float is implicitly convertible to gdb_byte, we
|
|
don't want implicit float->array_view<gdb_byte>
|
|
conversion. */
|
|
&& !is_convertible<float, array_view<const T>> ()
|
|
&& !is_convertible<float, array_view<T>> ());
|
|
}
|
|
|
|
static_assert (check_convertible (), "");
|
|
|
|
namespace no_slicing
|
|
{
|
|
struct A { int i; };
|
|
struct B : A { int j; };
|
|
struct C : A { int l; };
|
|
|
|
/* Check that there's no array->view conversion for arrays of derived
|
|
types or subclasses. */
|
|
static constexpr bool
|
|
check ()
|
|
{
|
|
using gdb::array_view;
|
|
|
|
return (true
|
|
|
|
/* array->view */
|
|
|
|
&& is_convertible <A (&)[1], array_view<A>> ()
|
|
&& !is_convertible <B (&)[1], array_view<A>> ()
|
|
&& !is_convertible <C (&)[1], array_view<A>> ()
|
|
|
|
&& !is_convertible <A (&)[1], array_view<B>> ()
|
|
&& is_convertible <B (&)[1], array_view<B>> ()
|
|
&& !is_convertible <C (&)[1], array_view<B>> ()
|
|
|
|
/* elem->view */
|
|
|
|
&& is_convertible <A, array_view<A>> ()
|
|
&& !is_convertible <B, array_view<A>> ()
|
|
&& !is_convertible <C, array_view<A>> ()
|
|
|
|
&& !is_convertible <A, array_view<B>> ()
|
|
&& is_convertible <B, array_view<B>> ()
|
|
&& !is_convertible <C, array_view<B>> ());
|
|
}
|
|
|
|
} /* namespace no_slicing */
|
|
|
|
static_assert (no_slicing::check (), "");
|
|
|
|
/* Check that array_view implicitly converts from std::vector. */
|
|
|
|
static constexpr bool
|
|
check_convertible_from_std_vector ()
|
|
{
|
|
using gdb::array_view;
|
|
using T = gdb_byte;
|
|
|
|
/* Note there's no such thing as std::vector<const T>. */
|
|
|
|
return (true
|
|
&& is_convertible <std::vector<T>, array_view<T>> ()
|
|
&& is_convertible <std::vector<T>, array_view<const T>> ());
|
|
}
|
|
|
|
static_assert (check_convertible_from_std_vector (), "");
|
|
|
|
/* Check that array_view implicitly converts from std::array. */
|
|
|
|
static constexpr bool
|
|
check_convertible_from_std_array ()
|
|
{
|
|
using gdb::array_view;
|
|
using T = gdb_byte;
|
|
|
|
/* Note: a non-const T view can't refer to a const T array. */
|
|
|
|
return (true
|
|
&& is_convertible <std::array<T, 1>, array_view<T>> ()
|
|
&& is_convertible <std::array<T, 1>, array_view<const T>> ()
|
|
&& !is_convertible <std::array<const T, 1>, array_view<T>> ()
|
|
&& is_convertible <std::array<const T, 1>, array_view<const T>> ());
|
|
}
|
|
|
|
static_assert (check_convertible_from_std_array (), "");
|
|
|
|
/* Check that VIEW views C (a container like std::vector/std::array)
|
|
correctly. */
|
|
|
|
template<typename View, typename Container>
|
|
static bool
|
|
check_container_view (const View &view, const Container &c)
|
|
{
|
|
if (view.empty ())
|
|
return false;
|
|
if (view.size () != c.size ())
|
|
return false;
|
|
if (view.data () != c.data ())
|
|
return false;
|
|
for (size_t i = 0; i < c.size (); i++)
|
|
{
|
|
if (&view[i] != &c[i])
|
|
return false;
|
|
if (view[i] != c[i])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* Check that VIEW views E (an object of the type of a view element)
|
|
correctly. */
|
|
|
|
template<typename View, typename Elem>
|
|
static bool
|
|
check_elem_view (const View &view, const Elem &e)
|
|
{
|
|
if (view.empty ())
|
|
return false;
|
|
if (view.size () != 1)
|
|
return false;
|
|
if (view.data () != &e)
|
|
return false;
|
|
if (&view[0] != &e)
|
|
return false;
|
|
if (view[0] != e)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/* Check for operator[]. The first overload is taken iff
|
|
'view<T>()[0] = T()' is a valid expression. */
|
|
|
|
template<typename View,
|
|
typename = decltype (std::declval<View> ()[0]
|
|
= std::declval<typename View::value_type> ())>
|
|
static bool
|
|
check_op_subscript (const View &view)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/* This overload is taken iff 'view<T>()[0] = T()' is not a valid
|
|
expression. */
|
|
|
|
static bool
|
|
check_op_subscript (...)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/* Check construction with pointer + size. This is a template in
|
|
order to test both gdb_byte and const gdb_byte. */
|
|
|
|
template<typename T>
|
|
static void
|
|
check_ptr_size_ctor ()
|
|
{
|
|
T data[] = {0x11, 0x22, 0x33, 0x44};
|
|
|
|
gdb::array_view<T> view (data + 1, 2);
|
|
|
|
SELF_CHECK (!view.empty ());
|
|
SELF_CHECK (view.size () == 2);
|
|
SELF_CHECK (view.data () == &data[1]);
|
|
SELF_CHECK (view[0] == data[1]);
|
|
SELF_CHECK (view[1] == data[2]);
|
|
|
|
gdb::array_view<const T> cview (data + 1, 2);
|
|
SELF_CHECK (!cview.empty ());
|
|
SELF_CHECK (cview.size () == 2);
|
|
SELF_CHECK (cview.data () == &data[1]);
|
|
SELF_CHECK (cview[0] == data[1]);
|
|
SELF_CHECK (cview[1] == data[2]);
|
|
}
|
|
|
|
/* Asserts std::is_constructible. */
|
|
|
|
template<typename T, typename... Args>
|
|
static constexpr bool
|
|
require_not_constructible ()
|
|
{
|
|
static_assert (!std::is_constructible<T, Args...>::value, "");
|
|
|
|
/* constexpr functions can't return void in C++11 (N3444). */
|
|
return true;
|
|
};
|
|
|
|
/* Check the array_view<T>(PTR, SIZE) ctor, when T is a pointer. */
|
|
|
|
void
|
|
check_ptr_size_ctor2 ()
|
|
{
|
|
struct A {};
|
|
A an_a;
|
|
|
|
A *array[] = { &an_a };
|
|
const A * const carray[] = { &an_a };
|
|
|
|
gdb::array_view<A *> v1 = {array, ARRAY_SIZE (array)};
|
|
gdb::array_view<A *> v2 = {array, (char) ARRAY_SIZE (array)};
|
|
gdb::array_view<A * const> v3 = {array, ARRAY_SIZE (array)};
|
|
gdb::array_view<const A * const> cv1 = {carray, ARRAY_SIZE (carray)};
|
|
|
|
require_not_constructible<gdb::array_view<A *>, decltype (carray), size_t> ();
|
|
|
|
SELF_CHECK (v1[0] == array[0]);
|
|
SELF_CHECK (v2[0] == array[0]);
|
|
SELF_CHECK (v3[0] == array[0]);
|
|
|
|
SELF_CHECK (!v1.empty ());
|
|
SELF_CHECK (v1.size () == 1);
|
|
SELF_CHECK (v1.data () == &array[0]);
|
|
|
|
SELF_CHECK (cv1[0] == carray[0]);
|
|
|
|
SELF_CHECK (!cv1.empty ());
|
|
SELF_CHECK (cv1.size () == 1);
|
|
SELF_CHECK (cv1.data () == &carray[0]);
|
|
}
|
|
|
|
/* Check construction with a pair of pointers. This is a template in
|
|
order to test both gdb_byte and const gdb_byte. */
|
|
|
|
template<typename T>
|
|
static void
|
|
check_ptr_ptr_ctor ()
|
|
{
|
|
T data[] = {0x11, 0x22, 0x33, 0x44};
|
|
|
|
gdb::array_view<T> view (data + 1, data + 3);
|
|
|
|
SELF_CHECK (!view.empty ());
|
|
SELF_CHECK (view.size () == 2);
|
|
SELF_CHECK (view.data () == &data[1]);
|
|
SELF_CHECK (view[0] == data[1]);
|
|
SELF_CHECK (view[1] == data[2]);
|
|
|
|
gdb_byte array[] = {0x11, 0x22, 0x33, 0x44};
|
|
const gdb_byte *p1 = array;
|
|
gdb_byte *p2 = array + ARRAY_SIZE (array);
|
|
gdb::array_view<const gdb_byte> view2 (p1, p2);
|
|
}
|
|
|
|
/* Check construction with a pair of pointers of mixed constness. */
|
|
|
|
static void
|
|
check_ptr_ptr_mixed_cv ()
|
|
{
|
|
gdb_byte array[] = {0x11, 0x22, 0x33, 0x44};
|
|
const gdb_byte *cp = array;
|
|
gdb_byte *p = array;
|
|
gdb::array_view<const gdb_byte> view1 (cp, p);
|
|
gdb::array_view<const gdb_byte> view2 (p, cp);
|
|
SELF_CHECK (view1.empty ());
|
|
SELF_CHECK (view2.empty ());
|
|
}
|
|
|
|
/* Check range-for support (i.e., begin()/end()). This is a template
|
|
in order to test both gdb_byte and const gdb_byte. */
|
|
|
|
template<typename T>
|
|
static void
|
|
check_range_for ()
|
|
{
|
|
T data[] = {1, 2, 3, 4};
|
|
gdb::array_view<T> view (data);
|
|
|
|
typename std::decay<T>::type sum = 0;
|
|
for (auto &elem : view)
|
|
sum += elem;
|
|
SELF_CHECK (sum == 1 + 2 + 3 + 4);
|
|
}
|
|
|
|
/* Entry point. */
|
|
|
|
static void
|
|
run_tests ()
|
|
{
|
|
/* Empty views. */
|
|
{
|
|
constexpr gdb::array_view<gdb_byte> view1;
|
|
constexpr gdb::array_view<const gdb_byte> view2;
|
|
|
|
static_assert (view1.empty (), "");
|
|
static_assert (view1.data () == nullptr, "");
|
|
static_assert (view1.size () == 0, "");
|
|
static_assert (view2.empty (), "");
|
|
static_assert (view2.size () == 0, "");
|
|
static_assert (view2.data () == nullptr, "");
|
|
}
|
|
|
|
std::vector<gdb_byte> vec = {0x11, 0x22, 0x33, 0x44 };
|
|
std::array<gdb_byte, 4> array = {{0x11, 0x22, 0x33, 0x44}};
|
|
|
|
/* Various tests of views over std::vector. */
|
|
{
|
|
gdb::array_view<gdb_byte> view = vec;
|
|
SELF_CHECK (check_container_view (view, vec));
|
|
gdb::array_view<const gdb_byte> cview = vec;
|
|
SELF_CHECK (check_container_view (cview, vec));
|
|
}
|
|
|
|
/* Likewise, over std::array. */
|
|
{
|
|
gdb::array_view<gdb_byte> view = array;
|
|
SELF_CHECK (check_container_view (view, array));
|
|
gdb::array_view<gdb_byte> cview = array;
|
|
SELF_CHECK (check_container_view (cview, array));
|
|
}
|
|
|
|
/* op=(std::vector/std::array/elem) */
|
|
{
|
|
gdb::array_view<gdb_byte> view;
|
|
|
|
view = vec;
|
|
SELF_CHECK (check_container_view (view, vec));
|
|
view = std::move (vec);
|
|
SELF_CHECK (check_container_view (view, vec));
|
|
|
|
view = array;
|
|
SELF_CHECK (check_container_view (view, array));
|
|
view = std::move (array);
|
|
SELF_CHECK (check_container_view (view, array));
|
|
|
|
gdb_byte elem = 0;
|
|
view = elem;
|
|
SELF_CHECK (check_elem_view (view, elem));
|
|
view = std::move (elem);
|
|
SELF_CHECK (check_elem_view (view, elem));
|
|
}
|
|
|
|
/* Test copy/move ctor and mutable->immutable conversion. */
|
|
{
|
|
gdb_byte data[] = {0x11, 0x22, 0x33, 0x44};
|
|
gdb::array_view<gdb_byte> view1 = data;
|
|
gdb::array_view<gdb_byte> view2 = view1;
|
|
gdb::array_view<gdb_byte> view3 = std::move (view1);
|
|
gdb::array_view<const gdb_byte> cview1 = data;
|
|
gdb::array_view<const gdb_byte> cview2 = cview1;
|
|
gdb::array_view<const gdb_byte> cview3 = std::move (cview1);
|
|
SELF_CHECK (view1[0] == data[0]);
|
|
SELF_CHECK (view2[0] == data[0]);
|
|
SELF_CHECK (view3[0] == data[0]);
|
|
SELF_CHECK (cview1[0] == data[0]);
|
|
SELF_CHECK (cview2[0] == data[0]);
|
|
SELF_CHECK (cview3[0] == data[0]);
|
|
}
|
|
|
|
/* Same, but op=(view). */
|
|
{
|
|
gdb_byte data[] = {0x55, 0x66, 0x77, 0x88};
|
|
gdb::array_view<gdb_byte> view1;
|
|
gdb::array_view<gdb_byte> view2;
|
|
gdb::array_view<gdb_byte> view3;
|
|
gdb::array_view<const gdb_byte> cview1;
|
|
gdb::array_view<const gdb_byte> cview2;
|
|
gdb::array_view<const gdb_byte> cview3;
|
|
|
|
view1 = data;
|
|
view2 = view1;
|
|
view3 = std::move (view1);
|
|
cview1 = data;
|
|
cview2 = cview1;
|
|
cview3 = std::move (cview1);
|
|
SELF_CHECK (view1[0] == data[0]);
|
|
SELF_CHECK (view2[0] == data[0]);
|
|
SELF_CHECK (view3[0] == data[0]);
|
|
SELF_CHECK (cview1[0] == data[0]);
|
|
SELF_CHECK (cview2[0] == data[0]);
|
|
SELF_CHECK (cview3[0] == data[0]);
|
|
}
|
|
|
|
/* op[] */
|
|
{
|
|
std::vector<gdb_byte> vec = {0x11, 0x22};
|
|
gdb::array_view<gdb_byte> view = vec;
|
|
gdb::array_view<const gdb_byte> cview = vec;
|
|
|
|
/* Check that op[] on a non-const view of non-const T returns a
|
|
mutable reference. */
|
|
view[0] = 0x33;
|
|
SELF_CHECK (vec[0] == 0x33);
|
|
|
|
/* OTOH, check that assigning through op[] on a view of const T
|
|
wouldn't compile. */
|
|
SELF_CHECK (!check_op_subscript (cview));
|
|
/* For completeness. */
|
|
SELF_CHECK (check_op_subscript (view));
|
|
}
|
|
|
|
check_ptr_size_ctor<const gdb_byte> ();
|
|
check_ptr_size_ctor<gdb_byte> ();
|
|
check_ptr_size_ctor2 ();
|
|
check_ptr_ptr_ctor<const gdb_byte> ();
|
|
check_ptr_ptr_ctor<gdb_byte> ();
|
|
check_ptr_ptr_mixed_cv ();
|
|
|
|
check_range_for<gdb_byte> ();
|
|
check_range_for<const gdb_byte> ();
|
|
|
|
/* Check that the right ctor overloads are taken when the element is
|
|
a container. */
|
|
{
|
|
using Vec = std::vector<gdb_byte>;
|
|
Vec vecs[3];
|
|
|
|
gdb::array_view<Vec> view_array = vecs;
|
|
SELF_CHECK (view_array.size () == 3);
|
|
|
|
Vec elem;
|
|
gdb::array_view<Vec> view_elem = elem;
|
|
SELF_CHECK (view_elem.size () == 1);
|
|
}
|
|
}
|
|
|
|
} /* namespace array_view_tests */
|
|
} /* namespace selftests */
|
|
|
|
void
|
|
_initialize_array_view_selftests ()
|
|
{
|
|
selftests::register_test ("array_view",
|
|
selftests::array_view_tests::run_tests);
|
|
}
|