1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <algorithm>
17
18 #include <gtest/gtest.h>
19
20 #include <base/containers/array_view.h>
21 #include <base/containers/iterator.h>
22 #include <base/containers/string.h>
23 #include <base/containers/string_view.h>
24 #include <base/containers/vector.h>
25
26 using namespace testing::ext;
27
28 namespace {
29 class CustomAllocator {
30 public:
31 // simple linear allocator.
32 uint8_t buf[42 * sizeof(uint32_t)];
33 size_t pos { 0 };
Reset()34 void Reset()
35 {
36 pos = 0;
37 memset_s(buf, sizeof(buf), 0, sizeof(buf));
38 }
alloc(BASE_NS::allocator::size_type size)39 void* alloc(BASE_NS::allocator::size_type size)
40 {
41 void* ret = &buf[pos];
42 pos += size;
43 return ret;
44 };
Free(void *)45 void Free(void*)
46 {
47 return;
48 };
alloc(void * instance,BASE_NS::allocator::size_type size)49 static void* alloc(void* instance, BASE_NS::allocator::size_type size)
50 {
51 return ((CustomAllocator*)instance)->alloc(size);
52 }
Free(void * instance,void * ptr)53 static void Free(void* instance, void* ptr)
54 {
55 ((CustomAllocator*)instance)->Free(ptr);
56 };
57 } g_aca;
58
59 BASE_NS::allocator ca { &g_aca, CustomAllocator::alloc, CustomAllocator::Free };
60
61 struct Thing {
Thing__anone782cc550111::Thing62 explicit constexpr Thing(int v) : i(v) {}
~Thing__anone782cc550111::Thing63 ~Thing() {}
Thing__anone782cc550111::Thing64 constexpr Thing(const Thing& o) : i(o.i) {}
Thing__anone782cc550111::Thing65 constexpr Thing(Thing&& o) noexcept : i(o.i) {}
operator =__anone782cc550111::Thing66 constexpr Thing& operator=(const Thing& o)
67 {
68 i = o.i;
69 return *this;
70 }
operator =__anone782cc550111::Thing71 constexpr Thing& operator=(Thing&& o) noexcept
72 {
73 i = o.i;
74 return *this;
75 }
operator ==__anone782cc550111::Thing76 constexpr bool operator==(const Thing& o) const
77 {
78 return i == o.i;
79 }
80 int i;
81 };
82 } // namespace
83
84 template<typename T>
85 class ProtectedVectorTest : public BASE_NS::vector<T> {
86 public:
87 using value_type = T;
88 using difference_type = ptrdiff_t;
89 using pointer = value_type*;
90 using reference = value_type&;
91
92 using iterator = BASE_NS::iterator<BASE_NS::vector<T>>;
93 using const_iterator = BASE_NS::const_iterator<BASE_NS::vector<T>>;
94 using reverse_iterator = BASE_NS::reverse_iterator<BASE_NS::vector<T>>;
95 // using const_reverse_iterator = BASE_NS::reverse_iterator<const_iterator>;
96
97 using size_type = size_t;
98 using const_reference = const value_type&;
99 using const_pointer = const value_type*;
100
101 // do not need instance of class. Just memory realocation
WrapUninitializedDefaultConstruct(pointer first,pointer last)102 void WrapUninitializedDefaultConstruct(pointer first, pointer last)
103 {
104 return BASE_NS::vector<T>::uninitialized_default_construct(first, last);
105 }
106
WrapUninitializedValueConstruct(pointer first,pointer last)107 void WrapUninitializedValueConstruct(pointer first, pointer last)
108 {
109 return BASE_NS::vector<T>::uninitialized_value_construct(first, last);
110 }
111
WrapUninitializedCopy(const_pointer first,const_pointer last,pointer dFirst)112 void WrapUninitializedCopy(const_pointer first, const_pointer last, pointer dFirst)
113 {
114 return BASE_NS::vector<T>::uninitialized_copy(first, last, dFirst);
115 }
116
WrapUninitializedFill(pointer first,const_pointer last,const_reference value)117 void WrapUninitializedFill(pointer first, const_pointer last, const_reference value)
118 {
119 return BASE_NS::vector<T>::uninitialized_fill(first, last, value);
120 }
121
WrapUninitializedMove(pointer first,const_pointer last,pointer dFirst)122 void WrapUninitializedMove(pointer first, const_pointer last, pointer dFirst)
123 {
124 return BASE_NS::vector<T>::uninitialized_move(first, last, dFirst);
125 }
126
127 template<class InputIt>
WrapCopy(pointer pos,InputIt first,InputIt last)128 void WrapCopy(pointer pos, InputIt first, InputIt last)
129 {
130 return BASE_NS::vector<T>::copy(pos, first, last);
131 }
132
WrapMove(pointer first,const_pointer last,pointer dFirst)133 void WrapMove(pointer first, const_pointer last, pointer dFirst)
134 {
135 return BASE_NS::vector<T>::move(first, last, dFirst);
136 }
137
WrapInitValue(pointer dst,size_t count)138 pointer WrapInitValue(pointer dst, size_t count)
139 {
140 return BASE_NS::vector<T>::init_value(dst, count);
141 }
142
WrapInitFill(pointer dst,size_t count,const_reference value)143 pointer WrapInitFill(pointer dst, size_t count, const_reference value)
144 {
145 return BASE_NS::vector<T>::init_fill(dst, count, value);
146 }
147
WrapInitCopy(pointer dst,const_pointer src,size_type size)148 pointer WrapInitCopy(pointer dst, const_pointer src, size_type size)
149 {
150 return BASE_NS::vector<T>::init_copy(dst, src, size);
151 }
152
153 template<class InputIt>
WrapInsertImpl(const_iterator pos,InputIt first,InputIt last)154 iterator WrapInsertImpl(const_iterator pos, InputIt first, InputIt last)
155 {
156 return BASE_NS::vector<T>::insert_impl(pos, first, last);
157 }
158 };
159
160 class VectorTest : public testing::Test {
161 public:
SetUpTestSuite()162 static void SetUpTestSuite() {}
TearDownTestSuite()163 static void TearDownTestSuite() {}
SetUp()164 void SetUp() override {}
TearDown()165 void TearDown() override {}
166 };
167
168 HWTEST_F(VectorTest, SetAllocator, TestSize.Level1)
169 {
170 g_aca.Reset();
171 // create with default allocator
172 BASE_NS::vector<uint32_t> duh;
173 duh.push_back(1);
174 // set custom allocator
175 duh.setAllocator(ca);
176 // add data
177 duh.push_back(42);
178 ASSERT_EQ(duh[0], 1);
179 ASSERT_EQ(duh[1], 42);
180 duh.setAllocator(BASE_NS::default_allocator());
181 ASSERT_EQ(&duh.getAllocator(), &BASE_NS::default_allocator());
182 ASSERT_EQ(duh[0], 1);
183 ASSERT_EQ(duh[1], 42);
184 }
185
186 HWTEST_F(VectorTest, SetAllocator02, TestSize.Level1)
187 {
188 g_aca.Reset();
189 // create with default allocator
190 BASE_NS::vector<uint32_t> duh;
191 // add data
192 duh.push_back(42);
193 duh.setAllocator(ca);
194 ASSERT_EQ(&duh.getAllocator(), &ca);
195
196 // make copy, (with the same allocator)
197 BASE_NS::vector<uint32_t> duh2(duh);
198 ASSERT_EQ(&duh2.getAllocator(), &ca);
199
200 // make copy, (with the default allocator)
201 BASE_NS::vector<uint32_t> duh3(duh, BASE_NS::default_allocator());
202 ASSERT_EQ(&duh3.getAllocator(), &BASE_NS::default_allocator());
203 }
204
205 HWTEST_F(VectorTest, CustomAllocator, TestSize.Level1)
206 {
207 g_aca.Reset();
208 // create with custom allocator
209 BASE_NS::vector<uint32_t> duh(ca);
210 duh.push_back(42);
211 duh.push_back(12);
212 ASSERT_EQ(duh[0], 42);
213 ASSERT_EQ(duh[1], 12);
214 ASSERT_EQ(duh.size(), 2U);
215 ASSERT_GE(duh.capacity(), 2U);
216 duh.reserve(5);
217 ASSERT_EQ(duh.size(), 2U);
218 ASSERT_GE(duh.capacity(), 5U);
219 ASSERT_EQ(duh[0], 42);
220 ASSERT_EQ(duh[1], 12);
221 duh.resize(5);
222 ASSERT_EQ(duh.size(), 5U);
223 ASSERT_GE(duh.capacity(), 5U);
224 ASSERT_EQ(duh[0], 42);
225 ASSERT_EQ(duh[1], 12);
226 ASSERT_EQ(duh[2], 0);
227
228 duh.insert(duh.begin(), 4);
229 ASSERT_EQ(duh.size(), 6U);
230 ASSERT_GE(duh.capacity(), 6U);
231 ASSERT_EQ(duh[0], 4);
232 ASSERT_EQ(duh[1], 42);
233 ASSERT_EQ(duh[2], 12);
234 ASSERT_EQ(duh[3], 0);
235
236 duh.erase(duh.begin() + 1);
237 ASSERT_EQ(duh.size(), 5U);
238 ASSERT_GE(duh.capacity(), 6U);
239 ASSERT_EQ(duh[0], 4);
240 ASSERT_EQ(duh[1], 12);
241 ASSERT_EQ(duh[2], 0);
242
243 // BASE_NS::vector<uint32_t> duh2(duh); Currently uses the same allocator.. which might not be correct? (in this
244 // test it's an issue :)
245 BASE_NS::vector<uint32_t> duh2; // default constructor uses default_allocator.
246 duh2 = duh;
247 ASSERT_EQ(duh2.size(), 5U);
248 ASSERT_GE(duh2.capacity(), 5U);
249 ASSERT_EQ(duh2[0], 4);
250 ASSERT_EQ(duh2[1], 12);
251
252 duh2.resize(2);
253 ASSERT_EQ(duh2.size(), 2U);
254 ASSERT_GE(duh2.capacity(), 5U);
255 duh2.shrink_to_fit();
256 ASSERT_EQ(duh2.size(), 2U);
257 ASSERT_GE(duh2.capacity(), 2U);
258
259 duh.resize(2, 1);
260 ASSERT_EQ(duh.size(), 2U);
261 ASSERT_GE(duh.capacity(), 2U);
262 ASSERT_EQ(duh[0], 4);
263 ASSERT_EQ(duh[1], 12);
264
265 duh.resize(3, 1);
266 ASSERT_EQ(duh.size(), 3U);
267 ASSERT_GE(duh.capacity(), 3U);
268 ASSERT_EQ(duh[0], 4);
269 ASSERT_EQ(duh[1], 12);
270 ASSERT_EQ(duh[2], 1);
271 }
272
273 HWTEST_F(VectorTest, DefaultAllocator, TestSize.Level1)
274 {
275 // create with default allocator
276 BASE_NS::vector<uint32_t> duh(BASE_NS::default_allocator());
277 duh.push_back(42);
278 duh.push_back(12);
279 ASSERT_EQ(duh[0], 42);
280 ASSERT_EQ(duh[1], 12);
281 ASSERT_EQ(duh.size(), 2U);
282 ASSERT_GE(duh.capacity(), 2U);
283 duh.reserve(5);
284 ASSERT_EQ(duh.size(), 2U);
285 ASSERT_GE(duh.capacity(), 5U);
286 ASSERT_EQ(duh[0], 42);
287 ASSERT_EQ(duh[1], 12);
288 duh.resize(5);
289 ASSERT_EQ(duh.size(), 5U);
290 ASSERT_GE(duh.capacity(), 5U);
291 ASSERT_EQ(duh[0], 42);
292 ASSERT_EQ(duh[1], 12);
293 ASSERT_EQ(duh[2], 0);
294 duh.insert(duh.begin(), 4);
295 ASSERT_EQ(duh.size(), 6U);
296 ASSERT_GE(duh.capacity(), 6U);
297 ASSERT_EQ(duh[0], 4);
298 ASSERT_EQ(duh[1], 42);
299 ASSERT_EQ(duh[2], 12);
300 ASSERT_EQ(duh[3], 0);
301
302 duh.erase(duh.begin() + 1);
303 ASSERT_EQ(duh.size(), 5U);
304 ASSERT_GE(duh.capacity(), 6U);
305 ASSERT_EQ(duh[0], 4);
306 ASSERT_EQ(duh[1], 12);
307 ASSERT_EQ(duh[2], 0);
308
309 BASE_NS::vector<uint32_t> duh2(duh); // default constructor uses default_allocator.
310 ASSERT_EQ(duh2.size(), 5U);
311 ASSERT_GE(duh2.capacity(), 5U);
312 ASSERT_EQ(duh2[0], 4);
313 ASSERT_EQ(duh2[1], 12);
314
315 duh2.resize(2);
316 ASSERT_EQ(duh2.size(), 2U);
317 ASSERT_GE(duh2.capacity(), 5U);
318 duh2.shrink_to_fit();
319 ASSERT_EQ(duh2.size(), 2U);
320 ASSERT_GE(duh2.capacity(), 2U);
321
322 duh.resize(2, 1);
323 ASSERT_EQ(duh.size(), 2U);
324 ASSERT_GE(duh.capacity(), 2U);
325 ASSERT_EQ(duh[0], 4);
326 ASSERT_EQ(duh[1], 12);
327
328 duh.resize(3, 1);
329 ASSERT_EQ(duh.size(), 3U);
330 ASSERT_GE(duh.capacity(), 3U);
331 ASSERT_EQ(duh[0], 4);
332 ASSERT_EQ(duh[1], 12);
333 ASSERT_EQ(duh[2], 1);
334 }
335
336 HWTEST_F(VectorTest, Insert, TestSize.Level1)
337 {
338 BASE_NS::vector<uint32_t> duh(BASE_NS::default_allocator());
339 duh.insert(duh.begin(), 99U);
340 ASSERT_EQ(duh.size(), 1U);
341 ASSERT_EQ(duh[0], 99U);
342 duh.insert(duh.end(), 99U);
343 ASSERT_EQ(duh.size(), 2U);
344 ASSERT_EQ(duh[1], 99U);
345 const uint32_t VALUE1 = 1U;
346 const uint32_t VALUE2 = 2U;
347 duh.insert(duh.begin(), VALUE1);
348 ASSERT_EQ(duh.size(), 3U);
349 ASSERT_EQ(duh[0], VALUE1);
350 duh.insert(duh.begin() + 2, VALUE1);
351 ASSERT_EQ(duh.size(), 4U);
352 ASSERT_EQ(duh[2], VALUE1);
353 duh.insert(duh.end(), VALUE1);
354 ASSERT_EQ(duh.size(), 5U);
355 ASSERT_EQ(duh[4], VALUE1);
356
357 duh.insert(duh.begin(), 0, VALUE2);
358 ASSERT_EQ(duh.size(), 5U);
359 duh.insert(duh.begin(), 2, VALUE2);
360 ASSERT_EQ(duh.size(), 7U);
361 ASSERT_EQ(duh[0], VALUE2);
362 ASSERT_EQ(duh[1], VALUE2);
363 duh.insert(duh.end(), 2, VALUE2); // 2 values at end are the same ?
364 ASSERT_EQ(duh.size(), 9U);
365 ASSERT_EQ(duh[7], VALUE2);
366 ASSERT_EQ(duh[8], VALUE2);
367
368 // Case when no alloctation is needed
369 duh.insert(duh.end(), 99U);
370 ASSERT_EQ(duh.size(), 10U);
371 ASSERT_EQ(duh[9], 99U);
372 duh.insert(duh.end(), VALUE1);
373 ASSERT_EQ(duh.size(), 11U);
374 ASSERT_EQ(duh[10], VALUE1);
375 }
376
377 HWTEST_F(VectorTest, InsertAndConvertVectorElementType, TestSize.Level1)
378 {
379 // this is valid for std so should be valid for us. (see LUME-1402)
380 // ie. if the elements can be converted (basic copy conversion etc) then they can be inserted.
381 BASE_NS::vector<short> short_vec;
382 short_vec.push_back(1);
383 short_vec.push_back(53);
384 short_vec.push_back(469);
385 BASE_NS::vector<int> int_vec;
386 int_vec.insert(int_vec.end(), short_vec.begin(), short_vec.end());
387 ASSERT_TRUE(int_vec.size() == short_vec.size());
388 ASSERT_TRUE(int_vec[0] == (int)short_vec[0]);
389 ASSERT_TRUE(int_vec[1] == (int)short_vec[1]);
390 ASSERT_TRUE(int_vec[2] == (int)short_vec[2]);
391
392 int_vec.insert(int_vec.begin() + 2, short_vec.begin(), short_vec.end());
393
394 ASSERT_TRUE(int_vec.size() == 2 * short_vec.size());
395 ASSERT_TRUE(int_vec[0] == (int)short_vec[0]);
396 ASSERT_TRUE(int_vec[1] == (int)short_vec[1]);
397 ASSERT_TRUE(int_vec[2] == (int)short_vec[0]);
398 ASSERT_TRUE(int_vec[3] == (int)short_vec[1]);
399 ASSERT_TRUE(int_vec[4] == (int)short_vec[2]);
400 ASSERT_TRUE(int_vec[5] == (int)short_vec[2]);
401
402 int_vec.reserve(4 * short_vec.size());
403 int_vec.insert(int_vec.begin() + 2, short_vec.begin(), short_vec.end());
404
405 ASSERT_TRUE(int_vec.size() == 3 * short_vec.size());
406 ASSERT_TRUE(int_vec[0] == (int)short_vec[0]);
407 ASSERT_TRUE(int_vec[1] == (int)short_vec[1]);
408 ASSERT_TRUE(int_vec[2] == (int)short_vec[0]);
409 ASSERT_TRUE(int_vec[3] == (int)short_vec[1]);
410 ASSERT_TRUE(int_vec[4] == (int)short_vec[2]);
411 ASSERT_TRUE(int_vec[5] == (int)short_vec[0]);
412 ASSERT_TRUE(int_vec[6] == (int)short_vec[1]);
413 ASSERT_TRUE(int_vec[7] == (int)short_vec[2]);
414 ASSERT_TRUE(int_vec[8] == (int)short_vec[2]);
415
416 int_vec.insert(int_vec.end(), short_vec.begin(), short_vec.end());
417
418 ASSERT_TRUE(int_vec.size() == 4 * short_vec.size());
419 ASSERT_TRUE(int_vec[0] == (int)short_vec[0]);
420 ASSERT_TRUE(int_vec[1] == (int)short_vec[1]);
421 ASSERT_TRUE(int_vec[2] == (int)short_vec[0]);
422 ASSERT_TRUE(int_vec[3] == (int)short_vec[1]);
423 ASSERT_TRUE(int_vec[4] == (int)short_vec[2]);
424 ASSERT_TRUE(int_vec[5] == (int)short_vec[0]);
425 ASSERT_TRUE(int_vec[6] == (int)short_vec[1]);
426 ASSERT_TRUE(int_vec[7] == (int)short_vec[2]);
427 ASSERT_TRUE(int_vec[8] == (int)short_vec[2]);
428 ASSERT_TRUE(int_vec[9] == (int)short_vec[0]);
429 ASSERT_TRUE(int_vec[10] == (int)short_vec[1]);
430 ASSERT_TRUE(int_vec[11] == (int)short_vec[2]);
431 /*
432 // this will fail with "error C2338: Invalid input iterator type" (static_assert for types are not matching)
433 CORE_NS::vector<CORE_NS::Math::Vec3> vec3_vec;
434 int_vec.insert(int_vec.end(),vec3_vec.begin(),vec3_vec.end());
435 */
436
437 // the following is valid. due to class B providing the conversion operator.
438 class A {
439 public:
440 int val { 42 };
441 };
442 class B {
443 public:
444 int val { 6 };
operator A() const445 operator A() const
446 {
447 A tmp;
448 tmp.val = val;
449 return tmp;
450 }
451 };
452 BASE_NS::vector<A> as;
453 BASE_NS::vector<B> bs;
454 as.resize(3);
455 bs.resize(3);
456 as.insert(as.end(), bs.begin(), bs.end());
457
458 ASSERT_TRUE(as[0].val == 42);
459 ASSERT_TRUE(as[1].val == 42);
460 ASSERT_TRUE(as[2].val == 42);
461 ASSERT_TRUE(as[3].val == 6);
462 ASSERT_TRUE(as[4].val == 6);
463 ASSERT_TRUE(as[5].val == 6);
464 }
465
466 HWTEST_F(VectorTest, InsertPointerIterators, TestSize.Level1)
467 {
468 int data[] = { 135, 32, 1 };
469 BASE_NS::vector<int> int_vec;
470 int_vec.insert(int_vec.end(), &data[0], &data[0] + BASE_NS::countof(data));
471
472 ASSERT_TRUE(int_vec.size() == BASE_NS::countof(data));
473 ASSERT_TRUE(int_vec[0] == data[0]);
474 ASSERT_TRUE(int_vec[1] == data[1]);
475 ASSERT_TRUE(int_vec[2] == data[2]);
476 }
477
478 HWTEST_F(VectorTest, InsertArrayViewIterators, TestSize.Level1)
479 {
480 {
481 int data[] = { 135, 32, 1 };
482 BASE_NS::array_view<int> int_av(&data[0], BASE_NS::countof(data));
483 BASE_NS::vector<int> int_vec;
484 int_vec.insert(int_vec.end(), int_av.begin(), int_av.end());
485 ASSERT_TRUE(int_vec.size() == BASE_NS::countof(data));
486 ASSERT_TRUE(int_vec[0] == data[0]);
487 ASSERT_TRUE(int_vec[1] == data[1]);
488 ASSERT_TRUE(int_vec[2] == data[2]);
489 }
490 {
491 int data[] = { 135, 32, 1 };
492 BASE_NS::array_view<int> int_av(&data[0], BASE_NS::countof(data));
493 BASE_NS::vector<int> int_vec;
494 int_vec.insert(
495 int_vec.end(), int_av.cbegin(), int_av.cend()); // no difference, InputIt array_view::const_iterator
496 ASSERT_TRUE(int_vec.size() == BASE_NS::countof(data));
497 ASSERT_TRUE(int_vec[0] == data[0]);
498 ASSERT_TRUE(int_vec[1] == data[1]);
499 ASSERT_TRUE(int_vec[2] == data[2]);
500 }
501 }
502
503 HWTEST_F(VectorTest, InsertVectorIterators, TestSize.Level1)
504 {
505 {
506 BASE_NS::vector<int> data;
507 data.push_back(146);
508 data.push_back(15);
509 data.push_back(26);
510 BASE_NS::vector<int> int_vec;
511 int_vec.insert(int_vec.end(), data.begin(), data.end());
512 ASSERT_TRUE(int_vec.size() == data.size());
513 ASSERT_TRUE(int_vec[0] == data[0]);
514 ASSERT_TRUE(int_vec[1] == data[1]);
515 ASSERT_TRUE(int_vec[2] == data[2]);
516 }
517 {
518 BASE_NS::vector<int> data;
519 data.push_back(146);
520 data.push_back(15);
521 data.push_back(26);
522 BASE_NS::vector<int> int_vec;
523 int_vec.insert(int_vec.end(), data.cbegin(), data.cend());
524 ASSERT_TRUE(int_vec.size() == data.size());
525 ASSERT_TRUE(int_vec[0] == data[0]);
526 ASSERT_TRUE(int_vec[1] == data[1]);
527 ASSERT_TRUE(int_vec[2] == data[2]);
528 }
529 }
530
531 HWTEST_F(VectorTest, Append, TestSize.Level1)
532 {
533 // append(count, value)
534 {
535 BASE_NS::vector<uint32_t> duh(BASE_NS::default_allocator());
536
537 duh.append(0U, 42U);
538 ASSERT_TRUE(duh.empty());
539
540 duh.append(1U, 42U);
541 ASSERT_FALSE(duh.empty());
542 ASSERT_EQ(duh.size(), 1U);
543 ASSERT_EQ(duh[0U], 42U);
544
545 duh.append(1U, 43U);
546 ASSERT_EQ(duh.size(), 2U);
547 ASSERT_EQ(duh[0U], 42U);
548 ASSERT_EQ(duh[1U], 43U);
549
550 duh.append(3U, 44U);
551 ASSERT_EQ(duh.size(), 5U);
552 ASSERT_EQ(duh[0U], 42U);
553 ASSERT_EQ(duh[1U], 43U);
554 ASSERT_EQ(duh[2U], 44U);
555 ASSERT_EQ(duh[3U], 44U);
556 ASSERT_EQ(duh[4U], 44U);
557 }
558
559 // append(begin, end)
560 {
561 static constexpr uint32_t VALUES[] = { 0U, 1U, 2U, 3U };
562
563 BASE_NS::vector<uint32_t> duh(BASE_NS::default_allocator());
564 duh.append(std::begin(VALUES), std::end(VALUES));
565 ASSERT_EQ(duh.size(), 4U);
566 ASSERT_EQ(duh[0U], 0U);
567 ASSERT_EQ(duh[1U], 1U);
568 ASSERT_EQ(duh[2U], 2U);
569 ASSERT_EQ(duh[3U], 3U);
570
571 static constexpr auto VIEW = BASE_NS::array_view(VALUES);
572 duh.append(std::begin(VIEW), std::end(VIEW));
573 ASSERT_EQ(duh.size(), 8U);
574 ASSERT_EQ(duh[0U], 0U);
575 ASSERT_EQ(duh[1U], 1U);
576 ASSERT_EQ(duh[2U], 2U);
577 ASSERT_EQ(duh[3U], 3U);
578 ASSERT_EQ(duh[4U], 0U);
579 ASSERT_EQ(duh[5U], 1U);
580 ASSERT_EQ(duh[6U], 2U);
581 ASSERT_EQ(duh[7U], 3U);
582 }
583 }
584
585 using namespace BASE_NS;
586
587 HWTEST_F(VectorTest, Default, TestSize.Level1)
588 {
589 // Test some types
590 BASE_NS::vector<int> vecInt;
591 BASE_NS::vector<bool> vecBool;
592 BASE_NS::vector<float> vecFloat;
593 BASE_NS::vector<double> vecDouble;
594 BASE_NS::vector<BASE_NS::string> vecString;
595 BASE_NS::vector<string_view> vecStringView;
596 BASE_NS::vector<BASE_NS::vector<int>> vecVec;
597 }
598
599 template<typename T>
g_allocate(BASE_NS::vector<T> vec,int size)600 T* g_allocate(BASE_NS::vector<T> vec, int size)
601 {
602 // Allocate space for size(s) elements
603 return static_cast<T*>(vec.getAllocator().alloc(vec.getAllocator().instance, size));
604 }
605
606 HWTEST_F(VectorTest, Initialization, TestSize.Level1)
607 {
608 // Test some types
609 BASE_NS::vector<int> vecInt;
610 vecInt.push_back(0);
611 vecInt.push_back(5);
612 ASSERT_EQ(vecInt[0], 0);
613 ASSERT_EQ(vecInt[1], 5);
614
615 BASE_NS::vector<bool> vecBool;
616 vecBool.push_back(true);
617 vecBool.push_back(false);
618 ASSERT_EQ(vecBool[0], true);
619 ASSERT_EQ(vecBool[1], false);
620
621 BASE_NS::vector<float> vecFloat;
622 vecFloat.push_back(0.000001f);
623 vecFloat.push_back(9999999.9f);
624 ASSERT_FLOAT_EQ(vecFloat[0], 0.000001f);
625 ASSERT_FLOAT_EQ(vecFloat[1], 9999999.9f);
626
627 BASE_NS::vector<double> vecDouble;
628 vecDouble.push_back(0.0000000001);
629 vecDouble.push_back(99.999998);
630 ASSERT_EQ(vecDouble[0], 0.0000000001);
631 ASSERT_EQ(vecDouble[1], 99.999998);
632
633 BASE_NS::vector<BASE_NS::string> vecString;
634 vecString.push_back("Hello");
635 vecString.push_back(" WoRlD");
636 ASSERT_STREQ(vecString[0].c_str(), "Hello");
637 ASSERT_STREQ(vecString[1].c_str(), " WoRlD");
638
639 BASE_NS::vector<string_view> vecStringView;
640 vecStringView.push_back("Hello");
641 vecStringView.push_back(" WoRlD");
642 ASSERT_EQ(vecStringView[0], "Hello");
643 ASSERT_EQ(vecStringView[1], " WoRlD");
644
645 BASE_NS::vector<BASE_NS::vector<int>> vecVec;
646 BASE_NS::vector<int> innerVec;
647 innerVec.push_back(0);
648 innerVec.push_back(5);
649 vecVec.push_back(innerVec);
650 ASSERT_EQ(vecVec[0][0], 0);
651 ASSERT_EQ(vecVec[0][1], 5);
652
653 // Operator=
654 vecInt[0] = 6;
655 ASSERT_EQ(vecInt[0], 6);
656 }
657
658 HWTEST_F(VectorTest, InitialzationByPointers, TestSize.Level1)
659 {
660 {
661 BASE_NS::vector<int> data = { 1, 2, 3 };
662 BASE_NS::vector<int> vecInt = BASE_NS::vector(&(*data.begin()), &(*data.end()));
663 ASSERT_TRUE(vecInt.size() == data.size());
664 ASSERT_TRUE(vecInt[0] == data[0]);
665 ASSERT_TRUE(vecInt[1] == data[1]);
666 ASSERT_TRUE(vecInt[2] == data[2]);
667 }
668 {
669 BASE_NS::vector<int> data = { 1, 2, 3 };
670 BASE_NS::vector<int> vecInt = BASE_NS::vector<int>(data.begin(), data.end());
671 ASSERT_TRUE(vecInt.size() == data.size());
672 ASSERT_TRUE(vecInt[0] == data[0]);
673 ASSERT_TRUE(vecInt[1] == data[1]);
674 ASSERT_TRUE(vecInt[2] == data[2]);
675 }
676 }
677
678 HWTEST_F(VectorTest, SetAllocators, TestSize.Level1)
679 {
680 allocator a1 = default_allocator();
681 allocator a2 = default_allocator();
682 BASE_NS::vector<int> vecInt1;
683 BASE_NS::vector<int> vecInt2;
684 // poisoning allocator for different instance values
685 ASSERT_TRUE(ClearToValue(&a2, sizeof(int), POISON, sizeof(int)));
686 vecInt1.setAllocator(a1);
687 vecInt2.setAllocator(a2);
688 ASSERT_FALSE(vecInt1.getAllocator().instance == vecInt2.getAllocator().instance);
689 const auto a2_old = vecInt2.getAllocator();
690 a2 = a1;
691 ASSERT_TRUE(vecInt1.getAllocator().instance == vecInt2.getAllocator().instance);
692 ASSERT_FALSE(a2_old.instance == vecInt2.getAllocator().instance);
693 vecInt2.setAllocator(a1);
694 ASSERT_TRUE(vecInt1.getAllocator().instance == vecInt2.getAllocator().instance);
695
696 const BASE_NS::vector<int> vecInt3(ca);
697 const auto a3_const = vecInt3.getAllocator();
698 ASSERT_TRUE(ca.instance == a3_const.instance);
699 }
700
701 HWTEST_F(VectorTest, InitialzationByList, TestSize.Level1)
702 {
703 BASE_NS::vector<int> vecBase;
704 vecBase = { 1, 2, 3, 4 };
705 BASE_NS::vector<int> vec = vecBase;
706 BASE_NS::vector<int> vec2;
707 ASSERT_EQ(vecBase[0], vec[0]);
708 ASSERT_EQ(vecBase[1], vec[1]);
709 ASSERT_EQ(vecBase[2], vec[2]);
710 ASSERT_EQ(vecBase[3], vec[3]);
711
712 vec2 = static_cast<BASE_NS::vector<int>&&>(vec); // without erase
713 ASSERT_EQ(vecBase[0], vec2[0]);
714 ASSERT_EQ(vecBase[1], vec2[1]);
715 ASSERT_EQ(vecBase[2], vec2[2]);
716 ASSERT_EQ(vecBase[3], vec2[3]);
717 ASSERT_EQ(vec.size(), 0);
718
719 vec2 = { 0, 0, 0 };
720 ASSERT_NE(vecBase[0], vec2[0]);
721 ASSERT_NE(vecBase[1], vec2[1]);
722 ASSERT_NE(vecBase[2], vec2[2]);
723
724 vec2 = static_cast<BASE_NS::vector<int>&&>(vec); // with erase but from already empty
725 ASSERT_EQ(vec2.size(), 0);
726
727 vec = vecBase;
728 vec2 = static_cast<BASE_NS::vector<int>&&>(vec); // with erase but from already empty
729 ASSERT_EQ(vecBase[0], vec2[0]);
730 ASSERT_EQ(vecBase[1], vec2[1]);
731 ASSERT_EQ(vecBase[2], vec2[2]);
732 ASSERT_EQ(vecBase[3], vec2[3]);
733 }
734
735 HWTEST_F(VectorTest, InitialzationByConst, TestSize.Level1)
736 {
737 const int cInt = 5;
738 BASE_NS::vector<int> vecInt = BASE_NS::vector(2, cInt);
739 ASSERT_EQ(vecInt[0], 5);
740 ASSERT_EQ(vecInt[1], 5);
741
742 BASE_NS::vector<bool> vecBool(2, true);
743 ASSERT_EQ(vecBool[0], true);
744 ASSERT_EQ(vecBool[1], true);
745
746 BASE_NS::vector<float> vecFloat(2, 0.000001f);
747 ASSERT_FLOAT_EQ(vecFloat[0], 0.000001f);
748 ASSERT_FLOAT_EQ(vecFloat[1], 0.000001f);
749
750 BASE_NS::vector<double> vecDouble(2, 0.0000000001);
751 ASSERT_EQ(vecDouble[0], 0.0000000001);
752 ASSERT_EQ(vecDouble[1], 0.0000000001);
753
754 BASE_NS::vector<BASE_NS::string> vecString(2, "Hello");
755 ASSERT_STREQ(vecString[0].c_str(), "Hello");
756 ASSERT_STREQ(vecString[1].c_str(), "Hello");
757
758 BASE_NS::vector<string_view> vecStringView(2, "Hello");
759 ASSERT_EQ(vecStringView[0], "Hello");
760 ASSERT_EQ(vecStringView[1], "Hello");
761
762 BASE_NS::vector<BASE_NS::vector<int>> vecVec(1, BASE_NS::vector(2, 3));
763 ASSERT_EQ(vecVec[0][0], 3);
764 ASSERT_EQ(vecVec[0][1], 3);
765
766 BASE_NS::vector<int> vecEmpty(0, 10000);
767 ASSERT_EQ(vecEmpty.size(), 0);
768 }
769
770 HWTEST_F(VectorTest, Poisoning, TestSize.Level1)
771 {
772 BASE_NS::vector<int> vecInt;
773 vecInt.push_back(1);
774 vecInt.push_back(2);
775 vecInt.push_back(3);
776 vecInt.pop_back();
777 // without poisoning, value is not changed.
778 ASSERT_EQ(vecInt.data()[2], 3);
779 ASSERT_TRUE(ClearToValue(&vecInt.data()[2], sizeof(int), POISON, sizeof(int)));
780 // with poisoning, value is changed to huge constant.
781 ASSERT_FALSE(vecInt.data()[2] == 3);
782 // poisoning of nullpointer
783 ASSERT_FALSE(ClearToValue(nullptr, sizeof(int), POISON, sizeof(int)));
784 // poisoning 2 elements, cnt>dist -> bad cnt
785 ASSERT_TRUE(ClearToValue(&vecInt[0], sizeof(int), POISON, sizeof(int) * 2));
786 ASSERT_FALSE(vecInt[0] == 1);
787 ASSERT_TRUE(vecInt[1] == 2);
788 // poisoning 2 elements, cnt == dist
789 ASSERT_TRUE(ClearToValue(&vecInt[0], sizeof(int) * 2, POISON, sizeof(int) * 2));
790 ASSERT_FALSE(vecInt[0] == 1);
791 ASSERT_FALSE(vecInt[1] == 2);
792 }
793
794 HWTEST_F(VectorTest, ElementAccess, TestSize.Level1)
795 {
796 {
797 BASE_NS::vector<int> vecInt;
798 vecInt.push_back(2);
799 vecInt.push_back(5);
800
801 // At
802 ASSERT_EQ(vecInt.at(0), 2);
803 ASSERT_EQ(vecInt.at(1), 5);
804
805 // Operator[]
806 ASSERT_EQ(vecInt[0], 2);
807 ASSERT_EQ(vecInt[1], 5);
808
809 // Front
810 ASSERT_EQ(vecInt.front(), 2);
811
812 // Back
813 ASSERT_EQ(vecInt.back(), 5);
814
815 // Data
816 int* p = vecInt.data();
817 ASSERT_EQ(p[0], 2);
818 ASSERT_EQ(p[1], 5);
819 }
820 {
821 const BASE_NS::vector<int> vecInt = { 2, 5 };
822
823 // At
824 ASSERT_EQ(vecInt.at(0), 2);
825 ASSERT_EQ(vecInt.at(1), 5);
826
827 // Operator[]
828 ASSERT_EQ(vecInt[0], 2);
829 ASSERT_EQ(vecInt[1], 5);
830
831 // Front
832 ASSERT_EQ(vecInt.front(), 2);
833
834 // Back
835 ASSERT_EQ(vecInt.back(), 5);
836
837 // Data
838 const int* p = vecInt.data();
839 ASSERT_EQ(p[0], 2);
840 ASSERT_EQ(p[1], 5);
841 }
842 }
843
844 HWTEST_F(VectorTest, ProtectedUninitializedMemory, TestSize.Level1)
845 {
846 ProtectedVectorTest<int> classInstance;
847 ProtectedVectorTest<uint32_t> classInstanceU32;
848 {
849 BASE_NS::vector<int> vecInt;
850 vecInt.resize(0); // allocate 0 memory
851 classInstance.WrapUninitializedDefaultConstruct(vecInt.begin().ptr(), vecInt.begin().ptr());
852 ASSERT_EQ(vecInt.size(), 0);
853 }
854 {
855 BASE_NS::vector<int> vecInt;
856 vecInt.resize(2); // allocate some memory for int without value
857 classInstance.WrapUninitializedDefaultConstruct(vecInt.begin().ptr(), (vecInt.begin() + 2).ptr());
858 ASSERT_EQ(vecInt.size(), 2);
859 ASSERT_EQ(vecInt[0], 0);
860 ASSERT_EQ(vecInt[1], 0);
861 }
862 {
863 BASE_NS::vector<int> vecInt; // allocate 0 memory
864 vecInt.resize(0);
865 classInstance.WrapUninitializedValueConstruct(vecInt.begin().ptr(), vecInt.begin().ptr());
866 }
867 {
868 BASE_NS::vector<int> vecInt; // allocate some memory for int with default value
869 vecInt.resize(2);
870 classInstance.WrapUninitializedValueConstruct(vecInt.begin().ptr(), (vecInt.begin() + 2).ptr());
871 ASSERT_EQ(vecInt.size(), 2);
872 ASSERT_EQ(vecInt[0], 0);
873 ASSERT_EQ(vecInt[1], 0);
874 }
875 {
876 BASE_NS::vector<int> vecBase = { 1, 2, 3 };
877 BASE_NS::vector<int> vecInt; // allocate 0 memory
878 vecInt.resize(0);
879 classInstance.WrapUninitializedCopy(vecInt.begin().ptr(), vecInt.begin().ptr(), &(*vecBase.begin()));
880 ASSERT_EQ(vecInt.size(), 0);
881 }
882 {
883 BASE_NS::vector<int> vecBase = { 1, 2, 3 };
884 BASE_NS::vector<int> vecInt; // allocate some memory for int with values from vecBase
885 vecInt.resize(2);
886 classInstance.WrapUninitializedCopy(vecInt.begin().ptr(), (vecInt.begin() + 2).ptr(), &(*vecBase.begin()));
887 ASSERT_EQ(vecInt.size(), 2);
888 ASSERT_EQ(vecInt[0], vecBase[0]);
889 ASSERT_EQ(vecInt[1], vecBase[1]);
890 }
891 {
892 BASE_NS::vector<uint32_t> vecBase = { 1, 2, 3 };
893 BASE_NS::vector<uint32_t> vecInt; // allocate some memory for int with values from vecBase
894 vecInt.resize(2);
895 classInstanceU32.WrapUninitializedCopy(vecInt.begin().ptr(), (vecInt.begin() + 2).ptr(), &(*vecBase.begin()));
896 ASSERT_EQ(vecInt.size(), 2);
897 ASSERT_EQ(vecInt[0], vecBase[0]);
898 ASSERT_EQ(vecInt[1], vecBase[1]);
899 }
900 {
901 BASE_NS::vector<int> vecBase = { 1, 2, 3 };
902 BASE_NS::vector<int>::const_reference& A = vecBase.front();
903 BASE_NS::vector<int> vecInt; // allocate 0 memory
904 vecInt.resize(0);
905 classInstance.WrapUninitializedFill(vecInt.begin().ptr(), vecInt.begin().ptr(), A);
906 ASSERT_EQ(vecInt.size(), 0);
907 }
908 {
909 BASE_NS::vector<int> vecBase = { 1, 2, 3 };
910 BASE_NS::vector<int>::const_reference& A = vecBase.front();
911 BASE_NS::vector<int> vecInt; // unitialize some memory with vecBase[0]
912 vecInt.resize(2);
913 classInstance.WrapUninitializedFill(vecInt.begin().ptr(), (vecInt.begin() + 2).ptr(), A);
914 ASSERT_EQ(vecInt.size(), 2);
915 ASSERT_EQ(vecInt[0], vecBase[0]);
916 ASSERT_EQ(vecInt[1], vecBase[0]);
917 }
918 {
919 BASE_NS::vector<uint32_t> vecBase = { 1, 2, 3 };
920 BASE_NS::vector<uint32_t>::const_reference& A = vecBase.front();
921 BASE_NS::vector<uint32_t> vecInt; // unitialize some memory with vecBase[0]
922 vecInt.resize(2);
923 classInstanceU32.WrapUninitializedFill(vecInt.begin().ptr(), (vecInt.begin() + 2).ptr(), A);
924 ASSERT_EQ(vecInt.size(), 2);
925 ASSERT_EQ(vecInt[0], vecBase[0]);
926 ASSERT_EQ(vecInt[1], vecBase[0]);
927 }
928 {
929 BASE_NS::vector<int> vecBase = { 1, 2, 3 };
930 BASE_NS::vector<int> vecInt; // allocate 0 memory
931 vecInt.resize(0);
932 classInstance.WrapUninitializedMove(vecInt.begin().ptr(), vecInt.begin().ptr(), &(*vecBase.begin()));
933 ASSERT_EQ(vecInt.size(), 0);
934 }
935 {
936 BASE_NS::vector<int> vecBase = { 1, 2, 3 };
937 BASE_NS::vector<int> vecInt; // allocate some memory for int with values from vecBase[2]
938 vecInt.resize(2);
939 classInstance.WrapUninitializedMove(vecInt.begin().ptr(), (vecInt.begin() + 2).ptr(), &(*vecBase.begin()));
940 ASSERT_EQ(vecInt.size(), 2);
941 ASSERT_EQ(vecInt[0], 0);
942 ASSERT_EQ(vecInt[1], 0);
943 ASSERT_EQ(vecBase[0], 0);
944 ASSERT_EQ(vecBase[1], 0);
945 ASSERT_EQ(vecBase[2], 3);
946 }
947 {
948 BASE_NS::vector<uint32_t> vecBase = { 1, 2, 3 };
949 BASE_NS::vector<uint32_t> vecInt; // allocate some memory for int with values from vecBase[2]
950 vecInt.resize(2);
951 classInstanceU32.WrapUninitializedMove(vecInt.begin().ptr(), (vecInt.begin() + 2).ptr(), &(*vecBase.begin()));
952 ASSERT_EQ(vecInt.size(), 2);
953 ASSERT_EQ(vecInt[0], 0);
954 ASSERT_EQ(vecInt[1], 0);
955 ASSERT_EQ(vecBase[0], 0);
956 ASSERT_EQ(vecBase[1], 0);
957 ASSERT_EQ(vecBase[2], 3);
958 }
959 }
960
961 HWTEST_F(VectorTest, ProtectedInitializedMemory, TestSize.Level1)
962 {
963 ProtectedVectorTest<int> classInstance;
964 ProtectedVectorTest<uint32_t> classInstanceU32;
965
966 // move values, not references
967 {
968 BASE_NS::vector<int> vecInt = { 1, 2, 3 };
969 BASE_NS::vector<int> vecInt2 = { 3, 2, 1 };
970 BASE_NS::vector<uint32_t> vecUint = { 99U, 88U, 77U };
971
972 classInstance.WrapCopy(&(*vecInt2.begin()), vecInt.begin().ptr(), vecInt.begin().ptr());
973 ASSERT_EQ(vecInt2[0], 3);
974 ASSERT_EQ(vecInt2[1], 2);
975 ASSERT_EQ(vecInt2[2], 1);
976
977 classInstance.WrapCopy<uint32_t*>(&(*vecInt2.begin()), &(*vecUint.begin()), &(*vecUint.begin()));
978 ASSERT_EQ(vecInt2[0], 3);
979 ASSERT_EQ(vecInt2[1], 2);
980 ASSERT_EQ(vecInt2[2], 1);
981
982 classInstance.WrapCopy<iterator<BASE_NS::vector<int>>>(&(*vecInt2.begin()), vecInt.begin(), vecInt.begin());
983 ASSERT_EQ(vecInt2[0], 3);
984 ASSERT_EQ(vecInt2[1], 2);
985 ASSERT_EQ(vecInt2[2], 1);
986
987 classInstance.WrapCopy(&(*vecInt2.begin()), vecInt.begin().ptr(), &(*vecInt.end()));
988 ASSERT_EQ(vecInt2[0], 1);
989 ASSERT_EQ(vecInt2[1], 2);
990 ASSERT_EQ(vecInt2[2], 3);
991 ASSERT_EQ(vecInt[0], 1);
992 ASSERT_EQ(vecInt[1], 2);
993 ASSERT_EQ(vecInt[2], 3);
994
995 classInstance.WrapCopy<uint32_t*>(&(*vecInt2.begin()), &(*vecUint.begin()), &(*vecUint.end()));
996 ASSERT_EQ(vecInt2[0], 99U);
997 ASSERT_EQ(vecInt2[1], 88U);
998 ASSERT_EQ(vecInt2[2], 77U);
999 ASSERT_EQ(vecUint[0], 99U);
1000 ASSERT_EQ(vecUint[1], 88U);
1001 ASSERT_EQ(vecUint[2], 77U);
1002
1003 classInstance.WrapCopy<iterator<BASE_NS::vector<int>>>(&(*vecInt2.begin()), vecInt.begin(), vecInt.end());
1004 ASSERT_EQ(vecInt2[0], 1);
1005 ASSERT_EQ(vecInt2[1], 2);
1006 ASSERT_EQ(vecInt2[2], 3);
1007 ASSERT_EQ(vecInt[0], 1);
1008 ASSERT_EQ(vecInt[1], 2);
1009 ASSERT_EQ(vecInt[2], 3);
1010 }
1011
1012 // move values, not references
1013 {
1014 BASE_NS::vector<int> vecInt = { 1, 2, 3 };
1015 BASE_NS::vector<int> vecInt2 = { 3, 2, 1 };
1016
1017 classInstance.WrapMove(vecInt.begin().ptr(), vecInt.begin().ptr(), &(*vecInt2.begin()));
1018 ASSERT_EQ(vecInt2[0], 3);
1019 ASSERT_EQ(vecInt2[1], 2);
1020 ASSERT_EQ(vecInt2[2], 1);
1021
1022 classInstance.WrapMove(vecInt.begin().ptr(), &(*(vecInt.begin() + 2)), &(*vecInt2.begin()));
1023 ASSERT_EQ(vecInt2[0], 1);
1024 ASSERT_EQ(vecInt2[1], 2);
1025 ASSERT_EQ(vecInt2[2], 1);
1026 ASSERT_EQ(vecInt[0], 1);
1027 ASSERT_EQ(vecInt[1], 2);
1028 ASSERT_EQ(vecInt[2], 3);
1029
1030 classInstance.WrapMove(vecInt.begin().ptr(), &(*(vecInt.end())), &(*vecInt2.begin()));
1031 ASSERT_EQ(vecInt2[0], 1);
1032 ASSERT_EQ(vecInt2[1], 2);
1033 ASSERT_EQ(vecInt2[2], 3);
1034 ASSERT_EQ(vecInt[0], 1);
1035 ASSERT_EQ(vecInt[1], 2);
1036 ASSERT_EQ(vecInt[2], 3);
1037 }
1038
1039 {
1040 BASE_NS::vector<uint32_t> vecInt = { 1, 2, 3 };
1041 BASE_NS::vector<uint32_t> vecInt2 = { 3, 2, 1 };
1042
1043 classInstanceU32.WrapMove(vecInt.begin().ptr(), vecInt.begin().ptr(), &(*vecInt2.begin()));
1044 ASSERT_EQ(vecInt2[0], 3);
1045 ASSERT_EQ(vecInt2[1], 2);
1046 ASSERT_EQ(vecInt2[2], 1);
1047
1048 classInstanceU32.WrapMove(vecInt.begin().ptr(), &(*(vecInt.begin() + 2)), &(*vecInt2.begin()));
1049 ASSERT_EQ(vecInt2[0], 1);
1050 ASSERT_EQ(vecInt2[1], 2);
1051 ASSERT_EQ(vecInt2[2], 1);
1052 ASSERT_EQ(vecInt[0], 1);
1053 ASSERT_EQ(vecInt[1], 2);
1054 ASSERT_EQ(vecInt[2], 3);
1055
1056 classInstanceU32.WrapMove(vecInt.begin().ptr(), &(*(vecInt.end())), &(*vecInt2.begin()));
1057 ASSERT_EQ(vecInt2[0], 1);
1058 ASSERT_EQ(vecInt2[1], 2);
1059 ASSERT_EQ(vecInt2[2], 3);
1060 ASSERT_EQ(vecInt[0], 1);
1061 ASSERT_EQ(vecInt[1], 2);
1062 ASSERT_EQ(vecInt[2], 3);
1063 }
1064 }
1065 HWTEST_F(VectorTest, ProtectedPointerMemoryActions, TestSize.Level1)
1066 {
1067 ProtectedVectorTest<int> classInstance;
1068 ProtectedVectorTest<uint32_t> classInstanceU32;
1069 {
1070 BASE_NS::vector<int> vecInt;
1071 int* p;
1072
1073 vecInt.resize(0);
1074 p = classInstance.WrapInitValue(vecInt.begin().ptr(), 0);
1075 ASSERT_EQ(p, vecInt.begin().ptr());
1076 ASSERT_EQ(vecInt.size(), 0);
1077
1078 vecInt.resize(2);
1079 ASSERT_EQ(vecInt[0], 0);
1080 ASSERT_EQ(vecInt[1], 0);
1081
1082 p = classInstance.WrapInitValue(vecInt.begin().ptr(), 2);
1083 ASSERT_EQ(p, &(*(vecInt.begin() + 2)));
1084 ASSERT_EQ(vecInt[0], 0);
1085 ASSERT_EQ(vecInt[1], 0);
1086 }
1087
1088 {
1089 BASE_NS::vector<int> vecInt;
1090 int* p;
1091
1092 vecInt.resize(0);
1093 p = classInstance.WrapInitFill(vecInt.begin().ptr(), 0, 1);
1094 ASSERT_EQ(p, vecInt.begin().ptr());
1095 ASSERT_EQ(vecInt.size(), 0);
1096
1097 vecInt.resize(2);
1098 ASSERT_EQ(vecInt[0], 0);
1099 ASSERT_EQ(vecInt[1], 0);
1100
1101 p = classInstance.WrapInitFill(vecInt.begin().ptr(), 2, 1);
1102 ASSERT_EQ(p, &(*(vecInt.begin() + 2)));
1103 ASSERT_EQ(vecInt[0], 1);
1104 ASSERT_EQ(vecInt[1], 1);
1105
1106 // refresh
1107 p = classInstance.WrapInitValue(&(*(vecInt.begin() + 1)), 1);
1108 ASSERT_EQ(p, &(*(vecInt.begin() + 2)));
1109 ASSERT_EQ(vecInt[0], 1);
1110 ASSERT_EQ(vecInt[1], 0);
1111 }
1112
1113 {
1114 BASE_NS::vector<int> vecInt;
1115 BASE_NS::vector<int> vecInt2 = { 1, 2, 3 };
1116 int* p;
1117
1118 vecInt.resize(0);
1119 p = classInstance.WrapInitCopy(vecInt.begin().ptr(), &(*vecInt2.begin()), 0);
1120 ASSERT_EQ(p, vecInt.begin().ptr());
1121 ASSERT_EQ(vecInt.size(), 0);
1122
1123 vecInt.resize(4);
1124 ASSERT_EQ(vecInt[0], 0);
1125 ASSERT_EQ(vecInt[1], 0);
1126 ASSERT_EQ(vecInt[2], 0);
1127 ASSERT_EQ(vecInt[3], 0);
1128
1129 p = classInstance.WrapInitCopy(vecInt.begin().ptr(), &(*vecInt2.begin()), 3);
1130 ASSERT_EQ(p, &(*(vecInt.begin() + 3)));
1131 ASSERT_EQ(vecInt[0], 1);
1132 ASSERT_EQ(vecInt[1], 2);
1133 ASSERT_EQ(vecInt[2], 3);
1134 ASSERT_EQ(vecInt[3], 0);
1135
1136 p = classInstance.WrapInitCopy(&(*(p - 2)), &(*vecInt2.begin()), 3);
1137 ASSERT_EQ(p, &(*(vecInt.end())));
1138 ASSERT_EQ(vecInt[0], 1);
1139 ASSERT_EQ(vecInt[1], 1);
1140 ASSERT_EQ(vecInt[2], 2);
1141 ASSERT_EQ(vecInt[3], 3);
1142 }
1143
1144 {
1145 BASE_NS::vector<int> vecInt = { 1, 2, 3 };
1146 BASE_NS::vector<uint32_t> vecUint = { 99U, 88U, 77U };
1147 iterator<BASE_NS::vector<int>> pInt; // here pointer to beginning, not end.
1148
1149 classInstance.resize(0);
1150 pInt = classInstance.WrapInsertImpl<int*>(classInstance.begin(), vecInt.begin().ptr(), vecInt.begin().ptr());
1151 ASSERT_EQ(pInt, classInstance.begin());
1152 ASSERT_EQ(classInstance.size(), 0);
1153
1154 classInstance.resize(4);
1155 ASSERT_EQ(classInstance[0], 0);
1156 ASSERT_EQ(classInstance[1], 0);
1157 ASSERT_EQ(classInstance[2], 0);
1158 ASSERT_EQ(classInstance[3], 0);
1159
1160 pInt = classInstance.WrapInsertImpl<iterator<BASE_NS::vector<int>>>(
1161 classInstance.begin(), vecInt.begin(), vecInt.end());
1162 ASSERT_EQ(pInt, classInstance.begin());
1163 ASSERT_EQ(classInstance[0], 1);
1164 ASSERT_EQ(classInstance[1], 2);
1165 ASSERT_EQ(classInstance[2], 3);
1166 ASSERT_EQ(classInstance[3], 0);
1167
1168 pInt = classInstance.WrapInsertImpl<uint32_t*>(
1169 (classInstance.begin() + 1), vecUint.begin().ptr(), vecUint.end().ptr());
1170 ASSERT_EQ(pInt, classInstance.begin() + 1);
1171 ASSERT_EQ(classInstance[0], 1);
1172 ASSERT_EQ(classInstance[1], 99);
1173 ASSERT_EQ(classInstance[2], 88);
1174 ASSERT_EQ(classInstance[3], 77);
1175 }
1176 }
1177 HWTEST_F(VectorTest, Iterators, TestSize.Level1)
1178 {
1179 int vec[5] = { 1, 2, 4, 8, 16 };
1180 BASE_NS::vector<int> vecInt { 1, 2, 4, 8, 16 };
1181
1182 // Iterator begin, end
1183 int index = 0;
1184 for (auto it = vecInt.begin(); it != vecInt.end(); ++it) {
1185 ASSERT_EQ(*it, vec[index]);
1186 index++;
1187 };
1188
1189 index = 0;
1190 for (auto it = vecInt.cbegin(); it != vecInt.cend(); ++it) {
1191 ASSERT_EQ(*it, vec[index]);
1192 index++;
1193 };
1194
1195 index = 4;
1196 for (auto it = vecInt.rbegin(); it != vecInt.rend(); ++it) {
1197 ASSERT_EQ(*it, vec[index]);
1198 index--;
1199 };
1200
1201 index = 4;
1202 for (auto it = vecInt.crbegin(); it != vecInt.crend(); ++it) {
1203 ASSERT_EQ(*it, vec[index]);
1204 index--;
1205 };
1206 }
1207
1208 HWTEST_F(VectorTest, Capacity, TestSize.Level1)
1209 {
1210 BASE_NS::vector<int> vecInt;
1211 const int nEle = 1000;
1212
1213 // Empty
1214 ASSERT_TRUE(vecInt.empty());
1215
1216 // Max size
1217 ASSERT_GT(vecInt.max_size(), 0U);
1218
1219 // Reserve
1220 vecInt.reserve(nEle);
1221
1222 // Size & Capacity
1223 ASSERT_EQ(vecInt.capacity(), nEle);
1224 ASSERT_EQ(vecInt.capacity_in_bytes(), nEle * sizeof(int));
1225 ASSERT_EQ(vecInt.size(), 0U);
1226 ASSERT_EQ(vecInt.size_in_bytes(), 0U * sizeof(int));
1227 ASSERT_TRUE(vecInt.empty());
1228
1229 const int nEleHalf = nEle >> 1;
1230 for (int i = 0; i < nEleHalf; ++i)
1231 vecInt.push_back(i % 2);
1232 ASSERT_EQ(vecInt.capacity(), nEle);
1233 ASSERT_EQ(vecInt.capacity_in_bytes(), nEle * sizeof(int));
1234 ASSERT_EQ(vecInt.size(), nEleHalf);
1235 ASSERT_EQ(vecInt.size_in_bytes(), nEleHalf * sizeof(int));
1236 ASSERT_FALSE(vecInt.empty());
1237
1238 // Shrink to fit
1239 vecInt.shrink_to_fit();
1240 ASSERT_EQ(vecInt.capacity(), nEleHalf);
1241 ASSERT_EQ(vecInt.capacity_in_bytes(), nEleHalf * sizeof(int));
1242 ASSERT_EQ(vecInt.size(), nEleHalf);
1243 ASSERT_EQ(vecInt.size_in_bytes(), nEleHalf * sizeof(int));
1244 }
1245
1246 HWTEST_F(VectorTest, Assign, TestSize.Level1)
1247 {
1248 {
1249 BASE_NS::vector<int> vecA;
1250 BASE_NS::vector<int> vecB;
1251 vecA = vecB;
1252 EXPECT_EQ(vecA.size(), vecB.size());
1253 }
1254 // assign to smaller (will allocate and copy construct)
1255 {
1256 BASE_NS::vector<int> vecA = { 1 };
1257 BASE_NS::vector<int> vecB = { 2, 3, 4 };
1258 vecA = vecB;
1259 EXPECT_EQ(vecA.size(), vecB.size());
1260 EXPECT_EQ(vecA.size(), 3U);
1261 EXPECT_TRUE(std::equal(vecA.begin(), vecA.end(), vecB.begin()));
1262 }
1263 // assign to smaller, but with extra capacity (will copy assign and copy construct)
1264 {
1265 BASE_NS::vector<int> vecA = { 1, 2 };
1266 vecA.reserve(16);
1267 BASE_NS::vector<int> vecB = { 3, 4, 5 };
1268 vecA = vecB;
1269 EXPECT_EQ(vecA.size(), vecB.size());
1270 EXPECT_TRUE(std::equal(vecA.begin(), vecA.end(), vecB.begin()));
1271 EXPECT_EQ(vecA.size(), 3U);
1272 }
1273 // assign to larger (will allocate and copy construct)
1274 {
1275 BASE_NS::vector<int> vecA = { 1, 2, 3 };
1276 BASE_NS::vector<int> vecB = { 4 };
1277 vecA = vecB;
1278 EXPECT_EQ(vecA.size(), vecB.size());
1279 EXPECT_TRUE(std::equal(vecA.begin(), vecA.end(), vecB.begin()));
1280 EXPECT_EQ(vecA.size(), 1U);
1281 }
1282 // assign to larger but with bigger capacity (will copy assign and destroy elements)
1283 {
1284 BASE_NS::vector<int> vecA = { 1, 2, 3 };
1285 vecA.reserve(16);
1286 BASE_NS::vector<int> vecB = { 4 };
1287 vecA = vecB;
1288 EXPECT_EQ(vecA.size(), vecB.size());
1289 EXPECT_TRUE(std::equal(vecA.begin(), vecA.end(), vecB.begin()));
1290 EXPECT_EQ(vecA.size(), 1U);
1291 }
1292
1293 // do the same with A non-trivially destructable and copyable
1294 {
1295 BASE_NS::vector<Thing> vecA;
1296 BASE_NS::vector<Thing> vecB;
1297 vecA = vecB;
1298 EXPECT_EQ(vecA.size(), vecB.size());
1299 }
1300 // assign to smaller (will allocate and copy construct)
1301 {
1302 BASE_NS::vector<Thing> vecA = { Thing(1) };
1303 BASE_NS::vector<Thing> vecB = { Thing(2), Thing(3), Thing(4) };
1304 vecA = vecB;
1305 EXPECT_EQ(vecA.size(), vecB.size());
1306 EXPECT_EQ(vecA.size(), 3U);
1307 EXPECT_TRUE(std::equal(vecA.begin(), vecA.end(), vecB.begin()));
1308 }
1309 // assign to smaller, but with extra capacity (will copy assign and copy construct)
1310 {
1311 BASE_NS::vector<Thing> vecA = { Thing(1), Thing(2) };
1312 vecA.reserve(16);
1313 BASE_NS::vector<Thing> vecB = { Thing(3), Thing(4), Thing(5) };
1314 vecA = vecB;
1315 EXPECT_EQ(vecA.size(), vecB.size());
1316 EXPECT_EQ(vecA.size(), 3U);
1317 EXPECT_TRUE(std::equal(vecA.begin(), vecA.end(), vecB.begin()));
1318 }
1319 // assign to larger (will allocate and copy construct)
1320 {
1321 BASE_NS::vector<Thing> vecA = { Thing(1), Thing(2), Thing(3) };
1322 BASE_NS::vector<Thing> vecB = { Thing(4) };
1323 vecA = vecB;
1324 EXPECT_EQ(vecA.size(), vecB.size());
1325 EXPECT_EQ(vecA.size(), 1U);
1326 EXPECT_TRUE(std::equal(vecA.begin(), vecA.end(), vecB.begin()));
1327 }
1328 // assign to larger but with bigger capacity (will copy assign and destroy elements)
1329 {
1330 BASE_NS::vector<Thing> vecA = { Thing(1), Thing(2), Thing(3) };
1331 vecA.reserve(16);
1332 BASE_NS::vector<Thing> vecB = { Thing(4) };
1333 vecA = vecB;
1334 EXPECT_EQ(vecA.size(), vecB.size());
1335 EXPECT_EQ(vecA.size(), 1U);
1336 EXPECT_TRUE(std::equal(vecA.begin(), vecA.end(), vecB.begin()));
1337 }
1338 }
1339
1340 template<typename T>
1341 struct Foo {
1342 int n;
1343 T x;
FooFoo1344 Foo(int val1, T val2) : n(val1), x(val2) {}
1345 };
1346
1347 HWTEST_F(VectorTest, Modifiers, TestSize.Level1)
1348 {
1349 BASE_NS::vector<Foo<float>> vFoo;
1350 BASE_NS::vector<int> vecInt { 1, 2, 4, 8, 16 };
1351
1352 // Push back
1353 vecInt.push_back(32);
1354 ASSERT_EQ(*(vecInt.end() - 1), 32);
1355
1356 // Erase
1357 vecInt.erase(vecInt.begin() + 2);
1358
1359 ASSERT_EQ(vecInt[2], 8);
1360 ASSERT_EQ(vecInt[1], 2);
1361 vecInt.erase(vecInt.end());
1362 ASSERT_EQ(*(vecInt.end() - 1), 32);
1363 vecInt.erase(vecInt.end() - 1);
1364 ASSERT_EQ(*(vecInt.end() - 1), 16);
1365
1366 // Emplace
1367 vFoo.emplace(vFoo.begin(), 2, 3.1416f);
1368 ASSERT_EQ(vFoo[0].n, 2);
1369 ASSERT_FLOAT_EQ(vFoo[0].x, 3.1416f);
1370
1371 vecInt.emplace(vecInt.begin() + 2, 4);
1372 ASSERT_EQ(vecInt[2], 4);
1373
1374 // Emplace back
1375 vecInt.emplace_back(32);
1376 ASSERT_EQ(*(vecInt.end() - 1), 32);
1377
1378 // Insert
1379 vFoo.insert(vFoo.end(), Foo(0, 0.2f));
1380 ASSERT_EQ(vFoo[1].n, 0);
1381 ASSERT_FLOAT_EQ(vFoo[1].x, 0.2f);
1382
1383 vecInt.insert(vecInt.begin(), 0);
1384
1385 // Clear
1386 ASSERT_GT(vecInt.size(), 0U);
1387 vecInt.clear();
1388 ASSERT_EQ(vecInt.size(), 0U);
1389 }