From 6ab22d9a6bd6112906ceac5a53676a2f2af3aad1 Mon Sep 17 00:00:00 2001 From: wangchaole Date: Fri, 30 Dec 2022 15:37:51 +0800 Subject: [PATCH] fix: add unit test Signed-off-by: wangchaole --- .../unittest/common/camera_source/BUILD.gn | 1 + .../callback/dcamera_source_callback_test.cpp | 161 ++++++++++++ .../common/distributedcameramgr/BUILD.gn | 1 + ...camera_source_config_stream_state_test.cpp | 245 ++++++++++++++++++ .../dcamera_stream_data_process_test.cpp | 2 + 5 files changed, 410 insertions(+) create mode 100644 interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp create mode 100644 services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_config_stream_state_test.cpp diff --git a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/BUILD.gn b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/BUILD.gn index e60b6fcb..a152f830 100644 --- a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/BUILD.gn +++ b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/BUILD.gn @@ -38,6 +38,7 @@ ohos_unittest("DCameraSourceHandlerTest") { module_out_path = module_out_path sources = [ + "callback/dcamera_source_callback_test.cpp", "dcamera_source_handler_ipc_test.cpp", "dcamera_source_handler_test.cpp", ] diff --git a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp new file mode 100644 index 00000000..560f126b --- /dev/null +++ b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_source/callback/dcamera_source_callback_test.cpp @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2022 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 + +#define private public +#include "dcamera_source_callback.h" +#undef private + +#include "anonymous_string.h" +#include "distributed_camera_errno.h" +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraSourceCallbackTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr sourceCallback_; +}; + +class RegisterCallbackTest : public RegisterCallback { +public: + RegisterCallbackTest() = default; + virtual ~RegisterCallbackTest() = default; + + int32_t OnRegisterResult(const std::string &uuid, const std::string &dhId, int32_t status, + const std::string &data) + { + return 0; + } +}; + +class UnregisterCallbackTest : public UnregisterCallback { +public: + UnregisterCallbackTest() = default; + virtual ~UnregisterCallbackTest() = default; + + int32_t OnUnregisterResult(const std::string &uuid, const std::string &dhId, int32_t status, + const std::string &data) + { + return 0; + } +}; + +void DCameraSourceCallbackTest::SetUpTestCase(void) +{ + DHLOGI("DCameraSourceCallbackTest::SetUpTestCase"); +} + +void DCameraSourceCallbackTest::TearDownTestCase(void) +{ + DHLOGI("DCameraSourceCallbackTest::TearDownTestCase"); +} + +void DCameraSourceCallbackTest::SetUp(void) +{ + DHLOGI("DCameraSourceCallbackTest::SetUp"); + sourceCallback_ = std::make_shared(); +} + +void DCameraSourceCallbackTest::TearDown(void) +{ + DHLOGI("DCameraSourceCallbackTest::TearDown"); + sourceCallback_ = nullptr; +} + +/** + * @tc.name: dcamera_source_callback_test_001 + * @tc.desc: Verify the OnNotifyRegResult function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_001, TestSize.Level1) +{ + const std::string devId = "devId"; + const std::string dhId = "dhId"; + std::string reqId = "reqIdReg"; + int32_t status = 0; + std::string data = "data"; + std::shared_ptr callback = std::make_shared(); + sourceCallback_->PushRegCallback(reqId, callback); + int32_t ret = sourceCallback_->OnNotifyRegResult(devId, dhId, reqId, status, data); + sourceCallback_->PopRegCallback(reqId); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_source_callback_test_002 + * @tc.desc: Verify the OnNotifyRegResult function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_002, TestSize.Level1) +{ + const std::string devId = "devId"; + const std::string dhId = "dhId"; + std::string reqId = "reqId"; + int32_t status = 0; + std::string data = "data"; + int32_t ret = sourceCallback_->OnNotifyRegResult(devId, dhId, reqId, status, data); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_source_callback_test_003 + * @tc.desc: Verify the OnNotifyUnregResult function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_003, TestSize.Level1) +{ + const std::string devId = "devId"; + const std::string dhId = "dhId"; + std::string reqId = "reqId"; + int32_t status = 0; + std::string data = "data"; + std::shared_ptr callback = nullptr; + sourceCallback_->PushRegCallback(reqId, callback); + int32_t ret = sourceCallback_->OnNotifyUnregResult(devId, dhId, reqId, status, data); + sourceCallback_->PopRegCallback(reqId); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_source_callback_test_004 + * @tc.desc: Verify the OnNotifyUnregResult function. + * @tc.type: FUNC + * @tc.require: issue + */ +HWTEST_F(DCameraSourceCallbackTest, dcamera_source_callback_test_004, TestSize.Level1) +{ + const std::string devId = "devId"; + const std::string dhId = "dhId"; + std::string reqId = "reqId"; + int32_t status = 0; + std::string data = "data"; + int32_t ret = sourceCallback_->OnNotifyUnregResult(devId, dhId, reqId, status, data); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +} +} \ No newline at end of file diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/BUILD.gn b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/BUILD.gn index 6dab097c..a8ce7074 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/BUILD.gn +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/BUILD.gn @@ -58,6 +58,7 @@ ohos_unittest("DCameraSourceMgrTest") { sources = [ "dcamera_hdf_operate_test.cpp", "dcamera_provider_callback_impl_test.cpp", + "dcamera_source_config_stream_state_test.cpp", "dcamera_source_controller_test.cpp", "dcamera_source_data_process_test.cpp", "dcamera_source_dev_test.cpp", diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_config_stream_state_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_config_stream_state_test.cpp new file mode 100644 index 00000000..0bd9c62e --- /dev/null +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_config_stream_state_test.cpp @@ -0,0 +1,245 @@ +/* + * Copyright (c) 2021 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 +#include +#define private public +#include "dcamera_source_config_stream_state.h" +#include "dcamera_source_opened_state.h" +#include "dcamera_source_capture_state.h" +#undef private + +#include "dcamera_source_state.h" +#include "dcamera_source_regist_state.h" +#include "dcamera_source_state_machine.h" +#include "mock_dcamera_source_dev.h" +#include "mock_dcamera_source_state_listener.h" +#include "anonymous_string.h" +#include "distributed_camera_constants.h" +#include "distributed_camera_errno.h" +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraSourceConfigStreamStateTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr camDev_; + std::shared_ptr stateListener_; + std::shared_ptr stateMachine_; + std::shared_ptr g_registParam; +}; + +namespace { +const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7"; +const std::string TEST_CAMERA_DH_ID_0 = "camera_0"; +const std::string TEST_REQID = "0xFFFF"; +const std::string TEST_PARAM = "0xFFFF"; + +} + +void DCameraSourceConfigStreamStateTest::SetUpTestCase(void) +{ +} + +void DCameraSourceConfigStreamStateTest::TearDownTestCase(void) +{ +} + +void DCameraSourceConfigStreamStateTest::SetUp(void) +{ + stateListener_ = std::make_shared(); + camDev_ = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, stateListener_); + stateMachine_ = std::make_shared(camDev_); + g_registParam = std::make_shared(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, TEST_REQID, TEST_PARAM); +} + +void DCameraSourceConfigStreamStateTest::TearDown(void) +{ + stateMachine_ = nullptr; + camDev_ = nullptr; + stateListener_ = nullptr; + g_registParam = nullptr; +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_001 + * @tc.desc: Verify source DoUnregisterTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_001, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); + std::shared_ptr configstate = + std::make_shared(stateMachine_); + int32_t ret = configstate->DoUnregisterTask(camDev_, event0); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_002 + * @tc.desc: Verify source DoUpdateSettingsTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_002, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); + std::shared_ptr configstate = + std::make_shared(stateMachine_); + int32_t ret = configstate->DoUpdateSettingsTask(camDev_, event0); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_003 + * @tc.desc: Verify source DoEventNofityTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_003, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_REGIST, g_registParam); + std::shared_ptr configstate = + std::make_shared(stateMachine_); + int32_t ret = configstate->DoEventNofityTask(camDev_, event0); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_004 + * @tc.desc: Verify source DoUnregisterTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_004, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + std::shared_ptr openState = std::make_shared(stateMachine_); + int32_t ret = openState->DoUnregisterTask(camDev_, event0); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_005 + * @tc.desc: Verify source DoUpdateSettingsTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_005, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + std::shared_ptr openState = std::make_shared(stateMachine_); + int32_t ret = openState->DoUpdateSettingsTask(camDev_, event0); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_006 + * @tc.desc: Verify source DoEventNofityTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_006, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + std::shared_ptr openState = std::make_shared(stateMachine_); + int32_t ret = openState->DoEventNofityTask(camDev_, event0); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_007 + * @tc.desc: Verify source DoUnregisterTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_007, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + std::shared_ptr captureState = + std::make_shared(stateMachine_); + int32_t ret = captureState->DoUnregisterTask(camDev_, event0); + EXPECT_EQ(DCAMERA_OK, ret); +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_008 + * @tc.desc: Verify source DoStartCaptureTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_008, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + std::shared_ptr captureState = + std::make_shared(stateMachine_); + int32_t ret = captureState->DoStartCaptureTask(camDev_, event0); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_009 + * @tc.desc: Verify source DoStopCaptureTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_009, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + std::shared_ptr captureState = + std::make_shared(stateMachine_); + int32_t ret = captureState->DoStopCaptureTask(camDev_, event0); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_010 + * @tc.desc: Verify source DoUpdateSettingsTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_010, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + std::shared_ptr captureState = + std::make_shared(stateMachine_); + int32_t ret = captureState->DoUpdateSettingsTask(camDev_, event0); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} + +/** + * @tc.name: dcamera_source_config_stream_state_test_011 + * @tc.desc: Verify source DoEventNofityTask state. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(DCameraSourceConfigStreamStateTest, dcamera_source_config_stream_state_test_011, TestSize.Level1) +{ + DCameraSourceEvent event0(*camDev_, DCAMERA_EVENT_OPEN, g_registParam); + std::shared_ptr captureState = + std::make_shared(stateMachine_); + int32_t ret = captureState->DoEventNofityTask(camDev_, event0); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_test.cpp index cf6e3d19..d414c3d2 100644 --- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_test.cpp +++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_test.cpp @@ -46,6 +46,7 @@ const int32_t TEST_WIDTH = 1920; const int32_t TEST_HEIGTH = 1080; const int32_t TEST_FORMAT = 1; const int32_t TEST_DATASPACE = 1; +const int32_t SLEEP_TIME = 200000; } void DCameraStreamDataProcessTest::SetUpTestCase(void) { @@ -157,6 +158,7 @@ HWTEST_F(DCameraStreamDataProcessTest, dcamera_stream_data_process_test_004, Tes streamProcess->FeedStreamToContinue(buffer); streamProcess->srcConfig_ = srcConfig; streamProcess->CreatePipeline(); + usleep(SLEEP_TIME); streamProcess->FeedStreamToContinue(buffer); EXPECT_EQ(DCAMERA_OK, ret); } -- Gitee