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