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 "3d_widget_adapter_test.h"
17
18 #include "3d_widget_adapter_log.h"
19 #include "graphics_manager.h"
20
21 namespace OHOS::Render3D {
SetUpTestCase()22 void WidgetAdapter3DTest::SetUpTestCase()
23 {}
24
TearDownTestCase()25 void WidgetAdapter3DTest::TearDownTestCase()
26 {}
27
SetUp()28 void WidgetAdapter3DTest::SetUp()
29 {}
30
TearDown()31 void WidgetAdapter3DTest::TearDown()
32 {}
33
LoadEngineLib()34 bool EngineTest::LoadEngineLib()
35 {
36 return true;
37 }
38
InitEngine(EGLContext eglContext,const PlatformData & data)39 bool EngineTest::InitEngine(EGLContext eglContext, const PlatformData &data)
40 {
41 (void)(eglContext);
42 (void)(data);
43 return true;
44 }
45
InitializeScene(uint32_t key)46 void EngineTest::InitializeScene(uint32_t key)
47 {
48 (void)(key);
49 }
50
SetupCameraViewPort(uint32_t width,uint32_t height)51 void EngineTest::SetupCameraViewPort(uint32_t width, uint32_t height)
52 {
53 (void)(width);
54 (void)(height);
55 }
56
SetupCameraTransform(const Position & position,const Vec3 & lookAt,const Vec3 & up,const Quaternion & rotation)57 void EngineTest::SetupCameraTransform(
58 const Position &position, const Vec3 &lookAt, const Vec3 &up, const Quaternion &rotation)
59 {
60 (void)(position);
61 (void)(lookAt);
62 (void)(up);
63 (void)(rotation);
64 }
65
SetupCameraViewProjection(float zNear,float zFar,float fovDegrees)66 void EngineTest::SetupCameraViewProjection(float zNear, float zFar, float fovDegrees)
67 {
68 (void)(zNear);
69 (void)(zFar);
70 (void)(fovDegrees);
71 }
72
LoadSceneModel(const std::string & modelPath)73 void EngineTest::LoadSceneModel(const std::string &modelPath)
74 {
75 (void)(modelPath);
76 }
77
LoadEnvModel(const std::string & modelPath,BackgroundType type)78 void EngineTest::LoadEnvModel(const std::string &modelPath, BackgroundType type)
79 {
80 (void)(modelPath);
81 (void)(type);
82 }
83
OnTouchEvent(const PointerEvent & event)84 void EngineTest::OnTouchEvent(const PointerEvent &event)
85 {
86 (void)(event);
87 }
88
OnWindowChange(const TextureInfo & textureInfo)89 void EngineTest::OnWindowChange(const TextureInfo &textureInfo)
90 {
91 (void)(textureInfo);
92 }
93
UpdateGeometries(const std::vector<std::shared_ptr<Geometry>> & shapes)94 void EngineTest::UpdateGeometries(const std::vector<std::shared_ptr<Geometry>> &shapes)
95 {
96 (void)(shapes);
97 }
98
UpdateGLTFAnimations(const std::vector<std::shared_ptr<GLTFAnimation>> & animations)99 void EngineTest::UpdateGLTFAnimations(const std::vector<std::shared_ptr<GLTFAnimation>> &animations)
100 {
101 (void)(animations);
102 }
103
UpdateLights(const std::vector<std::shared_ptr<Light>> & lights)104 void EngineTest::UpdateLights(const std::vector<std::shared_ptr<Light>> &lights)
105 {
106 (void)(lights);
107 }
108
UpdateCustomRender(const std::shared_ptr<CustomRenderDescriptor> & customRender)109 void EngineTest::UpdateCustomRender(const std::shared_ptr<CustomRenderDescriptor> &customRender)
110 {
111 (void)(customRender);
112 }
113
UpdateShaderPath(const std::string & shaderPath)114 void EngineTest::UpdateShaderPath(const std::string &shaderPath)
115 {
116 (void)(shaderPath);
117 }
118
UpdateImageTexturePaths(const std::vector<std::string> & imageTextures)119 void EngineTest::UpdateImageTexturePaths(const std::vector<std::string> &imageTextures)
120 {
121 (void)(imageTextures);
122 }
123
UpdateShaderInputBuffer(const std::shared_ptr<ShaderInputBuffer> & shaderInputBuffer)124 void EngineTest::UpdateShaderInputBuffer(const std::shared_ptr<ShaderInputBuffer> &shaderInputBuffer)
125 {
126 (void)(shaderInputBuffer);
127 }
128
NeedsRepaint()129 bool EngineTest::NeedsRepaint()
130 {
131 return true;
132 }
133
134 namespace {
135 /**
136 * @tc.name: Initialize1
137 * @tc.desc: Verify set valid engine
138 * @tc.type: FUNC
139 * @tc.require: SR000GUGO2
140 */
141 HWTEST_F(WidgetAdapter3DTest, Initialize1, testing::ext::TestSize.Level1)
142 {
143 WidgetAdapter adapter(0U);
144
145 auto engine = std::make_unique<EngineTest>();
146 bool ret = adapter.Initialize(std::move(engine));
147 ASSERT_EQ(ret, true);
148 }
149
150 /**
151 * @tc.name: Initialize2
152 * @tc.desc: Verify set null engine
153 * @tc.type: FUNC
154 * @tc.require: SR000GUGO2
155 */
156 HWTEST_F(WidgetAdapter3DTest, Initialize2, testing::ext::TestSize.Level1)
157 {
158 WidgetAdapter adapter(0U);
159
160 bool ret = adapter.Initialize(nullptr);
161 ASSERT_EQ(ret, false);
162 }
163
164 /**
165 * @tc.name: OnWindowChange1
166 * @tc.desc: Verify WidgetAdapter WindowChange
167 * @tc.type: FUNC
168 * @tc.require: SR000GUGO2
169 */
170 HWTEST_F(WidgetAdapter3DTest, OnWindowChange1, testing::ext::TestSize.Level1)
171 {
172 WidgetAdapter adapter(0U);
173
174 auto engine = std::make_unique<EngineTest>();
175 adapter.Initialize(std::move(engine));
176
177 TextureInfo texture{};
178 bool ret = adapter.OnWindowChange(texture);
179 ASSERT_EQ(ret, true);
180 }
181
182 /**
183 * @tc.name: SetupCameraTransform1
184 * @tc.desc: Verify WidgetAdapter setup Camera Transform
185 * @tc.type: FUNC
186 * @tc.require: SR000GUGO2
187 */
188 HWTEST_F(WidgetAdapter3DTest, SetupCameraTransform1, testing::ext::TestSize.Level1)
189 {
190 WidgetAdapter adapter(0U);
191 Position position{};
192 Vec3 lookAt{};
193 Vec3 up{};
194 Quaternion rotation{};
195
196 auto engine = std::make_unique<EngineTest>();
197 adapter.Initialize(std::move(engine));
198
199 bool ret = adapter.SetupCameraTransform(position, lookAt, up, rotation);
200 ASSERT_EQ(ret, true);
201 }
202
203 /**
204 * @tc.name: SetupCameraViewProjection1
205 * @tc.desc: Verify WidgetAdapter setup projection
206 * @tc.type: FUNC
207 * @tc.require: SR000GUGO2
208 */
209 HWTEST_F(WidgetAdapter3DTest, SetupCameraViewProjection1, testing::ext::TestSize.Level1)
210 {
211 WidgetAdapter adapter(0U);
212 float near = 0.0f;
213 float far = 0.0f;
214 float degree = 0.0f;
215
216 auto engine = std::make_unique<EngineTest>();
217 adapter.Initialize(std::move(engine));
218
219 bool ret = adapter.SetupCameraViewProjection(near, far, degree);
220 ASSERT_EQ(ret, true);
221 }
222
223 /**
224 * @tc.name: SetupCameraViewport1
225 * @tc.desc: Verify WidgetAdapter setup Viewport
226 * @tc.type: FUNC
227 * @tc.require: SR000GUGO2
228 */
229 HWTEST_F(WidgetAdapter3DTest, SetupCameraViewport1, testing::ext::TestSize.Level1)
230 {
231 WidgetAdapter adapter(0U);
232 uint32_t width = 0;
233 uint32_t height = 0;
234
235 auto engine = std::make_unique<EngineTest>();
236 adapter.Initialize(std::move(engine));
237
238 bool ret = adapter.SetupCameraViewport(width, height);
239 ASSERT_EQ(ret, true);
240 }
241
242 /**
243 * @tc.name: OnTouchEvent1
244 * @tc.desc: Verify WidgetAdapter handle touch event
245 * @tc.type: FUNC
246 * @tc.require: SR000GUGO2
247 */
248 HWTEST_F(WidgetAdapter3DTest, OnTouchEvent1, testing::ext::TestSize.Level1)
249 {
250 WidgetAdapter adapter(0U);
251 PointerEvent event{};
252
253 auto engine = std::make_unique<EngineTest>();
254 adapter.Initialize(std::move(engine));
255 bool ret = adapter.OnTouchEvent(event);
256 ASSERT_EQ(ret, true);
257 }
258
259 /**
260 * @tc.name: NeedsRepaint1
261 * @tc.desc: Verify WidgetAdapter handle Repaint
262 * @tc.type: FUNC
263 * @tc.require: SR000GUGO2
264 */
265 HWTEST_F(WidgetAdapter3DTest, NeedsRepaint1, testing::ext::TestSize.Level1)
266 {
267 WidgetAdapter adapter(0U);
268
269 auto engine = std::make_unique<EngineTest>();
270 adapter.Initialize(std::move(engine));
271 bool ret = adapter.NeedsRepaint();
272 ASSERT_EQ(ret, true);
273 }
274
275 /**
276 * @tc.name: DrawFrame1
277 * @tc.desc: Verify WidgetAdapter render frame
278 * @tc.type: FUNC
279 * @tc.require: SR000GUI0P
280 */
281 HWTEST_F(WidgetAdapter3DTest, DrawFrame1, testing::ext::TestSize.Level1)
282 {
283 WidgetAdapter adapter(0U);
284
285 auto engine = std::make_unique<EngineTest>();
286 adapter.Initialize(std::move(engine));
287 bool ret = adapter.DrawFrame();
288 ASSERT_EQ(ret, true);
289 }
290
291 /**
292 * @tc.name: UpdateGeometries1
293 * @tc.desc: Verify WidgetAdapter Update geometries
294 * @tc.type: FUNC
295 * @tc.require: SR000GUGO2
296 */
297 HWTEST_F(WidgetAdapter3DTest, UpdateGeometries1, testing::ext::TestSize.Level1)
298 {
299 WidgetAdapter adapter(0U);
300
301 auto engine = std::make_unique<EngineTest>();
302 adapter.Initialize(std::move(engine));
303 bool ret = adapter.UpdateGeometries({});
304 ASSERT_EQ(ret, true);
305 }
306
307 /**
308 * @tc.name: UpdateGLTFAnimations1
309 * @tc.desc: Verify update gltf animation
310 * @tc.type: FUNC
311 * @tc.require: SR000GUGO2
312 */
313 HWTEST_F(WidgetAdapter3DTest, UpdateGLTFAnimations1, testing::ext::TestSize.Level1)
314 {
315 WidgetAdapter adapter(0U);
316
317 auto engine = std::make_unique<EngineTest>();
318 adapter.Initialize(std::move(engine));
319 bool ret = adapter.UpdateGLTFAnimations({});
320 ASSERT_EQ(ret, true);
321 }
322
323 /**
324 * @tc.name: UpdateLights1
325 * @tc.desc: Verify update lights
326 * @tc.type: FUNC
327 * @tc.require: SR000GUGO2
328 */
329 HWTEST_F(WidgetAdapter3DTest, UpdateLights1, testing::ext::TestSize.Level1)
330 {
331 WidgetAdapter adapter(0U);
332
333 auto engine = std::make_unique<EngineTest>();
334 adapter.Initialize(std::move(engine));
335 bool ret = adapter.UpdateLights({});
336 ASSERT_EQ(ret, true);
337 }
338
339 /**
340 * @tc.name: UpdateCustomRender1
341 * @tc.desc: Verify update CustomRender
342 * @tc.type: FUNC
343 * @tc.require: SR000GUGO2
344 */
345 HWTEST_F(WidgetAdapter3DTest, UpdateCustomRender1, testing::ext::TestSize.Level1)
346 {
347 WidgetAdapter adapter(0U);
348
349 auto engine = std::make_unique<EngineTest>();
350 adapter.Initialize(std::move(engine));
351 bool ret = adapter.UpdateCustomRender(nullptr);
352 ASSERT_EQ(ret, true);
353 }
354
355 /**
356 * @tc.name: UpdateShaderPath1
357 * @tc.desc: Verify update ShaderPath
358 * @tc.type: FUNC
359 * @tc.require: SR000GUGO2
360 */
361 HWTEST_F(WidgetAdapter3DTest, UpdateShaderPath1, testing::ext::TestSize.Level1)
362 {
363 WidgetAdapter adapter(0U);
364 std::string shaderPath = "path";
365
366 auto engine = std::make_unique<EngineTest>();
367 adapter.Initialize(std::move(engine));
368 bool ret = adapter.UpdateShaderPath(shaderPath);
369 ASSERT_EQ(ret, true);
370 }
371
372 /**
373 * @tc.name: UpdateImageTexturePaths1
374 * @tc.desc: Verify update ImageTexturePaths
375 * @tc.type: FUNC
376 * @tc.require: SR000GUGO2
377 */
378 HWTEST_F(WidgetAdapter3DTest, UpdateImageTexturePaths1, testing::ext::TestSize.Level1)
379 {
380 WidgetAdapter adapter(0U);
381
382 auto engine = std::make_unique<EngineTest>();
383 adapter.Initialize(std::move(engine));
384 bool ret = adapter.UpdateImageTexturePaths({});
385 ASSERT_EQ(ret, true);
386 }
387
388 /**
389 * @tc.name: UpdateShaderInputBuffer1
390 * @tc.desc: Verify update ImageTexturePaths
391 * @tc.type: FUNC
392 * @tc.require: SR000GUGO2
393 */
394 HWTEST_F(WidgetAdapter3DTest, UpdateShaderInputBuffer1, testing::ext::TestSize.Level1)
395 {
396 WidgetAdapter adapter(0U);
397
398 auto engine = std::make_unique<EngineTest>();
399 adapter.Initialize(std::move(engine));
400 bool ret = adapter.UpdateShaderInputBuffer(nullptr);
401 ASSERT_EQ(ret, true);
402 }
403
404 /**
405 * @tc.name: LoadSceneModel1
406 * @tc.desc: Verify Load SceneModel
407 * @tc.type: FUNC
408 * @tc.require: SR000GUGO2
409 */
410 HWTEST_F(WidgetAdapter3DTest, LoadSceneModel1, testing::ext::TestSize.Level1)
411 {
412 WidgetAdapter adapter(0U);
413 std::string scene = "scene";
414
415 auto engine = std::make_unique<EngineTest>();
416 adapter.Initialize(std::move(engine));
417 bool ret = adapter.LoadSceneModel(scene);
418 ASSERT_EQ(ret, true);
419 }
420
421 /**
422 * @tc.name: LoadEnvModel1
423 * @tc.desc: Verify Load EnvModel
424 * @tc.type: FUNC
425 * @tc.require: SR000GUGO2
426 */
427 HWTEST_F(WidgetAdapter3DTest, LoadEnvModel1, testing::ext::TestSize.Level1)
428 {
429 WidgetAdapter adapter(0U);
430 std::string enviroment = "enviroment";
431 BackgroundType type{};
432
433 auto engine = std::make_unique<EngineTest>();
434 adapter.Initialize(std::move(engine));
435 bool ret = adapter.LoadEnvModel(enviroment, type);
436 ASSERT_EQ(ret, true);
437 }
438
439 /**
440 * @tc.name: UnloadSceneModel1
441 * @tc.desc: Verify UnLoad SceneModel
442 * @tc.type: FUNC
443 * @tc.require: SR000GUGO2
444 */
445 HWTEST_F(WidgetAdapter3DTest, UnloadSceneModel1, testing::ext::TestSize.Level1)
446 {
447 WidgetAdapter adapter(0U);
448
449 auto engine = std::make_unique<EngineTest>();
450 adapter.Initialize(std::move(engine));
451 bool ret = adapter.UnloadSceneModel();
452 ASSERT_EQ(ret, true);
453 }
454
455 /**
456 * @tc.name: UnloadEnvModel1
457 * @tc.desc: Verify UnLoad EnvModel
458 * @tc.type: FUNC
459 * @tc.require: SR000GUGO2
460 */
461 HWTEST_F(WidgetAdapter3DTest, UnloadEnvModel1, testing::ext::TestSize.Level1)
462 {
463 WidgetAdapter adapter(0U);
464
465 auto engine = std::make_unique<EngineTest>();
466 adapter.Initialize(std::move(engine));
467 bool ret = adapter.UnloadEnvModel();
468 ASSERT_EQ(ret, true);
469 }
470 } // namespace
471 } // namespace OHOS::Render3D
472