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 "src/__support/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 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 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 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 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 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 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 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 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 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 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 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 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 TEST(LlvmLibcArrayRefTest, ConstructFromVoidPtr) { 222 unsigned data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 223 void *ptr = data; 224 const void *const_ptr = data; 225 ArrayRef<unsigned> ref(const_ptr, sizeof(data)); 226 MutableArrayRef<unsigned> mutable_ref(ptr, sizeof(data)); 227 ASSERT_EQ(ref.size(), sizeof(data) / sizeof(unsigned)); 228 ASSERT_EQ(mutable_ref.size(), sizeof(data) / sizeof(unsigned)); 229 230 unsigned val = 123; 231 for (size_t i = 0; i < sizeof(data) / sizeof(unsigned); ++i) 232 mutable_ref[i] = val; 233 234 for (size_t i = 0; i < sizeof(data) / sizeof(unsigned); ++i) 235 ASSERT_EQ(ref[i], val); 236 } 237 238 } // namespace cpp 239 } // namespace __llvm_libc 240