1 /*
2 * Copyright (c) 2021-2022 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 #include "hashlist_test.h"
16
17 #include <string>
18
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace Developtools {
23 namespace HiPerf {
24 class HashListTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30 const std::size_t size_ {20};
31 };
32
SetUpTestCase(void)33 void HashListTest::SetUpTestCase(void) {}
TearDownTestCase(void)34 void HashListTest::TearDownTestCase(void) {}
SetUp()35 void HashListTest::SetUp() {}
TearDown()36 void HashListTest::TearDown() {}
37
38 HWTEST_F(HashListTest, size, TestSize.Level1)
39 {
40 HashList<std::size_t, std::size_t> hashList {size_};
41 ASSERT_TRUE(hashList.empty());
42 ASSERT_FALSE(hashList.IsFull());
43 ASSERT_EQ(hashList.capacity(), size_);
44 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
45 hashList.push_back(curSize, curSize);
46 EXPECT_EQ(hashList.size(), curSize + 1);
47 }
48 }
49
50 HWTEST_F(HashListTest, empty, TestSize.Level1)
51 {
52 HashList<std::size_t, std::size_t> hashList {size_};
53 EXPECT_TRUE(hashList.empty());
54 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
55 hashList.push_back(curSize, curSize);
56 EXPECT_FALSE(hashList.empty());
57 }
58 }
59
60 HWTEST_F(HashListTest, count, TestSize.Level1)
61 {
62 HashList<std::size_t, std::size_t> hashList {size_};
63 std::size_t temp {125};
64 EXPECT_EQ(hashList.count(temp), 0u);
65 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
66 hashList.push_back(curSize, curSize);
67 EXPECT_EQ(hashList.count(curSize), 1u);
68 }
69 }
70
71 HWTEST_F(HashListTest, begin, TestSize.Level0)
72 {
73 HashList<std::size_t, std::size_t> hashList {size_};
74 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
75 hashList.push_back(curSize, curSize);
76 }
77 for (std::size_t count = 0; count < size_; ++count) {
78 auto first = hashList.begin();
79 EXPECT_EQ(*first, count);
80 hashList.pop_front();
81 }
82 }
83
84 HWTEST_F(HashListTest, cbegin, TestSize.Level2)
85 {
86 HashList<std::size_t, std::size_t> hashList {size_};
87 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
88 hashList.push_back(curSize, curSize);
89 }
90 for (std::size_t count = 0; count < size_; ++count) {
91 const auto first = hashList.cbegin();
92 EXPECT_EQ(*first, count);
93 hashList.pop_front();
94 }
95 }
96
97 HWTEST_F(HashListTest, end, TestSize.Level1)
98 {
99 HashList<std::size_t, std::size_t> hashList {size_};
100 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
101 hashList.push_back(curSize, curSize);
102 }
103 for (std::size_t count = size_ - 1; count > 0; --count) {
104 auto last = hashList.end();
105 last--;
106 EXPECT_EQ(*last, count);
107 hashList.pop_back();
108 }
109 }
110
111 HWTEST_F(HashListTest, cend, TestSize.Level2)
112 {
113 HashList<std::size_t, std::size_t> hashList {size_};
114 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
115 hashList.push_back(curSize, curSize);
116 }
117 for (std::size_t count = size_ - 1; count > 0; --count) {
118 const auto last = hashList.cend();
119 auto temp = last;
120 temp--;
121 EXPECT_EQ(*temp, count);
122 hashList.pop_back();
123 }
124 }
125
126 HWTEST_F(HashListTest, rbegin, TestSize.Level1)
127 {
128 HashList<std::size_t, std::size_t> hashList {size_};
129 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
130 hashList.push_back(curSize, curSize);
131 }
132 for (std::size_t count = size_ - 1; count > 0; --count) {
133 auto last = hashList.rbegin();
134 EXPECT_EQ(*last, count);
135 hashList.pop_back();
136 }
137 }
138
139 HWTEST_F(HashListTest, crbegin, TestSize.Level2)
140 {
141 HashList<std::size_t, std::size_t> hashList {size_};
142 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
143 hashList.push_back(curSize, curSize);
144 }
145 for (std::size_t count = size_ - 1; count > 0; --count) {
146 const auto last = hashList.crbegin();
147 EXPECT_EQ(*last, count);
148 hashList.pop_back();
149 }
150 }
151
152 HWTEST_F(HashListTest, rend, TestSize.Level1)
153 {
154 HashList<std::size_t, std::size_t> hashList {size_};
155 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
156 hashList.push_back(curSize, curSize);
157 }
158 for (std::size_t count = 0; count < size_; ++count) {
159 auto first = hashList.rend();
160 --first;
161 EXPECT_EQ(*first, count);
162 hashList.pop_front();
163 }
164 }
165
166 HWTEST_F(HashListTest, crend, TestSize.Level1)
167 {
168 HashList<std::size_t, std::size_t> hashList {size_};
169 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
170 hashList.push_back(curSize, curSize);
171 }
172 for (std::size_t count = 0; count < size_; ++count) {
173 const auto first = hashList.rend();
174 auto temp = first;
175 --temp;
176 EXPECT_EQ(*temp, count);
177 hashList.pop_front();
178 }
179 }
180
181 HWTEST_F(HashListTest, front, TestSize.Level1)
182 {
183 HashList<std::size_t, std::size_t> hashList {size_};
184 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
185 hashList.push_back(curSize, curSize);
186 }
187 for (std::size_t count = 0; count < size_; ++count) {
188 auto first1 = hashList.front();
189 const auto first2 = hashList.front();
190 EXPECT_EQ(first1, count);
191 EXPECT_EQ(first2, count);
192 hashList.pop_front();
193 }
194 }
195
196 HWTEST_F(HashListTest, back, TestSize.Level2)
197 {
198 HashList<std::size_t, std::size_t> hashList {size_};
199 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
200 hashList.push_back(curSize, curSize);
201 }
202 for (std::size_t count = size_ - 1; count > 0; --count) {
203 auto last1 = hashList.back(true);
204 auto last2 = hashList.front();
205 EXPECT_EQ(last1, count);
206 EXPECT_EQ(last2, count);
207 }
208 }
209
210 HWTEST_F(HashListTest, subscription, TestSize.Level1)
211 {
212 HashList<std::size_t, std::size_t> hashList {size_};
213 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
214 hashList.push_back(curSize, curSize);
215 }
216 for (std::size_t count = 0; count < size_; ++count) {
217 auto val1 = hashList[count];
218 auto val2 = hashList.front();
219 EXPECT_EQ(val1, val2);
220 }
221 }
222
223 HWTEST_F(HashListTest, find, TestSize.Level1)
224 {
225 HashList<std::size_t, std::size_t> hashList {size_};
226 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
227 hashList.push_back(curSize, curSize);
228 }
229 for (std::size_t count = 0; count < (size_ + size_); ++count) {
230 auto itr = hashList.find(count);
231 if (count < size_) {
232 EXPECT_EQ(*itr, count);
233 } else {
234 EXPECT_TRUE(itr == hashList.end());
235 }
236 }
237 }
238
239 HWTEST_F(HashListTest, push_front, TestSize.Level1)
240 {
241 HashList<std::size_t, std::size_t> hashList {size_};
242 constexpr std::size_t size {20};
243 for (std::size_t curSize = 0; curSize < size; ++curSize) {
244 hashList.push_front(curSize, curSize);
245 std::size_t tmp = hashList.front();
246 EXPECT_EQ(tmp, curSize);
247 }
248 }
249
250 HWTEST_F(HashListTest, push_back, TestSize.Level2)
251 {
252 HashList<std::size_t, std::size_t> hashList {size_};
253 constexpr std::size_t size {20};
254 for (std::size_t curSize = 0; curSize < size; ++curSize) {
255 hashList.push_back(curSize, curSize);
256 std::size_t tmp = hashList.back();
257 EXPECT_EQ(tmp, curSize);
258 }
259 }
260
261 HWTEST_F(HashListTest, pop_front, TestSize.Level1)
262 {
263 HashList<std::size_t, std::size_t> hashList {size_};
264 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
265 hashList.push_back(curSize, curSize);
266 }
267 for (std::size_t count = 0; count < size_; ++count) {
268 std::size_t tmp = hashList.front();
269 EXPECT_EQ(tmp, count);
270 EXPECT_EQ(hashList.size(), size_ - count);
271 hashList.pop_front();
272 }
273 EXPECT_TRUE(hashList.empty());
274 }
275
276 HWTEST_F(HashListTest, pop_back, TestSize.Level2)
277 {
278 HashList<std::size_t, std::size_t> hashList {size_};
279 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
280 hashList.push_front(curSize, curSize);
281 }
282 for (std::size_t count = 0; count < size_; ++count) {
283 std::size_t tmp = hashList.back();
284 EXPECT_EQ(tmp, count);
285 EXPECT_EQ(static_cast<std::size_t>(hashList.size()), size_ - count);
286 hashList.pop_back();
287 }
288 EXPECT_TRUE(hashList.empty());
289 }
290
291 HWTEST_F(HashListTest, erase, TestSize.Level1)
292 {
293 HashList<std::size_t, std::size_t> hashList {size_};
294 for (std::size_t curSize = 0; curSize < size_; ++curSize) {
295 hashList.push_back(curSize, curSize);
296 }
297 for (std::size_t count = 0; count < size_; ++count) {
298 std::size_t tmp = hashList.front();
299 EXPECT_EQ(tmp, count);
300 EXPECT_EQ(static_cast<std::size_t>(hashList.size()), size_ - count);
301 hashList.erase(count);
302 }
303 EXPECT_TRUE(hashList.empty());
304 }
305
306 HWTEST_F(HashListTest, clear, TestSize.Level2)
307 {
308 HashList<std::size_t, std::size_t> hashList {size_};
309 constexpr std::size_t size = 20;
310 for (std::size_t curSize = 0; curSize < size; ++curSize) {
311 hashList.push_back(curSize, curSize);
312 std::size_t tmp = hashList.back();
313 EXPECT_EQ(tmp, curSize);
314 }
315 hashList.clear();
316 EXPECT_TRUE(hashList.empty());
317 }
318 } // end of namespace HiPerf
319 } // end of namespace Developtools
320 } // end of namespace OHOS
321