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 <iservice_registry.h>
17 #include <surface.h>
18 #include <buffer_extra_data_impl.h>
19 #include <buffer_queue_producer.h>
20 #include "buffer_consumer_listener.h"
21 #include "sync_fence.h"
22 #include "accesstoken_kit.h"
23 #include "nativetoken_kit.h"
24 #include "token_setproc.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS::Rosen {
30 class BufferQueueProducerRemoteTest : public testing::Test {
31 public:
32 static void SetUpTestCase();
33 static void TearDownTestCase();
34
35 static inline BufferRequestConfig requestConfig = {
36 .width = 0x100,
37 .height = 0x100,
38 .strideAlignment = 0x8,
39 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
40 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
41 .timeout = 0,
42 };
43 static inline BufferFlushConfigWithDamages flushConfig = {
44 .damages = {
45 {
46 .w = 0x100,
47 .h = 0x100,
48 }
49 },
50 };
51 static inline std::vector<uint32_t> deletingBuffers;
52 static inline int64_t timestamp = 0;
53 static inline std::vector<Rect> damages = {};
54 static inline sptr<IBufferProducer> bp = nullptr;
55 static inline sptr<BufferQueue> bq = nullptr;
56 static inline sptr<BufferQueueProducer> bqp = nullptr;
57 static inline sptr<BufferExtraData> bedata = nullptr;
58 };
59
SetUpTestCase()60 void BufferQueueProducerRemoteTest::SetUpTestCase()
61 {
62 bq = new BufferQueue("test");
63 bqp = new BufferQueueProducer(bq);
64 sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
65 bq->RegisterConsumerListener(listener);
66 bp = bqp;
67 bedata = new OHOS::BufferExtraDataImpl;
68 }
69
TearDownTestCase()70 void BufferQueueProducerRemoteTest::TearDownTestCase()
71 {
72 bedata = nullptr;
73 bp = nullptr;
74 bqp = nullptr;
75 bq = nullptr;
76 }
77
78 /*
79 * Function: SetQueueSize and GetQueueSize
80 * Type: Function
81 * Rank: Important(2)
82 * EnvConditions: N/A
83 * CaseDescription: 1. call SetQueueSize
84 * 2. call SetQueueSize again with abnormal input
85 * 3. check ret and call GetQueueSize
86 */
87 HWTEST_F(BufferQueueProducerRemoteTest, QueueSize001, TestSize.Level0)
88 {
89 GSError ret = bp->SetQueueSize(2);
90 ASSERT_EQ(ret, OHOS::GSERROR_OK);
91
92 ret = bp->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1);
93 ASSERT_NE(ret, OHOS::GSERROR_OK);
94
95 ASSERT_EQ(bp->GetQueueSize(), 2u);
96 }
97
98 /*
99 * Function: RequestBuffer, CancelBuffer and AcquireBuffer
100 * Type: Function
101 * Rank: Important(2)
102 * EnvConditions: N/A
103 * CaseDescription: 1. call RequestBuffer
104 * 2. call CancelBuffer
105 * 3. call AcquireBuffer and check ret
106 */
107 HWTEST_F(BufferQueueProducerRemoteTest, ReqCan001, TestSize.Level0)
108 {
109 IBufferProducer::RequestBufferReturnValue retval;
110 GSError ret = bp->RequestBuffer(requestConfig, bedata, retval);
111 ASSERT_EQ(ret, OHOS::GSERROR_OK);
112
113 ret = bp->CancelBuffer(retval.sequence, bedata);
114 ASSERT_EQ(ret, OHOS::GSERROR_OK);
115
116 ret = bq->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
117 ASSERT_NE(ret, OHOS::GSERROR_OK);
118 }
119
120 /*
121 * Function: RequestBuffer, CancelBuffer and AcquireBuffer
122 * Type: Function
123 * Rank: Important(2)
124 * EnvConditions: N/A
125 * CaseDescription: 1. call RequestBuffer
126 * 2. call CancelBuffer
127 * 3. call CancelBuffer again
128 * 4. call AcquireBuffer and check ret
129 */
130 HWTEST_F(BufferQueueProducerRemoteTest, ReqCan002, TestSize.Level0)
131 {
132 IBufferProducer::RequestBufferReturnValue retval;
133 GSError ret = bp->RequestBuffer(requestConfig, bedata, retval);
134 ASSERT_EQ(ret, OHOS::GSERROR_OK);
135
136 ret = bp->CancelBuffer(retval.sequence, bedata);
137 ASSERT_EQ(ret, OHOS::GSERROR_OK);
138
139 ret = bp->CancelBuffer(retval.sequence, bedata);
140 ASSERT_NE(ret, OHOS::GSERROR_OK);
141
142 ret = bq->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
143 ASSERT_NE(ret, OHOS::GSERROR_OK);
144 }
145
146 /*
147 * Function: RequestBuffer, CancelBuffer and AcquireBuffer
148 * Type: Function
149 * Rank: Important(2)
150 * EnvConditions: N/A
151 * CaseDescription: 1. call RequestBuffer and CancelBuffer by different retval
152 * 2. call AcquireBuffer and check ret
153 */
154 HWTEST_F(BufferQueueProducerRemoteTest, ReqCan003, TestSize.Level0)
155 {
156 IBufferProducer::RequestBufferReturnValue retval1;
157 IBufferProducer::RequestBufferReturnValue retval2;
158 IBufferProducer::RequestBufferReturnValue retval3;
159 GSError ret;
160
161 ret = bp->RequestBuffer(requestConfig, bedata, retval1);
162 ASSERT_EQ(ret, OHOS::GSERROR_OK);
163 ASSERT_EQ(retval1.buffer, nullptr);
164
165 ret = bp->RequestBuffer(requestConfig, bedata, retval2);
166 ASSERT_EQ(ret, OHOS::GSERROR_OK);
167 ASSERT_NE(retval2.buffer, nullptr);
168
169 ret = bp->RequestBuffer(requestConfig, bedata, retval3);
170 ASSERT_NE(ret, OHOS::GSERROR_OK);
171 ASSERT_EQ(retval3.buffer, nullptr);
172
173 ret = bp->CancelBuffer(retval1.sequence, bedata);
174 ASSERT_EQ(ret, OHOS::GSERROR_OK);
175
176 ret = bp->CancelBuffer(retval2.sequence, bedata);
177 ASSERT_EQ(ret, OHOS::GSERROR_OK);
178
179 ret = bp->CancelBuffer(retval3.sequence, bedata);
180 ASSERT_NE(ret, OHOS::GSERROR_OK);
181
182 ret = bq->AcquireBuffer(retval1.buffer, retval1.fence, timestamp, damages);
183 ASSERT_NE(ret, OHOS::GSERROR_OK);
184 }
185
186 /*
187 * Function: RequestBuffer, FlushBuffer, AcquireBuffer and ReleaseBuffer
188 * Type: Function
189 * Rank: Important(2)
190 * EnvConditions: N/A
191 * CaseDescription: 1. call RequestBuffer and FlushBuffer
192 * 2. call AcquireBuffer and ReleaseBuffer
193 * 3. call AcquireBuffer again
194 * 4. check ret
195 */
196 HWTEST_F(BufferQueueProducerRemoteTest, ReqFlu001, TestSize.Level0)
197 {
198 IBufferProducer::RequestBufferReturnValue retval;
199 GSError ret = bp->RequestBuffer(requestConfig, bedata, retval);
200 ASSERT_EQ(ret, OHOS::GSERROR_OK);
201
202 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
203 ret = bp->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
204 ASSERT_EQ(ret, OHOS::GSERROR_OK);
205
206 ret = bq->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
207 ASSERT_EQ(ret, OHOS::GSERROR_OK);
208
209 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
210 ret = bq->ReleaseBuffer(retval.buffer, releaseFence);
211 ASSERT_EQ(ret, OHOS::GSERROR_OK);
212
213 ret = bq->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
214 ASSERT_NE(ret, OHOS::GSERROR_OK);
215 }
216
217 /*
218 * Function: RequestBuffer, FlushBuffer, AcquireBuffer and ReleaseBuffer
219 * Type: Function
220 * Rank: Important(2)
221 * EnvConditions: N/A
222 * CaseDescription: 1. call RequestBuffer and FlushBuffer
223 * 2. call FlushBuffer again
224 * 3. call AcquireBuffer and ReleaseBuffer
225 * 4. call AcquireBuffer again
226 * 5. check ret
227 */
228 HWTEST_F(BufferQueueProducerRemoteTest, ReqFlu002, TestSize.Level0)
229 {
230 IBufferProducer::RequestBufferReturnValue retval;
231 GSError ret = bp->RequestBuffer(requestConfig, bedata, retval);
232 ASSERT_EQ(ret, OHOS::GSERROR_OK);
233
234 sptr<SyncFence> acquireFence = SyncFence::INVALID_FENCE;
235 ret = bp->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
236 ASSERT_EQ(ret, OHOS::GSERROR_OK);
237
238 ret = bp->FlushBuffer(retval.sequence, bedata, acquireFence, flushConfig);
239 ASSERT_NE(ret, OHOS::GSERROR_OK);
240
241 ret = bq->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
242 ASSERT_EQ(ret, OHOS::GSERROR_OK);
243
244 sptr<SyncFence> releaseFence = SyncFence::INVALID_FENCE;
245 ret = bq->ReleaseBuffer(retval.buffer, releaseFence);
246 ASSERT_EQ(ret, OHOS::GSERROR_OK);
247
248 ret = bq->AcquireBuffer(retval.buffer, retval.fence, timestamp, damages);
249 ASSERT_NE(ret, OHOS::GSERROR_OK);
250 }
251 }
252