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