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 HWTEST_F(BufferQueueConsumerTest, AddBranchCoverage001, Function | MediumTest | Level2)
84 {
85 sptr<BufferQueue> bufferQueue = nullptr;
86 sptr<BufferQueueConsumer> consumer = new BufferQueueConsumer(bufferQueue);
87
88 sptr<SurfaceBuffer> buffer = nullptr;
89 sptr<SyncFence> fence = nullptr;
90 int64_t timestamp = 0;
91 std::vector<Rect> damages;
92 sptr<IRemoteObject> client = nullptr;
93 sptr<Surface> cSurface = nullptr;
94 sptr<IBufferConsumerListener> listener = nullptr;
95 IBufferConsumerListenerClazz *listenerClass = nullptr;
96 OnReleaseFunc func;
97 OnDeleteBufferFunc deleteFunc;
98 bool isForUniRedraw = false;
99 std::string result;
100 ScalingMode scalingMode;
101 HDRMetaDataType type;
102 std::vector<GraphicHDRMetaData> metaData;
103 GraphicHDRMetadataKey key;
104 std::vector<uint8_t> metaData1;
105 GraphicPresentTimestamp timestamp1;
106 bool isInCache = false;
107 int32_t alpha = -1;
108 ASSERT_EQ(consumer->AcquireBuffer(buffer, fence, timestamp, damages), OHOS::SURFACE_ERROR_UNKOWN);
109 ASSERT_EQ(consumer->ReleaseBuffer(buffer, fence), OHOS::SURFACE_ERROR_UNKOWN);
110 ASSERT_EQ(consumer->AttachBufferToQueue(buffer), OHOS::SURFACE_ERROR_UNKOWN);
111 ASSERT_EQ(consumer->DetachBufferFromQueue(buffer), OHOS::SURFACE_ERROR_UNKOWN);
112 ASSERT_EQ(consumer->AttachBuffer(buffer), OHOS::GSERROR_INVALID_ARGUMENTS);
113 ASSERT_EQ(consumer->DetachBuffer(buffer), OHOS::GSERROR_INVALID_ARGUMENTS);
114 ASSERT_EQ(consumer->RegisterSurfaceDelegator(client, cSurface), OHOS::GSERROR_INVALID_ARGUMENTS);
115 ASSERT_EQ(consumer->QueryIfBufferAvailable(), false);
116 ASSERT_EQ(consumer->RegisterConsumerListener(listener), OHOS::GSERROR_INVALID_ARGUMENTS);
117 ASSERT_EQ(consumer->RegisterConsumerListener(listenerClass), OHOS::GSERROR_INVALID_ARGUMENTS);
118 ASSERT_EQ(consumer->RegisterReleaseListener(func), OHOS::GSERROR_INVALID_ARGUMENTS);
119 ASSERT_EQ(consumer->RegisterDeleteBufferListener(deleteFunc, isForUniRedraw), OHOS::GSERROR_INVALID_ARGUMENTS);
120 ASSERT_EQ(consumer->UnregisterConsumerListener(), OHOS::GSERROR_INVALID_ARGUMENTS);
121 ASSERT_EQ(consumer->SetDefaultWidthAndHeight(0, 0), OHOS::GSERROR_INVALID_ARGUMENTS);
122 ASSERT_EQ(consumer->SetDefaultUsage(0), OHOS::GSERROR_INVALID_ARGUMENTS);
123 consumer->Dump(result);
124 ASSERT_EQ(consumer->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_BUTT);
125 ASSERT_EQ(consumer->GetScalingMode(0, scalingMode), OHOS::GSERROR_INVALID_ARGUMENTS);
126 ASSERT_EQ(consumer->QueryMetaDataType(0, type), OHOS::GSERROR_INVALID_ARGUMENTS);
127 ASSERT_EQ(consumer->GetMetaData(0, metaData), OHOS::GSERROR_INVALID_ARGUMENTS);
128 ASSERT_EQ(consumer->GetMetaDataSet(0, key, metaData1), OHOS::GSERROR_INVALID_ARGUMENTS);
129 ASSERT_EQ(consumer->GetTunnelHandle(), nullptr);
130 ASSERT_EQ(consumer->SetPresentTimestamp(0, timestamp1), OHOS::GSERROR_INVALID_ARGUMENTS);
131 consumer->SetBufferHold(0);
132 ASSERT_EQ(consumer->OnConsumerDied(), OHOS::GSERROR_INVALID_ARGUMENTS);
133 ASSERT_EQ(consumer->GoBackground(), OHOS::GSERROR_INVALID_ARGUMENTS);
134 ASSERT_EQ(consumer->GetHdrWhitePointBrightness(), OHOS::SURFACE_ERROR_UNKOWN);
135 ASSERT_EQ(consumer->GetSdrWhitePointBrightness(), OHOS::SURFACE_ERROR_UNKOWN);
136 ASSERT_EQ(consumer->IsSurfaceBufferInCache(0, isInCache), OHOS::SURFACE_ERROR_UNKOWN);
137 ASSERT_EQ(consumer->GetGlobalAlpha(alpha), OHOS::SURFACE_ERROR_UNKOWN);
138 }
139
140 /*
141 * Function: AcquireBuffer and ReleaseBuffer
142 * Type: Function
143 * Rank: Important(2)
144 * EnvConditions: N/A
145 * CaseDescription: 1. call RequestBuffer and FlushBuffer
146 * 2. call AcquireBuffer and ReleaseBuffer
147 * 3. call ReleaseBuffer again
148 * 4. check ret
149 */
150 HWTEST_F(BufferQueueConsumerTest, AcqRel002, Function | MediumTest | Level2)
151 {
152 IBufferProducer::RequestBufferReturnValue retval;
153 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
154 ASSERT_EQ(ret, OHOS::GSERROR_OK);
155 ASSERT_GE(retval.sequence, 0);
156 ASSERT_EQ(retval.buffer, nullptr);
157
158 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
159 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
160 ASSERT_EQ(ret, OHOS::GSERROR_OK);
161
162 sptr<SurfaceBuffer>& buffer = retval.buffer;
163 ret = bqc->AcquireBuffer(buffer, retval.fence, timestamp, damages);
164 ASSERT_EQ(ret, OHOS::GSERROR_OK);
165
166 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
167 ret = bqc->ReleaseBuffer(buffer, releaseFence);
168 ASSERT_EQ(ret, OHOS::GSERROR_OK);
169
170 ret = bqc->ReleaseBuffer(buffer, releaseFence);
171 ASSERT_NE(ret, OHOS::GSERROR_OK);
172
173 int32_t timeOut = 1;
174 ret = bqc->AttachBuffer(buffer, timeOut);
175 ASSERT_EQ(ret, OHOS::GSERROR_OK);
176 }
177
178 HWTEST_F(BufferQueueConsumerTest, RegisterSurfaceDelegator003, Function | MediumTest | Level2)
179 {
180 sptr<ProducerSurfaceDelegator> surfaceDelegator = ProducerSurfaceDelegator::Create();
181 GSError ret = bqc->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), nullptr);
182 ASSERT_EQ(ret, OHOS::GSERROR_OK);
183 }
184
185 /* Function: RegisterSurfaceDelegator
186 * Type: Function
187 * Rank: Important(2)
188 * EnvConditions: N/A
189 * CaseDescription: 1. check ret
190 * 2. call RegisterSurfaceDelegator
191 */
192 HWTEST_F(BufferQueueConsumerTest, RegisterSurfaceDelegator001, Function | MediumTest | Level2)
193 {
194 sptr<BufferQueue> bufferqueue = nullptr;
195 auto bqcTmp = new BufferQueueConsumer(bufferqueue);
196
197 sptr<ProducerSurfaceDelegator> surfaceDelegator = ProducerSurfaceDelegator::Create();
198 GSError ret = bqcTmp->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), surface);
199 ASSERT_NE(ret, OHOS::GSERROR_OK);
200 }
201
202 /*
203 * Function: AttachBuffer001
204 * Type: Function
205 * Rank: Important(2)
206 * EnvConditions: N/A
207 * CaseDescription: 1. check bufferQueue_
208 * 2. call AttachBuffer
209 */
210 HWTEST_F(BufferQueueConsumerTest, AttachBuffer001, Function | MediumTest | Level2)
211 {
212 int32_t timeOut = 0;
213 IBufferProducer::RequestBufferReturnValue retval;
214 sptr<SurfaceBuffer> &buffer = retval.buffer;
215
216 sptr<BufferQueue> bufferqueue = nullptr;
217 auto bqcTmp = new BufferQueueConsumer(bufferqueue);
218
219 GSError ret = bqcTmp->AttachBuffer(buffer, timeOut);
220 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
221 }
222
223 HWTEST_F(BufferQueueConsumerTest, RegisterSurfaceDelegator002, Function | MediumTest | Level2)
224 {
225 sptr<ProducerSurfaceDelegator> surfaceDelegator = ProducerSurfaceDelegator::Create();
226 GSError ret = bqc->RegisterSurfaceDelegator(surfaceDelegator->AsObject(), surface);
227 ASSERT_EQ(ret, OHOS::GSERROR_OK);
228 }
229
230 /*
231 * Function: AcquireBuffer and ReleaseBuffer
232 * Type: Function
233 * Rank: Important(2)
234 * EnvConditions: N/A
235 * CaseDescription: 1. call RequestBuffer and FlushBuffer
236 * 2. call AcquireBuffer and ReleaseBuffer
237 * 3. check ret
238 */
239 HWTEST_F(BufferQueueConsumerTest, AcqRel001, Function | MediumTest | Level2)
240 {
241 IBufferProducer::RequestBufferReturnValue retval;
242 GSError ret = bq->RequestBuffer(requestConfig, bedata, retval);
243 ASSERT_EQ(ret, OHOS::GSERROR_OK);
244 ASSERT_GE(retval.sequence, 0);
245 ASSERT_NE(retval.buffer, nullptr);
246
247 uint8_t *addr1 = reinterpret_cast<uint8_t*>(retval.buffer->GetVirAddr());
248 ASSERT_NE(addr1, nullptr);
249
250 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
251 ret = bq->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
252 ASSERT_EQ(ret, OHOS::GSERROR_OK);
253
254 ret = bqc->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
255 ASSERT_EQ(ret, OHOS::GSERROR_OK);
256
257 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
258 ret = bqc->ReleaseBuffer(retval.buffer, releaseFence);
259 ASSERT_EQ(ret, OHOS::GSERROR_OK);
260 }
261 }
262