1 /* Self tests for array_view for GDB, the GNU debugger. 2 3 Copyright (C) 2017-2023 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "gdbsupport/selftest.h" 22 #include "gdbsupport/array-view.h" 23 #include <array> 24 #include <vector> 25 26 namespace selftests { 27 namespace array_view_tests { 28 29 /* Triviality checks. */ 30 #define CHECK_TRAIT(TRAIT) \ 31 static_assert (std::TRAIT<gdb::array_view<gdb_byte>>::value, "") 32 33 #if HAVE_IS_TRIVIALLY_COPYABLE 34 35 CHECK_TRAIT (is_trivially_copyable); 36 CHECK_TRAIT (is_trivially_move_assignable); 37 CHECK_TRAIT (is_trivially_move_constructible); 38 CHECK_TRAIT (is_trivially_destructible); 39 40 #endif 41 42 #undef CHECK_TRAIT 43 44 /* Wrapper around std::is_convertible to make the code using it a bit 45 shorter. (With C++14 we'd use a variable template instead.) */ 46 47 template<typename From, typename To> 48 static constexpr bool 49 is_convertible () 50 { 51 return std::is_convertible<From, To>::value; 52 } 53 54 /* Check for implicit conversion to immutable and mutable views. */ 55 56 static constexpr bool 57 check_convertible () 58 { 59 using T = gdb_byte; 60 using gdb::array_view; 61 62 return (true 63 /* immutable array_view */ 64 && is_convertible<const T (&) [1], array_view<const T>> () 65 && is_convertible<T (&) [1], array_view<const T>> () 66 && is_convertible<const T, array_view<const T>> () 67 && is_convertible<T, array_view<const T>> () 68 69 /* mutable array_view */ 70 && is_convertible<T (&) [1], array_view<T>> () 71 && !is_convertible<const T (&) [1], array_view<T>> () 72 && is_convertible<T, array_view<T>> () 73 && !is_convertible<const T, array_view<T>> () 74 75 /* While float is implicitly convertible to gdb_byte, we 76 don't want implicit float->array_view<gdb_byte> 77 conversion. */ 78 && !is_convertible<float, array_view<const T>> () 79 && !is_convertible<float, array_view<T>> ()); 80 } 81 82 static_assert (check_convertible (), ""); 83 84 namespace no_slicing 85 { 86 struct A { int i; }; 87 struct B : A { int j; }; 88 struct C : A { int l; }; 89 90 /* Check that there's no array->view conversion for arrays of derived types or 91 subclasses. */ 92 static constexpr bool 93 check () 94 { 95 using gdb::array_view; 96 97 return (true 98 99 /* array->view */ 100 101 && is_convertible <A (&)[1], array_view<A>> () 102 && !is_convertible <B (&)[1], array_view<A>> () 103 && !is_convertible <C (&)[1], array_view<A>> () 104 105 && !is_convertible <A (&)[1], array_view<B>> () 106 && is_convertible <B (&)[1], array_view<B>> () 107 && !is_convertible <C (&)[1], array_view<B>> () 108 109 /* elem->view */ 110 111 && is_convertible <A, array_view<A>> () 112 && !is_convertible <B, array_view<A>> () 113 && !is_convertible <C, array_view<A>> () 114 115 && !is_convertible <A, array_view<B>> () 116 && is_convertible <B, array_view<B>> () 117 && !is_convertible <C, array_view<B>> ()); 118 } 119 120 /* Check that there's no container->view conversion for containers of derived 121 types or subclasses. */ 122 123 template<template<typename ...> class Container> 124 static constexpr bool 125 check_ctor_from_container () 126 { 127 using gdb::array_view; 128 129 return ( is_convertible <Container<A>, array_view<A>> () 130 && !is_convertible <Container<B>, array_view<A>> () 131 && !is_convertible <Container<C>, array_view<A>> () 132 133 && !is_convertible <Container<A>, array_view<B>> () 134 && is_convertible <Container<B>, array_view<B>> () 135 && !is_convertible <Container<C>, array_view<B>> ()); 136 } 137 138 } /* namespace no_slicing */ 139 140 /* std::array with only one template argument, so we can pass it to 141 check_ctor_from_container. */ 142 template<typename T> using StdArray1 = std::array<T, 1>; 143 144 static_assert (no_slicing::check (), ""); 145 static_assert (no_slicing::check_ctor_from_container<std::vector> (), ""); 146 static_assert (no_slicing::check_ctor_from_container<StdArray1> (), ""); 147 static_assert (no_slicing::check_ctor_from_container<gdb::array_view> (), ""); 148 149 /* Check that array_view implicitly converts from std::vector. */ 150 151 static constexpr bool 152 check_convertible_from_std_vector () 153 { 154 using gdb::array_view; 155 using T = gdb_byte; 156 157 /* Note there's no such thing as std::vector<const T>. */ 158 159 return (true 160 && is_convertible <std::vector<T>, array_view<T>> () 161 && is_convertible <std::vector<T>, array_view<const T>> ()); 162 } 163 164 static_assert (check_convertible_from_std_vector (), ""); 165 166 /* Check that array_view implicitly converts from std::array. */ 167 168 static constexpr bool 169 check_convertible_from_std_array () 170 { 171 using gdb::array_view; 172 using T = gdb_byte; 173 174 /* Note: a non-const T view can't refer to a const T array. */ 175 176 return (true 177 && is_convertible <std::array<T, 1>, array_view<T>> () 178 && is_convertible <std::array<T, 1>, array_view<const T>> () 179 && !is_convertible <std::array<const T, 1>, array_view<T>> () 180 && is_convertible <std::array<const T, 1>, array_view<const T>> ()); 181 } 182 183 static_assert (check_convertible_from_std_array (), ""); 184 185 /* Check that VIEW views C (a container like std::vector/std::array) 186 correctly. */ 187 188 template<typename View, typename Container> 189 static bool 190 check_container_view (const View &view, const Container &c) 191 { 192 if (view.empty ()) 193 return false; 194 if (view.size () != c.size ()) 195 return false; 196 if (view.data () != c.data ()) 197 return false; 198 for (size_t i = 0; i < c.size (); i++) 199 { 200 if (&view[i] != &c[i]) 201 return false; 202 if (view[i] != c[i]) 203 return false; 204 } 205 return true; 206 } 207 208 /* Check that VIEW views E (an object of the type of a view element) 209 correctly. */ 210 211 template<typename View, typename Elem> 212 static bool 213 check_elem_view (const View &view, const Elem &e) 214 { 215 if (view.empty ()) 216 return false; 217 if (view.size () != 1) 218 return false; 219 if (view.data () != &e) 220 return false; 221 if (&view[0] != &e) 222 return false; 223 if (view[0] != e) 224 return false; 225 return true; 226 } 227 228 /* Check for operator[]. The first overload is taken iff 229 'view<T>()[0] = T()' is a valid expression. */ 230 231 template<typename View, 232 typename = decltype (std::declval<View> ()[0] 233 = std::declval<typename View::value_type> ())> 234 static bool 235 check_op_subscript (const View &view) 236 { 237 return true; 238 } 239 240 /* This overload is taken iff 'view<T>()[0] = T()' is not a valid 241 expression. */ 242 243 static bool 244 check_op_subscript (...) 245 { 246 return false; 247 } 248 249 /* Check construction with pointer + size. This is a template in 250 order to test both gdb_byte and const gdb_byte. */ 251 252 template<typename T> 253 static void 254 check_ptr_size_ctor () 255 { 256 T data[] = {0x11, 0x22, 0x33, 0x44}; 257 258 gdb::array_view<T> view (data + 1, 2); 259 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]); 265 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]); 272 } 273 274 /* Asserts std::is_constructible. */ 275 276 template<typename T, typename... Args> 277 static constexpr bool 278 require_not_constructible () 279 { 280 static_assert (!std::is_constructible<T, Args...>::value, ""); 281 282 /* constexpr functions can't return void in C++11 (N3444). */ 283 return true; 284 }; 285 286 /* Check the array_view<T>(PTR, SIZE) ctor, when T is a pointer. */ 287 288 static void 289 check_ptr_size_ctor2 () 290 { 291 struct A {}; 292 A an_a; 293 294 A *array[] = { &an_a }; 295 const A * const carray[] = { &an_a }; 296 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)}; 301 302 require_not_constructible<gdb::array_view<A *>, decltype (carray), size_t> (); 303 304 SELF_CHECK (v1[0] == array[0]); 305 SELF_CHECK (v2[0] == array[0]); 306 SELF_CHECK (v3[0] == array[0]); 307 308 SELF_CHECK (!v1.empty ()); 309 SELF_CHECK (v1.size () == 1); 310 SELF_CHECK (v1.data () == &array[0]); 311 312 SELF_CHECK (cv1[0] == carray[0]); 313 314 SELF_CHECK (!cv1.empty ()); 315 SELF_CHECK (cv1.size () == 1); 316 SELF_CHECK (cv1.data () == &carray[0]); 317 } 318 319 /* Check construction with a pair of pointers. This is a template in 320 order to test both gdb_byte and const gdb_byte. */ 321 322 template<typename T> 323 static void 324 check_ptr_ptr_ctor () 325 { 326 T data[] = {0x11, 0x22, 0x33, 0x44}; 327 328 gdb::array_view<T> view (data + 1, data + 3); 329 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]); 335 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); 340 } 341 342 /* Check construction with a pair of pointers of mixed constness. */ 343 344 static void 345 check_ptr_ptr_mixed_cv () 346 { 347 gdb_byte array[] = {0x11, 0x22, 0x33, 0x44}; 348 const gdb_byte *cp = array; 349 gdb_byte *p = 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 ()); 354 } 355 356 /* Check range-for support (i.e., begin()/end()). This is a template 357 in order to test both gdb_byte and const gdb_byte. */ 358 359 template<typename T> 360 static void 361 check_range_for () 362 { 363 T data[] = {1, 2, 3, 4}; 364 gdb::array_view<T> view (data); 365 366 typename std::decay<T>::type sum = 0; 367 for (auto &elem : view) 368 sum += elem; 369 SELF_CHECK (sum == 1 + 2 + 3 + 4); 370 } 371 372 /* Entry point. */ 373 374 static void 375 run_tests () 376 { 377 /* Empty views. */ 378 { 379 constexpr gdb::array_view<gdb_byte> view1; 380 constexpr gdb::array_view<const gdb_byte> view2; 381 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, ""); 388 } 389 390 std::vector<gdb_byte> vec = {0x11, 0x22, 0x33, 0x44 }; 391 std::array<gdb_byte, 4> array = {{0x11, 0x22, 0x33, 0x44}}; 392 393 /* Various tests of views over std::vector. */ 394 { 395 gdb::array_view<gdb_byte> view = vec; 396 SELF_CHECK (check_container_view (view, vec)); 397 gdb::array_view<const gdb_byte> cview = vec; 398 SELF_CHECK (check_container_view (cview, vec)); 399 } 400 401 /* Likewise, over std::array. */ 402 { 403 gdb::array_view<gdb_byte> view = array; 404 SELF_CHECK (check_container_view (view, array)); 405 gdb::array_view<gdb_byte> cview = array; 406 SELF_CHECK (check_container_view (cview, array)); 407 } 408 409 /* op=(std::vector/std::array/elem) */ 410 { 411 gdb::array_view<gdb_byte> view; 412 413 view = vec; 414 SELF_CHECK (check_container_view (view, vec)); 415 view = std::move (vec); 416 SELF_CHECK (check_container_view (view, vec)); 417 418 view = array; 419 SELF_CHECK (check_container_view (view, array)); 420 view = std::move (array); 421 SELF_CHECK (check_container_view (view, array)); 422 423 gdb_byte elem = 0; 424 view = elem; 425 SELF_CHECK (check_elem_view (view, elem)); 426 view = std::move (elem); 427 SELF_CHECK (check_elem_view (view, elem)); 428 } 429 430 /* Test copy/move ctor and mutable->immutable conversion. */ 431 { 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]); 445 } 446 447 /* Same, but op=(view). */ 448 { 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; 456 457 view1 = data; 458 view2 = view1; 459 view3 = std::move (view1); 460 cview1 = data; 461 cview2 = cview1; 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]); 469 } 470 471 /* op[] */ 472 { 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; 476 477 /* Check that op[] on a non-const view of non-const T returns a 478 mutable reference. */ 479 view[0] = 0x33; 480 SELF_CHECK (vec2[0] == 0x33); 481 482 /* OTOH, check that assigning through op[] on a view of const T 483 wouldn't compile. */ 484 SELF_CHECK (!check_op_subscript (cview)); 485 /* For completeness. */ 486 SELF_CHECK (check_op_subscript (view)); 487 } 488 489 check_ptr_size_ctor<const gdb_byte> (); 490 check_ptr_size_ctor<gdb_byte> (); 491 check_ptr_size_ctor2 (); 492 check_ptr_ptr_ctor<const gdb_byte> (); 493 check_ptr_ptr_ctor<gdb_byte> (); 494 check_ptr_ptr_mixed_cv (); 495 496 check_range_for<gdb_byte> (); 497 check_range_for<const gdb_byte> (); 498 499 /* Check that the right ctor overloads are taken when the element is 500 a container. */ 501 { 502 using Vec = std::vector<gdb_byte>; 503 Vec vecs[3]; 504 505 gdb::array_view<Vec> view_array = vecs; 506 SELF_CHECK (view_array.size () == 3); 507 508 Vec elem; 509 gdb::array_view<Vec> view_elem = elem; 510 SELF_CHECK (view_elem.size () == 1); 511 } 512 513 /* gdb::make_array_view, int length. */ 514 { 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); 518 519 SELF_CHECK (view.data () == data); 520 SELF_CHECK (view.size () == len); 521 522 for (size_t i = 0; i < len; i++) 523 SELF_CHECK (view[i] == data[i]); 524 } 525 526 /* Test slicing. */ 527 { 528 gdb_byte data[] = {0x55, 0x66, 0x77, 0x88, 0x99}; 529 gdb::array_view<gdb_byte> view = data; 530 531 { 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]); 537 } 538 539 { 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]); 545 } 546 } 547 } 548 549 template <typename T> 550 void 551 run_copy_test () 552 { 553 /* Test non-overlapping copy. */ 554 { 555 const std::vector<T> src_v = {1, 2, 3, 4}; 556 std::vector<T> dest_v (4, -1); 557 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); 561 } 562 563 /* Test overlapping copy, where the source is before the destination. */ 564 { 565 std::vector<T> vec = {1, 2, 3, 4, 5, 6, 7, 8}; 566 gdb::array_view<T> v = vec; 567 568 copy (v.slice (1, 4), 569 v.slice (2, 4)); 570 571 std::vector<T> expected = {1, 2, 2, 3, 4, 5, 7, 8}; 572 SELF_CHECK (vec == expected); 573 } 574 575 /* Test overlapping copy, where the source is after the destination. */ 576 { 577 std::vector<T> vec = {1, 2, 3, 4, 5, 6, 7, 8}; 578 gdb::array_view<T> v = vec; 579 580 copy (v.slice (2, 4), 581 v.slice (1, 4)); 582 583 std::vector<T> expected = {1, 3, 4, 5, 6, 6, 7, 8}; 584 SELF_CHECK (vec == expected); 585 } 586 587 /* Test overlapping copy, where the source is the same as the destination. */ 588 { 589 std::vector<T> vec = {1, 2, 3, 4, 5, 6, 7, 8}; 590 gdb::array_view<T> v = vec; 591 592 copy (v.slice (2, 4), 593 v.slice (2, 4)); 594 595 std::vector<T> expected = {1, 2, 3, 4, 5, 6, 7, 8}; 596 SELF_CHECK (vec == expected); 597 } 598 } 599 600 /* Class with a non-trivial copy assignment operator, used to test the 601 array_view copy function. */ 602 struct foo 603 { 604 /* Can be implicitly constructed from an int, such that we can use the same 605 templated test function to test against array_view<int> and 606 array_view<foo>. */ 607 foo (int n) 608 : n (n) 609 {} 610 611 /* Needed to avoid -Wdeprecated-copy-with-user-provided-copy error with 612 Clang. */ 613 foo (const foo &other) = default; 614 615 void operator= (const foo &other) 616 { 617 this->n = other.n; 618 this->n_assign_op_called++; 619 } 620 621 bool operator==(const foo &other) const 622 { 623 return this->n == other.n; 624 } 625 626 int n; 627 628 /* Number of times the assignment operator has been called. */ 629 static int n_assign_op_called; 630 }; 631 632 int foo::n_assign_op_called = 0; 633 634 /* Test the array_view copy free function. */ 635 636 static void 637 run_copy_tests () 638 { 639 /* Test with a trivial type. */ 640 run_copy_test<int> (); 641 642 /* Test with a non-trivial type. */ 643 foo::n_assign_op_called = 0; 644 run_copy_test<foo> (); 645 646 /* Make sure that for the non-trivial type foo, the assignment operator was 647 called an amount of times that makes sense. */ 648 SELF_CHECK (foo::n_assign_op_called == 12); 649 } 650 651 } /* namespace array_view_tests */ 652 } /* namespace selftests */ 653 654 void _initialize_array_view_selftests (); 655 void 656 _initialize_array_view_selftests () 657 { 658 selftests::register_test ("array_view", 659 selftests::array_view_tests::run_tests); 660 selftests::register_test ("array_view-copy", 661 selftests::array_view_tests::run_copy_tests); 662 } 663