1 /*
2 * Copyright (c) 2020-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
16 #include "gfx_utils/list.h"
17
18 #include <climits>
19 #include <gtest/gtest.h>
20
21 using namespace testing::ext;
22 namespace OHOS {
23 namespace {
24 const uint16_t FIRST_VALUE = 1;
25 const uint16_t SECOND_VALUE = 2;
26 const uint16_t THIRD_VALUE = 3;
27 }
28
29 class ListTest : public testing::Test {
30 public:
ListTest()31 ListTest() : list_(nullptr) {}
~ListTest()32 ~ListTest() {}
SetUpTestCase(void)33 static void SetUpTestCase(void) {}
TearDownTestCase(void)34 static void TearDownTestCase(void) {}
35 void SetUp();
36 void TearDown();
37
38 List<uint16_t>* list_;
39 };
40
SetUp()41 void ListTest::SetUp()
42 {
43 if (list_ == nullptr) {
44 list_ = new List<uint16_t>();
45 }
46 }
47
TearDown()48 void ListTest::TearDown()
49 {
50 if (list_ != nullptr) {
51 delete list_;
52 list_ = nullptr;
53 }
54 }
55 /**
56 * @tc.name: ListFront_001
57 * @tc.desc: Verify Front function, equal.
58 * @tc.type: FUNC
59 * @tc.require: AR000EEMQ9
60 */
61 HWTEST_F(ListTest, ListFront_001, TestSize.Level0)
62 {
63 if (list_ == nullptr) {
64 EXPECT_EQ(1, 0);
65 return;
66 }
67 list_->PushBack(FIRST_VALUE);
68 list_->PushBack(SECOND_VALUE);
69 EXPECT_EQ(list_->Front(), FIRST_VALUE);
70 }
71
72 /**
73 * @tc.name: ListBack_001
74 * @tc.desc: Verify Back function, equal.
75 * @tc.type: FUNC
76 * @tc.require: AR000EEMQ9
77 */
78 HWTEST_F(ListTest, ListBack_001, TestSize.Level0)
79 {
80 if (list_ == nullptr) {
81 EXPECT_EQ(1, 0);
82 return;
83 }
84 list_->PushBack(FIRST_VALUE);
85 list_->PushBack(SECOND_VALUE);
86 EXPECT_EQ(list_->Back(), SECOND_VALUE);
87 }
88
89 /**
90 * @tc.name: ListPushBack_001
91 * @tc.desc: Verify PushBack function, equal.
92 * @tc.type: FUNC
93 * @tc.require: AR000EEMQ9
94 */
95 HWTEST_F(ListTest, ListPushBack_001, TestSize.Level0)
96 {
97 uint16_t size = 0;
98 if (list_ == nullptr) {
99 EXPECT_EQ(1, 0);
100 return;
101 }
102 list_->PushBack(FIRST_VALUE);
103 size++;
104 list_->PushBack(SECOND_VALUE);
105 size++;
106 EXPECT_EQ(list_->Size(), size);
107 EXPECT_EQ(list_->Front(), FIRST_VALUE);
108 EXPECT_EQ(list_->Back(), SECOND_VALUE);
109 }
110
111 /**
112 * @tc.name: ListPushFront_001
113 * @tc.desc: Verify PushFront function, equal.
114 * @tc.type: FUNC
115 * @tc.require: AR000EEMQ9
116 */
117 HWTEST_F(ListTest, ListPushFront_001, TestSize.Level0)
118 {
119 uint16_t size = 0;
120 if (list_ == nullptr) {
121 EXPECT_EQ(1, 0);
122 return;
123 }
124 list_->PushFront(FIRST_VALUE);
125 size++;
126 list_->PushFront(SECOND_VALUE);
127 size++;
128 EXPECT_EQ(list_->Size(), size);
129 EXPECT_EQ(list_->Front(), SECOND_VALUE);
130 EXPECT_EQ(list_->Back(), FIRST_VALUE);
131 }
132
133 /**
134 * @tc.name: ListPopBack_001
135 * @tc.desc: Verify PopBack function, equal.
136 * @tc.type: FUNC
137 * @tc.require: AR000EEMQ9
138 */
139 HWTEST_F(ListTest, ListPopBack_001, TestSize.Level0)
140 {
141 uint16_t size = 0;
142 if (list_ == nullptr) {
143 EXPECT_EQ(1, 0);
144 return;
145 }
146 list_->PushBack(FIRST_VALUE);
147 size++;
148 list_->PushBack(SECOND_VALUE);
149 size++;
150 list_->PopBack();
151 size--;
152 EXPECT_EQ(list_->Size(), size);
153 EXPECT_EQ(list_->Front(), FIRST_VALUE);
154 EXPECT_EQ(list_->Back(), FIRST_VALUE);
155 }
156
157 /**
158 * @tc.name: ListPopFront_001
159 * @tc.desc: Verify PopFront function, equal.
160 * @tc.type: FUNC
161 * @tc.require: AR000EEMQ9
162 */
163 HWTEST_F(ListTest, ListPopFront_001, TestSize.Level0)
164 {
165 uint16_t size = 0;
166 if (list_ == nullptr) {
167 EXPECT_EQ(1, 0);
168 return;
169 }
170 list_->PushBack(FIRST_VALUE);
171 size++;
172 list_->PushBack(SECOND_VALUE);
173 size++;
174 list_->PopFront();
175 size--;
176 EXPECT_EQ(list_->Size(), size);
177 EXPECT_EQ(list_->Front(), SECOND_VALUE);
178 EXPECT_EQ(list_->Back(), SECOND_VALUE);
179 }
180
181 /**
182 * @tc.name: ListInsert_001
183 * @tc.desc: Verify Insert function, equal.
184 * @tc.type: FUNC
185 * @tc.require: AR000EEMQ9
186 */
187 HWTEST_F(ListTest, ListInsert_001, TestSize.Level0)
188 {
189 uint16_t size = 0;
190 if (list_ == nullptr) {
191 EXPECT_EQ(1, 0);
192 return;
193 }
194 list_->PushBack(FIRST_VALUE);
195 size++;
196 list_->PushBack(SECOND_VALUE);
197 size++;
198 ListNode<uint16_t>* node = list_->Tail();
199 list_->Insert(node, THIRD_VALUE);
200 size++;
201 EXPECT_EQ(list_->Size(), size);
202 EXPECT_EQ(list_->Front(), FIRST_VALUE);
203 EXPECT_EQ(list_->Head()->next_->data_, THIRD_VALUE);
204 EXPECT_EQ(list_->Back(), SECOND_VALUE);
205 }
206
207 /**
208 * @tc.name: ListRemove_001
209 * @tc.desc: Verify Remove function, equal.
210 * @tc.type: FUNC
211 * @tc.require: AR000EEMQ9
212 */
213 HWTEST_F(ListTest, ListRemove_001, TestSize.Level0)
214 {
215 uint16_t size = 0;
216 if (list_ == nullptr) {
217 EXPECT_EQ(1, 0);
218 return;
219 }
220 list_->PushBack(FIRST_VALUE);
221 size++;
222 list_->PushBack(SECOND_VALUE);
223 size++;
224 ListNode<uint16_t>* node = list_->Head();
225 auto nextNode = list_->Remove(node);
226 size--;
227 EXPECT_EQ(list_->Size(), size);
228 EXPECT_EQ(nextNode->data_, SECOND_VALUE);
229 EXPECT_EQ(list_->Front(), SECOND_VALUE);
230 EXPECT_EQ(list_->Back(), SECOND_VALUE);
231 }
232
233 /**
234 * @tc.name: ListClear_001
235 * @tc.desc: Verify Clear function, equal.
236 * @tc.type: FUNC
237 * @tc.require: AR000EEMQ9
238 */
239 HWTEST_F(ListTest, ListClear_001, TestSize.Level0)
240 {
241 if (list_ == nullptr) {
242 EXPECT_EQ(1, 0);
243 return;
244 }
245 list_->PushBack(FIRST_VALUE);
246 list_->PushBack(SECOND_VALUE);
247 list_->Clear();
248 EXPECT_EQ(list_->Size(), 0);
249 }
250
251 /**
252 * @tc.name: ListHead_001
253 * @tc.desc: Verify Head function, equal.
254 * @tc.type: FUNC
255 * @tc.require: AR000EEMQ9
256 */
257 HWTEST_F(ListTest, ListHead_001, TestSize.Level0)
258 {
259 if (list_ == nullptr) {
260 EXPECT_EQ(1, 0);
261 return;
262 }
263 list_->PushBack(FIRST_VALUE);
264 list_->PushBack(SECOND_VALUE);
265 EXPECT_EQ(list_->Head()->data_, FIRST_VALUE);
266 }
267
268 /**
269 * @tc.name: ListTail_001
270 * @tc.desc: Verify Tail function, equal.
271 * @tc.type: FUNC
272 * @tc.require: AR000EEMQ9
273 */
274 HWTEST_F(ListTest, ListTail_001, TestSize.Level0)
275 {
276 if (list_ == nullptr) {
277 EXPECT_EQ(1, 0);
278 return;
279 }
280 list_->PushBack(FIRST_VALUE);
281 list_->PushBack(SECOND_VALUE);
282 EXPECT_EQ(list_->Tail()->data_, SECOND_VALUE);
283 }
284
285 /**
286 * @tc.name: ListBegin_001
287 * @tc.desc: Verify Begin function, equal.
288 * @tc.type: FUNC
289 * @tc.require: AR000EEMQ9
290 */
291 HWTEST_F(ListTest, ListBegin_001, TestSize.Level0)
292 {
293 if (list_ == nullptr) {
294 EXPECT_EQ(1, 0);
295 return;
296 }
297 list_->PushBack(FIRST_VALUE);
298 list_->PushBack(SECOND_VALUE);
299 EXPECT_EQ(list_->Begin()->data_, FIRST_VALUE);
300 }
301
302 /**
303 * @tc.name: ListNext_001
304 * @tc.desc: Verify Next function, equal.
305 * @tc.type: FUNC
306 * @tc.require: AR000EEMQ9
307 */
308 HWTEST_F(ListTest, ListNext_001, TestSize.Level0)
309 {
310 if (list_ == nullptr) {
311 EXPECT_EQ(1, 0);
312 return;
313 }
314 list_->PushBack(FIRST_VALUE);
315 list_->PushBack(SECOND_VALUE);
316 EXPECT_EQ(list_->Next(list_->Head())->data_, SECOND_VALUE);
317 }
318
319 /**
320 * @tc.name: ListIsEmpty_001
321 * @tc.desc: Verify IsEmpty function, equal.
322 * @tc.type: FUNC
323 * @tc.require: AR000EEMQ9
324 */
325 HWTEST_F(ListTest, ListIsEmpty_001, TestSize.Level0)
326 {
327 if (list_ == nullptr) {
328 EXPECT_EQ(1, 0);
329 return;
330 }
331 list_->PushBack(FIRST_VALUE);
332 EXPECT_EQ(list_->IsEmpty(), false);
333 list_->Clear();
334 EXPECT_EQ(list_->IsEmpty(), true);
335 }
336
337 /**
338 * @tc.name: ListSize_001
339 * @tc.desc: Verify Size function, equal.
340 * @tc.type: FUNC
341 * @tc.require: AR000EEMQ9
342 */
343 HWTEST_F(ListTest, ListSize_001, TestSize.Level0)
344 {
345 if (list_ == nullptr) {
346 EXPECT_EQ(1, 0);
347 return;
348 }
349 uint16_t size = 0;
350
351 list_->PushBack(FIRST_VALUE);
352 size++;
353 EXPECT_EQ(list_->Size(), size);
354 list_->Clear();
355 EXPECT_EQ(list_->Size(), 0);
356 }
357 } // namespace OHOS
358