aboutsummaryrefslogtreecommitdiff
path: root/gdb/unittests
diff options
context:
space:
mode:
authorPedro Alves <palves@redhat.com>2017-09-04 17:10:12 +0100
committerPedro Alves <palves@redhat.com>2017-09-04 17:10:12 +0100
commit7c44b49cb63662b76c6301fdc8e022d7aca655bf (patch)
tree0d03dd6a993fe6b5b1b430b467905820256b9892 /gdb/unittests
parente439fa140afdaedb28a97acaa2b0432b884d8a91 (diff)
downloadgdb-7c44b49cb63662b76c6301fdc8e022d7aca655bf.zip
gdb-7c44b49cb63662b76c6301fdc8e022d7aca655bf.tar.gz
gdb-7c44b49cb63662b76c6301fdc8e022d7aca655bf.tar.bz2
Introduce gdb::array_view
An array_view is an abstraction that provides a non-owning view over a sequence of contiguous objects. A way to put it is that array_view is to std::vector (and std::array and built-in arrays with rank==1) like std::string_view is to std::string. The main intent of array_view is to use it as function input parameter type, making it possible to pass in any sequence of contiguous objects, irrespective of whether the objects live on the stack or heap and what actual container owns them. Implicit construction from the element type is supported too, making it easy to call functions that expect an array of elements when you only have one element (usually on the stack). For example: struct A { .... }; void function (gdb::array_view<A> as); std::vector<A> std_vec = ...; std::array<A, N> std_array = ...; A array[] = {...}; A elem; function (std_vec); function (std_array); function (array); function (elem); Views can be either mutable or const. A const view is simply created by specifying a const T as array_view template parameter, in which case operator[] of non-const array_view objects ends up returning const references. (Making the array_view itself const is analogous to making a pointer itself be const. I.e., disables re-seating the view/pointer.) Normally functions will pass around array_views by value. Uses of gdb::array_view (other than the ones in the unit tests) will be added in a follow up patch. gdb/ChangeLog 2017-09-04 Pedro Alves <palves@redhat.com> * Makefile.in (SUBDIR_UNITTESTS_SRCS): Add unittests/array-view-selftests.c. (SUBDIR_UNITTESTS_OBS): Add array-view-selftests.o. * common/array-view.h: New file. * unittests/array-view-selftests.c: New file.
Diffstat (limited to 'gdb/unittests')
-rw-r--r--gdb/unittests/array-view-selftests.c494
1 files changed, 494 insertions, 0 deletions
diff --git a/gdb/unittests/array-view-selftests.c b/gdb/unittests/array-view-selftests.c
new file mode 100644
index 0000000..c4c95bc
--- /dev/null
+++ b/gdb/unittests/array-view-selftests.c
@@ -0,0 +1,494 @@
+/* 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"
+
+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 (selftests::array_view_tests::run_tests);
+}