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 
16 #include "gtest/gtest.h"
17 
18 #include "platform/queuepool/queue.h"
19 #include "platform/queuepool/queue_pool.h"
20 #include "protocol/retcode_inner/aie_retcode_inner.h"
21 #include "utils/log/aie_log.h"
22 
23 using namespace OHOS::AI;
24 using namespace testing::ext;
25 
26 namespace {
27     const int SINGLE_QUEUE_CAPACITY = 3;
28     const int TEST_QUEUE_SINGLE_ELEMENT = 0;
29 }
30 
31 class QueuepoolTest : public testing::Test {
32 public:
33     // SetUpTestCase:The preset action of the test suite is executed before the first TestCase
SetUpTestCase()34     static void SetUpTestCase() {};
35 
36     // TearDownTestCase:The test suite cleanup action is executed after the last TestCase
TearDownTestCase()37     static void TearDownTestCase() {};
38 
39     // SetUp:Execute before each test case
SetUp()40     void SetUp() {};
41 
42     // TearDown:Execute after each test case
TearDown()43     void TearDown() {};
44 };
45 
46 /**
47  * @tc.name: TestQueuePool001
48  * @tc.desc: Get singleton of queue pool.
49  * @tc.type: FUNC
50  * @tc.require: AR000F77MS
51  */
52 HWTEST_F(QueuepoolTest, TestQueuePool001, TestSize.Level1)
53 {
54     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
55     ASSERT_NE(queuePool, nullptr);
56 
57     QueuePool<int>::ReleaseInstance();
58 }
59 
60 /**
61  * @tc.name: TestQueuePool002
62  * @tc.desc: Pop a queue from queue pool.
63  * @tc.type: FUNC
64  * @tc.require: AR000F77MS
65  */
66 HWTEST_F(QueuepoolTest, TestQueuePool002, TestSize.Level1)
67 {
68     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
69     ASSERT_NE(queuePool, nullptr);
70     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
71     ASSERT_NE(queue, nullptr);
72 
73     QueuePool<int>::ReleaseInstance();
74 }
75 
76 /**
77  * @tc.name: TestQueuePool003
78  * @tc.desc: Get the singleton of queue pool and test the number of busy queues.
79  * @tc.type: FUNC
80  * @tc.require: AR000F77MS
81  */
82 HWTEST_F(QueuepoolTest, TestQueuePool003, TestSize.Level1)
83 {
84     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
85     ASSERT_NE(queuePool, nullptr);
86     auto busyNum = queuePool->BusyQueueNum();
87     ASSERT_EQ(busyNum, 0);
88 
89     QueuePool<int>::ReleaseInstance();
90 }
91 
92 /**
93  * @tc.name: TestQueuePool004
94  * @tc.desc: Test the number of busy queues when pop a queue.
95  * @tc.type: FUNC
96  * @tc.require: AR000F77MS
97  */
98 HWTEST_F(QueuepoolTest, TestQueuePool004, TestSize.Level1)
99 {
100     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
101     ASSERT_NE(queuePool, nullptr);
102     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
103     ASSERT_NE(queue, nullptr);
104     auto busyNum = queuePool->BusyQueueNum();
105     ASSERT_EQ(busyNum, 1);
106 
107     QueuePool<int>::ReleaseInstance();
108 }
109 
110 /**
111  * @tc.name: TestQueuePool005
112  * @tc.desc: Pop a queue first, then push a queue to Test the busy queue number.
113  * @tc.type: FUNC
114  * @tc.require: AR000F77MS
115  */
116 HWTEST_F(QueuepoolTest, TestQueuePool005, TestSize.Level1)
117 {
118     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
119     ASSERT_NE(queuePool, nullptr);
120     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
121     ASSERT_NE(queue, nullptr);
122     queuePool->Push(queue);
123     auto busy = queuePool->BusyQueueNum();
124     ASSERT_EQ(busy, 0);
125 
126     QueuePool<int>::ReleaseInstance();
127 }
128 
129 /**
130  * @tc.name: TestQueuePool006
131  * @tc.desc: Release singleton of queue pool.
132  * @tc.type: FUNC
133  * @tc.require: AR000F77MS
134  */
135 HWTEST_F(QueuepoolTest, TestQueuePool006, TestSize.Level1)
136 {
137     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
138     ASSERT_NE(queuePool, nullptr);
139     QueuePool<int>::ReleaseInstance();
140     if (queuePool == nullptr) {
141         HILOGE("[Test]QueuePool is nullptr.");
142     }
143 }
144 
145 /**
146  * @tc.name: TestQueuePool007
147  * @tc.desc: Test the capacity of queue pool.
148  * @tc.type: FUNC
149  * @tc.require: AR000F77MS
150  */
151 HWTEST_F(QueuepoolTest, TestQueuePool007, TestSize.Level1)
152 {
153     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
154     ASSERT_NE(queuePool, nullptr);
155 
156     std::shared_ptr<Queue<int>> queue;
157     for (auto i = 0; i < MAX_QUEUE_COUNT; ++i) {
158         queue = queuePool->Pop();
159         ASSERT_NE(queue, nullptr);
160     }
161 
162     queue = queuePool->Pop();
163     ASSERT_EQ(queue, nullptr);
164 
165     QueuePool<int>::ReleaseInstance();
166 }
167 
168 /**
169  * @tc.name: TestQueuePool008
170  * @tc.desc: Push a queue to test whether the busy queue is abnormal.
171  * @tc.type: FUNC
172  * @tc.require: AR000F77MS
173  */
174 HWTEST_F(QueuepoolTest, TestQueuePool008, TestSize.Level1)
175 {
176     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
177     ASSERT_NE(queuePool, nullptr);
178 
179     std::shared_ptr<Queue<int>> queue;
180     queuePool->Push(queue);
181     auto busyNum = queuePool->BusyQueueNum();
182     ASSERT_FALSE(busyNum < 0);
183 
184     QueuePool<int>::ReleaseInstance();
185 }
186 
187 /**
188  * @tc.name: TestQueuePool009
189  * @tc.desc: Pop a queue and verify it is empty.
190  * @tc.type: FUNC
191  * @tc.require: AR000F77MS
192  */
193 HWTEST_F(QueuepoolTest, TestQueue001, TestSize.Level1)
194 {
195     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
196     ASSERT_NE(queuePool, nullptr);
197     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
198 
199     bool empty = queue->IsEmpty();
200     ASSERT_TRUE(empty);
201 
202     QueuePool<int>::ReleaseInstance();
203 }
204 
205 /**
206  * @tc.name: TestQueue002
207  * @tc.desc: Push an element and verify it is not empty.
208  * @tc.type: FUNC
209  * @tc.require: AR000F77MS
210  */
211 HWTEST_F(QueuepoolTest, TestQueue002, TestSize.Level1)
212 {
213     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
214     ASSERT_NE(queuePool, nullptr);
215     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
216     ASSERT_NE(queue, nullptr);
217 
218     int iv = TEST_QUEUE_SINGLE_ELEMENT;
219     queue->PushBack(iv);
220     bool notEmpty = !queue->IsEmpty();
221     ASSERT_TRUE(notEmpty);
222 
223     QueuePool<int>::ReleaseInstance();
224 }
225 
226 /**
227  * @tc.name: TestQueue003
228  * @tc.desc: Fill up a queue and test if it is full.
229  * @tc.type: FUNC
230  * @tc.require: AR000F77MS
231  */
232 HWTEST_F(QueuepoolTest, TestQueue003, TestSize.Level1)
233 {
234     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
235     ASSERT_NE(queuePool, nullptr);
236     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
237     ASSERT_NE(queue, nullptr);
238 
239     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
240         queue->PushBack(i);
241     }
242     ASSERT_TRUE(queue->IsFull());
243 
244     QueuePool<int>::ReleaseInstance();
245 }
246 
247 /**
248  * @tc.name: TestQueue004
249  * @tc.desc: Pop a queue and verify it is not full.
250  * @tc.type: FUNC
251  * @tc.require: AR000F77MS
252  */
253 HWTEST_F(QueuepoolTest, TestQueue004, TestSize.Level1)
254 {
255     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
256     ASSERT_NE(queuePool, nullptr);
257     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
258     ASSERT_NE(queue, nullptr);
259     ASSERT_FALSE(queue->IsFull());
260 
261     QueuePool<int>::ReleaseInstance();
262 }
263 
264 /**
265  * @tc.name: TestQueue005
266  * @tc.desc: Push back an element and verify the queue is not full.
267  * @tc.type: FUNC
268  * @tc.require: AR000F77MS
269  */
270 HWTEST_F(QueuepoolTest, TestQueue005, TestSize.Level1)
271 {
272     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
273     ASSERT_NE(queuePool, nullptr);
274     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
275     ASSERT_NE(queue, nullptr);
276 
277     int iv = TEST_QUEUE_SINGLE_ELEMENT;
278     queue->PushBack(iv);
279     ASSERT_FALSE(queue->IsFull());
280 
281     QueuePool<int>::ReleaseInstance();
282 }
283 
284 /**
285  * @tc.name: TestQueue006
286  * @tc.desc: Push back an element into queue.
287  * @tc.type: FUNC
288  * @tc.require: AR000F77MS
289  */
290 HWTEST_F(QueuepoolTest, TestQueue006, TestSize.Level1)
291 {
292     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
293     ASSERT_NE(queuePool, nullptr);
294     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
295     ASSERT_NE(queue, nullptr);
296 
297     int iv = TEST_QUEUE_SINGLE_ELEMENT;
298     int result = queue->PushBack(iv);
299     ASSERT_EQ(result, RETCODE_SUCCESS);
300 
301     QueuePool<int>::ReleaseInstance();
302 }
303 
304 /**
305  * @tc.name: TestQueue007
306  * @tc.desc: Push back elements that exceed the capacity of queue, and verify the queue is full.
307  * @tc.type: FUNC
308  * @tc.require: AR000F77MS
309  */
310 HWTEST_F(QueuepoolTest, TestQueue007, TestSize.Level1)
311 {
312     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
313     ASSERT_NE(queuePool, nullptr);
314     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
315     ASSERT_NE(queue, nullptr);
316 
317     int result;
318     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
319         result = queue->PushBack(i);
320         ASSERT_EQ(result, RETCODE_SUCCESS);
321     }
322 
323     int iv = TEST_QUEUE_SINGLE_ELEMENT;
324     result = queue->PushBack(iv);
325     ASSERT_EQ(result, RETCODE_QUEUE_FULL);
326 
327     QueuePool<int>::ReleaseInstance();
328 }
329 
330 /**
331  * @tc.name: TestQueue008
332  * @tc.desc: Pop Front element of empty queue.
333  * @tc.type: FUNC
334  * @tc.require: AR000F77MS
335  */
336 HWTEST_F(QueuepoolTest, TestQueue008, TestSize.Level1)
337 {
338     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
339     ASSERT_NE(queuePool, nullptr);
340     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
341     ASSERT_NE(queue, nullptr);
342 
343     int iv;
344     int result = queue->PopFront(iv);
345     ASSERT_EQ(result, RETCODE_QUEUE_EMPTY);
346 
347     QueuePool<int>::ReleaseInstance();
348 }
349 
350 /**
351  * @tc.name: TestQueue009
352  * @tc.desc: Push back an element into queue, then pop it and verify its value.
353  * @tc.type: FUNC
354  * @tc.require: AR000F77MS
355  */
356 HWTEST_F(QueuepoolTest, TestQueue009, TestSize.Level1)
357 {
358     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
359     ASSERT_NE(queuePool, nullptr);
360     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
361     ASSERT_NE(queue, nullptr);
362 
363     int iv = TEST_QUEUE_SINGLE_ELEMENT;
364     queue->PushBack(iv);
365     int result = queue->PopFront(iv);
366     ASSERT_EQ(result, RETCODE_SUCCESS);
367     ASSERT_EQ(iv, TEST_QUEUE_SINGLE_ELEMENT);
368 
369     QueuePool<int>::ReleaseInstance();
370 }
371 
372 /**
373  * @tc.name: TestQueue010
374  * @tc.desc: Test the availability of queue under capacity constraints.
375  * @tc.type: FUNC
376  * @tc.require: AR000F77MS
377  */
378 HWTEST_F(QueuepoolTest, TestQueue010, TestSize.Level1)
379 {
380     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
381     ASSERT_NE(queuePool, nullptr);
382     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
383     ASSERT_NE(queue, nullptr);
384 
385     int result;
386     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
387         result = queue->PushBack(i);
388         ASSERT_EQ(result, RETCODE_SUCCESS);
389     }
390 
391     int iv = 0;
392     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
393         result = queue->PopFront(iv);
394         ASSERT_EQ(result, RETCODE_SUCCESS);
395         ASSERT_EQ(iv, i);
396     }
397 
398     QueuePool<int>::ReleaseInstance();
399 }
400 
401 /**
402  * @tc.name: TestQueue011
403  * @tc.desc: Test the count of element in the empty queue.
404  * @tc.type: FUNC
405  * @tc.require: AR000F77MS
406  */
407 HWTEST_F(QueuepoolTest, TestQueue011, TestSize.Level1)
408 {
409     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
410     ASSERT_NE(queuePool, nullptr);
411     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
412     ASSERT_NE(queue, nullptr);
413     int count = queue->Count();
414     ASSERT_EQ(count, 0);
415 
416     QueuePool<int>::ReleaseInstance();
417 }
418 
419 /**
420  * @tc.name: TestQueue012
421  * @tc.desc: Test capacity limit of queue.
422  * @tc.type: FUNC
423  * @tc.require: AR000F77MS
424  */
425 HWTEST_F(QueuepoolTest, TestQueue012, TestSize.Level1)
426 {
427     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
428     ASSERT_NE(queuePool, nullptr);
429     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
430     ASSERT_NE(queue, nullptr);
431 
432     int i;
433     int count;
434 
435     for (i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
436         queue->PushBack(i);
437         count = queue->Count();
438         ASSERT_EQ(count, i + 1);
439     }
440 
441     queue->PushBack(i);
442     count = queue->Count();
443     ASSERT_EQ(count, SINGLE_QUEUE_CAPACITY);
444 
445     QueuePool<int>::ReleaseInstance();
446 }
447 
448 /**
449  * @tc.name: TestQueue013
450  * @tc.desc: Test the count of element in the queue when push back and pop repeatedly.
451  * @tc.type: FUNC
452  * @tc.require: AR000F77MS
453  */
454 HWTEST_F(QueuepoolTest, TestQueue013, TestSize.Level1)
455 {
456     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
457     ASSERT_NE(queuePool, nullptr);
458     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
459     ASSERT_NE(queue, nullptr);
460 
461     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
462         queue->PushBack(i);
463     }
464     int iv;
465     int count;
466 
467     for (int i = 0; i < SINGLE_QUEUE_CAPACITY; ++i) {
468         queue->PopFront(iv);
469         count = queue->Count();
470         ASSERT_EQ(count, SINGLE_QUEUE_CAPACITY - i - 1);
471     }
472 
473     queue->PopFront(iv);
474     count = queue->Count();
475     ASSERT_EQ(count, 0);
476 
477     QueuePool<int>::ReleaseInstance();
478 }
479 
480 /**
481  * @tc.name: TestQueue014
482  * @tc.desc: Pop more than one queue.
483  * @tc.type: FUNC
484  * @tc.require: AR000F77MS
485  */
486 HWTEST_F(QueuepoolTest, TestQueue014, TestSize.Level1)
487 {
488     QueuePool<int> *queuePool = QueuePool<int>::GetInstance(SINGLE_QUEUE_CAPACITY);
489     ASSERT_NE(queuePool, nullptr);
490     std::shared_ptr<Queue<int>> queue = queuePool->Pop();
491     ASSERT_NE(queue, nullptr);
492 
493     queuePool->Push(queue);
494 
495     queue = queuePool->Pop();
496     ASSERT_NE(queue, nullptr);
497 
498     QueuePool<int>::ReleaseInstance();
499 }
500