1 //===-- Unittests for ArrayRef --------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "utils/CPP/ArrayRef.h"
10 #include "utils/UnitTest/Test.h"
11
12 namespace __llvm_libc {
13 namespace cpp {
14
15 // The following tests run on both 'ArrayRef' and 'MutableArrayRef'.
16 using Types = testing::TypeList<ArrayRef<int>, MutableArrayRef<int>>;
17
TYPED_TEST(LlvmLibcArrayRefTest,ConstructFromElement,Types)18 TYPED_TEST(LlvmLibcArrayRefTest, ConstructFromElement, Types) {
19 using value_type = typename ParamType::value_type;
20 using const_pointer = typename ParamType::const_pointer;
21 value_type element = 5;
22 ParamType arrayref(element);
23 EXPECT_FALSE(arrayref.empty());
24 EXPECT_EQ(arrayref.size(), size_t(1));
25 EXPECT_EQ(arrayref[0], 5);
26 EXPECT_EQ((const_pointer)arrayref.data(), (const_pointer)&element);
27 }
28
TYPED_TEST(LlvmLibcArrayRefTest,ConstructFromPointerAndSize,Types)29 TYPED_TEST(LlvmLibcArrayRefTest, ConstructFromPointerAndSize, Types) {
30 using value_type = typename ParamType::value_type;
31 using const_pointer = typename ParamType::const_pointer;
32 value_type values[] = {1, 2};
33 ParamType arrayref(values, 2);
34 EXPECT_FALSE(arrayref.empty());
35 EXPECT_EQ(arrayref.size(), size_t(2));
36 EXPECT_EQ(arrayref[0], 1);
37 EXPECT_EQ(arrayref[1], 2);
38 EXPECT_EQ((const_pointer)arrayref.data(), (const_pointer)values);
39 }
40
TYPED_TEST(LlvmLibcArrayRefTest,ConstructFromIterator,Types)41 TYPED_TEST(LlvmLibcArrayRefTest, ConstructFromIterator, Types) {
42 using value_type = typename ParamType::value_type;
43 using const_pointer = typename ParamType::const_pointer;
44 value_type values[] = {1, 2};
45 ParamType arrayref(&values[0], &values[2]);
46 EXPECT_FALSE(arrayref.empty());
47 EXPECT_EQ(arrayref.size(), size_t(2));
48 EXPECT_EQ(arrayref[0], 1);
49 EXPECT_EQ(arrayref[1], 2);
50 EXPECT_EQ((const_pointer)arrayref.data(), (const_pointer)&values[0]);
51 }
52
TYPED_TEST(LlvmLibcArrayRefTest,ConstructFromCArray,Types)53 TYPED_TEST(LlvmLibcArrayRefTest, ConstructFromCArray, Types) {
54 using value_type = typename ParamType::value_type;
55 using const_pointer = typename ParamType::const_pointer;
56 value_type values[] = {1, 2};
57 ParamType arrayref(values);
58 EXPECT_FALSE(arrayref.empty());
59 EXPECT_EQ(arrayref.size(), size_t(2));
60 EXPECT_EQ(arrayref[0], 1);
61 EXPECT_EQ(arrayref[1], 2);
62 EXPECT_EQ((const_pointer)arrayref.data(), (const_pointer)values);
63 }
64
TYPED_TEST(LlvmLibcArrayRefTest,ConstructFromLibcArray,Types)65 TYPED_TEST(LlvmLibcArrayRefTest, ConstructFromLibcArray, Types) {
66 using value_type = typename ParamType::value_type;
67 using const_pointer = typename ParamType::const_pointer;
68 Array<value_type, 2> values = {1, 2};
69 ParamType arrayref(values);
70 EXPECT_FALSE(arrayref.empty());
71 EXPECT_EQ(arrayref.size(), size_t(2));
72 EXPECT_EQ(arrayref[0], 1);
73 EXPECT_EQ(arrayref[1], 2);
74 EXPECT_EQ((const_pointer)arrayref.data(), (const_pointer)values.data());
75 }
76
TYPED_TEST(LlvmLibcArrayRefTest,Equals,Types)77 TYPED_TEST(LlvmLibcArrayRefTest, Equals, Types) {
78 using value_type = typename ParamType::value_type;
79 value_type values[] = {1, 2, 3};
80 ParamType initial(values);
81 EXPECT_TRUE(initial.equals(initial));
82 ParamType shallow_copy(values);
83 EXPECT_TRUE(initial.equals(shallow_copy));
84 value_type same_values[] = {1, 2, 3};
85 EXPECT_TRUE(initial.equals(same_values));
86 value_type different_values[] = {1, 2, 4};
87 EXPECT_FALSE(initial.equals(different_values));
88 }
89
TYPED_TEST(LlvmLibcArrayRefTest,SliceUnary,Types)90 TYPED_TEST(LlvmLibcArrayRefTest, SliceUnary, Types) {
91 using value_type = typename ParamType::value_type;
92 value_type values[] = {1, 2, 3};
93 ParamType arrayref(values);
94 {
95 value_type values[] = {1, 2, 3};
96 EXPECT_TRUE(arrayref.slice(0).equals(values));
97 }
98 {
99 value_type values[] = {2, 3};
100 EXPECT_TRUE(arrayref.slice(1).equals(values));
101 }
102 {
103 value_type values[] = {3};
104 EXPECT_TRUE(arrayref.slice(2).equals(values));
105 }
106 { EXPECT_TRUE(arrayref.slice(3).empty()); }
107 }
108
TYPED_TEST(LlvmLibcArrayRefTest,SliceBinary,Types)109 TYPED_TEST(LlvmLibcArrayRefTest, SliceBinary, Types) {
110 using value_type = typename ParamType::value_type;
111 value_type values[] = {1, 2, 3};
112 ParamType arrayref(values);
113 {
114 EXPECT_TRUE(arrayref.slice(0, 0).empty());
115 EXPECT_TRUE(arrayref.slice(1, 0).empty());
116 EXPECT_TRUE(arrayref.slice(2, 0).empty());
117 EXPECT_TRUE(arrayref.slice(3, 0).empty());
118 }
119 {
120 value_type values[] = {1};
121 EXPECT_TRUE(arrayref.slice(0, 1).equals(values));
122 }
123 {
124 value_type values[] = {2};
125 EXPECT_TRUE(arrayref.slice(1, 1).equals(values));
126 }
127 {
128 value_type values[] = {3};
129 EXPECT_TRUE(arrayref.slice(2, 1).equals(values));
130 }
131 {
132 value_type values[] = {1, 2};
133 EXPECT_TRUE(arrayref.slice(0, 2).equals(values));
134 }
135 {
136 value_type values[] = {2, 3};
137 EXPECT_TRUE(arrayref.slice(1, 2).equals(values));
138 }
139 {
140 value_type values[] = {1, 2, 3};
141 EXPECT_TRUE(arrayref.slice(0, 3).equals(values));
142 }
143 }
144
TYPED_TEST(LlvmLibcArrayRefTest,DropFront,Types)145 TYPED_TEST(LlvmLibcArrayRefTest, DropFront, Types) {
146 using value_type = typename ParamType::value_type;
147 value_type values[] = {1, 2, 3};
148 ParamType arrayref(values);
149 {
150 value_type values[] = {1, 2, 3};
151 EXPECT_TRUE(arrayref.drop_front(0).equals(values));
152 }
153 {
154 value_type values[] = {2, 3};
155 EXPECT_TRUE(arrayref.drop_front(1).equals(values));
156 }
157 {
158 value_type values[] = {3};
159 EXPECT_TRUE(arrayref.drop_front(2).equals(values));
160 }
161 { EXPECT_TRUE(arrayref.drop_front(3).empty()); }
162 }
163
TYPED_TEST(LlvmLibcArrayRefTest,DropBack,Types)164 TYPED_TEST(LlvmLibcArrayRefTest, DropBack, Types) {
165 using value_type = typename ParamType::value_type;
166 value_type values[] = {1, 2, 3};
167 ParamType arrayref(values);
168 {
169 value_type values[] = {1, 2, 3};
170 EXPECT_TRUE(arrayref.drop_back(0).equals(values));
171 }
172 {
173 value_type values[] = {1, 2};
174 EXPECT_TRUE(arrayref.drop_back(1).equals(values));
175 }
176 {
177 value_type values[] = {1};
178 EXPECT_TRUE(arrayref.drop_back(2).equals(values));
179 }
180 { EXPECT_TRUE(arrayref.drop_back(3).empty()); }
181 }
182
TYPED_TEST(LlvmLibcArrayRefTest,TakeFront,Types)183 TYPED_TEST(LlvmLibcArrayRefTest, TakeFront, Types) {
184 using value_type = typename ParamType::value_type;
185 value_type values[] = {1, 2, 3};
186 ParamType arrayref(values);
187 { EXPECT_TRUE(arrayref.take_front(0).empty()); }
188 {
189 value_type values[] = {1};
190 EXPECT_TRUE(arrayref.take_front(1).equals(values));
191 }
192 {
193 value_type values[] = {1, 2};
194 EXPECT_TRUE(arrayref.take_front(2).equals(values));
195 }
196 {
197 value_type values[] = {1, 2, 3};
198 EXPECT_TRUE(arrayref.take_front(3).equals(values));
199 }
200 }
201
TYPED_TEST(LlvmLibcArrayRefTest,TakeBack,Types)202 TYPED_TEST(LlvmLibcArrayRefTest, TakeBack, Types) {
203 using value_type = typename ParamType::value_type;
204 value_type values[] = {1, 2, 3};
205 ParamType arrayref(values);
206 { EXPECT_TRUE(arrayref.take_back(0).empty()); }
207 {
208 value_type values[] = {3};
209 EXPECT_TRUE(arrayref.take_back(1).equals(values));
210 }
211 {
212 value_type values[] = {2, 3};
213 EXPECT_TRUE(arrayref.take_back(2).equals(values));
214 }
215 {
216 value_type values[] = {1, 2, 3};
217 EXPECT_TRUE(arrayref.take_back(3).equals(values));
218 }
219 }
220
221 } // namespace cpp
222 } // namespace __llvm_libc
223