21#include "gdbsupport/selftest.h"
22#include "gdbsupport/array-view.h"
27namespace array_view_tests {
30#define CHECK_TRAIT(TRAIT) \
31 static_assert (std::TRAIT<gdb::array_view<gdb_byte>>::value, "")
33#if HAVE_IS_TRIVIALLY_COPYABLE
47template<
typename From,
typename To>
51 return std::is_convertible<From, To>::value;
60 using gdb::array_view;
87struct B :
A {
int j; };
88struct C :
A {
int l; };
95 using gdb::array_view;
123template<
template<
typename ...>
class Container>
127 using gdb::array_view;
145static_assert (no_slicing::check_ctor_from_container<std::vector> (),
"");
146static_assert (no_slicing::check_ctor_from_container<StdArray1> (),
"");
147static_assert (no_slicing::check_ctor_from_container<gdb::array_view> (),
"");
154 using gdb::array_view;
171 using gdb::array_view;
180 &&
is_convertible <std::array<const T, 1>, array_view<const T>> ());
188template<
typename View,
typename Container>
194 if (view.size () != c.size ())
196 if (view.data () != c.data ())
198 for (
size_t i = 0; i < c.size (); i++)
200 if (&view[i] != &c[i])
211template<
typename View,
typename Elem>
217 if (view.size () != 1)
219 if (view.data () != &e)
231template<
typename View,
232 typename =
decltype (std::declval<View> ()[0]
233 = std::declval<typename View::value_type> ())>
256 T data[] = {0x11, 0x22, 0x33, 0x44};
258 gdb::array_view<T> view (data + 1, 2);
260 SELF_CHECK (!view.empty ());
261 SELF_CHECK (view.size () == 2);
262 SELF_CHECK (view.data () == &data[1]);
263 SELF_CHECK (view[0] == data[1]);
264 SELF_CHECK (view[1] == data[2]);
266 gdb::array_view<const T> cview (data + 1, 2);
267 SELF_CHECK (!cview.empty ());
268 SELF_CHECK (cview.size () == 2);
269 SELF_CHECK (cview.data () == &data[1]);
270 SELF_CHECK (cview[0] == data[1]);
271 SELF_CHECK (cview[1] == data[2]);
276template<
typename T,
typename... Args>
280 static_assert (!std::is_constructible<
T, Args...>
::value,
"");
294 A *array[] = { &an_a };
295 const A *
const carray[] = { &an_a };
297 gdb::array_view<A *> v1 = {array, ARRAY_SIZE (array)};
298 gdb::array_view<A *> v2 = {array, (char) ARRAY_SIZE (array)};
299 gdb::array_view<A * const> v3 = {array, ARRAY_SIZE (array)};
300 gdb::array_view<const A * const> cv1 = {carray, ARRAY_SIZE (carray)};
302 require_not_constructible<gdb::array_view<A *>,
decltype (carray),
size_t> ();
304 SELF_CHECK (v1[0] == array[0]);
305 SELF_CHECK (v2[0] == array[0]);
306 SELF_CHECK (v3[0] == array[0]);
308 SELF_CHECK (!v1.empty ());
309 SELF_CHECK (v1.size () == 1);
310 SELF_CHECK (v1.data () == &array[0]);
312 SELF_CHECK (cv1[0] == carray[0]);
314 SELF_CHECK (!cv1.empty ());
315 SELF_CHECK (cv1.size () == 1);
316 SELF_CHECK (cv1.data () == &carray[0]);
326 T data[] = {0x11, 0x22, 0x33, 0x44};
328 gdb::array_view<T> view (data + 1, data + 3);
330 SELF_CHECK (!view.empty ());
331 SELF_CHECK (view.size () == 2);
332 SELF_CHECK (view.data () == &data[1]);
333 SELF_CHECK (view[0] == data[1]);
334 SELF_CHECK (view[1] == data[2]);
336 gdb_byte array[] = {0x11, 0x22, 0x33, 0x44};
337 const gdb_byte *p1 = array;
338 gdb_byte *p2 = array + ARRAY_SIZE (array);
339 gdb::array_view<const gdb_byte> view2 (p1, p2);
347 gdb_byte array[] = {0x11, 0x22, 0x33, 0x44};
348 const gdb_byte *cp = array;
350 gdb::array_view<const gdb_byte> view1 (cp, p);
351 gdb::array_view<const gdb_byte> view2 (p, cp);
352 SELF_CHECK (view1.empty ());
353 SELF_CHECK (view2.empty ());
363 T data[] = {1, 2, 3, 4};
364 gdb::array_view<T> view (data);
366 typename std::decay<T>::type sum = 0;
367 for (
auto &elem : view)
369 SELF_CHECK (sum == 1 + 2 + 3 + 4);
379 constexpr gdb::array_view<gdb_byte> view1;
380 constexpr gdb::array_view<const gdb_byte> view2;
382 static_assert (view1.empty (),
"");
383 static_assert (view1.data () ==
nullptr,
"");
384 static_assert (view1.size () == 0,
"");
385 static_assert (view2.empty (),
"");
386 static_assert (view2.size () == 0,
"");
387 static_assert (view2.data () ==
nullptr,
"");
390 std::vector<gdb_byte> vec = {0x11, 0x22, 0x33, 0x44 };
391 std::array<gdb_byte, 4> array = {{0x11, 0x22, 0x33, 0x44}};
395 gdb::array_view<gdb_byte> view = vec;
397 gdb::array_view<const gdb_byte> cview = vec;
403 gdb::array_view<gdb_byte> view = array;
405 gdb::array_view<gdb_byte> cview = array;
411 gdb::array_view<gdb_byte> view;
415 view = std::move (vec);
420 view = std::move (array);
426 view = std::move (elem);
432 gdb_byte data[] = {0x11, 0x22, 0x33, 0x44};
433 gdb::array_view<gdb_byte> view1 = data;
434 gdb::array_view<gdb_byte> view2 = view1;
435 gdb::array_view<gdb_byte> view3 = std::move (view1);
436 gdb::array_view<const gdb_byte> cview1 = data;
437 gdb::array_view<const gdb_byte> cview2 = cview1;
438 gdb::array_view<const gdb_byte> cview3 = std::move (cview1);
439 SELF_CHECK (view1[0] == data[0]);
440 SELF_CHECK (view2[0] == data[0]);
441 SELF_CHECK (view3[0] == data[0]);
442 SELF_CHECK (cview1[0] == data[0]);
443 SELF_CHECK (cview2[0] == data[0]);
444 SELF_CHECK (cview3[0] == data[0]);
449 gdb_byte data[] = {0x55, 0x66, 0x77, 0x88};
450 gdb::array_view<gdb_byte> view1;
451 gdb::array_view<gdb_byte> view2;
452 gdb::array_view<gdb_byte> view3;
453 gdb::array_view<const gdb_byte> cview1;
454 gdb::array_view<const gdb_byte> cview2;
455 gdb::array_view<const gdb_byte> cview3;
459 view3 = std::move (view1);
462 cview3 = std::move (cview1);
463 SELF_CHECK (view1[0] == data[0]);
464 SELF_CHECK (view2[0] == data[0]);
465 SELF_CHECK (view3[0] == data[0]);
466 SELF_CHECK (cview1[0] == data[0]);
467 SELF_CHECK (cview2[0] == data[0]);
468 SELF_CHECK (cview3[0] == data[0]);
473 std::vector<gdb_byte> vec2 = {0x11, 0x22};
474 gdb::array_view<gdb_byte> view = vec2;
475 gdb::array_view<const gdb_byte> cview = vec2;
480 SELF_CHECK (vec2[0] == 0x33);
489 check_ptr_size_ctor<const gdb_byte> ();
490 check_ptr_size_ctor<gdb_byte> ();
492 check_ptr_ptr_ctor<const gdb_byte> ();
493 check_ptr_ptr_ctor<gdb_byte> ();
496 check_range_for<gdb_byte> ();
497 check_range_for<const gdb_byte> ();
502 using Vec = std::vector<gdb_byte>;
505 gdb::array_view<Vec> view_array = vecs;
506 SELF_CHECK (view_array.size () == 3);
509 gdb::array_view<Vec> view_elem = elem;
510 SELF_CHECK (view_elem.size () == 1);
515 gdb_byte data[] = {0x55, 0x66, 0x77, 0x88};
516 int len =
sizeof (data) /
sizeof (data[0]);
517 auto view = gdb::make_array_view (data, len);
519 SELF_CHECK (view.data () == data);
520 SELF_CHECK (view.size () == len);
522 for (
size_t i = 0; i < len; i++)
523 SELF_CHECK (view[i] == data[i]);
528 gdb_byte data[] = {0x55, 0x66, 0x77, 0x88, 0x99};
529 gdb::array_view<gdb_byte> view = data;
532 auto slc = view.slice (1, 3);
533 SELF_CHECK (slc.data () == data + 1);
534 SELF_CHECK (slc.size () == 3);
535 SELF_CHECK (slc[0] == data[1]);
536 SELF_CHECK (slc[0] == view[1]);
540 auto slc = view.slice (2);
541 SELF_CHECK (slc.data () == data + 2);
542 SELF_CHECK (slc.size () == 3);
543 SELF_CHECK (slc[0] == view[2]);
544 SELF_CHECK (slc[0] == data[2]);
555 const std::vector<T> src_v = {1, 2, 3, 4};
556 std::vector<T> dest_v (4, -1);
558 SELF_CHECK (dest_v != src_v);
559 copy (gdb::array_view<const T> (src_v), gdb::array_view<T> (dest_v));
560 SELF_CHECK (dest_v == src_v);
565 std::vector<T> vec = {1, 2, 3, 4, 5, 6, 7, 8};
566 gdb::array_view<T> v = vec;
568 copy (v.slice (1, 4),
571 std::vector<T> expected = {1, 2, 2, 3, 4, 5, 7, 8};
572 SELF_CHECK (vec == expected);
577 std::vector<T> vec = {1, 2, 3, 4, 5, 6, 7, 8};
578 gdb::array_view<T> v = vec;
580 copy (v.slice (2, 4),
583 std::vector<T> expected = {1, 3, 4, 5, 6, 6, 7, 8};
584 SELF_CHECK (vec == expected);
589 std::vector<T> vec = {1, 2, 3, 4, 5, 6, 7, 8};
590 gdb::array_view<T> v = vec;
592 copy (v.slice (2, 4),
595 std::vector<T> expected = {1, 2, 3, 4, 5, 6, 7, 8};
596 SELF_CHECK (vec == expected);
623 return this->
n == other.
n;
640 run_copy_test<int> ();
644 run_copy_test<foo> ();
658 selftests::register_test (
"array_view",
660 selftests::register_test (
"array_view-copy",
void _initialize_array_view_selftests()
#define CHECK_TRAIT(TRAIT)
static constexpr bool check_ctor_from_container()
static constexpr bool check()
std::array< T, 1 > StdArray1
static constexpr bool require_not_constructible()
static void check_range_for()
static bool check_container_view(const View &view, const Container &c)
static void check_ptr_ptr_ctor()
static constexpr bool is_convertible()
static void run_copy_tests()
static void check_ptr_size_ctor2()
static void check_ptr_ptr_mixed_cv()
static void check_ptr_size_ctor()
static constexpr bool check_convertible_from_std_array()
static bool check_op_subscript(const View &view)
static bool check_elem_view(const View &view, const Elem &e)
static constexpr bool check_convertible()
static constexpr bool check_convertible_from_std_vector()
void operator=(const foo &other)
static int n_assign_op_called
bool operator==(const foo &other) const
foo(const foo &other)=default