1 //
2 // Tests for
3 //  explicit bounded_array_ref(bounded_ptr<T, TrappingPolicy> data, size_t n);
4 //
5 
6 #include <libkern/c++/bounded_array_ref.h>
7 #include "test_policy.h"
8 #include <cstddef>
9 #include <darwintest.h>
10 #include <darwintest_utils.h>
11 
12 struct T { int i; };
13 inline bool
14 operator==(T const& a, T const& b)
15 {
16 	return a.i == b.i;
17 };
18 
19 template <typename T>
20 static void
21 tests()
22 {
23 	T array[5] = {T{0}, T{1}, T{2}, T{3}, T{4}};
24 	T* const begin = &array[0];
25 	T* const end = &array[5];
26 
27 	// T{0}     T{1}     T{2}     T{3}     T{4}     <one-past-last>
28 	//   ^                                                ^
29 	//   |                                                |
30 	// begin,ptr                                         end
31 	//
32 	//   ^------------------- view -----------------------^
33 	{
34 		test_bounded_ptr<T> ptr(&array[0], begin, end);
35 		test_bounded_array_ref<T> view(ptr, 5);
36 		CHECK(view.data() == &array[0]);
37 		CHECK(view.size() == 5);
38 		CHECK(view[0] == T{0});
39 		CHECK(view[1] == T{1});
40 		CHECK(view[2] == T{2});
41 		CHECK(view[3] == T{3});
42 		CHECK(view[4] == T{4});
43 	}
44 	// T{0}     T{1}     T{2}     T{3}     T{4}     <one-past-last>
45 	//   ^                                                ^
46 	//   |                                                |
47 	// begin,ptr                                         end
48 	//
49 	//   ^----- view -----^
50 	{
51 		test_bounded_ptr<T> ptr(&array[0], begin, end);
52 		test_bounded_array_ref<T> view(ptr, 3);
53 		CHECK(view.data() == &array[0]);
54 		CHECK(view.size() == 3);
55 		CHECK(view[0] == T{0});
56 		CHECK(view[1] == T{1});
57 		CHECK(view[2] == T{2});
58 	}
59 	// T{0}     T{1}     T{2}     T{3}     T{4}     <one-past-last>
60 	//   ^                          ^                     ^
61 	//   |                          |                     |
62 	// begin                       ptr                   end
63 	//
64 	//                              ^------- view --------^
65 	{
66 		test_bounded_ptr<T> ptr(&array[3], begin, end);
67 		test_bounded_array_ref<T> view(ptr, 2);
68 		CHECK(view.data() == &array[3]);
69 		CHECK(view.size() == 2);
70 		CHECK(view[0] == T{3});
71 		CHECK(view[1] == T{4});
72 	}
73 	// Check with a valid `bounded_ptr` and a size of 0.
74 	{
75 		test_bounded_ptr<T> ptr(&array[0], begin, end);
76 		test_bounded_array_ref<T> view(ptr, 0);
77 		CHECK(view.size() == 0);
78 	}
79 	// Check with a null `bounded_ptr` and a size of 0.
80 	{
81 		test_bounded_ptr<T> ptr = nullptr;
82 		test_bounded_array_ref<T> view(ptr, 0);
83 		CHECK(view.size() == 0);
84 	}
85 	// Check with a non-null but invalid `bounded_ptr` and a size of 0.
86 	{
87 		test_bounded_ptr<T> ptr(end, begin, end);
88 		test_bounded_array_ref<T> view(ptr, 0);
89 		CHECK(view.size() == 0);
90 	}
91 	// Make sure there's no ambiguity between constructors.
92 	{
93 		test_bounded_ptr<T> ptr(begin, begin, end);
94 		std::ptrdiff_t size = sizeof(array) / sizeof(*array);
95 		test_bounded_array_ref<T> view(ptr, size);
96 		CHECK(view.data() == &array[0]);
97 		CHECK(view.size() == 5);
98 	}
99 }
100 
101 T_DECL(ctor_bounded_ptr, "bounded_array_ref.ctor.bounded_ptr") {
102 	tests<T>();
103 	tests<T const>();
104 }
105