* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "3d_widget_adapter_test.h"
#include "3d_widget_adapter_log.h"
#include "graphics_manager.h"
namespace OHOS::Render3D {
void WidgetAdapter3DTest::SetUpTestCase()
{}
void WidgetAdapter3DTest::TearDownTestCase()
{}
void WidgetAdapter3DTest::SetUp()
{}
void WidgetAdapter3DTest::TearDown()
{}
bool EngineTest::LoadEngineLib()
{
return true;
}
bool EngineTest::InitEngine(EGLContext eglContext, const PlatformData& data)
{
(void)(eglContext);
(void)(data);
return true;
}
void EngineTest::InitializeScene(uint32_t key)
{
(void)(key);
}
void EngineTest::SetupCameraViewPort(uint32_t width, uint32_t height)
{
(void)(width);
(void)(height);
}
void EngineTest::SetupCameraTransform(
const Position& position, const Vec3& lookAt, const Vec3& up, const Quaternion& rotation)
{
(void)(position);
(void)(lookAt);
(void)(up);
(void)(rotation);
}
void EngineTest::SetupCameraViewProjection(float zNear, float zFar, float fovDegrees)
{
(void)(zNear);
(void)(zFar);
(void)(fovDegrees);
}
void EngineTest::LoadSceneModel(const std::string& modelPath)
{
(void)(modelPath);
}
void EngineTest::LoadEnvModel(const std::string& modelPath, BackgroundType type)
{
(void)(modelPath);
(void)(type);
}
void EngineTest::OnTouchEvent(const PointerEvent& event)
{
(void)(event);
}
void EngineTest::OnWindowChange(const TextureInfo& textureInfo)
{
(void)(textureInfo);
}
void EngineTest::UpdateGeometries(const std::vector<std::shared_ptr<Geometry>>& shapes)
{
(void)(shapes);
}
void EngineTest::UpdateGLTFAnimations(const std::vector<std::shared_ptr<GLTFAnimation>>& animations)
{
(void)(animations);
}
void EngineTest::UpdateLights(const std::vector<std::shared_ptr<Light>>& lights)
{
(void)(lights);
}
void EngineTest::UpdateCustomRender(const std::shared_ptr<CustomRenderDescriptor>& customRender)
{
(void)(customRender);
}
void EngineTest::UpdateShaderPath(const std::string& shaderPath)
{
(void)(shaderPath);
}
void EngineTest::UpdateImageTexturePaths(const std::vector<std::string>& imageTextures)
{
(void)(imageTextures);
}
void EngineTest::UpdateShaderInputBuffer(const std::shared_ptr<ShaderInputBuffer>& shaderInputBuffer)
{
(void)(shaderInputBuffer);
}
bool EngineTest::NeedsRepaint()
{
return true;
}
namespace {
* @tc.name: Initialize1
* @tc.desc: Verify set valid engine
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, Initialize1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
bool ret = adapter.Initialize(std::move(engine));
ASSERT_EQ(ret, true);
}
* @tc.name: Initialize2
* @tc.desc: Verify set null engine
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, Initialize2, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
bool ret = adapter.Initialize(nullptr);
ASSERT_EQ(ret, false);
}
* @tc.name: OnWindowChange1
* @tc.desc: Verify WidgetAdapter WindowChange
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, OnWindowChange1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
TextureInfo texture{};
bool ret = adapter.OnWindowChange(texture);
ASSERT_EQ(ret, true);
}
* @tc.name: SetupCameraTransform1
* @tc.desc: Verify WidgetAdapter setup Camera Transform
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, SetupCameraTransform1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
Position position{};
Vec3 lookAt{};
Vec3 up{};
Quaternion rotation{};
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.SetupCameraTransform(position, lookAt, up, rotation);
ASSERT_EQ(ret, true);
}
* @tc.name: SetupCameraViewProjection1
* @tc.desc: Verify WidgetAdapter setup projection
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, SetupCameraViewProjection1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
float near = 0.0f;
float far = 0.0f;
float degree = 0.0f;
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.SetupCameraViewProjection(near, far, degree);
ASSERT_EQ(ret, true);
}
* @tc.name: SetupCameraViewport1
* @tc.desc: Verify WidgetAdapter setup Viewport
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, SetupCameraViewport1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
uint32_t width = 0;
uint32_t height = 0;
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.SetupCameraViewport(width, height);
ASSERT_EQ(ret, true);
}
* @tc.name: OnTouchEvent1
* @tc.desc: Verify WidgetAdapter handle touch event
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, OnTouchEvent1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
PointerEvent event{};
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.OnTouchEvent(event);
ASSERT_EQ(ret, true);
}
* @tc.name: NeedsRepaint1
* @tc.desc: Verify WidgetAdapter handle Repaint
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, NeedsRepaint1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.NeedsRepaint();
ASSERT_EQ(ret, true);
}
* @tc.name: DrawFrame1
* @tc.desc: Verify WidgetAdapter render frame
* @tc.type: FUNC
* @tc.require: SR000GUI0P
*/
HWTEST_F(WidgetAdapter3DTest, DrawFrame1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.DrawFrame();
ASSERT_EQ(ret, true);
}
* @tc.name: UpdateGeometries1
* @tc.desc: Verify WidgetAdapter Update geometries
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, UpdateGeometries1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.UpdateGeometries({});
ASSERT_EQ(ret, true);
}
* @tc.name: UpdateGLTFAnimations1
* @tc.desc: Verify update gltf animation
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, UpdateGLTFAnimations1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.UpdateGLTFAnimations({});
ASSERT_EQ(ret, true);
}
* @tc.name: UpdateLights1
* @tc.desc: Verify update lights
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, UpdateLights1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.UpdateLights({});
ASSERT_EQ(ret, true);
}
* @tc.name: UpdateCustomRender1
* @tc.desc: Verify update CustomRender
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, UpdateCustomRender1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.UpdateCustomRender(nullptr);
ASSERT_EQ(ret, true);
}
* @tc.name: UpdateShaderPath1
* @tc.desc: Verify update ShaderPath
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, UpdateShaderPath1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
std::string shaderPath = "path";
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.UpdateShaderPath(shaderPath);
ASSERT_EQ(ret, true);
}
* @tc.name: UpdateImageTexturePaths1
* @tc.desc: Verify update ImageTexturePaths
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, UpdateImageTexturePaths1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.UpdateImageTexturePaths({});
ASSERT_EQ(ret, true);
}
* @tc.name: UpdateShaderInputBuffer1
* @tc.desc: Verify update ImageTexturePaths
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, UpdateShaderInputBuffer1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.UpdateShaderInputBuffer(nullptr);
ASSERT_EQ(ret, true);
}
* @tc.name: LoadSceneModel1
* @tc.desc: Verify Load SceneModel
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, LoadSceneModel1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
std::string scene = "scene";
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.LoadSceneModel(scene);
ASSERT_EQ(ret, true);
}
* @tc.name: LoadEnvModel1
* @tc.desc: Verify Load EnvModel
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, LoadEnvModel1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
std::string enviroment = "enviroment";
BackgroundType type{};
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.LoadEnvModel(enviroment, type);
ASSERT_EQ(ret, true);
}
* @tc.name: UnloadSceneModel1
* @tc.desc: Verify UnLoad SceneModel
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, UnloadSceneModel1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.UnloadSceneModel();
ASSERT_EQ(ret, true);
}
* @tc.name: UnloadEnvModel1
* @tc.desc: Verify UnLoad EnvModel
* @tc.type: FUNC
* @tc.require: SR000GUGO2
*/
HWTEST_F(WidgetAdapter3DTest, UnloadEnvModel1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret = adapter.UnloadEnvModel();
ASSERT_EQ(ret, true);
}
* @tc.name: DrawFrame2
* @tc.desc: Verify DrawFrame with firstFrame is false
* @tc.type: FUNC
*/
HWTEST_F(WidgetAdapter3DTest, DrawFrame2, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool ret1 = adapter.DrawFrame();
ASSERT_EQ(ret1, true);
bool ret2 = adapter.DrawFrame();
ASSERT_EQ(ret2, true);
bool ret3 = adapter.DrawFrame();
ASSERT_EQ(ret3, true);
}
* @tc.name: DeInitEngine1
* @tc.desc: Verify DeInitEngine with valid engine
* @tc.type: FUNC
*/
HWTEST_F(WidgetAdapter3DTest, DeInitEngine1, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
auto engine = std::make_unique<EngineTest>();
adapter.Initialize(std::move(engine));
bool beforeDeinit = adapter.SetupCameraViewport(800, 600);
ASSERT_EQ(beforeDeinit, true);
adapter.DeInitEngine();
bool afterDeinit = adapter.SetupCameraViewport(800, 600);
ASSERT_EQ(afterDeinit, false);
}
* @tc.name: DeInitEngine2
* @tc.desc: Verify DeInitEngine with null engine
* @tc.type: FUNC
*/
HWTEST_F(WidgetAdapter3DTest, DeInitEngine2, testing::ext::TestSize.Level1)
{
WidgetAdapter adapter(0U);
adapter.DeInitEngine();
auto engine = std::make_unique<EngineTest>();
bool ret = adapter.Initialize(std::move(engine));
ASSERT_EQ(ret, true);
}
}
}
