From 686da99e78a5e3b480191cf9dc876f4d0088b0b3 Mon Sep 17 00:00:00 2001 From: z00838083 Date: Sat, 23 Sep 2023 15:35:49 +0800 Subject: [PATCH 1/2] Add sink event UT Signed-off-by: z00838083 --- .../common/distributedcameramgr/BUILD.gn | 4 + .../dcamera_frame_trigger_event_test.cpp | 75 ++++++++++++++++ .../dcamera_photo_output_event_test.cpp | 81 +++++++++++++++++ .../dcamera_post_authorization_event_test.cpp | 90 +++++++++++++++++++ .../dcamera_video_output_event_test.cpp | 81 +++++++++++++++++ 5 files changed, 331 insertions(+) create mode 100644 services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp create mode 100644 services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp create mode 100644 services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_post_authorization_event_test.cpp create mode 100644 services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_video_output_event_test.cpp diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/BUILD.gn b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/BUILD.gn index 1f79a5dd..91df5cd1 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/BUILD.gn +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/BUILD.gn @@ -65,6 +65,10 @@ ohos_unittest("DCameraSinkMgrTest") { "dcamera_sink_dev_test.cpp", "dcamera_sink_output_test.cpp", "dcamera_sink_service_ipc_test.cpp", + "eventbus/dcamera_frame_trigger_event_test.cpp", + "eventbus/dcamera_photo_output_event_test.cpp", + "eventbus/dcamera_post_authorization_event_test.cpp", + "eventbus/dcamera_video_output_event_test.cpp", ] configs = [ ":module_private_config" ] diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp new file mode 100644 index 00000000..67126276 --- /dev/null +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2023 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_frame_trigger_event.h" +#undef private +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraFrameTriggerEventTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::string TEST_PARAM = "testing_param"; + std::shared_ptr testsender_ = nullptr; + std::shared_ptr testDCameraFrameTriggerEvent_ = nullptr; +}; + +void DCameraFrameTriggerEventTest::SetUpTestCase(void) +{ + DHLOGI("DCameraFrameTriggerEventTest SetUpTestCase"); +} + +void DCameraFrameTriggerEventTest::TearDownTestCase(void) +{ + DHLOGI("DCameraFrameTriggerEventTest TearDownTestCase"); +} + +void DCameraFrameTriggerEventTest::SetUp(void) +{ + DHLOGI("DCameraFrameTriggerEventTest SetUp"); + testsender_ = std::make_shared(); + testDCameraFrameTriggerEvent_ = std::make_shared(*testsender_, TEST_PARAM); +} + +void DCameraFrameTriggerEventTest::TearDown(void) +{ + DHLOGI("DCameraFrameTriggerEventTest SetUp"); + testsender_ = nullptr; + testDCameraFrameTriggerEvent_ = nullptr; +} + +/** + * @tc.name: dcamera_frame_trigger_event_test_001 + * @tc.desc: Verify DCameraFrameTriggerEvent init param correct + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraFrameTriggerEventTest, dcamera_frame_trigger_event_test_001, TestSize.Level1) +{ + std::string param = testDCameraFrameTriggerEvent_->GetParam(); + EXPECT_EQ(param, TEST_PARAM); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp new file mode 100644 index 00000000..8eaac363 --- /dev/null +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2023 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_photo_output_event.h" +#undef private +#include "data_buffer.h" +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraPhotoOutputEventTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr dataBuffer_ = nullptr; + std::shared_ptr testsender_ = nullptr; + std::shared_ptr testDCameraPhotoOutputEvent_ = nullptr; +}; + +namespace { + constexpr size_t TEST_CAPACITY = 1; +} + +void DCameraPhotoOutputEventTest::SetUpTestCase(void) +{ + DHLOGI("DCameraPhotoOutputEventTest SetUpTestCase"); +} + +void DCameraPhotoOutputEventTest::TearDownTestCase(void) +{ + DHLOGI("DCameraPhotoOutputEventTest TearDownTestCase"); +} + +void DCameraPhotoOutputEventTest::SetUp(void) +{ + DHLOGI("DCameraPhotoOutputEventTest SetUp"); + dataBuffer_ = std::make_shared(TEST_CAPACITY); + testsender_ = std::make_shared(); + testDCameraPhotoOutputEvent_ = std::make_shared(*testsender_, dataBuffer_); +} + +void DCameraPhotoOutputEventTest::TearDown(void) +{ + DHLOGI("DCameraPhotoOutputEventTest SetUp"); + testsender_ = nullptr; + testDCameraPhotoOutputEvent_ = nullptr; +} + +/** + * @tc.name: dcamera_photo_output_event_test_001 + * @tc.desc: Verify DCameraPhotoOutputEvent init param correct + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraPhotoOutputEventTest, dcamera_photo_output_event_test_001, TestSize.Level1) +{ + std::shared_ptr buffer = testDCameraPhotoOutputEvent_->GetParam(); + EXPECT_EQ(buffer->Capacity(), TEST_CAPACITY); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_post_authorization_event_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_post_authorization_event_test.cpp new file mode 100644 index 00000000..dbb8754e --- /dev/null +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_post_authorization_event_test.cpp @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2023 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_post_authorization_event.h" +#undef private +#include "dcamera_capture_info_cmd.h" +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraPostAuthorizationEventTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr videoInfo; + std::vector> captureInfos; + std::shared_ptr testsender_; + std::shared_ptr testDCameraPostAuthorizationEvent_; +}; + +namespace { + constexpr int32_t TEST_WIDTH = 640; + constexpr int32_t TEST_HEIGHT = 480; + constexpr int32_t TEST_FORMAT_VIDEO = OHOS_CAMERA_FORMAT_RGBA_8888; +} + +void DCameraPostAuthorizationEventTest::SetUpTestCase(void) +{ + DHLOGI("DCameraPostAuthorizationEventTest SetUpTestCase"); +} + +void DCameraPostAuthorizationEventTest::TearDownTestCase(void) +{ + DHLOGI("DCameraPostAuthorizationEventTest TearDownTestCase"); +} + +void DCameraPostAuthorizationEventTest::SetUp(void) +{ + DHLOGI("DCameraPostAuthorizationEventTest SetUp"); + videoInfo = std::make_shared(); + videoInfo->width_ = TEST_WIDTH; + videoInfo->height_ = TEST_HEIGHT; + videoInfo->format_ = TEST_FORMAT_VIDEO; + videoInfo->isCapture_ = true; + videoInfo->streamType_ = CONTINUOUS_FRAME; + captureInfos.push_back(videoInfo); + testsender_ = std::make_shared(); + testDCameraPostAuthorizationEvent_ = std::make_shared(*testsender_, captureInfos); +} + +void DCameraPostAuthorizationEventTest::TearDown(void) +{ + DHLOGI("DCameraPostAuthorizationEventTest SetUp"); + testsender_ = nullptr; + testDCameraPostAuthorizationEvent_ = nullptr; +} + +/** + * @tc.name: dcamera_post_authorization_event_test_001 + * @tc.desc: Verify DCameraPostAuthorizationEvent init param correct + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraPostAuthorizationEventTest, dcamera_post_authorization_event_test_001, TestSize.Level1) +{ + std::vector> info = testDCameraPostAuthorizationEvent_->GetParam(); + EXPECT_EQ(info.size(), captureInfos.size()); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_video_output_event_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_video_output_event_test.cpp new file mode 100644 index 00000000..300c0158 --- /dev/null +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_video_output_event_test.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2023 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_video_output_event.h" +#undef private +#include "data_buffer.h" +#include "distributed_hardware_log.h" + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +class DCameraVideoOutputEventTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr dataBuffer_ = nullptr; + std::shared_ptr testsender_ = nullptr; + std::shared_ptr testDCameraVideoOutputEvent_ = nullptr; +}; + +namespace { + constexpr size_t TEST_CAPACITY = 1; +} + +void DCameraVideoOutputEventTest::SetUpTestCase(void) +{ + DHLOGI("DCameraVideoOutputEventTest SetUpTestCase"); +} + +void DCameraVideoOutputEventTest::TearDownTestCase(void) +{ + DHLOGI("DCameraVideoOutputEventTest TearDownTestCase"); +} + +void DCameraVideoOutputEventTest::SetUp(void) +{ + DHLOGI("DCameraVideoOutputEventTest SetUp"); + dataBuffer_ = std::make_shared(TEST_CAPACITY); + testsender_ = std::make_shared(); + testDCameraVideoOutputEvent_ = std::make_shared(*testsender_, dataBuffer_); +} + +void DCameraVideoOutputEventTest::TearDown(void) +{ + DHLOGI("DCameraVideoOutputEventTest SetUp"); + testsender_ = nullptr; + testDCameraVideoOutputEvent_ = nullptr; +} + +/** + * @tc.name: dcamera_video_output_event_test_001 + * @tc.desc: Verify DCameraVideoOutputEvent init param correct + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DCameraVideoOutputEventTest, dcamera_video_output_event_test_001, TestSize.Level1) +{ + std::shared_ptr buffer = testDCameraVideoOutputEvent_->GetParam(); + EXPECT_EQ(buffer->Capacity(), TEST_CAPACITY); +} +} // namespace DistributedHardware +} // namespace OHOS -- Gitee From 7b29d1a382fcf65dcbbef974b03b325b8b01dce8 Mon Sep 17 00:00:00 2001 From: z00838083 Date: Tue, 26 Sep 2023 14:12:57 +0800 Subject: [PATCH 2/2] Add camera sink service ut Signed-off-by: z00838083 --- .../distributed_camera_sink_service_test.cpp | 142 ++++++++++++++++++ .../dcamera_frame_trigger_event_test.cpp | 2 - .../dcamera_photo_output_event_test.cpp | 2 - .../dcamera_post_authorization_event_test.cpp | 2 - .../dcamera_video_output_event_test.cpp | 2 - 5 files changed, 142 insertions(+), 8 deletions(-) diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/distributed_camera_sink_service_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/distributed_camera_sink_service_test.cpp index 886f4a2a..38c28aa8 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/distributed_camera_sink_service_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/distributed_camera_sink_service_test.cpp @@ -228,5 +228,147 @@ HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_007, TestSi int ret = sinkService_->Dump(fd, args); EXPECT_EQ(DCAMERA_OK, ret); } +/** + * @tc.name: dcamera_sink_service_test_008 + * @tc.desc: Verify the SubscribeLocalHardware function can't find id. + * @tc.type: FUNC + * @tc.require: AR000GK6MT + */ +HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_008, TestSize.Level1) +{ + DHLOGI("dcamera_sink_service_test_008"); + EXPECT_EQ(sinkService_ == nullptr, false); + + int32_t ret = sinkService_->InitSink(g_testParams); + EXPECT_EQ(DCAMERA_OK, ret); + + ret = sinkService_->SubscribeLocalHardware("", g_testParams); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); + + ret = sinkService_->ReleaseSink(); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_sink_service_test_009 + * @tc.desc: Verify the UnsubscribeLocalHardware function can't find id. + * @tc.type: FUNC + * @tc.require: AR000GK6MT + */ +HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_009, TestSize.Level1) +{ + DHLOGI("dcamera_sink_service_test_009"); + EXPECT_EQ(sinkService_ == nullptr, false); + + int32_t ret = sinkService_->InitSink(g_testParams); + EXPECT_EQ(DCAMERA_OK, ret); + + ret = sinkService_->UnsubscribeLocalHardware(""); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); + + ret = sinkService_->ReleaseSink(); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_sink_service_test_010 + * @tc.desc: Verify the ChannelNeg function can't find id. + * @tc.type: FUNC + */ +HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_010, TestSize.Level1) +{ + DHLOGI("dcamera_sink_service_test_010"); + EXPECT_EQ(sinkService_ == nullptr, false); + + int32_t ret = sinkService_->InitSink(g_testParams); + EXPECT_EQ(DCAMERA_OK, ret); + + ret = sinkService_->ChannelNeg("", g_testChannelInfoContinue); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); + + ret = sinkService_->ReleaseSink(); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_sink_service_test_011 + * @tc.desc: Verify the GetCameraInfo function can't find id. + * @tc.type: FUNC + */ +HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_011, TestSize.Level1) +{ + DHLOGI("dcamera_sink_service_test_011"); + EXPECT_EQ(sinkService_ == nullptr, false); + + int32_t ret = sinkService_->InitSink(g_testParams); + EXPECT_EQ(DCAMERA_OK, ret); + + ret = sinkService_->GetCameraInfo("", g_testCameraInfo); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); + + ret = sinkService_->ReleaseSink(); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_sink_service_test_012 + * @tc.desc: Verify the OpenChannel and CloseChannel function can't find id. + * @tc.type: FUNC + */ +HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_012, TestSize.Level1) +{ + DHLOGI("dcamera_sink_service_test_012"); + EXPECT_EQ(sinkService_ == nullptr, false); + + int32_t ret = sinkService_->InitSink(g_testParams); + EXPECT_EQ(DCAMERA_OK, ret); + + ret = sinkService_->OpenChannel("", g_testOpenInfoService); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); + + ret = sinkService_->CloseChannel(""); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); + + ret = sinkService_->ReleaseSink(); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_sink_service_test_013 + * @tc.desc: Verify the Dump function with large arg. + * @tc.type: FUNC + */ +HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_013, TestSize.Level1) +{ + DHLOGI("dcamera_sink_service_test_013"); + EXPECT_EQ(sinkService_ == nullptr, false); + + int32_t fd = 1; + std::vector args(sinkService_->DUMP_MAX_SIZE, u""); + std::u16string str(u""); + args.push_back(str); + int ret = sinkService_->Dump(fd, args); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} + +/** + * @tc.name: dcamera_sink_service_test_014 + * @tc.desc: Verify the StopCapture function can't find id. + * @tc.type: FUNC + */ +HWTEST_F(DistributedCameraSinkServiceTest, dcamera_sink_service_test_014, TestSize.Level1) +{ + DHLOGI("dcamera_sink_service_test_014"); + EXPECT_EQ(sinkService_ == nullptr, false); + + int32_t ret = sinkService_->InitSink(g_testParams); + EXPECT_EQ(DCAMERA_OK, ret); + + ret = sinkService_->StopCapture(""); + EXPECT_EQ(DCAMERA_NOT_FOUND, ret); + + ret = sinkService_->ReleaseSink(); + EXPECT_EQ(DCAMERA_BAD_VALUE, ret); +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp index 67126276..4e0453ba 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_frame_trigger_event_test.cpp @@ -15,9 +15,7 @@ #include -#define private public #include "dcamera_frame_trigger_event.h" -#undef private #include "distributed_hardware_log.h" using namespace testing::ext; diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp index 8eaac363..4777134f 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_photo_output_event_test.cpp @@ -15,9 +15,7 @@ #include -#define private public #include "dcamera_photo_output_event.h" -#undef private #include "data_buffer.h" #include "distributed_hardware_log.h" diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_post_authorization_event_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_post_authorization_event_test.cpp index dbb8754e..1b789e25 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_post_authorization_event_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_post_authorization_event_test.cpp @@ -15,9 +15,7 @@ #include -#define private public #include "dcamera_post_authorization_event.h" -#undef private #include "dcamera_capture_info_cmd.h" #include "distributed_hardware_log.h" diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_video_output_event_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_video_output_event_test.cpp index 300c0158..29be3e24 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_video_output_event_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/eventbus/dcamera_video_output_event_test.cpp @@ -15,9 +15,7 @@ #include -#define private public #include "dcamera_video_output_event.h" -#undef private #include "data_buffer.h" #include "distributed_hardware_log.h" -- Gitee