1 /*
2 * Copyright (c) 2023 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 <benchmark/benchmark.h>
17 #include "sorted_vector.h"
18 #include <iostream>
19 #include "benchmark_log.h"
20 #include "benchmark_assert.h"
21 using namespace std;
22
23 namespace OHOS {
24 namespace {
25
26 static constexpr ssize_t SVECTOR_START_POS_ASSIGN = 0;
27 static constexpr ssize_t SVECTOR_END_POS_ASSIGN = 9;
28 static constexpr ssize_t SVECTOR_START_POS_VALUE = 0;
29 static constexpr ssize_t SVECTOR_END_POS_VALUE = 10;
30 static constexpr ssize_t SVECTOR_INVALID_VALUE = -1;
31 const int VECTOR_SIZE_TEN = 10;
32 const int VECTOR_SIZE_TWENTY = 20;
33 const int ELEMENT_END_VALUE = 30;
34 const size_t EXPECTED_SIZE_AFTER_DUPLICATES = 30;
35
36 class BenchmarkSortedVector : public benchmark::Fixture {
37 public:
SetUp(const::benchmark::State & state)38 void SetUp(const ::benchmark::State& state) override
39 {
40 }
41
TearDown(const::benchmark::State & state)42 void TearDown(const ::benchmark::State& state) override
43 {
44 }
45
BenchmarkSortedVector()46 BenchmarkSortedVector()
47 {
48 Iterations(iterations);
49 Repetitions(repetitions);
50 ReportAggregatesOnly();
51 }
52
53 ~BenchmarkSortedVector() override = default;
54
55 protected:
56 const int32_t repetitions = 3;
57 const int32_t iterations = 1000;
58 };
59
BENCHMARK_F(BenchmarkSortedVector,testDefaultConsAndAddAndSort)60 BENCHMARK_F(BenchmarkSortedVector, testDefaultConsAndAddAndSort)(benchmark::State& state)
61 {
62 BENCHMARK_LOGD("SortedVector testDefaultConsAndAddAndSort start.");
63 while (state.KeepRunning()) {
64 SortedVector<int> svec;
65 std::vector<int> vec;
66 for (int i = 0; i < VECTOR_SIZE_TEN; i++) {
67 vec.push_back(i);
68 }
69
70 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
71 svec.Add(i);
72 }
73
74 auto it = svec.Begin();
75 auto it2 = vec.begin();
76 for (; (it != svec.End()) and (it2 != vec.end()); it2++, it++) {
77 AssertEqual(*it, *it2, "*it did not equal *it2 as expected.", state);
78 }
79 }
80 BENCHMARK_LOGD("SortedVector testDefaultConsAndAddAndSort end.");
81 }
82
BENCHMARK_F(BenchmarkSortedVector,testConsFromSortedAllowDup)83 BENCHMARK_F(BenchmarkSortedVector, testConsFromSortedAllowDup)(benchmark::State& state)
84 {
85 BENCHMARK_LOGD("SortedVector testConsFromSortedAllowDup start.");
86 while (state.KeepRunning()) {
87 SortedVector<int> svec;
88 std::vector<int> vec;
89 for (int i = 0; i < VECTOR_SIZE_TEN; i++) {
90 vec.push_back(i);
91 }
92
93 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
94 svec.Add(i);
95 }
96
97 SortedVector<int> newSvec(svec);
98 auto it = newSvec.Begin();
99 auto it2 = vec.begin();
100 for (; (it != newSvec.End()) and (it2 != vec.end()); it2++, it++) {
101 AssertEqual(*it, *it2, "*it did not equal *it2 as expected.", state);
102 }
103 }
104 BENCHMARK_LOGD("SortedVector testConsFromSortedAllowDup end.");
105 }
106
AddElement(SortedVector<int> & svec,std::vector<int> & vec)107 static void AddElement(SortedVector<int>& svec, std::vector<int>& vec)
108 {
109 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
110 vec.push_back(i);
111 }
112
113 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
114 svec.Add(i);
115 }
116
117 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
118 svec.Add(i);
119 }
120 }
121
BENCHMARK_F(BenchmarkSortedVector,testConsFromSortedNotAllowDuplicate)122 BENCHMARK_F(BenchmarkSortedVector, testConsFromSortedNotAllowDuplicate)(benchmark::State& state)
123 {
124 BENCHMARK_LOGD("SortedVector testConsFromSortedNotAllowDuplicate start.");
125 while (state.KeepRunning()) {
126 SortedVector<int> svec;
127 std::vector<int> vec;
128 AddElement(svec, vec);
129
130 AssertEqual(static_cast<size_t>(EXPECTED_SIZE_AFTER_DUPLICATES), svec.Size(),
131 "static_cast<size_t>(EXPECTED_SIZE_AFTER_DUPLICATES) did not equal svec.Size() as expected.", state);
132
133 SortedVector<int, false> newSvec(svec);
134 AssertEqual(static_cast<size_t>(VECTOR_SIZE_TWENTY), newSvec.Size(),
135 "static_cast<size_t>(VECTOR_SIZE_TWENTY) did not equal newSvec.Size() as expected.", state);
136 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
137 AssertEqual(vec[i], newSvec[i], "vec[i] did not equal newSvec[i] as expected.", state);
138 }
139 }
140 BENCHMARK_LOGD("SortedVector testConsFromSortedNotAllowDuplicate end.");
141 }
142
BENCHMARK_F(BenchmarkSortedVector,testConsFromSortedNotAllowToAlloworNotAllow)143 BENCHMARK_F(BenchmarkSortedVector, testConsFromSortedNotAllowToAlloworNotAllow)(benchmark::State& state)
144 {
145 BENCHMARK_LOGD("SortedVector testConsFromSortedNotAllowToAlloworNotAllow start.");
146 while (state.KeepRunning()) {
147 SortedVector<int, false> svec;
148 std::vector<int> vec;
149 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
150 vec.push_back(i);
151 }
152
153 for (int i = SVECTOR_START_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
154 svec.Add(i);
155 }
156
157 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
158 svec.Add(i);
159 }
160
161 AssertEqual(static_cast<size_t>(VECTOR_SIZE_TWENTY), svec.Size(),
162 "static_cast<size_t>(VECTOR_SIZE_TWENTY) did not equal svec.Size() as expected.", state);
163
164 SortedVector<int> newSvecTrue(svec);
165 AssertEqual(static_cast<size_t>(VECTOR_SIZE_TWENTY), newSvecTrue.Size(),
166 "static_cast<size_t>(VECTOR_SIZE_TWENTY) did not equal newSvecTrue.Size() as expected.", state);
167 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
168 AssertEqual(vec[i], newSvecTrue[i], "vec[i] did not equal newSvecTrue[i] as expected.", state);
169 }
170
171 SortedVector<int> newSvecFalse(svec);
172 AssertEqual(static_cast<size_t>(VECTOR_SIZE_TWENTY), newSvecFalse.Size(),
173 "static_cast<size_t>(VECTOR_SIZE_TWENTY) did not equal newSvecFalse.Size() as expected.", state);
174 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
175 AssertEqual(vec[i], newSvecFalse[i], "vec[i] did not equal newSvecFalse[i] as expected.", state);
176 }
177 }
178 BENCHMARK_LOGD("SortedVector testConsFromSortedNotAllowToAlloworNotAllow end.");
179 }
180
BENCHMARK_F(BenchmarkSortedVector,testoperatoreq)181 BENCHMARK_F(BenchmarkSortedVector, testoperatoreq)(benchmark::State& state)
182 {
183 BENCHMARK_LOGD("SortedVector testoperatoreq start.");
184 while (state.KeepRunning()) {
185 SortedVector<int> svec;
186 std::vector<int> vec;
187 for (int i = 0; i < VECTOR_SIZE_TEN; i++) {
188 vec.push_back(i);
189 }
190
191 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
192 svec.Add(i);
193 }
194
195 SortedVector<int> newSvec = svec;
196 auto it = newSvec.Begin();
197 auto it2 = svec.Begin();
198 for (; (it != newSvec.End()) and (it2 != svec.End()); it2++, it++) {
199 AssertEqual(*it, *it2, "*it did not equal *it2 as expected.", state);
200 }
201 }
202 BENCHMARK_LOGD("SortedVector testoperatoreq end.");
203 }
204
BENCHMARK_F(BenchmarkSortedVector,testOperatorEqAllowToNotAllow)205 BENCHMARK_F(BenchmarkSortedVector, testOperatorEqAllowToNotAllow)(benchmark::State& state)
206 {
207 BENCHMARK_LOGD("SortedVector testOperatorEqAllowToNotAllow start.");
208 while (state.KeepRunning()) {
209 SortedVector<int> svec;
210 std::vector<int> vec;
211 AddElement(svec, vec);
212
213 AssertEqual(static_cast<size_t>(EXPECTED_SIZE_AFTER_DUPLICATES), svec.Size(),
214 "static_cast<size_t>(EXPECTED_SIZE_AFTER_DUPLICATES) did not equal svec.Size() as expected.", state);
215
216 SortedVector<int, false> newSvec = svec;
217 AssertEqual(static_cast<size_t>(VECTOR_SIZE_TWENTY), newSvec.Size(),
218 "static_cast<size_t>(VECTOR_SIZE_TWENTY) did not equal newSvec.Size() as expected.", state);
219 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
220 AssertEqual(vec[i], newSvec[i], "vec[i] did not equal newSvec[i] as expected.", state);
221 }
222 }
223 BENCHMARK_LOGD("SortedVector testOperatorEqAllowToNotAllow end.");
224 }
225
BENCHMARK_F(BenchmarkSortedVector,testOperatorEqNotAllowToAllowOrNotAllow)226 BENCHMARK_F(BenchmarkSortedVector, testOperatorEqNotAllowToAllowOrNotAllow)(benchmark::State& state)
227 {
228 BENCHMARK_LOGD("SortedVector testOperatorEqNotAllowToAllowOrNotAllow start.");
229 while (state.KeepRunning()) {
230 SortedVector<int, false> svec;
231 std::vector<int> vec;
232 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
233 vec.push_back(i);
234 }
235
236 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
237 svec.Add(i);
238 }
239
240 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
241 svec.Add(i);
242 }
243
244 AssertEqual(static_cast<size_t>(VECTOR_SIZE_TWENTY), svec.Size(),
245 "static_cast<size_t>(VECTOR_SIZE_TWENTY) did not equal svec.Size() as expected.", state);
246
247 SortedVector<int, false> newSvecFalse = svec;
248 SortedVector<int, true> newSvecTrue = svec;
249 AssertEqual(static_cast<size_t>(VECTOR_SIZE_TWENTY), newSvecFalse.Size(),
250 "static_cast<size_t>(VECTOR_SIZE_TWENTY) did not equal newSvecFalse.Size() as expected.", state);
251 AssertEqual(static_cast<size_t>(VECTOR_SIZE_TWENTY), newSvecTrue.Size(),
252 "static_cast<size_t>(VECTOR_SIZE_TWENTY) did not equal newSvecTrue.Size() as expected.", state);
253 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
254 AssertEqual(vec[i], newSvecFalse[i], "vec[i] did not equal newSvecFalse[i] as expected.", state);
255 AssertEqual(vec[i], newSvecTrue[i], "vec[i] did not equal newSvecTrue[i] as expected.", state);
256 }
257 }
258 BENCHMARK_LOGD("SortedVector testOperatorEqNotAllowToAllowOrNotAllow end.");
259 }
260
BENCHMARK_F(BenchmarkSortedVector,testOperatorEqAssignmentTwice)261 BENCHMARK_F(BenchmarkSortedVector, testOperatorEqAssignmentTwice)(benchmark::State& state)
262 {
263 BENCHMARK_LOGD("SortedVector testOperatorEqAssignmentTwice start.");
264 while (state.KeepRunning()) {
265 SortedVector<int, true> svec;
266 std::vector<int> vec;
267 for (int i = VECTOR_SIZE_TWENTY; i < ELEMENT_END_VALUE; i++) {
268 vec.push_back(i);
269 }
270
271 for (int i = 0; i < VECTOR_SIZE_TWENTY; i++) {
272 svec.Add(i);
273 }
274
275 SortedVector<int, false> newSvecFalse;
276 for (int i = VECTOR_SIZE_TWENTY; i < ELEMENT_END_VALUE; i++) {
277 newSvecFalse.Add(i);
278 }
279
280 svec = newSvecFalse;
281 AssertEqual(static_cast<size_t>(VECTOR_SIZE_TEN), svec.Size(),
282 "static_cast<size_t>(VECTOR_SIZE_TEN) did not equal svec.Size() as expected.", state);
283 for (int i = 0; i < VECTOR_SIZE_TEN; i++) {
284 AssertEqual(vec[i], svec[i], "vec[i] did not equal svec[i] as expected.", state);
285 }
286 }
287 BENCHMARK_LOGD("SortedVector testOperatorEqAssignmentTwice end.");
288 }
289
BENCHMARK_F(BenchmarkSortedVector,testoperatorconsteq)290 BENCHMARK_F(BenchmarkSortedVector, testoperatorconsteq)(benchmark::State& state)
291 {
292 BENCHMARK_LOGD("SortedVector testoperatorconsteq start.");
293 while (state.KeepRunning()) {
294 SortedVector<int> svec;
295 std::vector<int> vec;
296 for (int i = 0; i < VECTOR_SIZE_TEN; i++) {
297 vec.push_back(i);
298 }
299
300 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
301 svec.Add(i);
302 }
303
304 const SortedVector<int> newSvec = svec;
305 auto it = newSvec.Begin();
306 auto it2 = svec.Begin();
307 for (; (it != newSvec.End()) and (it2 != svec.End()); it2++, it++) {
308 AssertEqual(*it, *it2, "*it did not equal *it2 as expected.", state);
309 }
310 }
311 BENCHMARK_LOGD("SortedVector testoperatorconsteq end.");
312 }
313
BENCHMARK_F(BenchmarkSortedVector,testsizeclearIsEmpty)314 BENCHMARK_F(BenchmarkSortedVector, testsizeclearIsEmpty)(benchmark::State& state)
315 {
316 BENCHMARK_LOGD("SortedVector testsizeclearIsEmpty start.");
317 const size_t expectedSizeEmpty = 0;
318 const size_t expectedSizeAfterAdd = 10;
319 while (state.KeepRunning()) {
320 SortedVector<int> svec;
321 AssertTrue(svec.IsEmpty(), "svec.IsEmpty() did not equal true as expected.", state);
322 AssertEqual(svec.Size(), static_cast<size_t>(expectedSizeEmpty),
323 "svec.Size() did not equal static_cast<size_t>(expectedSizeEmpty) as expected.", state);
324
325 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
326 svec.Add(i);
327 }
328 AssertEqual(svec.Size(), static_cast<const unsigned long>(expectedSizeAfterAdd),
329 "svec.Size() did not equal static_cast<const unsigned long>(expectedSizeAfterAdd) as expected.", state);
330 AssertFalse(svec.IsEmpty(), "svec.IsEmpty() did not equal false as expected.", state);
331
332 svec.Clear();
333 AssertTrue(svec.IsEmpty(), "svec.IsEmpty() did not equal true as expected.", state);
334 AssertEqual(svec.Size(), static_cast<size_t>(expectedSizeEmpty),
335 "svec.Size() did not equal static_cast<size_t>(expectedSizeEmpty) as expected.", state);
336 }
337 BENCHMARK_LOGD("SortedVector testsizeclearIsEmpty end.");
338 }
339
BENCHMARK_F(BenchmarkSortedVector,testCapasityandSetcapasity)340 BENCHMARK_F(BenchmarkSortedVector, testCapasityandSetcapasity)(benchmark::State& state)
341 {
342 BENCHMARK_LOGD("SortedVector testCapasityandSetcapasity start.");
343 const size_t initialCapacity = 1000;
344 const size_t reducedCapacity = 500;
345 while (state.KeepRunning()) {
346 SortedVector<int> svec;
347 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
348 svec.Add(i);
349 }
350
351 svec.SetCapcity(initialCapacity);
352 AssertEqual(svec.Capacity(), static_cast<size_t>(initialCapacity),
353 "svec.Capacity() did not equal static_cast<size_t>(initialCapacity) as expected.", state);
354 AssertLessThan(svec.SetCapcity(reducedCapacity), static_cast<ssize_t>(0),
355 "svec.SetCapcity(reducedCapacity) was not less than static_cast<ssize_t>(0) as expected.", state);
356 AssertEqual(svec.Capacity(), static_cast<size_t>(initialCapacity),
357 "svec.Capacity() did not equal static_cast<size_t>(initialCapacity) as expected.", state);
358 }
359 BENCHMARK_LOGD("SortedVector testCapasityandSetcapasity end.");
360 }
361
BENCHMARK_F(BenchmarkSortedVector,testconstArray)362 BENCHMARK_F(BenchmarkSortedVector, testconstArray)(benchmark::State& state)
363 {
364 BENCHMARK_LOGD("SortedVector testconstArray start.");
365 while (state.KeepRunning()) {
366 SortedVector<int> svec;
367 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
368 svec.Add(i);
369 }
370
371 const int* pi = svec.Array();
372 int arraySize = svec.Size();
373 auto it = svec.Begin();
374 int i = 0;
375 for (; (i < arraySize) && (it != svec.End()); ++it, ++i) {
376 AssertEqual(pi[i], *it, "pi[i] did not equal *it as expected.", state);
377 }
378
379 AssertEqual(i, arraySize, "i did not equal arraySize as expected.", state);
380 AssertEqual(it, svec.End(), "it did not equal svec.End() as expected.", state);
381 }
382 BENCHMARK_LOGD("SortedVector testconstArray end.");
383 }
384
BENCHMARK_F(BenchmarkSortedVector,testeditArray)385 BENCHMARK_F(BenchmarkSortedVector, testeditArray)(benchmark::State& state)
386 {
387 BENCHMARK_LOGD("SortedVector testeditArray start.");
388 while (state.KeepRunning()) {
389 SortedVector<int> svec;
390 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
391 svec.Add(i);
392 }
393
394 int* pi = svec.EditArray();
395 int arraySize = svec.Size();
396 // compare and equal
397 auto it = svec.Begin();
398 int i = 0;
399 for (; (i < arraySize) && (it != svec.End()); ++it, ++i) {
400 AssertEqual(pi[i], *it, "pi[i] did not equal *it as expected.", state);
401 }
402 // size equal
403 AssertEqual(i, arraySize, "i did not equal arraySize as expected.", state);
404 AssertEqual(it, svec.End(), "it did not equal svec.End() as expected.", state);
405
406 // fix value
407 for (int t = 0; t < arraySize; ++t) {
408 pi[t] += 1;
409 }
410
411 // compare and equal add 1
412 SortedVector<int> copyvec;
413 it = copyvec.Begin();
414 i = 0;
415 for (; (i < arraySize) && (it != copyvec.End()); ++it, ++i) {
416 AssertEqual(pi[i], *it + 1, "pi[i] did not equal *it + 1 as expected.", state);
417 }
418
419 // all renewed
420 it = svec.Begin();
421 i = 0;
422 for (; (i < arraySize) && (it != svec.End()); ++it, ++i) {
423 AssertEqual(pi[i], *it, "pi[i] did not equal *it as expected.", state);
424 }
425 }
426 BENCHMARK_LOGD("SortedVector testeditArray end.");
427 }
428
BENCHMARK_F(BenchmarkSortedVector,testIndexOf)429 BENCHMARK_F(BenchmarkSortedVector, testIndexOf)(benchmark::State& state)
430 {
431 BENCHMARK_LOGD("SortedVector testIndexOf start.");
432 const int searchValueTen = 10;
433 const int invalidIndex = -1;
434 while (state.KeepRunning()) {
435 SortedVector<int> svec;
436 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
437 svec.Add(i);
438 }
439
440 int arraySize = svec.Size();
441 auto it = svec.Begin();
442 int i = 0;
443 for (; (i < arraySize) && (it != svec.End()); ++it, ++i) {
444 AssertEqual(i, svec.IndexOf(i), "i did not equal svec.IndexOf(i) as expected.", state);
445 }
446 AssertEqual(invalidIndex, svec.IndexOf(searchValueTen),
447 "invalidIndex did not equal svec.IndexOf(searchValueTen) as expected.", state);
448 }
449 BENCHMARK_LOGD("SortedVector testIndexOf end.");
450 }
451
452
BENCHMARK_F(BenchmarkSortedVector,testOrderof)453 BENCHMARK_F(BenchmarkSortedVector, testOrderof)(benchmark::State& state)
454 {
455 BENCHMARK_LOGD("SortedVector testOrderof start.");
456 const int searchValueNegTwo = -2;
457 const int searchValueNegOne = -1;
458 const int searchValueNine = 9;
459 const int searchValueTen = 10;
460 const size_t orderNotFound = 0;
461 const size_t expectedOrderTen = 10;
462 while (state.KeepRunning()) {
463 SortedVector<int> svec;
464 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
465 svec.Add(i);
466 }
467
468 size_t count = svec.Size();
469 size_t order = 0;
470 for (size_t i = 0; i < count; i++) {
471 order = svec.OrderOf(i);
472 AssertEqual((i + 1), order, "i + 1 did not equal order as expected.", state);
473 }
474
475 AssertEqual(orderNotFound, svec.OrderOf(searchValueNegTwo),
476 "orderNotFound did not equal svec.OrderOf(searchValueNegTwo) as expected.", state);
477 AssertEqual(orderNotFound, svec.OrderOf(searchValueNegOne),
478 "orderNotFound did not equal svec.OrderOf(searchValueNegOne) as expected.", state);
479 AssertEqual(expectedOrderTen, svec.OrderOf(searchValueNine),
480 "expectedOrderTen did not equal svec.OrderOf(searchValueNine) as expected.", state);
481 AssertEqual(expectedOrderTen, svec.OrderOf(searchValueTen),
482 "expectedOrderTen did not equal svec.OrderOf(searchValueTen) as expected.", state);
483 }
484 BENCHMARK_LOGD("SortedVector testOrderof end.");
485 }
486
BENCHMARK_F(BenchmarkSortedVector,testoperatorAccess)487 BENCHMARK_F(BenchmarkSortedVector, testoperatorAccess)(benchmark::State& state)
488 {
489 BENCHMARK_LOGD("SortedVector testoperatorAccess start.");
490 while (state.KeepRunning()) {
491 SortedVector<int> svec;
492 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
493 svec.Add(i);
494 }
495
496 for (int i = SVECTOR_START_POS_ASSIGN; i <= SVECTOR_END_POS_ASSIGN; i++) {
497 AssertEqual(i, svec[i], "i did not equal svec[i] as expected.", state);
498 }
499 }
500 BENCHMARK_LOGD("SortedVector testoperatorAccess end.");
501 }
502
BENCHMARK_F(BenchmarkSortedVector,testBack)503 BENCHMARK_F(BenchmarkSortedVector, testBack)(benchmark::State& state)
504 {
505 BENCHMARK_LOGD("SortedVector testBack start.");
506 while (state.KeepRunning()) {
507 SortedVector<int> svec;
508 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
509 svec.Add(i);
510 }
511
512 AssertEqual(SVECTOR_END_POS_ASSIGN, svec.Back(),
513 "SVECTOR_END_POS_ASSIGN did not equal svec.Back() as expected.", state);
514 }
515 BENCHMARK_LOGD("SortedVector testBack end.");
516 }
517
BENCHMARK_F(BenchmarkSortedVector,testMirrorItemAt)518 BENCHMARK_F(BenchmarkSortedVector, testMirrorItemAt)(benchmark::State& state)
519 {
520 BENCHMARK_LOGD("SortedVector testMirrorItemAt start.");
521 const ssize_t mirrorStartIndex = -1; // Indicating the start index for mirror item test
522 const ssize_t mirrorEndIndex = -10; // Indicating the end index for mirror item test
523 const ssize_t mirrorOffset = 10; // Indicating the offset for calculating the mirror item
524 while (state.KeepRunning()) {
525 SortedVector<int> svec;
526 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
527 svec.Add(i);
528 }
529
530 for (ssize_t i = mirrorStartIndex; i >= mirrorEndIndex; i--) {
531 AssertEqual((i + mirrorOffset), svec.MirrorItemAt(i),
532 "i + mirrorOffset did not equal svec.MirrorItemAt(i) as expected.", state);
533 }
534
535 for (ssize_t i = SVECTOR_START_POS_ASSIGN; i <= SVECTOR_END_POS_ASSIGN; i++) {
536 AssertEqual(i, svec.MirrorItemAt(i), "i did not equal svec.MirrorItemAt(i) as expected.", state);
537 }
538 }
539 BENCHMARK_LOGD("SortedVector testMirrorItemAt end.");
540 }
541
BENCHMARK_F(BenchmarkSortedVector,testEditItemAt)542 BENCHMARK_F(BenchmarkSortedVector, testEditItemAt)(benchmark::State& state)
543 {
544 BENCHMARK_LOGD("SortedVector testEditItemAt start.");
545 while (state.KeepRunning()) {
546 SortedVector<int> svec;
547 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
548 svec.Add(i);
549 }
550
551 for (ssize_t i = SVECTOR_START_POS_ASSIGN; i <= SVECTOR_END_POS_ASSIGN; i++) {
552 svec.EditItemAt(i) += 1;
553 AssertEqual((i + 1), svec.EditItemAt(i), "i + 1 did not equal svec.EditItemAt(i) as expected.", state);
554 }
555 }
556 BENCHMARK_LOGD("SortedVector testEditItemAt end.");
557 }
558
BENCHMARK_F(BenchmarkSortedVector,testCopyCtorFromVector)559 BENCHMARK_F(BenchmarkSortedVector, testCopyCtorFromVector)(benchmark::State& state)
560 {
561 BENCHMARK_LOGD("SortedVector testCopyCtorFromVector start.");
562 while (state.KeepRunning()) {
563 std::vector<int> vec;
564 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
565 vec.push_back(i);
566 }
567
568 SortedVector<int> svec(vec);
569 for (ssize_t i = SVECTOR_START_POS_ASSIGN; i <= SVECTOR_END_POS_ASSIGN; i++) {
570 AssertEqual(i, svec[i], "i did not equal svec[i] as expected.", state);
571 }
572 }
573 BENCHMARK_LOGD("SortedVector testCopyCtorFromVector end.");
574 }
575
BENCHMARK_F(BenchmarkSortedVector,testConsFromVectorToNotAllowDuplicate)576 BENCHMARK_F(BenchmarkSortedVector, testConsFromVectorToNotAllowDuplicate)(benchmark::State& state)
577 {
578 BENCHMARK_LOGD("SortedVector testConsFromVectorToNotAllowDuplicate start.");
579 static constexpr size_t consFromVectorVectorSize = 30;
580 static constexpr size_t consFromVectorSortedVectorSize = 20;
581 while (state.KeepRunning()) {
582 std::vector<int> vec;
583 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
584 vec.push_back(i);
585 }
586
587 for (int i = 19; i >= 0; i--) {
588 vec.push_back(i);
589 }
590
591 AssertEqual(static_cast<size_t>(consFromVectorVectorSize), vec.size(),
592 "static_cast<size_t>(consFromVectorVectorSize) did not equal vec.size() as expected.", state);
593
594 SortedVector<int, false> svec(vec);
595 AssertEqual(static_cast<size_t>(consFromVectorSortedVectorSize), svec.Size(),
596 "static_cast<size_t>(consFromVectorSortedVectorSize) did not equal svec.Size() as expected.", state);
597 for (ssize_t i = 0; i <= 19; i++) {
598 AssertEqual(i, svec[i], "i did not equal svec[i] as expected.", state);
599 }
600 }
601 BENCHMARK_LOGD("SortedVector testConsFromVectorToNotAllowDuplicate end.");
602 }
603
BENCHMARK_F(BenchmarkSortedVector,testMergevector)604 BENCHMARK_F(BenchmarkSortedVector, testMergevector)(benchmark::State& state)
605 {
606 BENCHMARK_LOGD("SortedVector testMergevector start.");
607 static constexpr int mergeStart = 10; // Represents the starting position for adding elements to std::vector
608 static constexpr int mergeEnd = 20; // Represents the ending position for adding elements to
609 // std::vector and the expected size of SortedVector
610 while (state.KeepRunning()) {
611 SortedVector<int> svec;
612 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
613 svec.Add(i);
614 }
615
616 std::vector<int> vec;
617 for (int i = mergeStart; i < mergeEnd; i++) {
618 vec.push_back(i);
619 }
620
621 svec.Merge(vec);
622
623 for (ssize_t i = 0; i < mergeEnd; i++) {
624 AssertEqual(i, svec[i], "i did not equal svec[i] as expected.", state);
625 }
626 }
627 BENCHMARK_LOGD("SortedVector testMergevector end.");
628 }
629
BENCHMARK_F(BenchmarkSortedVector,testMergevectorNoduplicate)630 BENCHMARK_F(BenchmarkSortedVector, testMergevectorNoduplicate)(benchmark::State& state)
631 {
632 BENCHMARK_LOGD("SortedVector testMergevectorNoduplicate start.");
633 static constexpr int initialMergeStart = 0; // Represents the starting position for
634 // the first range of elements added to std::vector
635 static constexpr int initialMergeEnd = 20; // Represents the ending position for
636 // the first range of elements added to std::vector
637 static constexpr int extendedMergeStart = 10; // Represents the starting position for
638 // the second range of elements added to std::vector
639 static constexpr int extendedMergeEnd = 30; // Represents the ending position for
640 // the second range of elements added to std::vector
641 // and the expected size of SortedVector after merge
642 while (state.KeepRunning()) {
643 SortedVector<int, false> svec;
644 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
645 svec.Add(i);
646 }
647
648 std::vector<int> vec;
649 for (int i = initialMergeStart; i < initialMergeEnd; i++) {
650 vec.push_back(i);
651 }
652
653 for (int i = extendedMergeStart; i < extendedMergeEnd; i++) {
654 vec.push_back(i);
655 }
656
657 svec.Merge(vec);
658
659 AssertEqual(svec.Size(), static_cast<size_t>(extendedMergeEnd),
660 "svec.Size() did not equal static_cast<size_t>(extendedMergeEnd) as expected.", state);
661 for (ssize_t i = initialMergeStart; i < extendedMergeEnd; i++) {
662 AssertEqual(i, svec[i], "i did not equal svec[i] as expected.", state);
663 }
664 }
665 BENCHMARK_LOGD("SortedVector testMergevectorNoduplicate end.");
666 }
667
BENCHMARK_F(BenchmarkSortedVector,testMergesortedvectorNoduplicate)668 BENCHMARK_F(BenchmarkSortedVector, testMergesortedvectorNoduplicate)(benchmark::State& state)
669 {
670 BENCHMARK_LOGD("SortedVector testMergesortedvectorNoduplicate start.");
671 const size_t expectedSizeAfterMerge = 10; // Expected size of the vector after merging
672 // two vectors without duplicates
673 const ssize_t startValueForElements = 0; // Start value of elements to be added to the vector
674 const ssize_t endValueForElements = 9; // End value of elements to be added to the vector
675 while (state.KeepRunning()) {
676 SortedVector<int, false> svec;
677 SortedVector<int, false> svec2;
678 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
679 svec.Add(i);
680 svec2.Add(i);
681 }
682
683 svec.Merge(svec2);
684
685 AssertEqual(static_cast<size_t>(expectedSizeAfterMerge), svec.Size(),
686 "Expected size after merge did not equal svec.Size().", state);
687 // 0,1,2,3,4,5,6,7,8,9
688 for (ssize_t i = startValueForElements; i <= endValueForElements; i++) {
689 AssertEqual(i, svec[i], "Element value did not match expected value.", state);
690 }
691 }
692 BENCHMARK_LOGD("SortedVector testMergesortedvectorNoduplicate end.");
693 }
694
BENCHMARK_F(BenchmarkSortedVector,testMergesortedvector)695 BENCHMARK_F(BenchmarkSortedVector, testMergesortedvector)(benchmark::State& state)
696 {
697 BENCHMARK_LOGD("SortedVector testMergesortedvector start.");
698 static constexpr ssize_t expectedMergedSize = 20; // Represents the expected size of SortedVector after merge
699 static constexpr int duplicateFactor = 2; // Represents the factor of duplication for each element in SortedVector
700 while (state.KeepRunning()) {
701 SortedVector<int> svec;
702 SortedVector<int> svec2;
703 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
704 svec.Add(i);
705 svec2.Add(i);
706 }
707
708 svec.Merge(svec2);
709
710 // 0,0,1,1,2,2,3,3...
711 for (ssize_t i = 0; i < expectedMergedSize; i++) {
712 AssertEqual((i / duplicateFactor), svec[i],
713 "(i / duplicateFactor) did not equal svec[i] as expected.", state);
714 }
715 }
716 BENCHMARK_LOGD("SortedVector testMergesortedvector end.");
717 }
718
BENCHMARK_F(BenchmarkSortedVector,testAddNotAllowDuplicate)719 BENCHMARK_F(BenchmarkSortedVector, testAddNotAllowDuplicate)(benchmark::State& state)
720 {
721 BENCHMARK_LOGD("SortedVector testAddNotAllowDuplicate start.");
722 static constexpr int addNotAllowedSvectorSize = 10;
723 while (state.KeepRunning()) {
724 SortedVector<int, false> svec;
725 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
726 AssertUnequal(svec.Add(i), static_cast<ssize_t>(SVECTOR_INVALID_VALUE),
727 "svec.Add(i) was not different from static_cast<ssize_t>(-1) as expected.", state);
728 }
729 AssertEqual(static_cast<size_t>(addNotAllowedSvectorSize), svec.Size(),
730 "static_cast<size_t>(addNotAllowedSvectorSize) did not equal svec.Size() as expected.", state);
731
732 // duplicate
733 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
734 AssertEqual(svec.Add(i), static_cast<ssize_t>(SVECTOR_INVALID_VALUE),
735 "svec.Add(i) did not equal static_cast<ssize_t>(-1) as expected.", state);
736 AssertEqual(static_cast<size_t>(addNotAllowedSvectorSize), svec.Size(),
737 "static_cast<size_t>(addNotAllowedSvectorSize) did not equal svec.Size() as expected.", state);
738 }
739
740 for (ssize_t i = SVECTOR_START_POS_VALUE; i < SVECTOR_END_POS_VALUE; i++) {
741 AssertEqual(i, svec[i], "i did not equal svec[i] as expected.", state);
742 }
743 }
744 BENCHMARK_LOGD("SortedVector testAddNotAllowDuplicate end.");
745 }
746
BENCHMARK_F(BenchmarkSortedVector,testConsVectorAllowDuplicate)747 BENCHMARK_F(BenchmarkSortedVector, testConsVectorAllowDuplicate)(benchmark::State& state)
748 {
749 BENCHMARK_LOGD("SortedVector testConsVectorAllowDuplicate start.");
750 while (state.KeepRunning()) {
751 SortedVector<int> svec;
752 std::vector<int> vec;
753 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
754 vec.push_back(i);
755 svec.Add(i);
756 }
757
758 SortedVector<int> newSvec(vec);
759 auto it = newSvec.Begin();
760 auto it2 = svec.Begin();
761 for (; (it != newSvec.End()) and (it2 != vec.end()); it2++, it++) {
762 AssertEqual(*it, *it2, "*it did not equal *it2 as expected.", state);
763 }
764 }
765 BENCHMARK_LOGD("SortedVector testConsVectorAllowDuplicate end.");
766 }
767
BENCHMARK_F(BenchmarkSortedVector,testFront)768 BENCHMARK_F(BenchmarkSortedVector, testFront)(benchmark::State& state)
769 {
770 BENCHMARK_LOGD("SortedVector testFront start.");
771 static constexpr int frontSvectorFrontValue = 0;
772 while (state.KeepRunning()) {
773 SortedVector<int> svec;
774 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
775 svec.Add(i);
776 }
777
778 AssertEqual(svec.Front(), frontSvectorFrontValue, "svec.Front() did not equal 0 as expected.", state);
779 }
780 BENCHMARK_LOGD("SortedVector testFront end.");
781 }
782
BENCHMARK_F(BenchmarkSortedVector,testPopBack)783 BENCHMARK_F(BenchmarkSortedVector, testPopBack)(benchmark::State& state)
784 {
785 BENCHMARK_LOGD("SortedVector testPopBack start.");
786 static constexpr int popBackSvectorBackValue = 8;
787 static constexpr size_t popBackSvectorSize = 9;
788 while (state.KeepRunning()) {
789 SortedVector<int> svec;
790 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
791 svec.Add(i);
792 }
793
794 svec.PopBack();
795 AssertEqual(svec.Back(), popBackSvectorBackValue, "svec.Back() did not equal 8 as expected.", state);
796 AssertEqual(svec.Size(), popBackSvectorSize, "svec.Size() did not equal 9 as expected.", state);
797 }
798 BENCHMARK_LOGD("SortedVector testPopBack end.");
799 }
800
BENCHMARK_F(BenchmarkSortedVector,testErase)801 BENCHMARK_F(BenchmarkSortedVector, testErase)(benchmark::State& state)
802 {
803 BENCHMARK_LOGD("SortedVector testErase start.");
804 const size_t erasePosition = 5;
805 const int expectedValueAtErasePosition = 6;
806 const size_t expectedSizeAfterErase = 9;
807 while (state.KeepRunning()) {
808 SortedVector<int> svec;
809 for (int i = SVECTOR_END_POS_ASSIGN; i >= SVECTOR_START_POS_ASSIGN; i--) {
810 svec.Add(i);
811 }
812
813 svec.Erase(erasePosition);
814 AssertEqual(svec[erasePosition], expectedValueAtErasePosition,
815 "svec[erasePosition] did not equal expectedValueAtErasePosition as expected.", state);
816 AssertEqual(svec.Size(), expectedSizeAfterErase,
817 "svec.Size() did not equal expectedSizeAfterErase as expected.", state);
818 }
819 BENCHMARK_LOGD("SortedVector testErase end.");
820 }
821 } // namespace
822 } // namespace OHOS
823 // Run the benchmark
824 BENCHMARK_MAIN();