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 <gtest/gtest.h>
16 #include <surface.h>
17 #include <buffer_queue_consumer.h>
18 #include "buffer_consumer_listener.h"
19 #include "buffer_extra_data_impl.h"
20 #include "sync_fence.h"
21 #include "consumer_surface.h"
22 #include "producer_surface_delegator.h"
23 #include "buffer_client_producer.h"
24 
25 using namespace testing;
26 using namespace testing::ext;
27 
28 namespace OHOS::Rosen {
29 class BufferQueueConsumerTest : public testing::Test {
30 public:
31     static void SetUpTestCase();
32     static void TearDownTestCase();
33 
34     static inline BufferRequestConfig requestConfig = {
35         .width = 0x100,
36         .height = 0x100,
37         .strideAlignment = 0x8,
38         .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
39         .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
40         .timeout = 0,
41     };
42 
43     static inline BufferFlushConfigWithDamages flushConfig = {
44         .damages = {
45             {
46                 .w = 0x100,
47                 .h = 0x100,
48             }
49         },
50     };
51     static inline int64_t timestamp = 0;
52     static inline std::vector<Rect> damages = {};
53     static inline sptr<BufferQueue> bq = nullptr;
54     static inline sptr<BufferQueueConsumer> bqc = nullptr;
55     static inline sptr<BufferQueueConsumer> byt = nullptr;
56     static inline sptr<BufferExtraData> bedata = nullptr;
57     static inline sptr<ProducerSurfaceDelegator> surfaceDelegator = nullptr;
58     static inline sptr<IConsumerSurface> csurface = nullptr;
59     static inline sptr<IBufferProducer> bufferProducer = nullptr;
60     static inline sptr<Surface> surface = nullptr;
61 };
62 
SetUpTestCase()63 void BufferQueueConsumerTest::SetUpTestCase()
64 {
65     bq = new BufferQueue("test");
66     bqc = new BufferQueueConsumer(bq);
67     sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
68     bqc->RegisterConsumerListener(listener);
69     bedata = new BufferExtraDataImpl;
70     csurface = IConsumerSurface::Create();
71     surfaceDelegator = ProducerSurfaceDelegator::Create();
72 
73     bufferProducer = csurface->GetProducer();
74     surface = Surface::CreateSurfaceAsProducer(bufferProducer);
75 }
76 
TearDownTestCase()77 void BufferQueueConsumerTest::TearDownTestCase()
78 {
79     bq = nullptr;
80     bqc = nullptr;
81 }
82 
83 /*
84  * Function: AcquireBuffer and ReleaseBuffer
85  * Type: Function
86  * Rank: Important(2)
87  * EnvConditions: N/A
88  * CaseDescription: 1. call RequestBuffer and FlushBuffer
89  *                  2. call AcquireBuffer and ReleaseBuffer
90  *                  3. check ret
91  */
92 HWTEST_F(BufferQueueConsumerTest, AcqRel001, Function | MediumTest | Level2)
93 {
94     IBufferProducer::RequestBufferReturnValue retval;
95     GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
96     ASSERT_EQ(ret, OHOS::GSERROR_OK);
97     ASSERT_GE(retval.sequence, 0);
98     ASSERT_NE(retval.buffer, nullptr);
99 
100     uint8_t *addr1 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
101     ASSERT_NE(addr1, nullptr);
102 
103     sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
104     ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
105     ASSERT_EQ(ret, OHOS::GSERROR_OK);
106 
107     ret = bqc->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
108     ASSERT_EQ(ret, OHOS::GSERROR_OK);
109 
110     sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
111     ret = bqc->ReleaseBuffer(retval.buffer, releaseFence);
112     ASSERT_EQ(ret, OHOS::GSERROR_OK);
113 }
114 
115 /*
116  * Function: AcquireBuffer and ReleaseBuffer
117  * Type: Function
118  * Rank: Important(2)
119  * EnvConditions: N/A
120  * CaseDescription: 1. call RequestBuffer and FlushBuffer
121  * 2. call AcquireBuffer and ReleaseBuffer
122  * 3. call ReleaseBuffer again
123  * 4. check ret
124  */
125 HWTEST_F(BufferQueueConsumerTest, AcqRel002, Function | MediumTest | Level2)
126 {
127     IBufferProducer::RequestBufferReturnValue retval;
128     GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
129     ASSERT_EQ(ret, OHOS::GSERROR_OK);
130     ASSERT_GE(retval.sequence, 0);
131     ASSERT_EQ(retval.buffer, nullptr);
132 
133     sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
134     ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
135     ASSERT_EQ(ret, OHOS::GSERROR_OK);
136 
137     sptr<SurfaceBuffer>& buffer = retval.buffer;
138     ret = bqc->AcquireBuffer(buffer, retval.fence, timestamp, damages);
139     ASSERT_EQ(ret, OHOS::GSERROR_OK);
140 
141     sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
142     ret = bqc->ReleaseBuffer(buffer, releaseFence);
143     ASSERT_EQ(ret, OHOS::GSERROR_OK);
144 
145     ret = bqc->ReleaseBuffer(buffer, releaseFence);
146     ASSERT_NE(ret, OHOS::GSERROR_OK);
147 
148     int32_t timeOut = 1;
149     ret = bqc->AttachBuffer(buffer, timeOut);
150     ASSERT_EQ(ret, OHOS::GSERROR_OK);
151 }
152 /*
153  * Function: AttachBuffer001
154  * Type: Function
155  * Rank: Important(2)
156  * EnvConditions: N/A
157  * CaseDescription: 1. check bufferQueue_
158  *    2. call AttachBuffer
159  */
160 HWTEST_F(BufferQueueConsumerTest, AttachBuffer001, Function | MediumTest | Level2)
161 {
162     int32_t timeOut = 0;
163     IBufferProducer::RequestBufferReturnValue retval;
164     sptr<SurfaceBuffer> &buffer = retval.buffer;
165 
166     sptr<BufferQueue> bufferqueue = nullptr;
167     auto bqcTmp = new BufferQueueConsumer(bufferqueue);
168 
169     GSError ret = bqcTmp->AttachBuffer(buffer, timeOut);
170     ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
171 }
172 /* Function: RegisterSurfaceDelegator
173  * Type: Function
174  * Rank: Important(2)
175  * EnvConditions: N/A
176  * CaseDescription: 1. check ret
177  *    2. call RegisterSurfaceDelegator
178  */
179 HWTEST_F(BufferQueueConsumerTest, RegisterSurfaceDelegator001, Function | MediumTest | Level2)
180 {
181     sptr<BufferQueue> bufferqueue = nullptr;
182     auto bqcTmp = new BufferQueueConsumer(bufferqueue);
183 
184     sptr<ProducerSurfaceDelegator> surfaceDelegator = ProducerSurfaceDelegator::Create();
185     GSError ret = bqcTmp->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), surface);
186     ASSERT_NE(ret, OHOS::GSERROR_OK);
187 }
188 
189 HWTEST_F(BufferQueueConsumerTest, RegisterSurfaceDelegator002, Function | MediumTest | Level2)
190 {
191     sptr<ProducerSurfaceDelegator> surfaceDelegator = ProducerSurfaceDelegator::Create();
192     GSError ret = bqc->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), surface);
193     ASSERT_EQ(ret, OHOS::GSERROR_OK);
194 }
195 
196 HWTEST_F(BufferQueueConsumerTest, RegisterSurfaceDelegator003, Function | MediumTest | Level2)
197 {
198     sptr<ProducerSurfaceDelegator> surfaceDelegator = ProducerSurfaceDelegator::Create();
199     GSError ret = bqc->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), nullptr);
200     ASSERT_EQ(ret, OHOS::GSERROR_OK);
201 }
202 
203 HWTEST_F(BufferQueueConsumerTest, AddBranchCoverage001, Function | MediumTest | Level2)
204 {
205     sptr<BufferQueue> bufferQueue = nullptr;
206     sptr<BufferQueueConsumer> consumer = new BufferQueueConsumer(bufferQueue);
207 
208     sptr<SurfaceBuffer> buffer = nullptr;
209     sptr<SyncFence> fence = nullptr;
210     int64_t timestamp = 0;
211     std::vector<Rect> damages;
212     sptr<IRemoteObject> client = nullptr;
213     sptr<Surface> cSurface = nullptr;
214     sptr<IBufferConsumerListener> listener = nullptr;
215     IBufferConsumerListenerClazz *listenerClass = nullptr;
216     OnReleaseFunc func;
217     OnDeleteBufferFunc deleteFunc;
218     bool isForUniRedraw = false;
219     std::string result;
220     ScalingMode scalingMode;
221     HDRMetaDataType type;
222     std::vector<GraphicHDRMetaData> metaData;
223     GraphicHDRMetadataKey key;
224     std::vector<uint8_t> metaData1;
225     GraphicPresentTimestamp timestamp1;
226     bool isInCache = false;
227     ASSERT_EQ(consumer->AcquireBuffer(buffer, fence, timestamp, damages), OHOS::SURFACE_ERROR_UNKOWN);
228     ASSERT_EQ(consumer->ReleaseBuffer(buffer, fence), OHOS::SURFACE_ERROR_UNKOWN);
229     ASSERT_EQ(consumer->AttachBufferToQueue(buffer), OHOS::SURFACE_ERROR_UNKOWN);
230     ASSERT_EQ(consumer->DetachBufferFromQueue(buffer), OHOS::SURFACE_ERROR_UNKOWN);
231     ASSERT_EQ(consumer->AttachBuffer(buffer), OHOS::GSERROR_INVALID_ARGUMENTS);
232     ASSERT_EQ(consumer->DetachBuffer(buffer), OHOS::GSERROR_INVALID_ARGUMENTS);
233     ASSERT_EQ(consumer->RegisterSurfaceDelegator(client, cSurface), OHOS::GSERROR_INVALID_ARGUMENTS);
234     ASSERT_EQ(consumer->QueryIfBufferAvailable(), false);
235     ASSERT_EQ(consumer->RegisterConsumerListener(listener), OHOS::GSERROR_INVALID_ARGUMENTS);
236     ASSERT_EQ(consumer->RegisterConsumerListener(listenerClass), OHOS::GSERROR_INVALID_ARGUMENTS);
237     ASSERT_EQ(consumer->RegisterReleaseListener(func), OHOS::GSERROR_INVALID_ARGUMENTS);
238     ASSERT_EQ(consumer->RegisterDeleteBufferListener(deleteFunc, isForUniRedraw), OHOS::GSERROR_INVALID_ARGUMENTS);
239     ASSERT_EQ(consumer->UnregisterConsumerListener(), OHOS::GSERROR_INVALID_ARGUMENTS);
240     ASSERT_EQ(consumer->SetDefaultWidthAndHeight(0, 0), OHOS::GSERROR_INVALID_ARGUMENTS);
241     ASSERT_EQ(consumer->SetDefaultUsage(0), OHOS::GSERROR_INVALID_ARGUMENTS);
242     consumer->Dump(result);
243     ASSERT_EQ(consumer->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_BUTT);
244     ASSERT_EQ(consumer->GetScalingMode(0, scalingMode), OHOS::GSERROR_INVALID_ARGUMENTS);
245     ASSERT_EQ(consumer->QueryMetaDataType(0, type), OHOS::GSERROR_INVALID_ARGUMENTS);
246     ASSERT_EQ(consumer->GetMetaData(0, metaData), OHOS::GSERROR_INVALID_ARGUMENTS);
247     ASSERT_EQ(consumer->GetMetaDataSet(0, key, metaData1), OHOS::GSERROR_INVALID_ARGUMENTS);
248     ASSERT_EQ(consumer->GetTunnelHandle(), nullptr);
249     ASSERT_EQ(consumer->SetPresentTimestamp(0, timestamp1), OHOS::GSERROR_INVALID_ARGUMENTS);
250     consumer->SetBufferHold(0);
251     ASSERT_EQ(consumer->OnConsumerDied(), OHOS::GSERROR_INVALID_ARGUMENTS);
252     ASSERT_EQ(consumer->GoBackground(), OHOS::GSERROR_INVALID_ARGUMENTS);
253     ASSERT_EQ(consumer->GetHdrWhitePointBrightness(), OHOS::SURFACE_ERROR_UNKOWN);
254     ASSERT_EQ(consumer->GetSdrWhitePointBrightness(), OHOS::SURFACE_ERROR_UNKOWN);
255     ASSERT_EQ(consumer->IsSurfaceBufferInCache(0, isInCache), OHOS::SURFACE_ERROR_UNKOWN);
256 }
257 }
258