1 /*
2 * Copyright (c) 2024 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 <buffer_extra_data_impl.h>
17 #include <gtest/gtest.h>
18 #include <message_option.h>
19 #include <message_parcel.h>
20 #include <native_window.h>
21 #include <securec.h>
22 #include <surface.h>
23
24 #include "buffer_queue_producer.h"
25 #include "consumer_surface.h"
26 #include "consumer_surface_delegator.h"
27 #include "sync_fence.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS::Rosen {
33 class ConsumerSurfaceDelegatorTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37
38 static inline sptr<ConsumerSurfaceDelegator> consumerDelegator = nullptr;
39 static inline sptr<BufferExtraData> bedata = nullptr;
40 static inline sptr<SurfaceBuffer> buffer = nullptr;
41 static inline sptr<BufferQueue> bq = nullptr;
42
43 static inline BufferRequestConfig requestConfig = {
44 .width = 0x100,
45 .height = 0x100,
46 .strideAlignment = 0x8,
47 .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
48 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
49 .timeout = 0,
50 };
51 };
52
SetUpTestCase()53 void ConsumerSurfaceDelegatorTest::SetUpTestCase()
54 {
55 consumerDelegator = ConsumerSurfaceDelegator::Create();
56 bedata = new OHOS::BufferExtraDataImpl;
57 buffer = SurfaceBuffer::Create();
58 bq = new BufferQueue("test");
59 }
60
TearDownTestCase()61 void ConsumerSurfaceDelegatorTest::TearDownTestCase()
62 {
63 consumerDelegator = nullptr;
64 bedata = nullptr;
65 buffer = nullptr;
66 bq = nullptr;
67 }
68
69 /*
70 * Function: DequeueBuffer
71 * Type: Function
72 * Rank: Important(2)
73 * EnvConditions: N/A
74 * CaseDescription: 1. call DequeueBuffer
75 * 2. check ret
76 */
77 HWTEST_F(ConsumerSurfaceDelegatorTest, DequeueBuffer001, TestSize.Level0)
78 {
79 IBufferProducer::RequestBufferReturnValue retval;
80 GSError ret = consumerDelegator->DequeueBuffer(requestConfig, bedata, retval);
81 ASSERT_EQ(ret, GSERROR_OK);
82 }
83
84
85 /*
86 * Function: QueueBuffer
87 * Type: Function
88 * Rank: Important(2)
89 * EnvConditions: N/A
90 * CaseDescription: 1. call QueueBuffer
91 * 2. check ret
92 */
93 HWTEST_F(ConsumerSurfaceDelegatorTest, QueueBuffer001, TestSize.Level0)
94 {
95 int32_t fenceFd = 3;
96 GSError ret = consumerDelegator->QueueBuffer(buffer, fenceFd);
97 ASSERT_EQ(ret, GSERROR_OK);
98 }
99
100 /*
101 * Function: ReleaseBuffer
102 * Type: Function
103 * Rank: Important(2)
104 * EnvConditions: N/A
105 * CaseDescription: 1. call ReleaseBuffer
106 * 2. check ret
107 */
108 HWTEST_F(ConsumerSurfaceDelegatorTest, ReleaseBuffer001, TestSize.Level0)
109 {
110 int slot = 0;
111 int32_t releaseFenceFd = 3;
112 GSError ret = consumerDelegator->ReleaseBuffer(slot, releaseFenceFd);
113 ASSERT_EQ(ret, GSERROR_OK);
114 }
115
116 /*
117 * Function: CancelBuffer
118 * Type: Function
119 * Rank: Important(2)
120 * EnvConditions: N/A
121 * CaseDescription: 1. call CancelBuffer
122 * 2. check ret
123 */
124 HWTEST_F(ConsumerSurfaceDelegatorTest, CancelBuffer001, TestSize.Level0)
125 {
126 int32_t slot = 0;
127 int32_t fenceFd = -1;
128 GSError ret = consumerDelegator->CancelBuffer(slot, fenceFd);
129 ASSERT_EQ(ret, GSERROR_OK);
130 }
131
132 /*
133 * Function: AsyncDequeueBuffer
134 * Type: Function
135 * Rank: Important(2)
136 * EnvConditions: N/A
137 * CaseDescription: 1. call AsyncDequeueBuffer
138 * 2. check ret
139 */
140 HWTEST_F(ConsumerSurfaceDelegatorTest, AsyncDequeueBuffer001, TestSize.Level0)
141 {
142 IBufferProducer::RequestBufferReturnValue retval;
143 GSError ret = consumerDelegator->AsyncDequeueBuffer(requestConfig, bedata, retval);
144 ASSERT_EQ(ret, GSERROR_OK);
145 }
146
147 /*
148 * Function: AsyncQueueBuffer
149 * Type: Function
150 * Rank: Important(2)
151 * EnvConditions: N/A
152 * CaseDescription: 1. call AsyncQueueBuffer
153 * 2. check ret
154 */
155 HWTEST_F(ConsumerSurfaceDelegatorTest, AsyncQueueBuffer001, TestSize.Level0)
156 {
157 int32_t fenceFd = 3;
158 GSError ret = consumerDelegator->AsyncQueueBuffer(buffer, fenceFd);
159 ASSERT_EQ(ret, GSERROR_OK);
160 }
161
162 /*
163 * Function: GetAncoAsyncFlag
164 * Type: Function
165 * Rank: Important(2)
166 * EnvConditions: N/A
167 * CaseDescription: 1. call GetAncoAsyncFlag
168 * 2. check ret
169 */
170 HWTEST_F(ConsumerSurfaceDelegatorTest, GetAncoAsyncFlag001, TestSize.Level0)
171 {
172 int ret = consumerDelegator->GetAncoAsyncFlag();
173 ASSERT_EQ(ret, ERR_NONE);
174 }
175
176 /*
177 * Function: DetachBuffer
178 * Type: Function
179 * Rank: Important(2)
180 * EnvConditions: N/A
181 * CaseDescription: 1. call DetachBuffer
182 * 2. check ret
183 */
184 HWTEST_F(ConsumerSurfaceDelegatorTest, DetachBuffer001, TestSize.Level0)
185 {
186 GSError ret = consumerDelegator->DetachBuffer(buffer);
187 ASSERT_EQ(ret, GSERROR_OK);
188 }
189
190 /*
191 * Function: SetBufferQueue
192 * Type: Function
193 * Rank: Important(2)
194 * EnvConditions: N/A
195 * CaseDescription: 1. call SetBufferQueue
196 * 2. check ret
197 */
198 HWTEST_F(ConsumerSurfaceDelegatorTest, SetBufferQueue001, TestSize.Level0)
199 {
200 bool ret = consumerDelegator->SetBufferQueue(bq);
201 ASSERT_EQ(ret, true);
202 }
203
204 /*
205 * Function: OnRemoteRequest
206 * Type: Function
207 * Rank: Important(2)
208 * EnvConditions: N/A
209 * CaseDescription: 1. call OnRemoteRequest
210 * 2. check ret
211 */
212 HWTEST_F(ConsumerSurfaceDelegatorTest, OnRemoteRequest001, TestSize.Level0)
213 {
214 uint32_t code = 1; // QUEUEBUFFER
215 MessageParcel reply;
216 MessageOption option;
217 MessageParcel dataQueue;
218 dataQueue.WriteInt32(10);
219 int ret = consumerDelegator->OnRemoteRequest(code, dataQueue, reply, option);
220 ASSERT_EQ(ret, ERR_NONE);
221 }
222
223 /*
224 * Function: GetSurfaceBuffer
225 * Type: Function
226 * Rank: Important(2)
227 * EnvConditions: N/A
228 * CaseDescription: 1. call GetSurfaceBuffer
229 * 2. check ret
230 */
231 HWTEST_F(ConsumerSurfaceDelegatorTest, GetSurfaceBuffer001, TestSize.Level0)
232 {
233 GSError ret = consumerDelegator->GetSurfaceBuffer(nullptr, buffer);
234 ASSERT_EQ(ret, GSERROR_OK);
235 }
236 }
237