1 /*
2 * Copyright (c) 2023 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 "gtest/gtest.h"
17 #include "nweb_log.h"
18 #define private public
19 #include "surface_adapter_impl.h"
20 #undef private
21 #include "ohos_adapter_helper.h"
22
23 using testing::ext::TestSize;
24
25 namespace OHOS::NWeb {
26 namespace {
27 const int32_t DEFAULT_WIDTH = 1396;
28 const int32_t DEFAULT_HEIGHT = 1396;
29 }
30 class BufferConsumerListenerTest : public IBufferConsumerListenerAdapter {
31 public:
32 BufferConsumerListenerTest() = default;
33 ~BufferConsumerListenerTest() override = default;
OnBufferAvailable(std::shared_ptr<SurfaceBufferAdapter> buffer)34 void OnBufferAvailable(std::shared_ptr<SurfaceBufferAdapter> buffer) override
35 {
36 WVLOG_I("test buffer is available, the format=%{public}d", buffer->GetFormat());
37 }
38 };
39
40 class SurfaceAdapterImplTest : public testing::Test {
41 protected:
42 void SetUp() override;
43 BufferRequestConfig GetBufferRequestConfig(int32_t myFormat);
44 std::unique_ptr<ConsumerSurfaceAdapterImpl> surfaceAdapter_;
45 std::unique_ptr<IBufferConsumerListenerAdapter> listenerTest_;
46 static inline BufferFlushConfig flushConfig_ = {
47 .damage = {
48 .w = 0x100,
49 .h = 0x100,
50 },
51 };
52 };
53
SetUp()54 void SurfaceAdapterImplTest::SetUp()
55 {
56 surfaceAdapter_ = std::make_unique<ConsumerSurfaceAdapterImpl>();
57 ASSERT_NE(surfaceAdapter_, nullptr);
58 ASSERT_NE(surfaceAdapter_->cSurface_, nullptr);
59 listenerTest_ = std::make_unique<BufferConsumerListenerTest>();
60 EXPECT_NE(listenerTest_, nullptr);
61 }
62
GetBufferRequestConfig(int32_t myFormat)63 BufferRequestConfig SurfaceAdapterImplTest::GetBufferRequestConfig(int32_t myFormat)
64 {
65 BufferRequestConfig requestConfig = {
66 .width = 0x100,
67 .height = 0x100,
68 .strideAlignment = 0x8,
69 .format = myFormat,
70 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
71 .timeout = 0,
72 };
73 return requestConfig;
74 }
75
76 class BufferRequestConfigAdapterMock : public BufferRequestConfigAdapter {
77 public:
78 BufferRequestConfigAdapterMock() = default;
79
80 ~BufferRequestConfigAdapterMock() override = default;
81
GetWidth()82 int32_t GetWidth() override
83 {
84 return DEFAULT_WIDTH;
85 }
86
GetHeight()87 int32_t GetHeight() override
88 {
89 return DEFAULT_HEIGHT;
90 }
91
GetStrideAlignment()92 int32_t GetStrideAlignment() override
93 {
94 return 1;
95 }
96
GetFormat()97 int32_t GetFormat() override
98 {
99 return 1;
100 }
101
GetUsage()102 uint64_t GetUsage() override
103 {
104 return 1;
105 }
106
GetTimeout()107 int32_t GetTimeout() override
108 {
109 return 1;
110 }
111
GetColorGamut()112 ColorGamutAdapter GetColorGamut() override
113 {
114 return ColorGamutAdapter::STANDARD_BT601;
115 }
116
GetTransformType()117 TransformTypeAdapter GetTransformType() override
118 {
119 return TransformTypeAdapter::ROTATE_90;
120 }
121 };
122
123 class BufferFlushConfigAdapterMock : public BufferFlushConfigAdapter {
124 public:
125 BufferFlushConfigAdapterMock() = default;
126
127 ~BufferFlushConfigAdapterMock() override = default;
128
GetX()129 int32_t GetX() override
130 {
131 return 1;
132 }
133
GetY()134 int32_t GetY() override
135 {
136 return 1;
137 }
138
GetW()139 int32_t GetW() override
140 {
141 return DEFAULT_WIDTH;
142 }
143
GetH()144 int32_t GetH() override
145 {
146 return DEFAULT_HEIGHT;
147 }
148
GetTimestamp()149 int64_t GetTimestamp() override
150 {
151 return 1;
152 }
153 };
154
155 /**
156 * @tc.name: InvalidSceneOfSurfaceAdapterImpl.
157 * @tc.desc: test invalid scene of SurfaceAdapterImpl.
158 * @tc.type: FUNC.
159 * @tc.require:
160 */
161 HWTEST_F(SurfaceAdapterImplTest, InvalidSceneOfSurfaceAdapterImpl, TestSize.Level1)
162 {
163 EXPECT_EQ(surfaceAdapter_->RegisterConsumerListener(nullptr), -1);
164 EXPECT_EQ(surfaceAdapter_->ReleaseBuffer(nullptr, 0), -1);
165
166 surfaceAdapter_->cSurface_ = nullptr;
167 EXPECT_EQ(surfaceAdapter_->RegisterConsumerListener(std::move(listenerTest_)), -1);
168 EXPECT_EQ(surfaceAdapter_->ReleaseBuffer(nullptr, 0), -1);
169 EXPECT_EQ(surfaceAdapter_->SetUserData("testkey", "testval"), -1);
170 EXPECT_EQ(surfaceAdapter_->SetQueueSize(0), -1);
171 }
172
173 /**
174 * @tc.name: InvalidSceneOfBufferConsumerListenerImpl.
175 * @tc.desc: test invalid scene of BufferConsumerListenerImpl.
176 * @tc.type: FUNC.
177 * @tc.require:
178 */
179 HWTEST_F(SurfaceAdapterImplTest, InvalidSceneOfBufferConsumerListenerImpl, TestSize.Level1)
180 {
181 auto consumerListener =
182 std::make_unique<BufferConsumerListenerImpl>(surfaceAdapter_->cSurface_, std::move(listenerTest_));
183 ASSERT_NE(consumerListener, nullptr);
184 consumerListener->OnBufferAvailable();
185 consumerListener->listener_ = nullptr;
186 consumerListener->OnBufferAvailable();
187 consumerListener->cSurface_ = nullptr;
188 consumerListener->OnBufferAvailable();
189 }
190
191 /**
192 * @tc.name: InvalidSceneOfSurfaceBufferAdapterImpl.
193 * @tc.desc: test invalid scene of SurfaceBufferAdapterImpl.
194 * @tc.type: FUNC.
195 * @tc.require:
196 */
197 HWTEST_F(SurfaceAdapterImplTest, InvalidSceneOfSurfaceBufferAdapterImpl, TestSize.Level1)
198 {
199 auto bufferAdapter = std::make_unique<SurfaceBufferAdapterImpl>(nullptr);
200 ASSERT_NE(bufferAdapter, nullptr);
201 EXPECT_EQ(bufferAdapter->GetFileDescriptor(), -1);
202 EXPECT_EQ(bufferAdapter->GetWidth(), -1);
203 EXPECT_EQ(bufferAdapter->GetHeight(), -1);
204 EXPECT_EQ(bufferAdapter->GetStride(), -1);
205 EXPECT_EQ(bufferAdapter->GetFormat(), -1);
206 EXPECT_EQ(bufferAdapter->GetSize(), 0);
207 EXPECT_EQ(bufferAdapter->GetVirAddr(), nullptr);
208 }
209
210 /**
211 * @tc.name: HandlesNormalScene.
212 * @tc.desc: test normal scene of SurfaceAdapterImpl.
213 * @tc.type: FUNC.
214 * @tc.require:
215 */
216 HWTEST_F(SurfaceAdapterImplTest, HandlesNormalScene, TestSize.Level1)
217 {
218 EXPECT_EQ(surfaceAdapter_->RegisterConsumerListener(std::move(listenerTest_)), OHOS::GSERROR_OK);
219 EXPECT_EQ(surfaceAdapter_->SetUserData("testkey", "testval"), OHOS::GSERROR_OK);
220 EXPECT_EQ(surfaceAdapter_->SetQueueSize(1), OHOS::GSERROR_OK);
221 auto cSurface = surfaceAdapter_->GetConsumerSurface();
222 auto producer = cSurface->GetProducer();
223 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
224 ASSERT_NE(pSurface, nullptr);
225
226 int32_t fence = -1;
227 std::array formatArray = { GRAPHIC_PIXEL_FMT_RGBA_8888, GRAPHIC_PIXEL_FMT_YCBCR_420_SP };
228 for (auto format : formatArray) {
229 sptr<SurfaceBuffer> buffer;
230 auto requestConfig = GetBufferRequestConfig(format);
231 EXPECT_EQ(pSurface->RequestBuffer(buffer, fence, requestConfig), OHOS::GSERROR_OK);
232 ASSERT_NE(buffer, nullptr);
233 EXPECT_EQ(pSurface->FlushBuffer(buffer, fence, flushConfig_), OHOS::GSERROR_OK);
234
235 auto bufferAdapter = std::make_unique<SurfaceBufferAdapterImpl>(buffer);
236 ASSERT_NE(bufferAdapter, nullptr);
237 EXPECT_GE(bufferAdapter->GetFileDescriptor(), 0);
238 EXPECT_GE(bufferAdapter->GetWidth(), 0);
239 EXPECT_GE(bufferAdapter->GetHeight(), 0);
240 EXPECT_GE(bufferAdapter->GetStride(), 0);
241 EXPECT_GE(bufferAdapter->GetFormat(), 0);
242 EXPECT_GT(bufferAdapter->GetSize(), 0);
243 EXPECT_NE(bufferAdapter->GetVirAddr(), nullptr);
244
245 surfaceAdapter_->ReleaseBuffer(std::move(bufferAdapter), fence);
246 }
247 }
248
249 /**
250 * @tc.name: HandlesNormalScene.
251 * @tc.desc: test normal scene of PixelFormatAdapter.
252 * @tc.type: FUNC.
253 * @tc.require:
254 */
255 HWTEST(PixelFormatAdapterTest, HandlesNormalScene, TestSize.Level1)
256 {
257 EXPECT_NE(PixelFormatAdapter::PIXEL_FMT_RGBA_8888, 0);
258 EXPECT_NE(PixelFormatAdapter::PIXEL_FMT_YCBCR_420_SP, 0);
259 EXPECT_EQ((int)PixelFormatAdapter::PIXEL_FMT_RGBA_8888, (int)GRAPHIC_PIXEL_FMT_RGBA_8888);
260 EXPECT_EQ((int)PixelFormatAdapter::PIXEL_FMT_YCBCR_420_SP, (int)GRAPHIC_PIXEL_FMT_YCBCR_420_SP);
261 }
262
263 /**
264 * @tc.name: ProducerSurfaceAdapterImpl.
265 * @tc.desc: test normal scene of SurfaceAdapterImplTest.
266 * @tc.type: FUNC.
267 * @tc.require:
268 */
269 HWTEST_F(SurfaceAdapterImplTest, ProducerSurfaceAdapterImpl, TestSize.Level1)
270 {
271 int32_t fence = -1;
272 auto surfaceAdapter = std::make_unique<ConsumerSurfaceAdapterImpl>();
273 auto cSurface = surfaceAdapter->GetConsumerSurface();
274 auto producer = cSurface->GetProducer();
275 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
276 ASSERT_NE(pSurface, nullptr);
277 auto adapter = std::make_unique<ProducerSurfaceAdapterImpl>(pSurface);
278 ASSERT_NE(adapter, nullptr);
279 GraphicTransformType type = adapter->TransToTransformType(TransformTypeAdapter::ROTATE_NONE);
280 EXPECT_EQ(type, GraphicTransformType::GRAPHIC_ROTATE_NONE);
281 type = adapter->TransToTransformType(static_cast<TransformTypeAdapter>(-1));
282 EXPECT_EQ(type, GraphicTransformType::GRAPHIC_ROTATE_NONE);
283 GraphicColorGamut gamut = adapter->TransToGraphicColorGamut(ColorGamutAdapter::INVALID);
284 EXPECT_EQ(gamut, GraphicColorGamut::GRAPHIC_COLOR_GAMUT_INVALID);
285 gamut = adapter->TransToGraphicColorGamut(static_cast<ColorGamutAdapter>(-2));
286 EXPECT_EQ(gamut, GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB);
287 BufferRequestConfig config;
288 auto configAdapter = std::make_shared<BufferRequestConfigAdapterMock>();
289 ASSERT_NE(configAdapter, nullptr);
290 auto flushConfigAdapter = std::make_shared<BufferFlushConfigAdapterMock>();
291 ASSERT_NE(flushConfigAdapter, nullptr);
292 adapter->TransToBufferConfig(nullptr, config);
293 adapter->TransToBufferConfig(configAdapter, config);
294 std::shared_ptr<SurfaceBufferAdapter> buffer = adapter->RequestBuffer(fence, configAdapter);
295 ASSERT_NE(buffer, nullptr);
296 buffer = adapter->RequestBuffer(fence, nullptr);
297 ASSERT_EQ(buffer, nullptr);
298 int32_t result = adapter->FlushBuffer(nullptr, 1, flushConfigAdapter);
299 EXPECT_EQ(result, -1);
300 result = adapter->FlushBuffer(buffer, 1, flushConfigAdapter);
301 EXPECT_NE(result, 0);
302 result = adapter->FlushBuffer(buffer, 1, nullptr);
303 EXPECT_EQ(result, -1);
304 adapter->surface_ = nullptr;
305 buffer = adapter->RequestBuffer(fence, configAdapter);
306 EXPECT_EQ(buffer, nullptr);
307 result = adapter->FlushBuffer(buffer, 1, flushConfigAdapter);
308 EXPECT_EQ(result, -1);
309 result = adapter->FlushBuffer(nullptr, 1, flushConfigAdapter);
310 EXPECT_EQ(result, -1);
311 }
312 } // namespace OHOS::NWeb
313