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 /*
154 * Function: GetLastConsumeTime
155 * Type: Function
156 * Rank: Important(2)
157 * EnvConditions: N/A
158 * CaseDescription: 1. call GetLastConsumeTime
159 * 2. check lastConsumeTime
160 */
161 HWTEST_F(BufferQueueConsumerTest, GetLastConsumeTimeTest, Function | MediumTest | Level2)
162 {
163 int64_t lastConsumeTime = 0;
164 bqc->GetLastConsumeTime(lastConsumeTime);
165 std::cout << "lastConsumeTime = " << lastConsumeTime << std::endl;
166 ASSERT_NE(lastConsumeTime, 0);
167 }
168
169 /*
170 * Function: AttachBuffer001
171 * Type: Function
172 * Rank: Important(2)
173 * EnvConditions: N/A
174 * CaseDescription: 1. check bufferQueue_
175 * 2. call AttachBuffer
176 */
177 HWTEST_F(BufferQueueConsumerTest, AttachBuffer001, Function | MediumTest | Level2)
178 {
179 int32_t timeOut = 0;
180 IBufferProducer::RequestBufferReturnValue retval;
181 sptr<SurfaceBuffer> &buffer = retval.buffer;
182
183 sptr<BufferQueue> bufferqueue = nullptr;
184 auto bqcTmp = new BufferQueueConsumer(bufferqueue);
185
186 GSError ret = bqcTmp->AttachBuffer(buffer, timeOut);
187 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
188 }
189 /* Function: RegisterSurfaceDelegator
190 * Type: Function
191 * Rank: Important(2)
192 * EnvConditions: N/A
193 * CaseDescription: 1. check ret
194 * 2. call RegisterSurfaceDelegator
195 */
196 HWTEST_F(BufferQueueConsumerTest, RegisterSurfaceDelegator001, Function | MediumTest | Level2)
197 {
198 sptr<BufferQueue> bufferqueue = nullptr;
199 auto bqcTmp = new BufferQueueConsumer(bufferqueue);
200
201 sptr<ProducerSurfaceDelegator> surfaceDelegator = ProducerSurfaceDelegator::Create();
202 GSError ret = bqcTmp->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), surface);
203 ASSERT_NE(ret, OHOS::GSERROR_OK);
204 }
205
206 HWTEST_F(BufferQueueConsumerTest, RegisterSurfaceDelegator002, Function | MediumTest | Level2)
207 {
208 sptr<ProducerSurfaceDelegator> surfaceDelegator = ProducerSurfaceDelegator::Create();
209 GSError ret = bqc->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), surface);
210 ASSERT_EQ(ret, OHOS::GSERROR_OK);
211 }
212
213 HWTEST_F(BufferQueueConsumerTest, RegisterSurfaceDelegator003, Function | MediumTest | Level2)
214 {
215 sptr<ProducerSurfaceDelegator> surfaceDelegator = ProducerSurfaceDelegator::Create();
216 GSError ret = bqc->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), nullptr);
217 ASSERT_EQ(ret, OHOS::GSERROR_OK);
218 }
219
220 HWTEST_F(BufferQueueConsumerTest, AddBranchCoverage001, Function | MediumTest | Level2)
221 {
222 sptr<BufferQueue> bufferQueue = nullptr;
223 sptr<BufferQueueConsumer> consumer = new BufferQueueConsumer(bufferQueue);
224
225 sptr<SurfaceBuffer> buffer = nullptr;
226 sptr<SyncFence> fence = nullptr;
227 int64_t timestamp = 0;
228 std::vector<Rect> damages;
229 sptr<IRemoteObject> client = nullptr;
230 sptr<Surface> cSurface = nullptr;
231 sptr<IBufferConsumerListener> listener = nullptr;
232 IBufferConsumerListenerClazz *listenerClass = nullptr;
233 OnReleaseFunc func;
234 OnDeleteBufferFunc deleteFunc;
235 bool isForUniRedraw = false;
236 std::string result;
237 ScalingMode scalingMode;
238 HDRMetaDataType type;
239 std::vector<GraphicHDRMetaData> metaData;
240 GraphicHDRMetadataKey key;
241 std::vector<uint8_t> metaData1;
242 GraphicPresentTimestamp timestamp1;
243 bool isInCache = false;
244 int32_t alpha = -1;
245 int64_t lastFlushedDesiredPresentTimeStamp = -1;
246 bool bufferSupportFastCompose = false;
247 ASSERT_EQ(consumer->AcquireBuffer(buffer, fence, timestamp, damages), OHOS::SURFACE_ERROR_UNKOWN);
248 ASSERT_EQ(consumer->ReleaseBuffer(buffer, fence), OHOS::SURFACE_ERROR_UNKOWN);
249 ASSERT_EQ(consumer->AttachBufferToQueue(buffer), OHOS::SURFACE_ERROR_UNKOWN);
250 ASSERT_EQ(consumer->DetachBufferFromQueue(buffer, false), OHOS::SURFACE_ERROR_UNKOWN);
251 ASSERT_EQ(consumer->AttachBuffer(buffer), OHOS::GSERROR_INVALID_ARGUMENTS);
252 ASSERT_EQ(consumer->DetachBuffer(buffer), OHOS::GSERROR_INVALID_ARGUMENTS);
253 ASSERT_EQ(consumer->RegisterSurfaceDelegator(client, cSurface), OHOS::GSERROR_INVALID_ARGUMENTS);
254 ASSERT_EQ(consumer->QueryIfBufferAvailable(), false);
255 ASSERT_EQ(consumer->RegisterConsumerListener(listener), OHOS::GSERROR_INVALID_ARGUMENTS);
256 ASSERT_EQ(consumer->RegisterConsumerListener(listenerClass), OHOS::GSERROR_INVALID_ARGUMENTS);
257 ASSERT_EQ(consumer->RegisterReleaseListener(func), OHOS::GSERROR_INVALID_ARGUMENTS);
258 ASSERT_EQ(consumer->RegisterDeleteBufferListener(deleteFunc, isForUniRedraw), OHOS::GSERROR_INVALID_ARGUMENTS);
259 ASSERT_EQ(consumer->UnregisterConsumerListener(), OHOS::GSERROR_INVALID_ARGUMENTS);
260 ASSERT_EQ(consumer->SetDefaultWidthAndHeight(0, 0), OHOS::GSERROR_INVALID_ARGUMENTS);
261 ASSERT_EQ(consumer->SetDefaultUsage(0), OHOS::GSERROR_INVALID_ARGUMENTS);
262 consumer->Dump(result);
263 ASSERT_EQ(consumer->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_BUTT);
264 ASSERT_EQ(consumer->GetScalingMode(0, scalingMode), OHOS::GSERROR_INVALID_ARGUMENTS);
265 ASSERT_EQ(consumer->QueryMetaDataType(0, type), OHOS::GSERROR_INVALID_ARGUMENTS);
266 ASSERT_EQ(consumer->GetMetaData(0, metaData), OHOS::GSERROR_INVALID_ARGUMENTS);
267 ASSERT_EQ(consumer->GetMetaDataSet(0, key, metaData1), OHOS::GSERROR_INVALID_ARGUMENTS);
268 ASSERT_EQ(consumer->GetTunnelHandle(), nullptr);
269 ASSERT_EQ(consumer->SetPresentTimestamp(0, timestamp1), OHOS::GSERROR_INVALID_ARGUMENTS);
270 consumer->SetBufferHold(0);
271 ASSERT_EQ(consumer->OnConsumerDied(), OHOS::GSERROR_INVALID_ARGUMENTS);
272 ASSERT_EQ(consumer->GoBackground(), OHOS::GSERROR_INVALID_ARGUMENTS);
273 ASSERT_EQ(consumer->GetHdrWhitePointBrightness(), OHOS::SURFACE_ERROR_UNKOWN);
274 ASSERT_EQ(consumer->GetSdrWhitePointBrightness(), OHOS::SURFACE_ERROR_UNKOWN);
275 ASSERT_EQ(consumer->IsSurfaceBufferInCache(0, isInCache), OHOS::SURFACE_ERROR_UNKOWN);
276 ASSERT_EQ(consumer->GetGlobalAlpha(alpha), OHOS::SURFACE_ERROR_UNKOWN);
277 ASSERT_EQ(consumer->GetLastFlushedDesiredPresentTimeStamp(
278 lastFlushedDesiredPresentTimeStamp), OHOS::SURFACE_ERROR_UNKOWN);
279 ASSERT_EQ(consumer->GetBufferSupportFastCompose(bufferSupportFastCompose), OHOS::SURFACE_ERROR_UNKOWN);
280 }
281 }
282