From 8af1b819b32cd62c7fc7075da1d92d599bfb7e7f Mon Sep 17 00:00:00 2001 From: ljh54_space Date: Tue, 26 Apr 2022 23:24:41 +0800 Subject: [PATCH 1/4] add screenserviceTest files Signed-off-by: ljh54_space --- .vscode/settings.json | 63 +++++++ bundle.json | 1 + services/screenservice/test/unittest/BUILD.gn | 20 +++ .../test/unittest/sinkservice/BUILD.gn | 94 ++++++++++ .../include/dscreen_sink_service_test.h | 47 +++++ .../include/dscreen_sink_stub_test.h | 40 +++++ .../include/mock_dscreen_sink_stub.h | 35 ++++ .../src/dscreen_sink_service_test.cpp | 91 ++++++++++ .../src/dscreen_sink_stub_test.cpp | 73 ++++++++ .../src/mock_dscreen_sink_stub.cpp | 52 ++++++ .../include/mock_iscreen_sink_trans.h | 35 ++++ .../include/screen_region_mgr_test.h | 49 +++++ .../include/screen_region_test.h | 44 +++++ .../src/mock_iscreen_sink_trans.cpp | 55 ++++++ .../src/screen_region_mgr_test.cpp | 48 +++++ .../src/screen_region_test.cpp | 167 ++++++++++++++++++ .../test/unittest/sourceservice/BUILD.gn | 97 ++++++++++ .../dscreenmgr/include/dscreen_manager_test.h | 46 +++++ .../dscreenmgr/include/dscreen_test.h | 45 +++++ .../include/screen_manager_adapter_test.h | 54 ++++++ .../dscreenmgr/src/dscreen_manager_test.cpp | 109 ++++++++++++ .../dscreenmgr/src/dscreen_test.cpp | 149 ++++++++++++++++ .../src/screen_manager_adapter_test.cpp | 137 ++++++++++++++ .../dscreen_source_callback_proxy_test.h | 42 +++++ .../include/dscreen_source_service_test.h | 47 +++++ .../include/dscreen_source_stub_test.h | 43 +++++ .../include/mock_dscreen_source_stub.h | 41 +++++ .../dscreen_source_callback_proxy_test.cpp | 118 +++++++++++++ .../src/dscreen_source_service_test.cpp | 118 +++++++++++++ .../src/dscreen_source_stub_test.cpp | 71 ++++++++ .../src/mock_dscreen_source_stub.cpp | 76 ++++++++ 31 files changed, 2107 insertions(+) create mode 100644 .vscode/settings.json create mode 100644 services/screenservice/test/unittest/BUILD.gn create mode 100644 services/screenservice/test/unittest/sinkservice/BUILD.gn create mode 100644 services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_service_test.h create mode 100644 services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_stub_test.h create mode 100644 services/screenservice/test/unittest/sinkservice/dscreenservice/include/mock_dscreen_sink_stub.h create mode 100644 services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp create mode 100644 services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp create mode 100644 services/screenservice/test/unittest/sinkservice/dscreenservice/src/mock_dscreen_sink_stub.cpp create mode 100644 services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h create mode 100644 services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_mgr_test.h create mode 100644 services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_test.h create mode 100644 services/screenservice/test/unittest/sinkservice/screenregionmgr/src/mock_iscreen_sink_trans.cpp create mode 100644 services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp create mode 100644 services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp create mode 100644 services/screenservice/test/unittest/sourceservice/BUILD.gn create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_test.h create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenmgr/include/screen_manager_adapter_test.h create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_service_test.h create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/include/mock_dscreen_source_stub.h create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp create mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 00000000..8f80e74c --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,63 @@ +{ + "files.associations": { + "algorithm": "cpp", + "atomic": "cpp", + "chrono": "cpp", + "cmath": "cpp", + "condition_variable": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "deque": "cpp", + "exception": "cpp", + "functional": "cpp", + "initializer_list": "cpp", + "iomanip": "cpp", + "ios": "cpp", + "iosfwd": "cpp", + "iostream": "cpp", + "istream": "cpp", + "limits": "cpp", + "list": "cpp", + "map": "cpp", + "memory": "cpp", + "mutex": "cpp", + "new": "cpp", + "ostream": "cpp", + "queue": "cpp", + "random": "cpp", + "ratio": "cpp", + "set": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "streambuf": "cpp", + "string": "cpp", + "system_error": "cpp", + "xthread": "cpp", + "thread": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "typeinfo": "cpp", + "utility": "cpp", + "vector": "cpp", + "xfacet": "cpp", + "xfunctional": "cpp", + "xiosbase": "cpp", + "xlocale": "cpp", + "xlocinfo": "cpp", + "xlocmon": "cpp", + "xlocnum": "cpp", + "xloctime": "cpp", + "xmemory": "cpp", + "xmemory0": "cpp", + "xstddef": "cpp", + "xstring": "cpp", + "xtr1common": "cpp", + "xtree": "cpp", + "xutility": "cpp" + } +} \ No newline at end of file diff --git a/bundle.json b/bundle.json index 3cedd469..10cfec3f 100644 --- a/bundle.json +++ b/bundle.json @@ -81,6 +81,7 @@ "//foundation/distributedhardware/distributedscreen/services/screentransport/test/unittest:screen_transport_test", "//foundation/distributedhardware/distributedscreen/services/softbusadapter/test/unittest:SoftBusAdapterTest", "//foundation/distributedhardware/distributedscreen/services/common/test/unittest:service_common_test", + "//foundation/distributedhardware/distributedscreen/services/screenservice/test/unittest:screen_service_test", "//foundation/distributedhardware/distributedscreen/screenhandler/test/fuzztest:fuzztest", "//foundation/distributedhardware/distributedscreen/interfaces/innerkits/native_cpp/test/fuzztest:fuzztest", "//foundation/distributedhardware/distributedscreen/services/softbusadapter/test/fuzztest:fuzztest", diff --git a/services/screenservice/test/unittest/BUILD.gn b/services/screenservice/test/unittest/BUILD.gn new file mode 100644 index 00000000..bdc8ca76 --- /dev/null +++ b/services/screenservice/test/unittest/BUILD.gn @@ -0,0 +1,20 @@ +# 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. + + group("screen_service_test") { + testonly = true + deps = [ + "sinkservice:sink_service_test", + "sourceservice:source_service_test", + ] + } \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/BUILD.gn b/services/screenservice/test/unittest/sinkservice/BUILD.gn new file mode 100644 index 00000000..c69367fb --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/BUILD.gn @@ -0,0 +1,94 @@ +# 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. + +import("//build/test.gni") +import("//foundation/distributedhardware/distributedscreen/distributedscreen.gni") + +module_out_path = "distributed_screen/services/sink_service_test" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "//third_party/json/include", + "//utils/native/base/include", + "//utils/system/safwk/native/include", + "//foundation/graphic/standard/interfaces/innerkits/surface", + "${windowmanager_path}/interfaces/innerkits/dm", + "${fwk_common_path}/utils/include", + ] + + include_dirs += [ + "./dscreenservice/include", + "./screenregionmgr/include", + "${interfaces_path}/innerkits/native_cpp/screen_sink/include", + "${interfaces_path}/innerkits/native_cpp/screen_sink/include/callback", + "${interfaces_path}/innerkits/native_cpp/screen_source/include", + "${interfaces_path}/innerkits/native_cpp/screen_source/include/callback", + "${common_path}/include", + "${services_path}/common/utils/include", + "${services_path}/common/databuffer/include", + "${services_path}/common/screen_channel/include", + "${services_path}/screentransport/screensinktrans/include", + "${services_path}/screentransport/screensinkprocessor/include", + "${services_path}/screentransport/screensinkprocessor/decoder/include", + "${services_path}/screenclient/include/", + "${services_path}/screenservice/test/unittest/sinkservice/include", + "${services_path}/screenservice/sinkservice/dscreenservice/include", + "${services_path}/screenservice/sinkservice/screenregionmgr/include", + "${services_path}/evevntcontrol/eventcollector/inlude", + ] +} + +##UnitTest sink_service_test +ohos_unittest("SinkServiceTest") { + module_out_path = module_out_path + + sources = [ + "${services_path}/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp", + "${services_path}/screenservice/test/unittest/sinkservice/dscreenservice/src/mock_dscreen_sink_stub.cpp", + "${services_path}/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp", + "${services_path}/screenservice/test/unittest/sinkservice/screenregionmgr/src/mock_iscreen_sink_trans.cpp", + "${services_path}/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp", + "${services_path}/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp", + + ] + + configs = [ ":module_private_config" ] + + deps = [ + "//third_party/googletest:gmock", + "//third_party/googletest:gtest_main", + "${fwk_utils_path}:distributedhardwareutils", + "//foundation/graphic/standard/frameworks/surface:surface", + "${common_path}:distributed_screen_utils", + "${services_path}/screentransport/screensinktrans:distributed_screen_sinktrans", + "${services_path}/screenservice/sinkservice:distributed_screen_sink", + "${services_path}/screenclient:distributed_screen_client", + "${windowmanager_path}/interfaces/innerkits:wm_interface", + "${windowmanager_path}/dm:libdm", + ] + + external_deps = [ + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr_standard:samgr_proxy", + "multimedia_media_standard:media_client", + ] +} + +group("sink_service_test") { + testonly = true + deps = [ ":SinkServiceTest" ] +} \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_service_test.h b/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_service_test.h new file mode 100644 index 00000000..17474bae --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_service_test.h @@ -0,0 +1,47 @@ +/* + * 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. + */ + +#ifndef OHOS_DSCREEN_SINK_SERVICE_TEST_H +#define OHOS_DSCREEN_SINK_SERVICE_TEST_H + +#include + +#include "if_system_ability_manager.h" +#include "ipc_skeleton.h" +#include "ipc_types.h" +#include "iservice_registry.h" +#include "system_ability_definition.h" +#include "string_ex.h" + +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_sink_service.h" +#include "dscreen_util.h" + +namespace OHOS { +namespace DistributedHardware { +class DScreenSinkServiceTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr sinkService_ = nullptr; +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_stub_test.h b/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_stub_test.h new file mode 100644 index 00000000..59ebd51b --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_stub_test.h @@ -0,0 +1,40 @@ +/* + * 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. + */ + +#ifndef OHOS_DSCREEN_SINK_STUB_TEST_H +#define OHOS_DSCREEN_SINK_STUB_TEST_H + +#include + +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_sink_stub.h" +#include "mock_dscreen_sink_stub.h" + +namespace OHOS { +namespace DistributedHardware { +class DScreenSinkStubTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + MockDScreenSinkStub *dScreenSinkStub_ = nullptr; +}; +} // DistributedHardware +} // OHOS +#endif diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/include/mock_dscreen_sink_stub.h b/services/screenservice/test/unittest/sinkservice/dscreenservice/include/mock_dscreen_sink_stub.h new file mode 100644 index 00000000..168d5ea9 --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/include/mock_dscreen_sink_stub.h @@ -0,0 +1,35 @@ +/* + * 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. + */ + +#ifndef OHOS_MOCK_DSCREEN_SINK_STUB_H +#define OHOS_MOCK_DSCREEN_SINK_STUB_H + +#include "dscreen_sink_stub.h" + +namespace OHOS { +namespace DistributedHardware { +class MockDScreenSinkStub : public DScreenSinkStub { +public: + MockDScreenSinkStub() = default; + virtual ~MockDScreenSinkStub() {}; + virtual int32_t InitSink(const std::string ¶ms); + virtual int32_t ReleaseSink(); + virtual int32_t SubscribeLocalHardware(const std::string &dhId, const std::string ¶m); + virtual int32_t UnsubscribeLocalHardware(const std::string &dhId); + virtual void DScreenNotify(const std::string &devId, int32_t eventCode, const std::string &eventContent); +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp new file mode 100644 index 00000000..88d157e2 --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp @@ -0,0 +1,91 @@ +/* + * 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. + */ + +#define private public +#include "dscreen_sink_service_test.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void DScreenSinkServiceTest::SetUpTestCase(void) {} + +void DScreenSinkServiceTest::TearDownTestCase(void) {} + +void DScreenSinkServiceTest::SetUp() +{ + int32_t saId = 4808; + bool runOnCreate = false; + sinkService_ = std::make_shared(saId, runOnCreate); +} + +void DScreenSinkServiceTest::TearDown(void) {} + +/** + * @tc.name: InitSink_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSinkServiceTest, InitSink_001, TestSize.Level1) +{ + std::string params = "hello"; + int32_t actual = sinkService_->InitSink(params); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: ReleaseSink_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSinkServiceTest, ReleaseSink_001, TestSize.Level1) +{ + std::string params = "hello"; + sinkService_->InitSink(params); + int32_t actual = sinkService_->ReleaseSink(); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: SubscribeLocalHardware_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSinkServiceTest, SubscribeLocalHardware_001, TestSize.Level1) +{ + std::string dhId = "dhId"; + std::string param = "param"; + int32_t actual = sinkService_->SubscribeLocalHardware(dhId, param); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: UnsubscribeLocalHardware_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSinkServiceTest, UnsubscribeLocalHardware_001, TestSize.Level1) +{ + std::string dhId = "dhId"; + int32_t actual = sinkService_->UnsubscribeLocalHardware(dhId); + EXPECT_EQ(DH_SUCCESS, actual); +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp new file mode 100644 index 00000000..c08603dc --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp @@ -0,0 +1,73 @@ +/* + * 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. + */ + +#define private public +#include "dscreen_sink_stub_test.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void DScreenSinkStubTest::SetUpTestCase(void) {} + +void DScreenSinkStubTest::TearDownTestCase(void) {} + +void DScreenSinkStubTest::SetUp(void) +{ + dScreenSinkStub_ = new MockDScreenSinkStub(); +} + +void DScreenSinkStubTest::TearDown(void) +{ + delete dScreenSinkStub_; + dScreenSinkStub_ = nullptr; +} + +/** + * @tc.name: OnRemoteRequest_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSinkStubTest, OnRemoteRequest_001, TestSize.Level1) +{ + uint32_t code = 0; + MessageParcel data; + MessageParcel reply; + MessageOption option; + dScreenSinkStub_->memberFuncMap_.emplace(IDScreenSink::INIT_SINK, &DScreenSinkStub::InitSinkInner); + int32_t actual = dScreenSinkStub_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: OnRemoteRequest_002 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSinkStubTest, OnRemoteRequest_002, TestSize.Level1) +{ + uint32_t code = 0; + MessageParcel data; + MessageParcel reply; + MessageOption option; + dScreenSinkStub_->memberFuncMap.clear(); + int32_t actual = dScreenSinkStub_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_SA_INVALID_IPC_CALL, actual); +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/mock_dscreen_sink_stub.cpp b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/mock_dscreen_sink_stub.cpp new file mode 100644 index 00000000..e8e5581a --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/mock_dscreen_sink_stub.cpp @@ -0,0 +1,52 @@ +/* + * 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 "mock_dscreen_sink_stub.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t MockDScreenSinkStub::InitSink(const std::string ¶ms) +{ + (void) params; + return 0; +} + +int32_t MockDScreenSinkStub::ReleaseSink() +{ + return 0; +} + +int32_t MockDScreenSinkStub::SubscribeLocalHardware(const std::string &dhId, const std::string ¶m) +{ + (void) dhId; + (void) param; + return 0; +} + +int32_t MockDScreenSinkStub::UnsubscribeLocalHardware(const std::string &dhId) +{ + (void) dhId; + return 0; +} + +void MockDScreenSinkStub::DScreenNotify(const std::string &devId, int32_t eventCode, const std::string &eventContent) +{ + (void) devId; + (void) eventCode; + (void) eventContent; + return; +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h new file mode 100644 index 00000000..835ee5ce --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h @@ -0,0 +1,35 @@ +/* + * 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. + */ + +#ifndef OHOS_MOCK_ISCREEN_SINK_TRANS_H +#define OHOS_MOCK_ISCREEN_SINK_TRANS_H + +#include "iscreen_sink_trans.h" + +namespace OHOS { +namespace DistributedHardware { +class MockIScreenSinkTrans : public IScreenSinkTrans { +public: + MockIScreenSinkTrans() = default; + ~MockIScreenSinkTrans() = default; + virtual int32_t SetUp(const VideoParam &localParam, const VideoParam &remoteParam, const std::string &peerDevId) override; + virtual int32_t Release() override; + virtual int32_t Start() override; + virtual int32_t Stop() override; + virtual int32_t RegisterStateCallback(const std::shared_ptr &callback) override; +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_mgr_test.h b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_mgr_test.h new file mode 100644 index 00000000..c5f765c7 --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_mgr_test.h @@ -0,0 +1,49 @@ +/* + * 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. + */ + +#ifndef OHOS_SCREEN_REGION_MGR_TEST_H +#define OHOS_SCREEN_REGION_MGR_TEST_H + +#include + +#include "display_manager.h" +#include "if_system_ability_manager.h" +#include "iservice_registry.h" +#include "nlohmann/json.hpp" + +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_maprelation.h" +#include "dscreen_util.h" +#include "idscreen_source.h" +#include "screen_client.h" +#include "screen_client_common.h" +#include "screenregionmgr.h" + +namespace OHOS { +namespace DistributedHardware { +class ScreenRegionManagerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr screenRegionManager_ = nullptr; +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_test.h b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_test.h new file mode 100644 index 00000000..cca4b3a9 --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_test.h @@ -0,0 +1,44 @@ +/* + * 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. + */ + +#ifndef OHOS_SCREEN_REGION_TEST_H +#define OHOS_SCREEN_REGION_TEST_H + +#include + +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_util.h" +#include "mock_iscreen_sink_trans.h" +#include "screen_client.h" +#include "screen_client_common.h" +#include "screenregion.h" +#include "screen_sink_trans.h" + +namespace OHOS { +namespace DistributedHardware { +class ScreenRegionTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr screenRegion_ = nullptr; +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/mock_iscreen_sink_trans.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/mock_iscreen_sink_trans.cpp new file mode 100644 index 00000000..ad23b232 --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/mock_iscreen_sink_trans.cpp @@ -0,0 +1,55 @@ +/* + * 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 "mock_iscreen_sink_trans.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t MockIScreenSinkTrans::SetUp(const VideoParam &localParam, const VideoParam &remoteParam, const std::string &peerDevId) +{ + (void) localParam; + (void) remoteParam; + (void) peerDevId; + return 0; +} + +int32_t MockIScreenSinkTrans::Release() +{ + return 0; +} + +int32_t MockIScreenSinkTrans::Start() +{ + return 0; +} +int32_t MockIScreenSinkTrans::Stop() +{ + return 0; +} + +int32_t MockIScreenSinkTrans::RegisterStateCallback(const std::shared_ptr &callback) +{ + (void) callback; + return 0; +} + +int32_t MockIScreenSinkTrans::SetImageSurface(const sptr &surface) +{ + (void) surface; + return 0; +} +} // DistributedHardware +} // OHOS + diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp new file mode 100644 index 00000000..ee30b6b4 --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp @@ -0,0 +1,48 @@ +/* + * 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. + */ + +#define private public +#include "screen_region_mgr_test.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void ScreenRegionManagerTest::SetUpTestCase(void) {} + +void ScreenRegionManagerTest::TearDownTestCase(void) {} + +void ScreenRegionManagerTest::SetUp(void) +{ + screenRegionManager_ = std::make_shared(); +} + +void ScreenRegionManagerTest::TearDown(void){} + +/** + * @tc.name: ReleaseAllRegions_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionManagerTest, ReleaseAllRegions_001, TestSize.Level1) +{ + + int32_t actual = screenRegionManager_->ReleaseAllRegions(); + EXPECT_EQ(DH_SUCCESS, actual); +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp new file mode 100644 index 00000000..0616b71b --- /dev/null +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp @@ -0,0 +1,167 @@ +/* + * 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. + */ + +#define private public +#include "screen_region_test.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void ScreenRegionTest::SetUpTestCase(void) {} + +void ScreenRegionTest::TearDownTestCase(void) {} + +void ScreenRegionTest::SetUp(void) +{ + const std::string remoteDevId = "hello"; + uint64_t screenId = 0; + uint64_t displayId = 0; + screenRegion_ = std::make_shared(remoteDevId, screenId, displayId); +} + +void ScreenRegionTest::TearDown(void) {} + +/** + * @tc.name: OnTransError_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionTest, OnTransError_001, TestSize.Level1) +{ + int32_t err = 0; + const std::string content = "hello"; + screenRegion_->OnTransError(err, content); +} + +/** + * @tc.name: SetVideoParam_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionTest, SetVideoParam_001, TestSize.Level1) +{ + std::shared_ptr videoParam = std::make_shared(); + screenRegion_->SetVideoParam(videoParam); +} + +/** + * @tc.name: SetMapRelation_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionTest, SetMapRelation_001, TestSize.Level1) +{ + std::shared_ptr mapRelation = std::make_shared(); + screenRegion_->SetMapRelation(mapRelation); +} + +/** + * @tc.name: SetUp_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionTest, SetUp_001, TestSize.Level1) +{ + int32_t actual = screenRegion_->SetUp(); + EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED, actual); +} + +/** + * @tc.name: Start_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionTest, Start_001, TestSize.Level1) +{ + int32_t actual = screenRegion_->Start(); + EXPECT_EQ(ERR_DH_SCREEN_SA_SINKTRANS_NOT_INIT, actual); +} + +/** + * @tc.name: Start_002 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionTest, Start_002, TestSize.Level1) +{ + screenRegion_->sinkTrans_ = std::make_shared(); + int32_t actual = screenRegion_->Start(); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: Stop_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionTest, Stop_001, TestSize.Level1) +{ + screenRegion_->Start(); + int32_t actual = screenRegion_->Stop(); + EXPECT_EQ(ERR_DH_SCREEN_SA_SINKTRANS_NOT_INIT, actual); +} + +/** + * @tc.name: Stop_002 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionTest, Stop_002, TestSize.Level1) +{ + screenRegion_->sinkTrans_ = std::make_shared(); + std::shared_ptr windowProperty = std::make_shared(); + int32_t windowId = INVALID_WINDOW_ID; + windowId = ScreenClient::GetInstance().AddWindow(windowProperty); + ScreenClient::GetInstance().RemoveWindow(windowId); + int32_t actual = screenRegion->Stop(); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: GetScreenId_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionTest, GetScreenId_001, TestSize.Level1) +{ + int32_t actual = screenRegion_->GetScreenId(); + EXPECT_EQ(0, actual); +} + +/** + * @tc.name: GetRemoteDevId_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenRegionTest, GetRemoteDevId_001, TestSize.Level1) +{ + screenRegion_->remoteDevId_ = "remoteDevId"; + std::string actual = screenRegion_->GetRemoteDevId(); + EXPECT_EQ(screenRegion_->remoteDevId_, actual); +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/BUILD.gn b/services/screenservice/test/unittest/sourceservice/BUILD.gn new file mode 100644 index 00000000..94b65283 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/BUILD.gn @@ -0,0 +1,97 @@ +# 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. + +import("//build/test.gni") +import( + "//foundation/distributedhardware/distributedscreen/distributedscreen.gni") + +module_out_path = "distributed_screen/source_service_test" + +config("module_private_config") { + visibility = [ ":*" ] + + include_dirs = [ + "//third_party/json/include", + "${windowmanager_path}/interfaces/innerkits/dm", + "//utils/native/base/include", + "//utils/system/safwk/native/include", + "//foundation/graphic/standard/interfaces/innerkits/surface", + "${fwk_utils_path}/include/log", + "${fwk_utils_path}/include", + "${fwk_common_path}/log/inlcude", + "${fwk_common_path}/utils/include", + ] + + include_dirs += [ + "./dscreenservice/include", + "./dscreenservice/include/callback", + "./dscreenmgr/include", + "${interfaces_path}/innerkits/native_cpp/screen_sink/include", + "${interfaces_path}/innerkits/native_cpp/screen_sink/include/callback", + "${interfaces_path}/innerkits/native_cpp/screen_source/include", + "${interfaces_path}/innerkits/native_cpp/screen_source/include/callback", + "${common_path}/include", + "${services_path}/common/utils/include", + "${services_path}/common/databuffer/include", + "${services_path}/common/screen_channel/include", + "${services_path}/screentransport/screensourceprocessor/include", + "${services_path}/screentransport/screensourceprocessor/encoder/include", + "${services_path}/screentransport/screensourcetrans/include", + "${services_path}/screenservice/test/unittest/sourceservice/include", + "${services_path}/screenservice/sourceservice/dscreenmgr/include", + "${services_path}/screenservice/sourceservice/dscreenservice/include", + "${services_path}/evevntcontrol/eventinjector/include", + ] +} + +##Unittest source_service_test +ohos_unittest("SourceServiceTest") { + module_out_path = module_our_path + + sources = [ + "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp", + "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp", + "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp", + "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp", + "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp", + "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp", + "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp", + ] + + configs = [ ":module_private_config" ] + + deps = [ + "//third_party/googletest:gmock", + "//third_party/googletest:gtest_main", + "//foundation/graphic/standard/frameworks/surface:surface", + "${common_path}:distributed_screen_utils", + "${services_path}/screentransport/screensourcetrans:distributed_screen_sourcetrans", + "${services_path}/screenservice/sourceservice:distributed_screen_source", + "utils/native/base:utils", + "${fwk_utils_path}:distributedhardwareutils", + "${windowmanager_path}/interfaces/innerkits:wm_interface", + "${windowmanager_path}/dm:libdm", + ] + + external_deps = [ + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr_standard:samgr_proxy", + ] +} + +group("source_service_test") { + testonly = true + deps = [ ":SourceServiceTest" ] +} \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h new file mode 100644 index 00000000..8471ffa4 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h @@ -0,0 +1,46 @@ +/* + * 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. + */ + +#ifndef OHOS_DSCREEN_MANAGER_TEST_H +#define OHOS_DSCREEN_MANAGER_TEST_H + +#include + +#include "if_system_ability_manager.h" +#include "iservice_registry.h" +#include "nlohmann/json.hpp" + +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_manager.h" +#include "dscreen_util.h" +#include "idscreen_sink.h" +#include "screen_manager_adapter.h" + +namespace OHOS { +namespace DistributedHardware { +class DScreenManagerTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr dscreenManager_ = nullptr; +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_test.h b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_test.h new file mode 100644 index 00000000..e0700a90 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_test.h @@ -0,0 +1,45 @@ +/* + * 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. + */ + +#ifndef OHOS_DSCREEN_TEST_H +#define OHOS_DSCREEN_TEST_H + +#include + +#include "avcodec_info.h" +#include "avcodec_list.h" + +#include "dscreen.h" +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_util.h" +#include "screen_manager_adapter.h" +#include "screen_source_trans.h" + +namespace OHOS { +namespace DistributedHardware { +class DScreenTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr dScreen_ = nullptr; +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/screen_manager_adapter_test.h b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/screen_manager_adapter_test.h new file mode 100644 index 00000000..2e51bd88 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/screen_manager_adapter_test.h @@ -0,0 +1,54 @@ +/* + * 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. + */ + +#ifndef OHOS_SCREEN_MANAGER_ADAPTER_TEST_H +#define OHOS_SCREEN_MANAGER_ADAPTER_TEST_H + +#include +#include + +#include "display_manager.h" +#include "dm_common.h" +#include "screen.h" + +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "screen_manager_adapter.h" + +namespace OHOS { +namespace DistributedHardware { +class ScreenMgrAdapterTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + ScreenMgrAdapter *screenMgrAdapter_ = nullptr; +}; + +class MockScreenGroupListener : public Rosen::ScreenManager::IScreenGroupListener { +public: + MockScreenGroupListener() = default; + ~MockScreenGroupListener() = default; + void OnChange(const std::vector &screenId, Rosen::ScreenGroupChangeEvent MockScreenGroupChangeEvent) override + { + return; + } +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp new file mode 100644 index 00000000..2e4ec397 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp @@ -0,0 +1,109 @@ +/* + * 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. + */ + +#define private public +#include "dscreen_manager_test.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void DScreenManagerTest::SetUpTestCase(void) {} + +void DScreenManagerTest::TearDownTestCase(void) {} + +void DScreenManagerTest::SetUp() +{ + dscreenManager_ = std::make_shared(); +} + +void DScreenManagerTest::TearDown(void) {} + +/** + * @tc.name: EnableDistributedScreen_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenManagerTest, EnableDistributedScreen_001, TestSize.Level1) +{ + std::string devId = "hello"; + std::string dhId = "hello"; + std::string param = "hello"; + std::string reqId = "hello"; + std::shared_ptr dScreenCallback = nullptr; + int32_t actual = dscreenManager_->EnableDistributedScreen(devId, dhId, param, reqId); + EXPECT_EQ(ERR_DH_SCREEN_SA_ENABLE_FAILED, actual); +} + +/** + * @tc.name: EnableDistributedScreen_002 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenManagerTest, EnableDistributedScreen_002, TestSize.Level1) +{ + std::string devId = "world"; + std::string dhId = "world"; + std::string param = "world"; + std::string reqId = "world"; + dscreenManager_->Init(); + std::shared_ptr task = nullptr; + int32_t actual = dscreenManager_->EnableDistributedScreen(devId, dhId, param, reqId); + EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_TASK_NOT_VALID, actual); +} + +/** + * @tc.name: DisableDistributedScreen_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenManagerTest, DisableDistributedScreen_001, TestSize.Level1) +{ + std::string devId = "devId"; + std::string dhId = "dhId"; + std::string reqId = "reqId"; + int32_t actual = dscreenManager_->DisableDistributedScreen(devId, dhId, reqId); + EXPECT_EQ(ERR_DH_SCREEN_SA_DISABLE_FAILED, actual); +} + +/** + * @tc.name: Init_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenManagerTest, Init_001, TestSize.Level1) +{ + int32_t actual = dscreenManager_->Init(); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: UnInit_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenManagerTest, UnInit_001, TestSize.Level1) +{ + int32_t actual = dscreenManager_->UnInit(); + EXPECT_EQ(DH_SUCCESS, actual); +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp new file mode 100644 index 00000000..d7a6bc12 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp @@ -0,0 +1,149 @@ +/* + * 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. + */ + +#define private public +#include "dscreen_test.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void DScreenTest::SetUpTestCase(void) {} + +void DScreenTest::TearDownTestCase(void) {} + +void DScreenTest::SetUp() +{ + const std::string devId = "hello"; + const std::string dhId = "hello"; + std::shared_ptr dscreenCallback = nullptr; + dScreen_ = std::make_shared(devId, dhId, dscreenCallback); +} + +void DScreenTest::TearDown(void) {} + +/** + * @tc.name: OnTransError_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTest, OnTransError_001, TestSize.Level1) +{ + int32_t err = 0; + const std::string content = "hello"; + dScreen_->OnTransError(err, content); +} + +/** + * @tc.name: GetVideoParam_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTest, GetVideoParam_001, TestSize.Level1) +{ + std::shared_ptr videoParam = std::make_shared(); + dScreen_->SetVideoParam(videoParam); + std::shared_ptr actual = dScreen_->GetVideoParam(); + EXPECT_NE(nullptr, actual); +} + +/** + * @tc.name: GetState_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTest, GetState_001, TestSize.Level1) +{ + DScreenState state = DISABLED; + dScreen_->SetState(state); + DScreenState actual = dScreen_->GetState(); + EXPECT_EQ(DISABLED, actual); +} + +/** + * @tc.name: GetScreenId_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTest, GetScreenId_001, TestSize.Level1) +{ + uint64_t screenId_ = 1000; + uint64_t actual = dScreen_->GetScreenId(); + EXPECT_NE(screenId_, actual); +} + +/** + * @tc.name: GetDHId_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTest, GetDHId_001, TestSize.Level1) +{ + std::string dhId_ = "hello"; + std::string actual = dScreen_->GetDHId(); + EXPECT_EQ(dhId_, actual); +} + +/** + * @tc.name: GetDevId_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTest, GetDevId_001, TestSize.Level1) +{ + std::string devId_ = "hello"; + std::string actual = dScreen_->GetDevId(); + EXPECT_EQ(devId_, actual); +} + +/** + * @tc.name: AddTask_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTest, AddTask_001, TestSize.Level1) +{ + int actual = dScreen_->AddTask(task); + EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_TASK_NOT_VALID, actual); +} + +/** + * @tc.name: AddTask_002 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenTest, AddTask_002, TestSize.Level1) +{ + TaskType taskType_; + std::string taskParam_ = "taskParam"; + taskType_ = TASK_ENABLE; + const std::shared_ptr task = std::make_shared(taskType_, taskParam_); + int32_t sizeFront = dScreen_->taskQueue_.size(); + int actual = dScreen_->AddTask(task); + int32_t sizeEnd = dScreen_->taskQueue_.size(); + EXPECT_GT(sizeEnd, sizeFront); + EXPECT_EQ(DH_SUCCESS, actual); +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp new file mode 100644 index 00000000..0c5b8639 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp @@ -0,0 +1,137 @@ +/* + * 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. + */ + +#define private public +#include "screen_manager_adapter_test.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void ScreenMgrAdapterTest::SetUpTestCase(void) {} + +void ScreenMgrAdapterTest::TearDownTestCase(void) {} + +void ScreenMgrAdapterTest::SetUp() +{ + screenMgrAdapter_ = new ScreenMgrAdapter(); +} + +void ScreenMgrAdapterTest::TearDown(void) +{ + delete screenMgrAdapter_; + screenMgrAdapter_ = nullptr; +} + +/** + * @tc.name: CreateVirtualScreen_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenMgrAdapterTest, CreateVirtualScreen_001, TestSize.Level1) +{ + std::string devId = "hello"; + std::string dhId = "hello"; + std::shared_ptr videoParam = std::make_shared(); + uint64_t screenId = SCREEN_ID_INVALID; + uint64_t actual = screenMgrAdapter_->CreateVirtualScreen(devId, dhId, videoParam); + EXPECT_NE(screenId, actual); + screenMgrAdapter_->RemoveVirtualScreen(actual); +} + +/** + * @tc.name: RemoveVirtualScreen_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenMgrAdapterTest, RemoveVirtualScreen_001, TestSize.Level1) +{ + uint64_t screenId = 0; + uint64_t actual = screenMgrAdapter_->RemoveVirtualScreen(screenId); + EXPECT_EQ(ERR_DH_SCREEN_SA_REMOVE_VIRTUALSCREEN_FAIL, actual); +} + +/** + * @tc.name: SetImageSurface_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenMgrAdapterTest, SetImageSurface_001, TestSize.Level1) +{ + uint64_t screenId = 0; + sptr surface; + int32_t actual = screenMgrAdapter_->SetImageSurface(screenId, surface); + EXPECT_EQ(DH_SUCCESS, actual); +} + + +/** + * @tc.name: RegisterScreenGroupListener_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenMgrAdapterTest, RegisterScreenGroupListener_001, TestSize.Level1) +{ + bool listnerRegistered = true; + sptr listener = new MockScreenGroupListener(); + int32_t actual = screenMgrAdapter_->RegisterScreenGroupListener(listener); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: RegisterScreenGroupListener_002 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenMgrAdapterTest, RegisterScreenGroupListener_002, TestSize.Level1) +{ + sptr listener = new MockScreenGroupListener(); + int32_t actual = screenMgrAdapter_->RegisterScreenGroupListener(listener); + EXPECT_EQ(ERR_DH_SCREEN_SA_REGISTER_SCREENLISTENER_FAIL, actual); +} + +/** + * @tc.name: UnregisterScreenGroupListener_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenMgrAdapterTest, UnregisterScreenGroupListener_001, TestSize.Level1) +{ + sptr listener = new MockScreenGroupListener(); + int32_t actual = screenMgrAdapter_->UnregisterScreenGroupListener(listener); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: GetMapRelation_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(ScreenMgrAdapterTest, GetMapRelation_001, TestSize.Level1) +{ + uint64_t screenId = 0; + std::shared_ptr actual = screenMgrAdapter_->GetMapRelation(screenId); + EXPECT_NE(nullptr, actual); +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h new file mode 100644 index 00000000..7edd17f5 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h @@ -0,0 +1,42 @@ +/* + * 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. + */ + +#ifndef OHOS_DSCREEN_SOURCE_CALLBACK_PROXY_TEST_H +#define OHOS_DSCREEN_SOURCE_CALLBACK_PROXY_TEST_H + +#include + +#include "parcel.h" + +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_source_callback_proxy.h" +#include "dscreen_util.h" + +namespace OHOS { +namespace DistributedHardware { +class DScreenSourceCallbackProxyTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + sptr dScreenSourceCallbackProxy_ = nullptr; + std:shared_ptr systemAbilityManagerClient_ = nullptr; +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_service_test.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_service_test.h new file mode 100644 index 00000000..500a1279 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_service_test.h @@ -0,0 +1,47 @@ +/* + * 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. + */ + +#ifndef OHOS_DSCREEN_SOURCE_SERVICE_TEST_H +#define OHOS_DSCREEN_SOURCE_SERVICE_TEST_H + +#include + +#include "if_system_ability_manager.h" +#include "ipc_skeleton.h" +#include "ipc_types.h" +#include "iservice_registry.h" +#include "string_ex.h" +#include "system_ability_definition.h" + +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_source_service.h" +#include "dscreen_util.h" + +namespace OHOS { +namespace DistributedHardware { +class DSCreenSourceServiceTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + std::shared_ptr dScreenSourceService_ = nullptr; +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h new file mode 100644 index 00000000..39b8b90f --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h @@ -0,0 +1,43 @@ +/* + * 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. + */ + +#ifndef OHOS_DSCREEN_SOURCE_STUB_TEST_H +#define OHOS_DSCREEN_SOURCE_STUB_TEST_H + +#include + +#include "iservice_registry.h" + +#include "dscreen_constants.h" +#include "dscreen_errcode.h" +#include "dscreen_log.h" +#include "dscreen_source_callback_proxy.h" +#include "dscreen_source_stub.h" +#include "mock_dscreen_source_stub.h" + +namespace OHOS { +namespace DistributedHardware { +class DScreenSourceStubTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); + + MockDScreenSourceStub *dScreenSourceStub_ = nullptr; +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/mock_dscreen_source_stub.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/mock_dscreen_source_stub.h new file mode 100644 index 00000000..d601e878 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/mock_dscreen_source_stub.h @@ -0,0 +1,41 @@ +/* + * 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. + */ + +#ifndef OHOS_MOCK_DSCREEN_SOURCE_STUB_H +#define OHOS_MOCK_DSCREEN_SOURCE_STUB_H + +#include "dscreen_source_stub.h" + +namespace OHOS { +namespace DistributedHardware { +class MockDScreenSourceStub : public DScreenSourceStub { +public: + MockDScreenSourceStub() = default; + virtual ~MockDScreenSourceStub() {}; + virtual int32_t InitSource(const std::string ¶ms, const sptr &callback); + virtual int32_t ReleaseSource(); + virtual int32_t RegisterDistributedHardware(const std::string &devId, const std::string &dhId, + const EnableParam ¶m, const std::string &reqId); + virtual int32_t UnregisterDistributedHardware(const std::string &devId, const std::string &dhId, + const std::string &reqId); + virtual int32_t ConfigDistributedHardware(const std::string &devId, const std::string &dhId, + const std::string &key, const std::string &value); + virtual void DScreenNotify(const std::string &devId, int32_t eventCode, + const std::string &eventContent); + virtual void MockScreenChange(const std::vector &screenIds, uint32_t event); +}; +} // DistributedHardware +} // OHOS +#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp new file mode 100644 index 00000000..81e17845 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp @@ -0,0 +1,118 @@ +/* + * 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. + */ + +#define private public +#include "dscreen_source_callback_proxy_test.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void DScreenSourceCallbackProxyTest::SetUpTestCase(void) {} + +void DScreenSourceCallbackProxyTest::TearDownTestCase(void) {} + +void DScreenSourceCallbackProxyTest::SetUp() +{ + systemAbilityManagerClient_ = std::make_shared(); + sptr samgr = systemAbilityManagerClient_->GetSystemAbilityManager(); + if (!samgr) { + return; + } + + sptr remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SINK_SA_ID); + if (!remoteObject) { + return; + } + + dScreenSourceCallbackProxy_ = new DScreenSourceCallbackProxy(remoteObject); +} + +void DScreenSourceCallbackProxyTest::TearDown(void) +{ + dScreenSourceCallbackProxy_.clear(); + systemAbilityManagerClient_->DestorySystemAbilityManagerObject(); +} + +/** + * @tc.name: OnNotifyRegResult_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyRegResult_001, TestSize.Level1) +{ + std::string devId = "hello"; + std::string dhId = "hello"; + std::string reqId = "hello"; + int32_t status = 0; + std::string resultData = "hello"; + int32_t actual = dScreenSourceCallbackProxy->OnNotifyRegResult(devId, dhId, reqId, status, resultData); + EXPECT_NE(ERR_DH_SCREEN_SA_WRITEPARAM_FAILED, actual); +} + +/** + * @tc.name: OnNotifyRegResult_002 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyRegResult_002, TestSize.Level1) +{ + std::string devId = "hello"; + std::string dhId = "hello"; + std::string reqId = "hello"; + int32_t status = 0; + std::string resultData = "hello"; + int32_t actual = dScreenSourceCallbackProxy->OnNotifyRegResult(devId, dhId, reqId, status, resultData); + EXPECT_NE(ERR_DH_SCREEN_SA_WRITEINTERFACETOKEN_FAILED, actual); +} + +/** + * @tc.name: OnNotifyUnregResult_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyUnregResult_001, TestSize.Level1) +{ + std::string devId = "hello"; + std::string dhId = "hello"; + std::string reqId = "hello"; + int32_t status = 0; + std::string resultData = "hello"; + int32_t actual = dScreenSourceCallbackProxy->OnNotifyUnregResult(devId, dhId, reqId, status, resultData); + EXPECT_NE(ERR_DH_SCREEN_SA_WRITEPARAM_FAILED, actual); +} + +/** + * @tc.name: OnNotifyUnregResult_002 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyUnregResult_002, TestSize.Level1) +{ + std::string devId = "hello"; + std::string dhId = "hello"; + std::string reqId = "hello"; + int32_t status = 0; + std::string resultData = "hello"; + int32_t actual = dScreenSourceCallbackProxy->OnNotifyRegResult(devId, dhId, reqId, status, resultData); + EXPECT_NE(ERR_DH_SCREEN_SA_WRITEINTERFACETOKEN_FAILED, actual); +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp new file mode 100644 index 00000000..3352f05e --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp @@ -0,0 +1,118 @@ +/* + * 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. + */ + +#define private public +#include "dscreen_source_service_test.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void DSCreenSourceServiceTest::SetUpTestCase(void) {} + +void DSCreenSourceServiceTest::TearDownTestCase(void) {} + +void DSCreenSourceServiceTest::SetUp() +{ + int32_t saId =4807; + bool runOnCreate = false; + dScreenSourceService_ = std::make_shared(saId, runOnCreate); +} + +void DSCreenSourceServiceTest::TearDown(void) {} + +/** + * @tc.name: InitSource_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DSCreenSourceServiceTest, InitSource_001, TestSize.Level1) +{ + std::string params = "hello"; + sptr callback = nullptr; + int32_t actual = dScreenSourceService_->InitSource(params, callback); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: ReleaseSource_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DSCreenSourceServiceTest, ReleaseSource_001, TestSize.Level1) +{ + std::string params = "hello"; + sptr callback = nullptr; + int32_t actual = dScreenSourceService_->InitSource(params, callback); + int32_t actual = dScreenSourceService_->ReleaseSource(); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: RegisterDistributedHardware_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DSCreenSourceServiceTest, RegisterDistributedHardware_001, TestSize.Level1) +{ + std::string devId = "hello"; + std::string dhId = "hello"; + EnableParam param; + param.version = "version"; + param.attrs = "attrs"; + std::string reqId = "hello"; + int32_t actual = dScreenSourceService_->RegisterDistributedHardware(devId, dhId, param, reqId); + EXPECT_EQ(ERR_DH_SCREEN_SA_ENABLE_FAILED, actual); +} + +/** + * @tc.name: UnregisterDistributedHardware_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DSCreenSourceServiceTest, UnregisterDistributedHardware_001, TestSize.Level1) +{ + std::string devIdTrue = "hello"; + std::string dhIdTrue = "hello"; + std::string reqId = "hello"; + std::string devIdFalse = "world"; + std::string dhIdFalse = "world"; + std::shared_ptr dScreen = std::make_shared(devIdFalse, dhIdFalse, dscreenCallback); + int32_t actual = dScreenSourceService_->UnregisterDistributedHardware(devIdTrue, dhIdTrue, reqId); + EXPECT_EQ(ERR_DH_SCREEN_SA_DISABLE_FAILED, actual); +} + +/** + * @tc.name: ConfigDistributedHardware_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DSCreenSourceServiceTest, ConfigDistributedHardware_001, TestSize.Level1) +{ + std::string devId = "DevId"; + std::string dhId = "DhId"; + std::string key = "Key"; + std::string value = "Value"; + int32_t actual = dScreenSourceService_->ConfigDistributedHardware(devId, dhId, key, value); + EXPECT_EQ(DH_SUCCESS, actual); +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp new file mode 100644 index 00000000..35e896d1 --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp @@ -0,0 +1,71 @@ +/* + * 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. + */ + +#define private public +#include "dscreen_source_stub_test.h" +#undef private + +using namespace testing::ext; + +namespace OHOS { +namespace DistributedHardware { +void DScreenSourceStubTest::SetUpTestCase(void) {} + +void DScreenSourceStubTest::TearDownTestCase(void) {} + +void DScreenSourceStubTest::SetUp() +{ + dScreenSourceStub_ = new MockDScreenSourceStub(); +} + +void DScreenSourceStubTest::TearDown(void) +{ + delete dScreenSourceStub_; + dScreenSourceStub_ = nullptr; +} + +/** + * @tc.name: OnRemoteRequest_001 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, OnRemoteRequest_001, TestSize.Level1) +{ + uint32_t code = 0; + MessageParcel data; + MessageParcel reply; + MessageOption option; + int32_t actual = dScreenSourceStub_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(DH_SUCCESS, actual); +} + +/** + * @tc.name: OnRemoteRequest_002 + * @tc.desc: Verify the Capacity function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(DScreenSourceStubTest, OnRemoteRequest_002, TestSize.Level1) +{ + uint32_t code = 6; + MessageParcel data; + MessageParcel reply; + MessageOption option; + int32_t actual = dScreenSourceStub_->OnRemoteRequest(code, data, reply, option); + EXPECT_EQ(ERR_DH_SCREEN_SA_REQUEST_CODE_INVALID, actual); +} +} // DistributedHardware +} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp new file mode 100644 index 00000000..7d03f48f --- /dev/null +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp @@ -0,0 +1,76 @@ +/* + * 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 "mock_dscreen_source_stub.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t MockDScreenSourceStub::InitSource(const std::string ¶ms, const sptr &callback) +{ + (void) params; + (void) callback; + return 0; +} + +int32_t MockDScreenSourceStub::ReleaseSource() +{ + return 0; +} + +int32_t MockDScreenSourceStub::RegisterDistributedHardware(const std::string &devId, const std::string &dhId, + const EnableParam ¶m, const std::string &reqId) +{ + (void) devId; + (void) dhId; + (void) param; + (void) reqId; + return 0; +} + +int32_t MockDScreenSourceStub::UnregisterDistributedHardware(const std::string &devId, const std::string &dhId, + const std::string &reqId) +{ + (void) devId; + (void) dhId; + (void) reqId; + return 0; +} + +int32_t MockDScreenSourceStub::ConfigDistributedHardware(const std::string &devId, const std::string &dhId, + const std::string &key, const std::string &value) +{ + (void) devId; + (void) dhId; + (void) key; + (void) value; + return 0; +} + +void MockDScreenSourceStub::DScreenNotify(const std::string &devId, int32_t eventCode, const std::string &eventContent) +{ + (void) devId; + (void) eventCode; + (void) eventContent; + return; +} + +void MockDScreenSourceStub::MockScreenChange(const std::vector &screenIds, uint32_t event) +{ + (void) screenIds; + (void) event; + return; +} +} // DistributedHardware +} // OHOS \ No newline at end of file -- Gitee From 8b0d295c5947915701beb0d2c378ca70475a0a60 Mon Sep 17 00:00:00 2001 From: ljh54_space Date: Wed, 27 Apr 2022 22:11:51 +0800 Subject: [PATCH 2/4] change UT files Signed-off-by: ljh54_space --- .vscode/settings.json | 63 ------------------- services/screenservice/test/unittest/BUILD.gn | 4 +- .../test/unittest/sinkservice/BUILD.gn | 3 +- .../src/dscreen_sink_stub_test.cpp | 2 +- .../include/mock_iscreen_sink_trans.h | 9 +-- .../src/mock_iscreen_sink_trans.cpp | 3 +- .../src/screen_region_mgr_test.cpp | 2 +- .../src/screen_region_test.cpp | 5 +- .../test/unittest/sourceservice/BUILD.gn | 10 ++- .../dscreenmgr/src/dscreen_manager_test.cpp | 2 +- .../dscreenmgr/src/dscreen_test.cpp | 1 + .../src/screen_manager_adapter_test.cpp | 14 ----- .../dscreen_source_callback_proxy_test.h | 5 ++ .../include/dscreen_source_stub_test.h | 1 + .../dscreen_source_callback_proxy_test.cpp | 10 +-- .../src/dscreen_source_service_test.cpp | 3 +- .../src/dscreen_source_stub_test.cpp | 2 +- .../src/mock_dscreen_source_stub.cpp | 6 +- 18 files changed, 43 insertions(+), 102 deletions(-) delete mode 100644 .vscode/settings.json diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 8f80e74c..00000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,63 +0,0 @@ -{ - "files.associations": { - "algorithm": "cpp", - "atomic": "cpp", - "chrono": "cpp", - "cmath": "cpp", - "condition_variable": "cpp", - "cstddef": "cpp", - "cstdint": "cpp", - "cstdio": "cpp", - "cstdlib": "cpp", - "cstring": "cpp", - "ctime": "cpp", - "cwchar": "cpp", - "deque": "cpp", - "exception": "cpp", - "functional": "cpp", - "initializer_list": "cpp", - "iomanip": "cpp", - "ios": "cpp", - "iosfwd": "cpp", - "iostream": "cpp", - "istream": "cpp", - "limits": "cpp", - "list": "cpp", - "map": "cpp", - "memory": "cpp", - "mutex": "cpp", - "new": "cpp", - "ostream": "cpp", - "queue": "cpp", - "random": "cpp", - "ratio": "cpp", - "set": "cpp", - "sstream": "cpp", - "stdexcept": "cpp", - "streambuf": "cpp", - "string": "cpp", - "system_error": "cpp", - "xthread": "cpp", - "thread": "cpp", - "tuple": "cpp", - "type_traits": "cpp", - "typeinfo": "cpp", - "utility": "cpp", - "vector": "cpp", - "xfacet": "cpp", - "xfunctional": "cpp", - "xiosbase": "cpp", - "xlocale": "cpp", - "xlocinfo": "cpp", - "xlocmon": "cpp", - "xlocnum": "cpp", - "xloctime": "cpp", - "xmemory": "cpp", - "xmemory0": "cpp", - "xstddef": "cpp", - "xstring": "cpp", - "xtr1common": "cpp", - "xtree": "cpp", - "xutility": "cpp" - } -} \ No newline at end of file diff --git a/services/screenservice/test/unittest/BUILD.gn b/services/screenservice/test/unittest/BUILD.gn index bdc8ca76..17d77d41 100644 --- a/services/screenservice/test/unittest/BUILD.gn +++ b/services/screenservice/test/unittest/BUILD.gn @@ -14,7 +14,7 @@ group("screen_service_test") { testonly = true deps = [ - "sinkservice:sink_service_test", - "sourceservice:source_service_test", + "sinkservice:sink_service_test", + "sourceservice:source_service_test", ] } \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/BUILD.gn b/services/screenservice/test/unittest/sinkservice/BUILD.gn index c69367fb..b20bfaca 100644 --- a/services/screenservice/test/unittest/sinkservice/BUILD.gn +++ b/services/screenservice/test/unittest/sinkservice/BUILD.gn @@ -43,7 +43,8 @@ config("module_private_config") { "${services_path}/screentransport/screensinkprocessor/include", "${services_path}/screentransport/screensinkprocessor/decoder/include", "${services_path}/screenclient/include/", - "${services_path}/screenservice/test/unittest/sinkservice/include", + "${services_path}/screenservice/test/unittest/sinkservice/dscreenservice/include", + "${services_path}/screenservice/test/unittest/sinkservice/screenregionmgr/include", "${services_path}/screenservice/sinkservice/dscreenservice/include", "${services_path}/screenservice/sinkservice/screenregionmgr/include", "${services_path}/evevntcontrol/eventcollector/inlude", diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp index c08603dc..b11e74d6 100644 --- a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp +++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp @@ -65,7 +65,7 @@ HWTEST_F(DScreenSinkStubTest, OnRemoteRequest_002, TestSize.Level1) MessageParcel data; MessageParcel reply; MessageOption option; - dScreenSinkStub_->memberFuncMap.clear(); + dScreenSinkStub_->memberFuncMap_.clear(); int32_t actual = dScreenSinkStub_->OnRemoteRequest(code, data, reply, option); EXPECT_EQ(ERR_DH_SCREEN_SA_INVALID_IPC_CALL, actual); } diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h index 835ee5ce..f106dc6e 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h @@ -25,10 +25,11 @@ public: MockIScreenSinkTrans() = default; ~MockIScreenSinkTrans() = default; virtual int32_t SetUp(const VideoParam &localParam, const VideoParam &remoteParam, const std::string &peerDevId) override; - virtual int32_t Release() override; - virtual int32_t Start() override; - virtual int32_t Stop() override; - virtual int32_t RegisterStateCallback(const std::shared_ptr &callback) override; + virtual int32_t Release(); + virtual int32_t Start(); + virtual int32_t Stop(); + virtual int32_t RegisterStateCallback(const std::shared_ptr &callback); + virtual int32_t SetImageSurface(const sptr &surface); }; } // DistributedHardware } // OHOS diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/mock_iscreen_sink_trans.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/mock_iscreen_sink_trans.cpp index ad23b232..08fdb98c 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/mock_iscreen_sink_trans.cpp +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/mock_iscreen_sink_trans.cpp @@ -17,7 +17,8 @@ namespace OHOS { namespace DistributedHardware { -int32_t MockIScreenSinkTrans::SetUp(const VideoParam &localParam, const VideoParam &remoteParam, const std::string &peerDevId) +int32_t MockIScreenSinkTrans::SetUp(const VideoParam &localParam, const VideoParam &remoteParam, + const std::string &peerDevId) { (void) localParam; (void) remoteParam; diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp index ee30b6b4..79fe3b00 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp @@ -30,7 +30,7 @@ void ScreenRegionManagerTest::SetUp(void) screenRegionManager_ = std::make_shared(); } -void ScreenRegionManagerTest::TearDown(void){} +void ScreenRegionManagerTest::TearDown(void) {} /** * @tc.name: ReleaseAllRegions_001 diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp index 0616b71b..825dfbd1 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp @@ -45,6 +45,7 @@ HWTEST_F(ScreenRegionTest, OnTransError_001, TestSize.Level1) { int32_t err = 0; const std::string content = "hello"; + screenRegion_->sinkTrans_ = nullptr; screenRegion_->OnTransError(err, content); } @@ -135,7 +136,7 @@ HWTEST_F(ScreenRegionTest, Stop_002, TestSize.Level1) int32_t windowId = INVALID_WINDOW_ID; windowId = ScreenClient::GetInstance().AddWindow(windowProperty); ScreenClient::GetInstance().RemoveWindow(windowId); - int32_t actual = screenRegion->Stop(); + int32_t actual = screenRegion_->Stop(); EXPECT_EQ(DH_SUCCESS, actual); } @@ -159,8 +160,8 @@ HWTEST_F(ScreenRegionTest, GetScreenId_001, TestSize.Level1) */ HWTEST_F(ScreenRegionTest, GetRemoteDevId_001, TestSize.Level1) { - screenRegion_->remoteDevId_ = "remoteDevId"; std::string actual = screenRegion_->GetRemoteDevId(); + screenRegion_->remoteDevId_ = "remoteDevId"; EXPECT_EQ(screenRegion_->remoteDevId_, actual); } } // DistributedHardware diff --git a/services/screenservice/test/unittest/sourceservice/BUILD.gn b/services/screenservice/test/unittest/sourceservice/BUILD.gn index 94b65283..2ea2ad74 100644 --- a/services/screenservice/test/unittest/sourceservice/BUILD.gn +++ b/services/screenservice/test/unittest/sourceservice/BUILD.gn @@ -30,6 +30,7 @@ config("module_private_config") { "${fwk_utils_path}/include", "${fwk_common_path}/log/inlcude", "${fwk_common_path}/utils/include", + "${mediastandard_path}/interfaces/innerkits/native/media/include", ] include_dirs += [ @@ -47,16 +48,19 @@ config("module_private_config") { "${services_path}/screentransport/screensourceprocessor/include", "${services_path}/screentransport/screensourceprocessor/encoder/include", "${services_path}/screentransport/screensourcetrans/include", - "${services_path}/screenservice/test/unittest/sourceservice/include", + "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/include", + "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/include", "${services_path}/screenservice/sourceservice/dscreenmgr/include", "${services_path}/screenservice/sourceservice/dscreenservice/include", + "${services_path}/screenservice/sourceservice/dscreenservice/callback", "${services_path}/evevntcontrol/eventinjector/include", + "out/baltimore/obj/foundation/multimedia/media_standard/interfaces/innerkits/native/media/include", ] } ##Unittest source_service_test ohos_unittest("SourceServiceTest") { - module_out_path = module_our_path + module_out_path = module_out_path sources = [ "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp", @@ -77,7 +81,7 @@ ohos_unittest("SourceServiceTest") { "${common_path}:distributed_screen_utils", "${services_path}/screentransport/screensourcetrans:distributed_screen_sourcetrans", "${services_path}/screenservice/sourceservice:distributed_screen_source", - "utils/native/base:utils", + "//utils/native/base:utils", "${fwk_utils_path}:distributedhardwareutils", "${windowmanager_path}/interfaces/innerkits:wm_interface", "${windowmanager_path}/dm:libdm", diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp index 2e4ec397..44e6e8ea 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp @@ -44,7 +44,7 @@ HWTEST_F(DScreenManagerTest, EnableDistributedScreen_001, TestSize.Level1) std::string dhId = "hello"; std::string param = "hello"; std::string reqId = "hello"; - std::shared_ptr dScreenCallback = nullptr; + std::shared_ptr dScreenCallback_ = nullptr; int32_t actual = dscreenManager_->EnableDistributedScreen(devId, dhId, param, reqId); EXPECT_EQ(ERR_DH_SCREEN_SA_ENABLE_FAILED, actual); } diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp index d7a6bc12..0aaa146d 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp @@ -123,6 +123,7 @@ HWTEST_F(DScreenTest, GetDevId_001, TestSize.Level1) */ HWTEST_F(DScreenTest, AddTask_001, TestSize.Level1) { + std::shared_ptr task = nullptr; int actual = dScreen_->AddTask(task); EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_TASK_NOT_VALID, actual); } diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp index 0c5b8639..4385e70d 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp @@ -89,25 +89,11 @@ HWTEST_F(ScreenMgrAdapterTest, SetImageSurface_001, TestSize.Level1) */ HWTEST_F(ScreenMgrAdapterTest, RegisterScreenGroupListener_001, TestSize.Level1) { - bool listnerRegistered = true; sptr listener = new MockScreenGroupListener(); int32_t actual = screenMgrAdapter_->RegisterScreenGroupListener(listener); EXPECT_EQ(DH_SUCCESS, actual); } -/** - * @tc.name: RegisterScreenGroupListener_002 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(ScreenMgrAdapterTest, RegisterScreenGroupListener_002, TestSize.Level1) -{ - sptr listener = new MockScreenGroupListener(); - int32_t actual = screenMgrAdapter_->RegisterScreenGroupListener(listener); - EXPECT_EQ(ERR_DH_SCREEN_SA_REGISTER_SCREENLISTENER_FAIL, actual); -} - /** * @tc.name: UnregisterScreenGroupListener_001 * @tc.desc: Verify the Capacity function. diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h index 7edd17f5..347c17d2 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h @@ -18,8 +18,13 @@ #include +#include "iservice_registry.h" +#include "if_system_ability_manager.h" +#include "ipc_skeleton.h" #include "parcel.h" +#include "system_ability_definition.h" +#include "dscreen_constants.h" #include "dscreen_errcode.h" #include "dscreen_log.h" #include "dscreen_source_callback_proxy.h" diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h index 39b8b90f..ec5e62e0 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h @@ -29,6 +29,7 @@ namespace OHOS { namespace DistributedHardware { +const int32_t WRONGNUM = 6; class DScreenSourceStubTest : public testing::Test { public: static void SetUpTestCase(void); diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp index 81e17845..e119912a 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp @@ -44,7 +44,7 @@ void DScreenSourceCallbackProxyTest::SetUp() void DScreenSourceCallbackProxyTest::TearDown(void) { dScreenSourceCallbackProxy_.clear(); - systemAbilityManagerClient_->DestorySystemAbilityManagerObject(); + systemAbilityManagerClient_->DestroySystemAbilityManagerObject(); } /** @@ -60,7 +60,7 @@ HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyRegResult_001, TestSize.Level1) std::string reqId = "hello"; int32_t status = 0; std::string resultData = "hello"; - int32_t actual = dScreenSourceCallbackProxy->OnNotifyRegResult(devId, dhId, reqId, status, resultData); + int32_t actual = dScreenSourceCallbackProxy_->OnNotifyRegResult(devId, dhId, reqId, status, resultData); EXPECT_NE(ERR_DH_SCREEN_SA_WRITEPARAM_FAILED, actual); } @@ -77,7 +77,7 @@ HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyRegResult_002, TestSize.Level1) std::string reqId = "hello"; int32_t status = 0; std::string resultData = "hello"; - int32_t actual = dScreenSourceCallbackProxy->OnNotifyRegResult(devId, dhId, reqId, status, resultData); + int32_t actual = dScreenSourceCallbackProxy_->OnNotifyRegResult(devId, dhId, reqId, status, resultData); EXPECT_NE(ERR_DH_SCREEN_SA_WRITEINTERFACETOKEN_FAILED, actual); } @@ -94,7 +94,7 @@ HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyUnregResult_001, TestSize.Level std::string reqId = "hello"; int32_t status = 0; std::string resultData = "hello"; - int32_t actual = dScreenSourceCallbackProxy->OnNotifyUnregResult(devId, dhId, reqId, status, resultData); + int32_t actual = dScreenSourceCallbackProxy_->OnNotifyUnregResult(devId, dhId, reqId, status, resultData); EXPECT_NE(ERR_DH_SCREEN_SA_WRITEPARAM_FAILED, actual); } @@ -111,7 +111,7 @@ HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyUnregResult_002, TestSize.Level std::string reqId = "hello"; int32_t status = 0; std::string resultData = "hello"; - int32_t actual = dScreenSourceCallbackProxy->OnNotifyRegResult(devId, dhId, reqId, status, resultData); + int32_t actual = dScreenSourceCallbackProxy_->OnNotifyRegResult(devId, dhId, reqId, status, resultData); EXPECT_NE(ERR_DH_SCREEN_SA_WRITEINTERFACETOKEN_FAILED, actual); } } // DistributedHardware diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp index 3352f05e..56a39153 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp @@ -58,7 +58,7 @@ HWTEST_F(DSCreenSourceServiceTest, ReleaseSource_001, TestSize.Level1) { std::string params = "hello"; sptr callback = nullptr; - int32_t actual = dScreenSourceService_->InitSource(params, callback); + dScreenSourceService_->InitSource(params, callback); int32_t actual = dScreenSourceService_->ReleaseSource(); EXPECT_EQ(DH_SUCCESS, actual); } @@ -94,6 +94,7 @@ HWTEST_F(DSCreenSourceServiceTest, UnregisterDistributedHardware_001, TestSize.L std::string reqId = "hello"; std::string devIdFalse = "world"; std::string dhIdFalse = "world"; + std::shared_ptr dscreenCallback = nullptr; std::shared_ptr dScreen = std::make_shared(devIdFalse, dhIdFalse, dscreenCallback); int32_t actual = dScreenSourceService_->UnregisterDistributedHardware(devIdTrue, dhIdTrue, reqId); EXPECT_EQ(ERR_DH_SCREEN_SA_DISABLE_FAILED, actual); diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp index 35e896d1..a4dc820a 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp @@ -60,7 +60,7 @@ HWTEST_F(DScreenSourceStubTest, OnRemoteRequest_001, TestSize.Level1) */ HWTEST_F(DScreenSourceStubTest, OnRemoteRequest_002, TestSize.Level1) { - uint32_t code = 6; + uint32_t code = WRONGNUM; MessageParcel data; MessageParcel reply; MessageOption option; diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp index 7d03f48f..e10f8e42 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp @@ -17,7 +17,8 @@ namespace OHOS { namespace DistributedHardware { -int32_t MockDScreenSourceStub::InitSource(const std::string ¶ms, const sptr &callback) +int32_t MockDScreenSourceStub::InitSource(const std::string ¶ms, + const sptr &callback) { (void) params; (void) callback; @@ -58,7 +59,8 @@ int32_t MockDScreenSourceStub::ConfigDistributedHardware(const std::string &devI return 0; } -void MockDScreenSourceStub::DScreenNotify(const std::string &devId, int32_t eventCode, const std::string &eventContent) +void MockDScreenSourceStub::DScreenNotify(const std::string &devId, int32_t eventCode, + const std::string &eventContent) { (void) devId; (void) eventCode; -- Gitee From 4cada9f63cb1b62268cf36f779931b3ed348f164 Mon Sep 17 00:00:00 2001 From: ljh54_space Date: Thu, 28 Apr 2022 23:22:59 +0800 Subject: [PATCH 3/4] Modifying error files Signed-off-by: ljh54_space --- .../screenregionmgr/include/mock_iscreen_sink_trans.h | 2 +- services/screenservice/test/unittest/sourceservice/BUILD.gn | 2 +- .../dscreenservice/include/dscreen_source_callback_proxy_test.h | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h index f106dc6e..d27df4c2 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/mock_iscreen_sink_trans.h @@ -24,7 +24,7 @@ class MockIScreenSinkTrans : public IScreenSinkTrans { public: MockIScreenSinkTrans() = default; ~MockIScreenSinkTrans() = default; - virtual int32_t SetUp(const VideoParam &localParam, const VideoParam &remoteParam, const std::string &peerDevId) override; + virtual int32_t SetUp(const VideoParam &localParam, const VideoParam &remoteParam, const std::string &peerDevId); virtual int32_t Release(); virtual int32_t Start(); virtual int32_t Stop(); diff --git a/services/screenservice/test/unittest/sourceservice/BUILD.gn b/services/screenservice/test/unittest/sourceservice/BUILD.gn index 2ea2ad74..fe77dd9d 100644 --- a/services/screenservice/test/unittest/sourceservice/BUILD.gn +++ b/services/screenservice/test/unittest/sourceservice/BUILD.gn @@ -52,7 +52,7 @@ config("module_private_config") { "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/include", "${services_path}/screenservice/sourceservice/dscreenmgr/include", "${services_path}/screenservice/sourceservice/dscreenservice/include", - "${services_path}/screenservice/sourceservice/dscreenservice/callback", + "${services_path}/screenservice/sourceservice/dscreenservice/include/callback", "${services_path}/evevntcontrol/eventinjector/include", "out/baltimore/obj/foundation/multimedia/media_standard/interfaces/innerkits/native/media/include", ] diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h index 347c17d2..fb2746c4 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h @@ -40,7 +40,7 @@ public: void TearDown(); sptr dScreenSourceCallbackProxy_ = nullptr; - std:shared_ptr systemAbilityManagerClient_ = nullptr; + std::shared_ptr systemAbilityManagerClient_ = nullptr; }; } // DistributedHardware } // OHOS -- Gitee From 207c93e04d98ead78ff48affb0a8053d29b7f5fd Mon Sep 17 00:00:00 2001 From: ljh54_space Date: Tue, 10 May 2022 15:15:34 +0800 Subject: [PATCH 4/4] change screenservice ut code Signed-off-by: ljh54_space --- bundle.json | 2 +- .../test/unittest/sinkservice/BUILD.gn | 5 - .../include/dscreen_sink_stub_test.h | 40 ------ .../include/mock_dscreen_sink_stub.h | 35 ------ .../src/dscreen_sink_service_test.cpp | 20 +-- .../src/dscreen_sink_stub_test.cpp | 73 ----------- .../src/mock_dscreen_sink_stub.cpp | 52 -------- .../include/screen_region_mgr_test.h | 49 -------- .../src/screen_region_mgr_test.cpp | 48 ------- .../src/screen_region_test.cpp | 31 ++--- .../test/unittest/sourceservice/BUILD.gn | 18 ++- .../dscreenmgr/include/dscreen_manager_test.h | 2 - .../include/screen_manager_adapter_test.h | 2 - .../dscreenmgr/src/dscreen_manager_test.cpp | 41 ++---- .../dscreenmgr/src/dscreen_test.cpp | 50 ++------ .../src/screen_manager_adapter_test.cpp | 51 +++----- .../dscreen_source_callback_proxy_test.h | 47 ------- .../include/dscreen_source_stub_test.h | 44 ------- .../include/mock_dscreen_source_stub.h | 41 ------ .../dscreen_source_callback_proxy_test.cpp | 118 ------------------ .../src/dscreen_source_service_test.cpp | 41 ++---- .../src/dscreen_source_stub_test.cpp | 71 ----------- .../src/mock_dscreen_source_stub.cpp | 78 ------------ 23 files changed, 68 insertions(+), 891 deletions(-) delete mode 100644 services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_stub_test.h delete mode 100644 services/screenservice/test/unittest/sinkservice/dscreenservice/include/mock_dscreen_sink_stub.h delete mode 100644 services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp delete mode 100644 services/screenservice/test/unittest/sinkservice/dscreenservice/src/mock_dscreen_sink_stub.cpp delete mode 100644 services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_mgr_test.h delete mode 100644 services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp delete mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h delete mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h delete mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/include/mock_dscreen_source_stub.h delete mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp delete mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp delete mode 100644 services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp diff --git a/bundle.json b/bundle.json index 10cfec3f..8d4b9fe8 100644 --- a/bundle.json +++ b/bundle.json @@ -82,10 +82,10 @@ "//foundation/distributedhardware/distributedscreen/services/softbusadapter/test/unittest:SoftBusAdapterTest", "//foundation/distributedhardware/distributedscreen/services/common/test/unittest:service_common_test", "//foundation/distributedhardware/distributedscreen/services/screenservice/test/unittest:screen_service_test", + "//foundation/distributedhardware/distributedscreen/interfaces/innerkits/native_cpp/test/unittest:screen_interface_test", "//foundation/distributedhardware/distributedscreen/screenhandler/test/fuzztest:fuzztest", "//foundation/distributedhardware/distributedscreen/interfaces/innerkits/native_cpp/test/fuzztest:fuzztest", "//foundation/distributedhardware/distributedscreen/services/softbusadapter/test/fuzztest:fuzztest", - "//foundation/distributedhardware/distributedscreen/services/screenservice/test/fuzztest:fuzztest", "//foundation/distributedhardware/distributedscreen/services/screentransport/test/fuzztest:fuzztest" ] } diff --git a/services/screenservice/test/unittest/sinkservice/BUILD.gn b/services/screenservice/test/unittest/sinkservice/BUILD.gn index b20bfaca..38004ee2 100644 --- a/services/screenservice/test/unittest/sinkservice/BUILD.gn +++ b/services/screenservice/test/unittest/sinkservice/BUILD.gn @@ -47,7 +47,6 @@ config("module_private_config") { "${services_path}/screenservice/test/unittest/sinkservice/screenregionmgr/include", "${services_path}/screenservice/sinkservice/dscreenservice/include", "${services_path}/screenservice/sinkservice/screenregionmgr/include", - "${services_path}/evevntcontrol/eventcollector/inlude", ] } @@ -57,11 +56,8 @@ ohos_unittest("SinkServiceTest") { sources = [ "${services_path}/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp", - "${services_path}/screenservice/test/unittest/sinkservice/dscreenservice/src/mock_dscreen_sink_stub.cpp", - "${services_path}/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp", "${services_path}/screenservice/test/unittest/sinkservice/screenregionmgr/src/mock_iscreen_sink_trans.cpp", "${services_path}/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp", - "${services_path}/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp", ] @@ -76,7 +72,6 @@ ohos_unittest("SinkServiceTest") { "${services_path}/screentransport/screensinktrans:distributed_screen_sinktrans", "${services_path}/screenservice/sinkservice:distributed_screen_sink", "${services_path}/screenclient:distributed_screen_client", - "${windowmanager_path}/interfaces/innerkits:wm_interface", "${windowmanager_path}/dm:libdm", ] diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_stub_test.h b/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_stub_test.h deleted file mode 100644 index 59ebd51b..00000000 --- a/services/screenservice/test/unittest/sinkservice/dscreenservice/include/dscreen_sink_stub_test.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * 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. - */ - -#ifndef OHOS_DSCREEN_SINK_STUB_TEST_H -#define OHOS_DSCREEN_SINK_STUB_TEST_H - -#include - -#include "dscreen_constants.h" -#include "dscreen_errcode.h" -#include "dscreen_log.h" -#include "dscreen_sink_stub.h" -#include "mock_dscreen_sink_stub.h" - -namespace OHOS { -namespace DistributedHardware { -class DScreenSinkStubTest : public testing::Test { -public: - static void SetUpTestCase(void); - static void TearDownTestCase(void); - void SetUp(); - void TearDown(); - - MockDScreenSinkStub *dScreenSinkStub_ = nullptr; -}; -} // DistributedHardware -} // OHOS -#endif diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/include/mock_dscreen_sink_stub.h b/services/screenservice/test/unittest/sinkservice/dscreenservice/include/mock_dscreen_sink_stub.h deleted file mode 100644 index 168d5ea9..00000000 --- a/services/screenservice/test/unittest/sinkservice/dscreenservice/include/mock_dscreen_sink_stub.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * 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. - */ - -#ifndef OHOS_MOCK_DSCREEN_SINK_STUB_H -#define OHOS_MOCK_DSCREEN_SINK_STUB_H - -#include "dscreen_sink_stub.h" - -namespace OHOS { -namespace DistributedHardware { -class MockDScreenSinkStub : public DScreenSinkStub { -public: - MockDScreenSinkStub() = default; - virtual ~MockDScreenSinkStub() {}; - virtual int32_t InitSink(const std::string ¶ms); - virtual int32_t ReleaseSink(); - virtual int32_t SubscribeLocalHardware(const std::string &dhId, const std::string ¶m); - virtual int32_t UnsubscribeLocalHardware(const std::string &dhId); - virtual void DScreenNotify(const std::string &devId, int32_t eventCode, const std::string &eventContent); -}; -} // DistributedHardware -} // OHOS -#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp index 88d157e2..ea8d626b 100644 --- a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp +++ b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_service_test.cpp @@ -27,12 +27,12 @@ void DScreenSinkServiceTest::TearDownTestCase(void) {} void DScreenSinkServiceTest::SetUp() { - int32_t saId = 4808; + int32_t saId = DISTRIBUTED_HARDWARE_SCREEN_SINK_SA_ID; bool runOnCreate = false; sinkService_ = std::make_shared(saId, runOnCreate); } -void DScreenSinkServiceTest::TearDown(void) {} +void DScreenSinkServiceTest::TearDown() {} /** * @tc.name: InitSink_001 @@ -42,25 +42,11 @@ void DScreenSinkServiceTest::TearDown(void) {} */ HWTEST_F(DScreenSinkServiceTest, InitSink_001, TestSize.Level1) { - std::string params = "hello"; + std::string params = "params"; int32_t actual = sinkService_->InitSink(params); EXPECT_EQ(DH_SUCCESS, actual); } -/** - * @tc.name: ReleaseSink_001 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenSinkServiceTest, ReleaseSink_001, TestSize.Level1) -{ - std::string params = "hello"; - sinkService_->InitSink(params); - int32_t actual = sinkService_->ReleaseSink(); - EXPECT_EQ(DH_SUCCESS, actual); -} - /** * @tc.name: SubscribeLocalHardware_001 * @tc.desc: Verify the Capacity function. diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp deleted file mode 100644 index b11e74d6..00000000 --- a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/dscreen_sink_stub_test.cpp +++ /dev/null @@ -1,73 +0,0 @@ -/* - * 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. - */ - -#define private public -#include "dscreen_sink_stub_test.h" -#undef private - -using namespace testing::ext; - -namespace OHOS { -namespace DistributedHardware { -void DScreenSinkStubTest::SetUpTestCase(void) {} - -void DScreenSinkStubTest::TearDownTestCase(void) {} - -void DScreenSinkStubTest::SetUp(void) -{ - dScreenSinkStub_ = new MockDScreenSinkStub(); -} - -void DScreenSinkStubTest::TearDown(void) -{ - delete dScreenSinkStub_; - dScreenSinkStub_ = nullptr; -} - -/** - * @tc.name: OnRemoteRequest_001 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenSinkStubTest, OnRemoteRequest_001, TestSize.Level1) -{ - uint32_t code = 0; - MessageParcel data; - MessageParcel reply; - MessageOption option; - dScreenSinkStub_->memberFuncMap_.emplace(IDScreenSink::INIT_SINK, &DScreenSinkStub::InitSinkInner); - int32_t actual = dScreenSinkStub_->OnRemoteRequest(code, data, reply, option); - EXPECT_EQ(DH_SUCCESS, actual); -} - -/** - * @tc.name: OnRemoteRequest_002 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenSinkStubTest, OnRemoteRequest_002, TestSize.Level1) -{ - uint32_t code = 0; - MessageParcel data; - MessageParcel reply; - MessageOption option; - dScreenSinkStub_->memberFuncMap_.clear(); - int32_t actual = dScreenSinkStub_->OnRemoteRequest(code, data, reply, option); - EXPECT_EQ(ERR_DH_SCREEN_SA_INVALID_IPC_CALL, actual); -} -} // DistributedHardware -} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/mock_dscreen_sink_stub.cpp b/services/screenservice/test/unittest/sinkservice/dscreenservice/src/mock_dscreen_sink_stub.cpp deleted file mode 100644 index e8e5581a..00000000 --- a/services/screenservice/test/unittest/sinkservice/dscreenservice/src/mock_dscreen_sink_stub.cpp +++ /dev/null @@ -1,52 +0,0 @@ -/* - * 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 "mock_dscreen_sink_stub.h" - -namespace OHOS { -namespace DistributedHardware { -int32_t MockDScreenSinkStub::InitSink(const std::string ¶ms) -{ - (void) params; - return 0; -} - -int32_t MockDScreenSinkStub::ReleaseSink() -{ - return 0; -} - -int32_t MockDScreenSinkStub::SubscribeLocalHardware(const std::string &dhId, const std::string ¶m) -{ - (void) dhId; - (void) param; - return 0; -} - -int32_t MockDScreenSinkStub::UnsubscribeLocalHardware(const std::string &dhId) -{ - (void) dhId; - return 0; -} - -void MockDScreenSinkStub::DScreenNotify(const std::string &devId, int32_t eventCode, const std::string &eventContent) -{ - (void) devId; - (void) eventCode; - (void) eventContent; - return; -} -} // DistributedHardware -} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_mgr_test.h b/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_mgr_test.h deleted file mode 100644 index c5f765c7..00000000 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/include/screen_region_mgr_test.h +++ /dev/null @@ -1,49 +0,0 @@ -/* - * 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. - */ - -#ifndef OHOS_SCREEN_REGION_MGR_TEST_H -#define OHOS_SCREEN_REGION_MGR_TEST_H - -#include - -#include "display_manager.h" -#include "if_system_ability_manager.h" -#include "iservice_registry.h" -#include "nlohmann/json.hpp" - -#include "dscreen_constants.h" -#include "dscreen_errcode.h" -#include "dscreen_log.h" -#include "dscreen_maprelation.h" -#include "dscreen_util.h" -#include "idscreen_source.h" -#include "screen_client.h" -#include "screen_client_common.h" -#include "screenregionmgr.h" - -namespace OHOS { -namespace DistributedHardware { -class ScreenRegionManagerTest : public testing::Test { -public: - static void SetUpTestCase(void); - static void TearDownTestCase(void); - void SetUp(); - void TearDown(); - - std::shared_ptr screenRegionManager_ = nullptr; -}; -} // DistributedHardware -} // OHOS -#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp deleted file mode 100644 index 79fe3b00..00000000 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_mgr_test.cpp +++ /dev/null @@ -1,48 +0,0 @@ -/* - * 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. - */ - -#define private public -#include "screen_region_mgr_test.h" -#undef private - -using namespace testing::ext; - -namespace OHOS { -namespace DistributedHardware { -void ScreenRegionManagerTest::SetUpTestCase(void) {} - -void ScreenRegionManagerTest::TearDownTestCase(void) {} - -void ScreenRegionManagerTest::SetUp(void) -{ - screenRegionManager_ = std::make_shared(); -} - -void ScreenRegionManagerTest::TearDown(void) {} - -/** - * @tc.name: ReleaseAllRegions_001 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(ScreenRegionManagerTest, ReleaseAllRegions_001, TestSize.Level1) -{ - - int32_t actual = screenRegionManager_->ReleaseAllRegions(); - EXPECT_EQ(DH_SUCCESS, actual); -} -} // DistributedHardware -} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp index 825dfbd1..c1e55934 100644 --- a/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp +++ b/services/screenservice/test/unittest/sinkservice/screenregionmgr/src/screen_region_test.cpp @@ -25,15 +25,15 @@ void ScreenRegionTest::SetUpTestCase(void) {} void ScreenRegionTest::TearDownTestCase(void) {} -void ScreenRegionTest::SetUp(void) +void ScreenRegionTest::SetUp() { - const std::string remoteDevId = "hello"; + const std::string remoteDevId = "remoteDevId"; uint64_t screenId = 0; uint64_t displayId = 0; screenRegion_ = std::make_shared(remoteDevId, screenId, displayId); } -void ScreenRegionTest::TearDown(void) {} +void ScreenRegionTest::TearDown() {} /** * @tc.name: OnTransError_001 @@ -44,7 +44,7 @@ void ScreenRegionTest::TearDown(void) {} HWTEST_F(ScreenRegionTest, OnTransError_001, TestSize.Level1) { int32_t err = 0; - const std::string content = "hello"; + const std::string content = "content"; screenRegion_->sinkTrans_ = nullptr; screenRegion_->OnTransError(err, content); } @@ -73,18 +73,6 @@ HWTEST_F(ScreenRegionTest, SetMapRelation_001, TestSize.Level1) screenRegion_->SetMapRelation(mapRelation); } -/** - * @tc.name: SetUp_001 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(ScreenRegionTest, SetUp_001, TestSize.Level1) -{ - int32_t actual = screenRegion_->SetUp(); - EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_SCREENGION_SETUP_FAILED, actual); -} - /** * @tc.name: Start_001 * @tc.desc: Verify the Capacity function. @@ -118,7 +106,8 @@ HWTEST_F(ScreenRegionTest, Start_002, TestSize.Level1) */ HWTEST_F(ScreenRegionTest, Stop_001, TestSize.Level1) { - screenRegion_->Start(); + screenRegion_->isRunning = true; + screenRegion_->sinkTrans_ = nullptr; int32_t actual = screenRegion_->Stop(); EXPECT_EQ(ERR_DH_SCREEN_SA_SINKTRANS_NOT_INIT, actual); } @@ -131,11 +120,6 @@ HWTEST_F(ScreenRegionTest, Stop_001, TestSize.Level1) */ HWTEST_F(ScreenRegionTest, Stop_002, TestSize.Level1) { - screenRegion_->sinkTrans_ = std::make_shared(); - std::shared_ptr windowProperty = std::make_shared(); - int32_t windowId = INVALID_WINDOW_ID; - windowId = ScreenClient::GetInstance().AddWindow(windowProperty); - ScreenClient::GetInstance().RemoveWindow(windowId); int32_t actual = screenRegion_->Stop(); EXPECT_EQ(DH_SUCCESS, actual); } @@ -149,7 +133,7 @@ HWTEST_F(ScreenRegionTest, Stop_002, TestSize.Level1) HWTEST_F(ScreenRegionTest, GetScreenId_001, TestSize.Level1) { int32_t actual = screenRegion_->GetScreenId(); - EXPECT_EQ(0, actual); + EXPECT_EQ(screenRegion_->screenId_, actual); } /** @@ -161,7 +145,6 @@ HWTEST_F(ScreenRegionTest, GetScreenId_001, TestSize.Level1) HWTEST_F(ScreenRegionTest, GetRemoteDevId_001, TestSize.Level1) { std::string actual = screenRegion_->GetRemoteDevId(); - screenRegion_->remoteDevId_ = "remoteDevId"; EXPECT_EQ(screenRegion_->remoteDevId_, actual); } } // DistributedHardware diff --git a/services/screenservice/test/unittest/sourceservice/BUILD.gn b/services/screenservice/test/unittest/sourceservice/BUILD.gn index fe77dd9d..807fb240 100644 --- a/services/screenservice/test/unittest/sourceservice/BUILD.gn +++ b/services/screenservice/test/unittest/sourceservice/BUILD.gn @@ -15,7 +15,7 @@ import("//build/test.gni") import( "//foundation/distributedhardware/distributedscreen/distributedscreen.gni") -module_out_path = "distributed_screen/source_service_test" +module_out_path = "distributed_screen/services/source_service_test" config("module_private_config") { visibility = [ ":*" ] @@ -26,21 +26,20 @@ config("module_private_config") { "//utils/native/base/include", "//utils/system/safwk/native/include", "//foundation/graphic/standard/interfaces/innerkits/surface", + "//foundation/graphic/standard/rosen/modules/render_service_base/include", "${fwk_utils_path}/include/log", "${fwk_utils_path}/include", "${fwk_common_path}/log/inlcude", "${fwk_common_path}/utils/include", "${mediastandard_path}/interfaces/innerkits/native/media/include", + "${mediastandard_path}/interfaces/inner_api/native", + "//foundation/multimedia/image_standard/interfaces/innerkits/include", ] include_dirs += [ "./dscreenservice/include", "./dscreenservice/include/callback", "./dscreenmgr/include", - "${interfaces_path}/innerkits/native_cpp/screen_sink/include", - "${interfaces_path}/innerkits/native_cpp/screen_sink/include/callback", - "${interfaces_path}/innerkits/native_cpp/screen_source/include", - "${interfaces_path}/innerkits/native_cpp/screen_source/include/callback", "${common_path}/include", "${services_path}/common/utils/include", "${services_path}/common/databuffer/include", @@ -53,8 +52,9 @@ config("module_private_config") { "${services_path}/screenservice/sourceservice/dscreenmgr/include", "${services_path}/screenservice/sourceservice/dscreenservice/include", "${services_path}/screenservice/sourceservice/dscreenservice/include/callback", - "${services_path}/evevntcontrol/eventinjector/include", - "out/baltimore/obj/foundation/multimedia/media_standard/interfaces/innerkits/native/media/include", + "${interfaces_path}/innerkits/native_cpp/screen_source/include", + "${interfaces_path}/innerkits/native_cpp/screen_source/include/callback", + "${interfaces_path}/innerkits/native_cpp/screen_sink/include", ] } @@ -66,10 +66,7 @@ ohos_unittest("SourceServiceTest") { "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp", "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp", "${services_path}/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp", - "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp", "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp", - "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp", - "${services_path}/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp", ] configs = [ ":module_private_config" ] @@ -83,7 +80,6 @@ ohos_unittest("SourceServiceTest") { "${services_path}/screenservice/sourceservice:distributed_screen_source", "//utils/native/base:utils", "${fwk_utils_path}:distributedhardwareutils", - "${windowmanager_path}/interfaces/innerkits:wm_interface", "${windowmanager_path}/dm:libdm", ] diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h index 8471ffa4..543c57bb 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/dscreen_manager_test.h @@ -38,8 +38,6 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - - std::shared_ptr dscreenManager_ = nullptr; }; } // DistributedHardware } // OHOS diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/screen_manager_adapter_test.h b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/screen_manager_adapter_test.h index 2e51bd88..72c0a376 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/screen_manager_adapter_test.h +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/include/screen_manager_adapter_test.h @@ -36,8 +36,6 @@ public: static void TearDownTestCase(void); void SetUp(); void TearDown(); - - ScreenMgrAdapter *screenMgrAdapter_ = nullptr; }; class MockScreenGroupListener : public Rosen::ScreenManager::IScreenGroupListener { diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp index 44e6e8ea..5848a292 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_manager_test.cpp @@ -25,12 +25,9 @@ void DScreenManagerTest::SetUpTestCase(void) {} void DScreenManagerTest::TearDownTestCase(void) {} -void DScreenManagerTest::SetUp() -{ - dscreenManager_ = std::make_shared(); -} +void DScreenManagerTest::SetUp() {} -void DScreenManagerTest::TearDown(void) {} +void DScreenManagerTest::TearDown() {} /** * @tc.name: EnableDistributedScreen_001 @@ -40,33 +37,15 @@ void DScreenManagerTest::TearDown(void) {} */ HWTEST_F(DScreenManagerTest, EnableDistributedScreen_001, TestSize.Level1) { - std::string devId = "hello"; - std::string dhId = "hello"; - std::string param = "hello"; - std::string reqId = "hello"; + std::string devId = "devId"; + std::string dhId = "dhId"; + std::string param = "param"; + std::string reqId = "reqId"; std::shared_ptr dScreenCallback_ = nullptr; - int32_t actual = dscreenManager_->EnableDistributedScreen(devId, dhId, param, reqId); + int32_t actual = DScreenManager::GetInstance().EnableDistributedScreen(devId, dhId, param, reqId); EXPECT_EQ(ERR_DH_SCREEN_SA_ENABLE_FAILED, actual); } -/** - * @tc.name: EnableDistributedScreen_002 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenManagerTest, EnableDistributedScreen_002, TestSize.Level1) -{ - std::string devId = "world"; - std::string dhId = "world"; - std::string param = "world"; - std::string reqId = "world"; - dscreenManager_->Init(); - std::shared_ptr task = nullptr; - int32_t actual = dscreenManager_->EnableDistributedScreen(devId, dhId, param, reqId); - EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_TASK_NOT_VALID, actual); -} - /** * @tc.name: DisableDistributedScreen_001 * @tc.desc: Verify the Capacity function. @@ -78,7 +57,7 @@ HWTEST_F(DScreenManagerTest, DisableDistributedScreen_001, TestSize.Level1) std::string devId = "devId"; std::string dhId = "dhId"; std::string reqId = "reqId"; - int32_t actual = dscreenManager_->DisableDistributedScreen(devId, dhId, reqId); + int32_t actual = DScreenManager::GetInstance().DisableDistributedScreen(devId, dhId, reqId); EXPECT_EQ(ERR_DH_SCREEN_SA_DISABLE_FAILED, actual); } @@ -90,7 +69,7 @@ HWTEST_F(DScreenManagerTest, DisableDistributedScreen_001, TestSize.Level1) */ HWTEST_F(DScreenManagerTest, Init_001, TestSize.Level1) { - int32_t actual = dscreenManager_->Init(); + int32_t actual = DScreenManager::GetInstance().Init(); EXPECT_EQ(DH_SUCCESS, actual); } @@ -102,7 +81,7 @@ HWTEST_F(DScreenManagerTest, Init_001, TestSize.Level1) */ HWTEST_F(DScreenManagerTest, UnInit_001, TestSize.Level1) { - int32_t actual = dscreenManager_->UnInit(); + int32_t actual = DScreenManager::GetInstance().UnInit(); EXPECT_EQ(DH_SUCCESS, actual); } } // DistributedHardware diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp index 0aaa146d..456fd2f0 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/dscreen_test.cpp @@ -27,26 +27,13 @@ void DScreenTest::TearDownTestCase(void) {} void DScreenTest::SetUp() { - const std::string devId = "hello"; - const std::string dhId = "hello"; + const std::string devId = "devId"; + const std::string dhId = "dhId"; std::shared_ptr dscreenCallback = nullptr; dScreen_ = std::make_shared(devId, dhId, dscreenCallback); } -void DScreenTest::TearDown(void) {} - -/** - * @tc.name: OnTransError_001 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenTest, OnTransError_001, TestSize.Level1) -{ - int32_t err = 0; - const std::string content = "hello"; - dScreen_->OnTransError(err, content); -} +void DScreenTest::TearDown() {} /** * @tc.name: GetVideoParam_001 @@ -84,9 +71,9 @@ HWTEST_F(DScreenTest, GetState_001, TestSize.Level1) */ HWTEST_F(DScreenTest, GetScreenId_001, TestSize.Level1) { - uint64_t screenId_ = 1000; + uint64_t screenId = 1000; uint64_t actual = dScreen_->GetScreenId(); - EXPECT_NE(screenId_, actual); + EXPECT_NE(screenId, actual); } /** @@ -97,9 +84,9 @@ HWTEST_F(DScreenTest, GetScreenId_001, TestSize.Level1) */ HWTEST_F(DScreenTest, GetDHId_001, TestSize.Level1) { - std::string dhId_ = "hello"; + std::string dhId = "dhId"; std::string actual = dScreen_->GetDHId(); - EXPECT_EQ(dhId_, actual); + EXPECT_EQ(dhId, actual); } /** @@ -110,9 +97,9 @@ HWTEST_F(DScreenTest, GetDHId_001, TestSize.Level1) */ HWTEST_F(DScreenTest, GetDevId_001, TestSize.Level1) { - std::string devId_ = "hello"; + std::string devId = "devId"; std::string actual = dScreen_->GetDevId(); - EXPECT_EQ(devId_, actual); + EXPECT_EQ(devId, actual); } /** @@ -127,24 +114,5 @@ HWTEST_F(DScreenTest, AddTask_001, TestSize.Level1) int actual = dScreen_->AddTask(task); EXPECT_EQ(ERR_DH_SCREEN_SA_DSCREEN_TASK_NOT_VALID, actual); } - -/** - * @tc.name: AddTask_002 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenTest, AddTask_002, TestSize.Level1) -{ - TaskType taskType_; - std::string taskParam_ = "taskParam"; - taskType_ = TASK_ENABLE; - const std::shared_ptr task = std::make_shared(taskType_, taskParam_); - int32_t sizeFront = dScreen_->taskQueue_.size(); - int actual = dScreen_->AddTask(task); - int32_t sizeEnd = dScreen_->taskQueue_.size(); - EXPECT_GT(sizeEnd, sizeFront); - EXPECT_EQ(DH_SUCCESS, actual); -} } // DistributedHardware } // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp index 4385e70d..a7119e30 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenmgr/src/screen_manager_adapter_test.cpp @@ -25,16 +25,9 @@ void ScreenMgrAdapterTest::SetUpTestCase(void) {} void ScreenMgrAdapterTest::TearDownTestCase(void) {} -void ScreenMgrAdapterTest::SetUp() -{ - screenMgrAdapter_ = new ScreenMgrAdapter(); -} +void ScreenMgrAdapterTest::SetUp() {} -void ScreenMgrAdapterTest::TearDown(void) -{ - delete screenMgrAdapter_; - screenMgrAdapter_ = nullptr; -} +void ScreenMgrAdapterTest::TearDown() {} /** * @tc.name: CreateVirtualScreen_001 @@ -44,13 +37,17 @@ void ScreenMgrAdapterTest::TearDown(void) */ HWTEST_F(ScreenMgrAdapterTest, CreateVirtualScreen_001, TestSize.Level1) { - std::string devId = "hello"; - std::string dhId = "hello"; - std::shared_ptr videoParam = std::make_shared(); + std::string devId = "devId"; + std::string dhId = "dhId"; uint64_t screenId = SCREEN_ID_INVALID; - uint64_t actual = screenMgrAdapter_->CreateVirtualScreen(devId, dhId, videoParam); - EXPECT_NE(screenId, actual); - screenMgrAdapter_->RemoveVirtualScreen(actual); + std::shared_ptr videoParam = std::make_shared(); + videoParam->SetScreenWidth(2560); + videoParam->SetScreenHeight(1600); + std::string screenName = DSCREEN_PREFIX + SEPERATOR + devId + SEPERATOR + dhId; + ScreenMgrAdapter::GetInstance().screenIdMap_.emplace(screenName, SCREEN_ID_INVALID); + uint64_t actual = ScreenMgrAdapter::GetInstance().CreateVirtualScreen(devId, dhId, videoParam); + EXPECT_EQ(screenId, actual); + ScreenMgrAdapter::GetInstance().RemoveVirtualScreen(actual); } /** @@ -62,8 +59,8 @@ HWTEST_F(ScreenMgrAdapterTest, CreateVirtualScreen_001, TestSize.Level1) HWTEST_F(ScreenMgrAdapterTest, RemoveVirtualScreen_001, TestSize.Level1) { uint64_t screenId = 0; - uint64_t actual = screenMgrAdapter_->RemoveVirtualScreen(screenId); - EXPECT_EQ(ERR_DH_SCREEN_SA_REMOVE_VIRTUALSCREEN_FAIL, actual); + uint64_t actual = ScreenMgrAdapter::GetInstance().RemoveVirtualScreen(screenId); + EXPECT_NE(DH_SUCCESS, actual); } /** @@ -76,7 +73,7 @@ HWTEST_F(ScreenMgrAdapterTest, SetImageSurface_001, TestSize.Level1) { uint64_t screenId = 0; sptr surface; - int32_t actual = screenMgrAdapter_->SetImageSurface(screenId, surface); + int32_t actual = ScreenMgrAdapter::GetInstance().SetImageSurface(screenId, surface); EXPECT_EQ(DH_SUCCESS, actual); } @@ -90,8 +87,9 @@ HWTEST_F(ScreenMgrAdapterTest, SetImageSurface_001, TestSize.Level1) HWTEST_F(ScreenMgrAdapterTest, RegisterScreenGroupListener_001, TestSize.Level1) { sptr listener = new MockScreenGroupListener(); - int32_t actual = screenMgrAdapter_->RegisterScreenGroupListener(listener); + int32_t actual = ScreenMgrAdapter::GetInstance().RegisterScreenGroupListener(listener); EXPECT_EQ(DH_SUCCESS, actual); + ScreenMgrAdapter::GetInstance().UnregisterScreenGroupListener(listener); } /** @@ -103,21 +101,8 @@ HWTEST_F(ScreenMgrAdapterTest, RegisterScreenGroupListener_001, TestSize.Level1) HWTEST_F(ScreenMgrAdapterTest, UnregisterScreenGroupListener_001, TestSize.Level1) { sptr listener = new MockScreenGroupListener(); - int32_t actual = screenMgrAdapter_->UnregisterScreenGroupListener(listener); + int32_t actual = ScreenMgrAdapter::GetInstance().UnregisterScreenGroupListener(listener); EXPECT_EQ(DH_SUCCESS, actual); } - -/** - * @tc.name: GetMapRelation_001 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(ScreenMgrAdapterTest, GetMapRelation_001, TestSize.Level1) -{ - uint64_t screenId = 0; - std::shared_ptr actual = screenMgrAdapter_->GetMapRelation(screenId); - EXPECT_NE(nullptr, actual); -} } // DistributedHardware } // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h deleted file mode 100644 index fb2746c4..00000000 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_callback_proxy_test.h +++ /dev/null @@ -1,47 +0,0 @@ -/* - * 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. - */ - -#ifndef OHOS_DSCREEN_SOURCE_CALLBACK_PROXY_TEST_H -#define OHOS_DSCREEN_SOURCE_CALLBACK_PROXY_TEST_H - -#include - -#include "iservice_registry.h" -#include "if_system_ability_manager.h" -#include "ipc_skeleton.h" -#include "parcel.h" -#include "system_ability_definition.h" - -#include "dscreen_constants.h" -#include "dscreen_errcode.h" -#include "dscreen_log.h" -#include "dscreen_source_callback_proxy.h" -#include "dscreen_util.h" - -namespace OHOS { -namespace DistributedHardware { -class DScreenSourceCallbackProxyTest : public testing::Test { -public: - static void SetUpTestCase(void); - static void TearDownTestCase(void); - void SetUp(); - void TearDown(); - - sptr dScreenSourceCallbackProxy_ = nullptr; - std::shared_ptr systemAbilityManagerClient_ = nullptr; -}; -} // DistributedHardware -} // OHOS -#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h deleted file mode 100644 index ec5e62e0..00000000 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/dscreen_source_stub_test.h +++ /dev/null @@ -1,44 +0,0 @@ -/* - * 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. - */ - -#ifndef OHOS_DSCREEN_SOURCE_STUB_TEST_H -#define OHOS_DSCREEN_SOURCE_STUB_TEST_H - -#include - -#include "iservice_registry.h" - -#include "dscreen_constants.h" -#include "dscreen_errcode.h" -#include "dscreen_log.h" -#include "dscreen_source_callback_proxy.h" -#include "dscreen_source_stub.h" -#include "mock_dscreen_source_stub.h" - -namespace OHOS { -namespace DistributedHardware { -const int32_t WRONGNUM = 6; -class DScreenSourceStubTest : public testing::Test { -public: - static void SetUpTestCase(void); - static void TearDownTestCase(void); - void SetUp(); - void TearDown(); - - MockDScreenSourceStub *dScreenSourceStub_ = nullptr; -}; -} // DistributedHardware -} // OHOS -#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/mock_dscreen_source_stub.h b/services/screenservice/test/unittest/sourceservice/dscreenservice/include/mock_dscreen_source_stub.h deleted file mode 100644 index d601e878..00000000 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/include/mock_dscreen_source_stub.h +++ /dev/null @@ -1,41 +0,0 @@ -/* - * 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. - */ - -#ifndef OHOS_MOCK_DSCREEN_SOURCE_STUB_H -#define OHOS_MOCK_DSCREEN_SOURCE_STUB_H - -#include "dscreen_source_stub.h" - -namespace OHOS { -namespace DistributedHardware { -class MockDScreenSourceStub : public DScreenSourceStub { -public: - MockDScreenSourceStub() = default; - virtual ~MockDScreenSourceStub() {}; - virtual int32_t InitSource(const std::string ¶ms, const sptr &callback); - virtual int32_t ReleaseSource(); - virtual int32_t RegisterDistributedHardware(const std::string &devId, const std::string &dhId, - const EnableParam ¶m, const std::string &reqId); - virtual int32_t UnregisterDistributedHardware(const std::string &devId, const std::string &dhId, - const std::string &reqId); - virtual int32_t ConfigDistributedHardware(const std::string &devId, const std::string &dhId, - const std::string &key, const std::string &value); - virtual void DScreenNotify(const std::string &devId, int32_t eventCode, - const std::string &eventContent); - virtual void MockScreenChange(const std::vector &screenIds, uint32_t event); -}; -} // DistributedHardware -} // OHOS -#endif \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp deleted file mode 100644 index e119912a..00000000 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_callback_proxy_test.cpp +++ /dev/null @@ -1,118 +0,0 @@ -/* - * 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. - */ - -#define private public -#include "dscreen_source_callback_proxy_test.h" -#undef private - -using namespace testing::ext; - -namespace OHOS { -namespace DistributedHardware { -void DScreenSourceCallbackProxyTest::SetUpTestCase(void) {} - -void DScreenSourceCallbackProxyTest::TearDownTestCase(void) {} - -void DScreenSourceCallbackProxyTest::SetUp() -{ - systemAbilityManagerClient_ = std::make_shared(); - sptr samgr = systemAbilityManagerClient_->GetSystemAbilityManager(); - if (!samgr) { - return; - } - - sptr remoteObject = samgr->GetSystemAbility(DISTRIBUTED_HARDWARE_SCREEN_SINK_SA_ID); - if (!remoteObject) { - return; - } - - dScreenSourceCallbackProxy_ = new DScreenSourceCallbackProxy(remoteObject); -} - -void DScreenSourceCallbackProxyTest::TearDown(void) -{ - dScreenSourceCallbackProxy_.clear(); - systemAbilityManagerClient_->DestroySystemAbilityManagerObject(); -} - -/** - * @tc.name: OnNotifyRegResult_001 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyRegResult_001, TestSize.Level1) -{ - std::string devId = "hello"; - std::string dhId = "hello"; - std::string reqId = "hello"; - int32_t status = 0; - std::string resultData = "hello"; - int32_t actual = dScreenSourceCallbackProxy_->OnNotifyRegResult(devId, dhId, reqId, status, resultData); - EXPECT_NE(ERR_DH_SCREEN_SA_WRITEPARAM_FAILED, actual); -} - -/** - * @tc.name: OnNotifyRegResult_002 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyRegResult_002, TestSize.Level1) -{ - std::string devId = "hello"; - std::string dhId = "hello"; - std::string reqId = "hello"; - int32_t status = 0; - std::string resultData = "hello"; - int32_t actual = dScreenSourceCallbackProxy_->OnNotifyRegResult(devId, dhId, reqId, status, resultData); - EXPECT_NE(ERR_DH_SCREEN_SA_WRITEINTERFACETOKEN_FAILED, actual); -} - -/** - * @tc.name: OnNotifyUnregResult_001 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyUnregResult_001, TestSize.Level1) -{ - std::string devId = "hello"; - std::string dhId = "hello"; - std::string reqId = "hello"; - int32_t status = 0; - std::string resultData = "hello"; - int32_t actual = dScreenSourceCallbackProxy_->OnNotifyUnregResult(devId, dhId, reqId, status, resultData); - EXPECT_NE(ERR_DH_SCREEN_SA_WRITEPARAM_FAILED, actual); -} - -/** - * @tc.name: OnNotifyUnregResult_002 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenSourceCallbackProxyTest, OnNotifyUnregResult_002, TestSize.Level1) -{ - std::string devId = "hello"; - std::string dhId = "hello"; - std::string reqId = "hello"; - int32_t status = 0; - std::string resultData = "hello"; - int32_t actual = dScreenSourceCallbackProxy_->OnNotifyRegResult(devId, dhId, reqId, status, resultData); - EXPECT_NE(ERR_DH_SCREEN_SA_WRITEINTERFACETOKEN_FAILED, actual); -} -} // DistributedHardware -} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp index 56a39153..169f1088 100644 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp +++ b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_service_test.cpp @@ -27,12 +27,12 @@ void DSCreenSourceServiceTest::TearDownTestCase(void) {} void DSCreenSourceServiceTest::SetUp() { - int32_t saId =4807; - bool runOnCreate = false; + int32_t saId = DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID; + bool runOnCreate = true; dScreenSourceService_ = std::make_shared(saId, runOnCreate); } -void DSCreenSourceServiceTest::TearDown(void) {} +void DSCreenSourceServiceTest::TearDown() {} /** * @tc.name: InitSource_001 @@ -42,27 +42,12 @@ void DSCreenSourceServiceTest::TearDown(void) {} */ HWTEST_F(DSCreenSourceServiceTest, InitSource_001, TestSize.Level1) { - std::string params = "hello"; + std::string params = "params"; sptr callback = nullptr; int32_t actual = dScreenSourceService_->InitSource(params, callback); EXPECT_EQ(DH_SUCCESS, actual); } -/** - * @tc.name: ReleaseSource_001 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DSCreenSourceServiceTest, ReleaseSource_001, TestSize.Level1) -{ - std::string params = "hello"; - sptr callback = nullptr; - dScreenSourceService_->InitSource(params, callback); - int32_t actual = dScreenSourceService_->ReleaseSource(); - EXPECT_EQ(DH_SUCCESS, actual); -} - /** * @tc.name: RegisterDistributedHardware_001 * @tc.desc: Verify the Capacity function. @@ -71,14 +56,14 @@ HWTEST_F(DSCreenSourceServiceTest, ReleaseSource_001, TestSize.Level1) */ HWTEST_F(DSCreenSourceServiceTest, RegisterDistributedHardware_001, TestSize.Level1) { - std::string devId = "hello"; - std::string dhId = "hello"; + std::string devId = "devId"; + std::string dhId = "dhId"; EnableParam param; param.version = "version"; param.attrs = "attrs"; - std::string reqId = "hello"; + std::string reqId = "reqId"; int32_t actual = dScreenSourceService_->RegisterDistributedHardware(devId, dhId, param, reqId); - EXPECT_EQ(ERR_DH_SCREEN_SA_ENABLE_FAILED, actual); + EXPECT_EQ(DH_SUCCESS, actual); } /** @@ -89,11 +74,11 @@ HWTEST_F(DSCreenSourceServiceTest, RegisterDistributedHardware_001, TestSize.Lev */ HWTEST_F(DSCreenSourceServiceTest, UnregisterDistributedHardware_001, TestSize.Level1) { - std::string devIdTrue = "hello"; - std::string dhIdTrue = "hello"; - std::string reqId = "hello"; - std::string devIdFalse = "world"; - std::string dhIdFalse = "world"; + std::string devIdTrue = "devIdTrue"; + std::string dhIdTrue = "dhIdTrue"; + std::string reqId = "reqId"; + std::string devIdFalse = "devIdFalse"; + std::string dhIdFalse = "dhIdFalse"; std::shared_ptr dscreenCallback = nullptr; std::shared_ptr dScreen = std::make_shared(devIdFalse, dhIdFalse, dscreenCallback); int32_t actual = dScreenSourceService_->UnregisterDistributedHardware(devIdTrue, dhIdTrue, reqId); diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp deleted file mode 100644 index a4dc820a..00000000 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/dscreen_source_stub_test.cpp +++ /dev/null @@ -1,71 +0,0 @@ -/* - * 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. - */ - -#define private public -#include "dscreen_source_stub_test.h" -#undef private - -using namespace testing::ext; - -namespace OHOS { -namespace DistributedHardware { -void DScreenSourceStubTest::SetUpTestCase(void) {} - -void DScreenSourceStubTest::TearDownTestCase(void) {} - -void DScreenSourceStubTest::SetUp() -{ - dScreenSourceStub_ = new MockDScreenSourceStub(); -} - -void DScreenSourceStubTest::TearDown(void) -{ - delete dScreenSourceStub_; - dScreenSourceStub_ = nullptr; -} - -/** - * @tc.name: OnRemoteRequest_001 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenSourceStubTest, OnRemoteRequest_001, TestSize.Level1) -{ - uint32_t code = 0; - MessageParcel data; - MessageParcel reply; - MessageOption option; - int32_t actual = dScreenSourceStub_->OnRemoteRequest(code, data, reply, option); - EXPECT_EQ(DH_SUCCESS, actual); -} - -/** - * @tc.name: OnRemoteRequest_002 - * @tc.desc: Verify the Capacity function. - * @tc.type: FUNC - * @tc.require: Issue Number - */ -HWTEST_F(DScreenSourceStubTest, OnRemoteRequest_002, TestSize.Level1) -{ - uint32_t code = WRONGNUM; - MessageParcel data; - MessageParcel reply; - MessageOption option; - int32_t actual = dScreenSourceStub_->OnRemoteRequest(code, data, reply, option); - EXPECT_EQ(ERR_DH_SCREEN_SA_REQUEST_CODE_INVALID, actual); -} -} // DistributedHardware -} // OHOS \ No newline at end of file diff --git a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp b/services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp deleted file mode 100644 index e10f8e42..00000000 --- a/services/screenservice/test/unittest/sourceservice/dscreenservice/src/mock_dscreen_source_stub.cpp +++ /dev/null @@ -1,78 +0,0 @@ -/* - * 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 "mock_dscreen_source_stub.h" - -namespace OHOS { -namespace DistributedHardware { -int32_t MockDScreenSourceStub::InitSource(const std::string ¶ms, - const sptr &callback) -{ - (void) params; - (void) callback; - return 0; -} - -int32_t MockDScreenSourceStub::ReleaseSource() -{ - return 0; -} - -int32_t MockDScreenSourceStub::RegisterDistributedHardware(const std::string &devId, const std::string &dhId, - const EnableParam ¶m, const std::string &reqId) -{ - (void) devId; - (void) dhId; - (void) param; - (void) reqId; - return 0; -} - -int32_t MockDScreenSourceStub::UnregisterDistributedHardware(const std::string &devId, const std::string &dhId, - const std::string &reqId) -{ - (void) devId; - (void) dhId; - (void) reqId; - return 0; -} - -int32_t MockDScreenSourceStub::ConfigDistributedHardware(const std::string &devId, const std::string &dhId, - const std::string &key, const std::string &value) -{ - (void) devId; - (void) dhId; - (void) key; - (void) value; - return 0; -} - -void MockDScreenSourceStub::DScreenNotify(const std::string &devId, int32_t eventCode, - const std::string &eventContent) -{ - (void) devId; - (void) eventCode; - (void) eventContent; - return; -} - -void MockDScreenSourceStub::MockScreenChange(const std::vector &screenIds, uint32_t event) -{ - (void) screenIds; - (void) event; - return; -} -} // DistributedHardware -} // OHOS \ No newline at end of file -- Gitee