diff --git a/bundle.json b/bundle.json index c3c4ec8..68c8d98 100755 --- a/bundle.json +++ b/bundle.json @@ -80,6 +80,7 @@ "//foundation/distributedhardware/distributed_input/sinkhandler/test:test", "//foundation/distributedhardware/distributed_input/test:test", "//foundation/distributedhardware/distributed_input/services/sink/transport/test:test", + "//foundation/distributedhardware/distributed_input/services/sink/inputcollector/test:test", "//foundation/distributedhardware/distributed_input/services/source/transport/test:test", "//foundation/distributedhardware/distributed_input/common/include/test:test", "//foundation/distributedhardware/distributed_input/services/source/inputinject/test:test", diff --git a/common/include/input_hub.h b/common/include/input_hub.h index 9717ac6..52ab7fc 100644 --- a/common/include/input_hub.h +++ b/common/include/input_hub.h @@ -44,7 +44,7 @@ public: size_t StartCollectInputHandler(InputDeviceEvent* buffer, size_t bufferSize); void StopCollectInputEvents(); void StopCollectInputHandler(); - size_t DeviceIsExists(InputDeviceEvent* event, size_t bufferSize); + size_t DeviceIsExists(InputDeviceEvent* buffer, size_t bufferSize); std::vector GetAllInputDevices(); // return efftive dhids AffectDhIds SetSupportInputType(bool enabled, const uint32_t &inputTypes); diff --git a/common/mock/session_mock.cpp b/common/mock/session_mock.cpp new file mode 100644 index 0000000..c1207ce --- /dev/null +++ b/common/mock/session_mock.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. + */ + +#include +#include +#include + +#include "securec.h" +#include "session_mock.h" + +constexpr int32_t DH_SUCCESS = 0; +constexpr int32_t DH_ERROR = -1; +constexpr int32_t MOCK_SESSION_ID = 1; +static ISessionListener g_listener; +static char g_peerDeviceId[CHAR_ARRAY_SIZE]; +static char g_peerSessionName[CHAR_ARRAY_SIZE]; +static char g_mySessionName[CHAR_ARRAY_SIZE]; +int CreateSessionServer(const char *pkgName, const char *sessionName, const ISessionListener *listener) +{ + std::cout << "CreateSessionServer start sessionName:" << sessionName << std::endl; + std::string tmpstr = sessionName; + if (tmpstr.size() <= 0) { + std::cout << "CreateSessionServer sessionName is empty." << std::endl; + return DH_ERROR; + } + if (listener == nullptr) { + std::cout << "CreateSessionServer listener is null." << std::endl; + return DH_ERROR; + } + if (strcpy_s(g_mySessionName, tmpstr.size(), tmpstr.c_str()) != DH_SUCCESS) { + std::cout << "strcpy_s faild" << std::endl; + return DH_ERROR; + } + g_listener.onBytesReceived = listener->onBytesReceived; + g_listener.onMessageReceived = listener->onMessageReceived; + g_listener.onSessionClosed = listener->onSessionClosed; + g_listener.onSessionOpened = listener->onSessionOpened; + g_listener.onStreamReceived = listener->onStreamReceived; + return DH_SUCCESS; +} + +int RemoveSessionServer(const char *pkgName, const char *sessionName) +{ + return DH_SUCCESS; +} + +int OpenSession(const char *mySessionName, const char *peerSessionName, const char *peerDeviceId, const char *groupId, + const SessionAttribute *attr) +{ + if (strlen(peerSessionName) <= 0) { + return DH_ERROR; + } + if (strlen(peerDeviceId) <= 0) { + return DH_ERROR; + } + if (strncpy_s(g_peerSessionName, sizeof(g_peerSessionName), peerSessionName, CHAR_ARRAY_SIZE) != DH_SUCCESS) { + std::cout << "strncpy_s faild" << std::endl; + return DH_ERROR; + } + if (strncpy_s(g_peerDeviceId, sizeof(g_peerDeviceId), peerDeviceId, DEVICE_ID_SIZE_MAX) != DH_SUCCESS) { + std::cout << "strncpy_s faild" << std::endl; + return DH_ERROR; + } + std::thread thd(OpenSessionResult); + thd.detach(); + return MOCK_SESSION_ID; +} + +void OpenSessionResult() +{ + g_listener.onSessionOpened(MOCK_SESSION_ID, DH_SUCCESS); +} + +void CloseSession(int sessionId) {} + +int SendBytes(int sessionId, const void *data, unsigned int len) +{ + return DH_SUCCESS; +} + +int SendMessage(int sessionId, const void *data, unsigned int len) +{ + return DH_SUCCESS; +} + +int SendStream(int sessionId, const StreamData *data, const StreamData *ext, const FrameInfo *param) +{ + return DH_SUCCESS; +} + +int GetMySessionName(int sessionId, char *sessionName, unsigned int len) +{ + if (strncpy_s(sessionName, sizeof(sessionName), g_mySessionName, CHAR_ARRAY_SIZE) != DH_SUCCESS) { + std::cout << "strncpy_s faild" << std::endl; + return DH_ERROR; + } + return DH_SUCCESS; +} + +int GetPeerSessionName(int sessionId, char *sessionName, unsigned int len) +{ + if (strncpy_s(sessionName, sizeof(sessionName), g_peerSessionName, CHAR_ARRAY_SIZE) != DH_SUCCESS) { + std::cout << "strncpy_s faild" << std::endl; + return DH_ERROR; + } + return DH_SUCCESS; +} + +int GetPeerDeviceId(int sessionId, char *devId, unsigned int len) +{ + if (strncpy_s(devId, sizeof(devId), g_peerDeviceId, DEVICE_ID_SIZE_MAX) != DH_SUCCESS) { + std::cout << "strncpy_s faild" << std::endl; + return DH_ERROR; + } + return DH_SUCCESS; +} + +int GetSessionSide(int sessionId) +{ + return DH_SUCCESS; +} + +int SetFileReceiveListener(const char *pkgName, const char *sessionName, const IFileReceiveListener *recvListener, + const char *rootDir) +{ + return DH_SUCCESS; +} + +int SetFileSendListener(const char *pkgName, const char *sessionName, const IFileSendListener *sendListener) +{ + return DH_SUCCESS; +} + +int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], uint32_t fileCnt) +{ + return DH_SUCCESS; +} \ No newline at end of file diff --git a/common/mock/session_mock.h b/common/mock/session_mock.h new file mode 100644 index 0000000..3fdd941 --- /dev/null +++ b/common/mock/session_mock.h @@ -0,0 +1,204 @@ +/* + * 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. + */ + +/** + * @addtogroup Softbus + * @{ + * + * @brief Provides high-speed, secure communication between devices. + * + * This module implements unified distributed communication capability management between + * nearby devices, and provides link-independent device discovery and transmission interfaces + * to support service publishing and data transmission. + * + * @since 1.0 + * @version 1.0 + */ + +/** + * @file session.h + * + * @brief Declares unified data transmission interfaces. + * + * This file provides data transmission capabilities, including creating and removing a session server, + * opening and closing sessions, receiving data, and querying basic session information. \n + * After multiple nearby devices are discovered and networked, these interfaces can be used to + * transmit data across devices. \n + * + * @since 1.0 + * @version 1.0 + */ +#ifndef SESSION_MOCK_H +#define SESSION_MOCK_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif +/** + * @brief business type of session + * + * @since 1.0 + * @version 1.0 + */ +typedef enum { + TYPE_MESSAGE = 1, + TYPE_BYTES, + TYPE_FILE, + TYPE_STREAM, + TYPE_BUTT, +} SessionType; + +typedef enum { + INVALID = -1, + /* + * Send any segment of a frame each time. + */ + RAW_STREAM, + /* + * Send a whole video frame each time. + */ + COMMON_VIDEO_STREAM, + /* + * Send a whole audio frame each time. + */ + COMMON_AUDIO_STREAM, + /* + * Slice frame mode. + */ + VIDEO_SLICE_STREAM, +} StreamType; + +typedef enum { + LINK_TYPE_WIFI_WLAN_5G = 1, + LINK_TYPE_WIFI_WLAN_2G = 2, + LINK_TYPE_WIFI_P2P = 3, + LINK_TYPE_BR = 4, + LINK_TYPE_MAX = 4, +} LinkType; + +typedef struct { + /* @brief dataType{@link SessionType} */ + int dataType; + int linkTypeNum; + LinkType linkType[LINK_TYPE_MAX]; + union { + struct StreamAttr { + int streamType; + } streamAttr; + } attr; +} SessionAttribute; + +typedef struct { + char *buf; + int bufLen; +} StreamData; + +typedef struct { + int type; + int64_t value; +} TV; + +typedef struct { + int frameType; + int64_t timeStamp; + int seqNum; + int seqSubNum; + int level; + int bitMap; + int tvCount; + TV *tvList; +} FrameInfo; + +enum FrameType { + NONE, + VIDEO_I, + VIDEO_P, + VIDEO_MAX = 50, + RADIO = VIDEO_MAX + 1, + RADIO_MAX = 100, +}; + +// APP should update StreamFrameInfo each time. +struct StreamFrameInfo { + uint32_t streamId = 0; + uint32_t seqNum = 0; + uint32_t level = 0; + FrameType frameType = NONE; + uint32_t timestamp = 0; + uint32_t bitrate = 0; +}; + +constexpr uint32_t DEVICE_ID_SIZE_MAX = 65; +constexpr uint32_t CHAR_ARRAY_SIZE = 100; + +typedef struct { + int (*onSessionOpened)(int sessionId, int result); + void (*onSessionClosed)(int sessionId); + void (*onBytesReceived)(int sessionId, const void *data, unsigned int dataLen); + void (*onMessageReceived)(int sessionId, const void *data, unsigned int dataLen); + void (*onStreamReceived)(int sessionId, const StreamData *data, const StreamData *ext, + const StreamFrameInfo *param); +} ISessionListener; + +typedef struct { + int (*onReceiveFileStarted)(int sessionId, const char *files, int fileCnt); + int (*onReceiveFileProcess)(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal); + void (*onReceiveFileFinished)(int sessionId, const char *files, int fileCnt); + void (*onFileTransError)(int sessionId); +} IFileReceiveListener; + +typedef struct { + int (*onSendFileProcess)(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal); + int (*onSendFileFinished)(int sessionId, const char *firstFile); + void (*onFileTransError)(int sessionId); +} IFileSendListener; + +int CreateSessionServer(const char *pkgName, const char *sessionName, const ISessionListener *listener); + +int RemoveSessionServer(const char *pkgName, const char *sessionName); + +int OpenSession(const char *mySessionName, const char *peerSessionName, const char *peerDeviceId, const char *groupId, + const SessionAttribute *attr); +void OpenSessionResult(void); + +void CloseSession(int sessionId); + +int SendBytes(int sessionId, const void *data, unsigned int len); + +int SendMessage(int sessionId, const void *data, unsigned int len); + +int SendStream(int sessionId, const StreamData *data, const StreamData *ext, const FrameInfo *param); + +int GetMySessionName(int sessionId, char *sessionName, unsigned int len); + +int GetPeerSessionName(int sessionId, char *sessionName, unsigned int len); + +int GetPeerDeviceId(int sessionId, char *devId, unsigned int len); + +int GetSessionSide(int sessionId); + +int SetFileReceiveListener(const char *pkgName, const char *sessionName, const IFileReceiveListener *recvListener, + const char *rootDir); + +int SetFileSendListener(const char *pkgName, const char *sessionName, const IFileSendListener *sendListener); + +int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], uint32_t fileCnt); + +#ifdef __cplusplus +} +#endif +#endif // SESSION_MOCK_H \ No newline at end of file diff --git a/common/mock/softbus_bus_center_mock.cpp b/common/mock/softbus_bus_center_mock.cpp new file mode 100644 index 0000000..11dd347 --- /dev/null +++ b/common/mock/softbus_bus_center_mock.cpp @@ -0,0 +1,28 @@ +/* + * 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 "softbus_bus_center_mock.h" + +constexpr int32_t DH_SUCCESS = 0; +int32_t GetLocalNodeDeviceInfo(const char *pkgName, NodeBasicInfo *info) +{ + NodeBasicInfo nodeBasicInfo = { + .networkId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00", + .deviceName = "f6d4c08647073e02e7a78f09473aa122ff57fc81c00981fcf5be989e7d112591", + .deviceTypeId = 1}; + (void)pkgName; + *info = nodeBasicInfo; + return DH_SUCCESS; +} \ No newline at end of file diff --git a/common/mock/softbus_bus_center_mock.h b/common/mock/softbus_bus_center_mock.h new file mode 100644 index 0000000..50e07bc --- /dev/null +++ b/common/mock/softbus_bus_center_mock.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 SOFTBUS_BUS_CENTER_MOCK_H +#define SOFTBUS_BUS_CENTER_MOCK_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif +constexpr uint32_t MOCK_NETWORK_ID_BUF_LEN = 65; +constexpr uint32_t MOCK_DEVICE_NAME_BUF_LEN = 65; +/** + * @brief Defines the basic information about a device. + * @since 1.0 + * @version 1.0 + */ +typedef struct { + char networkId[MOCK_NETWORK_ID_BUF_LEN]; + char deviceName[MOCK_DEVICE_NAME_BUF_LEN]; + uint16_t deviceTypeId; +} NodeBasicInfo; + +int32_t GetLocalNodeDeviceInfo(const char *pkgName, NodeBasicInfo *info); +#ifdef __cplusplus +} +#endif +#endif // SOFTBUS_BUS_CENTER_MOCK_H \ No newline at end of file diff --git a/services/sink/inputcollector/test/BUILD.gn b/services/sink/inputcollector/test/BUILD.gn new file mode 100644 index 0000000..d034b6a --- /dev/null +++ b/services/sink/inputcollector/test/BUILD.gn @@ -0,0 +1,18 @@ +# 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("test") { + testonly = true + + deps = [ "sinkcollectorunittest:sinkcollectorunittest" ] +} \ No newline at end of file diff --git a/services/sink/inputcollector/test/sinkcollectorunittest/BUILD.gn b/services/sink/inputcollector/test/sinkcollectorunittest/BUILD.gn new file mode 100644 index 0000000..6b9829b --- /dev/null +++ b/services/sink/inputcollector/test/sinkcollectorunittest/BUILD.gn @@ -0,0 +1,82 @@ +# 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/distributed_input/distributedinput.gni") +module_out_path = "distributed_input/sink_collector" + +group("sinkcollectorunittest") { + testonly = true + + deps = [ ":distributed_input_inner_sinkcollector_test" ] +} + +## UnitTest distributed_input_manager_service_test {{{ +ohos_unittest("distributed_input_inner_sinkcollector_test") { + module_out_path = module_out_path + + include_dirs = [ + "$services_sink_path/inputcollector/include", + "//commonlibrary/c_utils/base/include", + "//utils/system/safwk/native/include", + "${common_path}/include", + "${frameworks_path}/include", + "${fwk_common_path}/log/include", + "${fwk_common_path}/utils/include", + "${fwk_utils_path}/include/log", + "${fwk_utils_path}/include", + "${utils_path}/include", + "//third_party/json/include", + "${fwk_interfaces_path}/include", + "${fwk_interfaces_path}/include/ipc", + "//foundation/systemabilitymgr/safwk/interfaces/innerkits/safwk", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", + "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy/include", + ] + + sources = [ + "${common_path}/include/input_hub.cpp", + "//foundation/distributedhardware/distributed_input/services/sink/inputcollector/src/distributed_input_collector.cpp", + "distributed_input_collector_test.cpp", + ] + + cflags = [ + "-Wall", + "-Werror", + "-g3", + "-Dprivate=public", + "-Dprotected=public", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"distributedinpututtest\"", + "LOG_DOMAIN=0xD004100", + ] + + deps = [ + "//base/notification/eventhandler/frameworks/eventhandler:libeventhandler", + "//third_party/openssl:libcrypto_static", + "${fwk_utils_path}:distributedhardwareutils", + "${utils_path}:libdinput_utils", + ] + + external_deps = [ + "c_utils:utils", + ] + + cflags_cc = [ "-DHILOG_ENABLE" ] +} + +## UnitTest distributed_input_manager_service_test }}} \ No newline at end of file diff --git a/services/sink/inputcollector/test/sinkcollectorunittest/distributed_input_collector_test.cpp b/services/sink/inputcollector/test/sinkcollectorunittest/distributed_input_collector_test.cpp new file mode 100644 index 0000000..960ba8b --- /dev/null +++ b/services/sink/inputcollector/test/sinkcollectorunittest/distributed_input_collector_test.cpp @@ -0,0 +1,78 @@ +/* + * 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 "distributed_input_collector_test.h" +#include "event_handler.h" +#include "dinput_errcode.h" + +using namespace testing::ext; +using namespace OHOS::DistributedHardware::DistributedInput; +using namespace std; +namespace OHOS { +namespace DistributedHardware { +namespace DistributedInput { +void DistributedInputCollectorTest::SetUp() +{ +} + +void DistributedInputCollectorTest::TearDown() +{ + DistributedInputCollector::GetInstance().Release(); +} + +void DistributedInputCollectorTest::SetUpTestCase() +{ +} + +void DistributedInputCollectorTest::TearDownTestCase() +{ +} + +DistributedInputCollectorTest::DInputSinkCollectorEventHandler::DInputSinkCollectorEventHandler( + const std::shared_ptr &runner) : AppExecFwk::EventHandler(runner) +{ +} + +void DistributedInputCollectorTest::DInputSinkCollectorEventHandler::ProcessEvent( + const AppExecFwk::InnerEvent::Pointer &event) +{ + (void)event; +} + +HWTEST_F(DistributedInputCollectorTest, Init01, testing::ext::TestSize.Level1) +{ + std::shared_ptr eventHandler_ = nullptr; + int32_t ret = DistributedInputCollector::GetInstance().Init(eventHandler_); + EXPECT_EQ(ERR_DH_INPUT_SERVER_SINK_COLLECTOR_INIT_FAIL, ret); +} + +HWTEST_F(DistributedInputCollectorTest, Init02, testing::ext::TestSize.Level1) +{ + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + std::shared_ptr eventHandler_ = + std::make_shared(runner); + + int32_t ret = DistributedInputCollector::GetInstance().Init(eventHandler_); + EXPECT_EQ(DH_SUCCESS, ret); +} + +HWTEST_F(DistributedInputCollectorTest, IsAllDevicesStoped, testing::ext::TestSize.Level1) +{ + bool isStop = DistributedInputCollector::GetInstance().IsAllDevicesStoped(); + EXPECT_EQ(true, isStop); +} +} // namespace DistributedInput +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/sink/inputcollector/test/sinkcollectorunittest/distributed_input_collector_test.h b/services/sink/inputcollector/test/sinkcollectorunittest/distributed_input_collector_test.h new file mode 100644 index 0000000..04bcd63 --- /dev/null +++ b/services/sink/inputcollector/test/sinkcollectorunittest/distributed_input_collector_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 DISRIBUTED_INPUT_COLLECTOR_TEST_H +#define DISRIBUTED_INPUT_COLLECTOR_TEST_H + +#include + +#include "constants_dinput.h" +#include "distributed_input_collector.h" + +namespace OHOS { +namespace DistributedHardware { +namespace DistributedInput { +class DistributedInputCollectorTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; + + class DInputSinkCollectorEventHandler : public AppExecFwk::EventHandler { + public: + explicit DInputSinkCollectorEventHandler(const std::shared_ptr &runner); + ~DInputSinkCollectorEventHandler() {} + + void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override; + }; +}; +} // namespace DistributedInput +} // namespace DistributedHardware +} // namespace OHOS +#endif // DISRIBUTED_INPUT_COLLECTOR_TEST_H \ No newline at end of file diff --git a/services/sink/sinkmanager/test/sinkmanagerunittest/BUILD.gn b/services/sink/sinkmanager/test/sinkmanagerunittest/BUILD.gn index dc2ceac..1832a2a 100755 --- a/services/sink/sinkmanager/test/sinkmanagerunittest/BUILD.gn +++ b/services/sink/sinkmanager/test/sinkmanagerunittest/BUILD.gn @@ -58,6 +58,7 @@ ohos_unittest("distributed_input_sinkmanager_test") { "//drivers/peripheral/display/interfaces/include", "//drivers/peripheral/base", "//foundation/graphic/graphic_2d/utils/buffer_handle/export", + "${common_path}/mock", ] sources = [ @@ -70,6 +71,8 @@ ohos_unittest("distributed_input_sinkmanager_test") { "//foundation/distributedhardware/distributed_input/services/sink/transport/src/distributed_input_sink_switch.cpp", "//foundation/distributedhardware/distributed_input/services/sink/transport/src/distributed_input_sink_transport.cpp", "distributed_input_sinkmanager_test.cpp", + "${common_path}/mock/session_mock.cpp", + "${common_path}/mock/softbus_bus_center_mock.cpp", ] cflags = [ @@ -96,7 +99,6 @@ ohos_unittest("distributed_input_sinkmanager_test") { "${low_latency_path}:libdinput_low_latency", "${utils_path}:libdinput_utils", "//base/notification/eventhandler/frameworks/eventhandler:libeventhandler", - "//foundation/communication/dsoftbus/sdk:softbus_client", "//third_party/openssl:libcrypto_static", "${fwk_interfaces_path}:libdhfwk_sdk", "//foundation/window/window_manager/dm:libdm", diff --git a/services/sink/sinkmanager/test/sinkmanagerunittest/distributed_input_sinkmanager_test.cpp b/services/sink/sinkmanager/test/sinkmanagerunittest/distributed_input_sinkmanager_test.cpp index 5966f1d..5d4da4f 100644 --- a/services/sink/sinkmanager/test/sinkmanagerunittest/distributed_input_sinkmanager_test.cpp +++ b/services/sink/sinkmanager/test/sinkmanagerunittest/distributed_input_sinkmanager_test.cpp @@ -34,6 +34,10 @@ void DistributedInputSinkManagerTest::SetUp() void DistributedInputSinkManagerTest::TearDown() { + if (sinkManager_ != nullptr) { + delete sinkManager_; + sinkManager_ = nullptr; + } } void DistributedInputSinkManagerTest::SetUpTestCase() @@ -47,7 +51,23 @@ void DistributedInputSinkManagerTest::TearDownTestCase() HWTEST_F(DistributedInputSinkManagerTest, Init01, testing::ext::TestSize.Level0) { int32_t ret = sinkManager_->Init(); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SINK_MANAGER_INIT_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); +} + +HWTEST_F(DistributedInputSinkManagerTest, GetStartTransFlag, testing::ext::TestSize.Level0) +{ + DInputServerType flag = DInputServerType::SINK_SERVER_TYPE; + sinkManager_->SetStartTransFlag(flag); + DInputServerType retFlag = sinkManager_->GetStartTransFlag(); + EXPECT_EQ(flag, retFlag); +} + +HWTEST_F(DistributedInputSinkManagerTest, GetInputTypes, testing::ext::TestSize.Level0) +{ + uint32_t inputTypes = static_cast(DInputDeviceType::MOUSE); + sinkManager_->SetInputTypes(inputTypes); + uint32_t retType = sinkManager_->GetInputTypes(); + EXPECT_EQ(inputTypes, retType); } } // namespace DistributedInput } // namespace DistributedHardware diff --git a/services/sink/sinkmanager/test/sinkmanagerunittest/distributed_input_sinkmanager_test.h b/services/sink/sinkmanager/test/sinkmanagerunittest/distributed_input_sinkmanager_test.h index d56a892..7132506 100644 --- a/services/sink/sinkmanager/test/sinkmanagerunittest/distributed_input_sinkmanager_test.h +++ b/services/sink/sinkmanager/test/sinkmanagerunittest/distributed_input_sinkmanager_test.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef DISRIBUTED_INPUT_INNER_TEST_H -#define DISRIBUTED_INPUT_INNER_TEST_H +#ifndef DISRIBUTED_INPUT_SINKMANAGER_TEST_H +#define DISRIBUTED_INPUT_SINKMANAGER_TEST_H #include @@ -44,4 +44,4 @@ private: } // namespace DistributedHardware } // namespace OHOS -#endif // DISRIBUTED_INPUT_INNER_TEST_H +#endif // DISRIBUTED_INPUT_SINKMANAGER_TEST_H diff --git a/services/sink/transport/test/sinktransunittest/BUILD.gn b/services/sink/transport/test/sinktransunittest/BUILD.gn index 9006bb4..023e072 100755 --- a/services/sink/transport/test/sinktransunittest/BUILD.gn +++ b/services/sink/transport/test/sinktransunittest/BUILD.gn @@ -37,17 +37,19 @@ ohos_unittest("distributed_input_sinktrans_test") { "${fwk_utils_path}/include", "${service_common}/include", "//third_party/json/include", - "//foundation/distributedhardware/distributed_input/services/sink/transport/test/sinktransunittest/mock", "${dfx_utils_path}/include", "${utils_path}/include", "${low_latency_path}/include", "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", + "${common_path}/mock", ] sources = [ "//foundation/distributedhardware/distributed_input/services/sink/transport/src/distributed_input_sink_switch.cpp", "//foundation/distributedhardware/distributed_input/services/sink/transport/src/distributed_input_sink_transport.cpp", "distributed_input_sinktrans_test.cpp", + "${common_path}/mock/session_mock.cpp", + "${common_path}/mock/softbus_bus_center_mock.cpp", ] cflags = [ @@ -69,7 +71,6 @@ ohos_unittest("distributed_input_sinktrans_test") { "${fwk_utils_path}:distributedhardwareutils", "${utils_path}:libdinput_utils", "//base/notification/eventhandler/frameworks/eventhandler:libeventhandler", - "//foundation/communication/dsoftbus/sdk:softbus_client", ] external_deps = [ diff --git a/services/sink/transport/test/sinktransunittest/distributed_input_sinktrans_test.cpp b/services/sink/transport/test/sinktransunittest/distributed_input_sinktrans_test.cpp index e646b48..d91d259 100644 --- a/services/sink/transport/test/sinktransunittest/distributed_input_sinktrans_test.cpp +++ b/services/sink/transport/test/sinktransunittest/distributed_input_sinktrans_test.cpp @@ -41,7 +41,14 @@ void DistributedInputSinkTransTest::TearDownTestCase() HWTEST_F(DistributedInputSinkTransTest, Init, testing::ext::TestSize.Level0) { int32_t ret = DistributedInputSinkTransport::GetInstance().Init(); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SINK_TRANSPORT_INIT_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); +} + +HWTEST_F(DistributedInputSinkTransTest, GetSessionIdByNetId, testing::ext::TestSize.Level0) +{ + std::string srcId = ""; + int32_t ret = DistributedInputSinkTransport::GetInstance().GetSessionIdByNetId(srcId); + EXPECT_EQ(ERR_DH_INPUT_SERVER_SINK_TRANSPORT_GET_SESSIONID_FAIL, ret); } HWTEST_F(DistributedInputSinkTransTest, RespPrepareRemoteInput01, testing::ext::TestSize.Level1) @@ -60,6 +67,14 @@ HWTEST_F(DistributedInputSinkTransTest, RespPrepareRemoteInput02, testing::ext:: EXPECT_EQ(ERR_DH_INPUT_SERVER_SINK_TRANSPORT_RESPPREPARE_FAIL, ret); } +HWTEST_F(DistributedInputSinkTransTest, RespPrepareRemoteInput03, testing::ext::TestSize.Level1) +{ + int32_t sessionId = 1; + std::string smsg = ""; + int32_t ret = DistributedInputSinkTransport::GetInstance().RespPrepareRemoteInput(sessionId, smsg); + EXPECT_EQ(DH_SUCCESS, ret); +} + HWTEST_F(DistributedInputSinkTransTest, RespUnprepareRemoteInput01, testing::ext::TestSize.Level0) { int32_t sessionId = -1; @@ -76,6 +91,14 @@ HWTEST_F(DistributedInputSinkTransTest, RespUnprepareRemoteInput02, testing::ext EXPECT_EQ(ERR_DH_INPUT_SERVER_SINK_TRANSPORT_RESPUNPREPARE_FAIL, ret); } +HWTEST_F(DistributedInputSinkTransTest, RespUnprepareRemoteInput03, testing::ext::TestSize.Level1) +{ + int32_t sessionId = 1; + std::string smsg = ""; + int32_t ret = DistributedInputSinkTransport::GetInstance().RespUnprepareRemoteInput(sessionId, smsg); + EXPECT_EQ(DH_SUCCESS, ret); +} + HWTEST_F(DistributedInputSinkTransTest, RespStartRemoteInput01, testing::ext::TestSize.Level1) { int32_t sessionId = -1; @@ -92,6 +115,14 @@ HWTEST_F(DistributedInputSinkTransTest, RespStartRemoteInput02, testing::ext::Te EXPECT_EQ(ERR_DH_INPUT_SERVER_SINK_TRANSPORT_RESPSTART_FAIL, ret); } +HWTEST_F(DistributedInputSinkTransTest, RespStartRemoteInput03, testing::ext::TestSize.Level1) +{ + int32_t sessionId = 1; + std::string smsg = ""; + int32_t ret = DistributedInputSinkTransport::GetInstance().RespStartRemoteInput(sessionId, smsg); + EXPECT_EQ(DH_SUCCESS, ret); +} + HWTEST_F(DistributedInputSinkTransTest, RespStopRemoteInput01, testing::ext::TestSize.Level1) { int32_t sessionId = -1; @@ -108,6 +139,14 @@ HWTEST_F(DistributedInputSinkTransTest, RespStopRemoteInput02, testing::ext::Tes EXPECT_EQ(ERR_DH_INPUT_SERVER_SINK_TRANSPORT_RESPSTOP_FAIL, ret); } +HWTEST_F(DistributedInputSinkTransTest, RespStopRemoteInput03, testing::ext::TestSize.Level1) +{ + int32_t sessionId = 1; + std::string smsg = ""; + int32_t ret = DistributedInputSinkTransport::GetInstance().RespStopRemoteInput(sessionId, smsg); + EXPECT_EQ(DH_SUCCESS, ret); +} + HWTEST_F(DistributedInputSinkTransTest, GetEventHandler, testing::ext::TestSize.Level1) { std::shared_ptr eventHd = diff --git a/services/sink/transport/test/sinktransunittest/distributed_input_sinktrans_test.h b/services/sink/transport/test/sinktransunittest/distributed_input_sinktrans_test.h index 6fe5eac..ccb2bfe 100644 --- a/services/sink/transport/test/sinktransunittest/distributed_input_sinktrans_test.h +++ b/services/sink/transport/test/sinktransunittest/distributed_input_sinktrans_test.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef DISRIBUTED_INPUT_INNER_TEST_H -#define DISRIBUTED_INPUT_INNER_TEST_H +#ifndef DISRIBUTED_INPUT_SINKTRANS_TEST_H +#define DISRIBUTED_INPUT_SINKTRANS_TEST_H #include #include @@ -40,4 +40,4 @@ public: } // namespace DistributedHardware } // namespace OHOS -#endif // DISRIBUTED_INPUT_INNER_TEST_H +#endif // DISRIBUTED_INPUT_SINKTRANS_TEST_H diff --git a/services/source/inputinject/test/sourceinjectunittest/BUILD.gn b/services/source/inputinject/test/sourceinjectunittest/BUILD.gn index 0f9f074..57740db 100755 --- a/services/source/inputinject/test/sourceinjectunittest/BUILD.gn +++ b/services/source/inputinject/test/sourceinjectunittest/BUILD.gn @@ -36,6 +36,7 @@ ohos_unittest("distributed_input_inner_sourceinject_test") { "//commonlibrary/c_utils/base/include", "//utils/system/safwk/native/include", "${common_path}/include", + "${frameworks_path}/include", "${fwk_common_path}/log/include", "${fwk_common_path}/utils/include", "${fwk_utils_path}/include/log", @@ -50,10 +51,13 @@ ohos_unittest("distributed_input_inner_sourceinject_test") { "${distributedinput_path}/inputdevicehandler/include", "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", "//base/notification/eventhandler/interfaces/inner_api", + "//foundation/systemabilitymgr/safwk/interfaces/innerkits/safwk", + "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy/include", ] sources = [ "${common_path}/include/input_hub.cpp", + "//foundation/distributedhardware/distributed_input/inputdevicehandler/src/distributed_input_handler.cpp", "//foundation/distributedhardware/distributed_input/services/source/inputinject/src/distributed_input_inject.cpp", "//foundation/distributedhardware/distributed_input/services/source/inputinject/src/distributed_input_node_manager.cpp", "//foundation/distributedhardware/distributed_input/services/source/inputinject/src/virtual_device.cpp", @@ -82,12 +86,14 @@ ohos_unittest("distributed_input_inner_sourceinject_test") { "${dfx_utils_path}:libdinput_dfx_utils", "${fwk_utils_path}:distributedhardwareutils", "${utils_path}:libdinput_utils", - "//foundation/communication/dsoftbus/sdk:softbus_client", "//third_party/openssl:libcrypto_static", + "${distributedinput_path}/interfaces/inner_kits:libdinput_sdk", ] external_deps = [ "c_utils:utils", + "ipc:ipc_core", + "dsoftbus:softbus_client", ] cflags_cc = [ "-DHILOG_ENABLE" ] diff --git a/services/source/inputinject/test/sourceinjectunittest/distributed_input_sourceinject_test.cpp b/services/source/inputinject/test/sourceinjectunittest/distributed_input_sourceinject_test.cpp index c20e8e1..6fc0a21 100644 --- a/services/source/inputinject/test/sourceinjectunittest/distributed_input_sourceinject_test.cpp +++ b/services/source/inputinject/test/sourceinjectunittest/distributed_input_sourceinject_test.cpp @@ -51,6 +51,23 @@ void DistributedInputSourceInjectTest::TearDownTestCase() { } +void DistributedInputSourceInjectTest::TestInputNodeListener::OnNodeOnLine(const std::string srcDevId, + const std::string sinkDevId, const std::string sinkNodeId, const std::string sinkNodeDesc) +{ + (void)srcDevId; + (void)sinkDevId; + (void)sinkNodeId; + (void)sinkNodeDesc; +} + +void DistributedInputSourceInjectTest::TestInputNodeListener::OnNodeOffLine(const std::string srcDevId, + const std::string sinkDevId, const std::string sinkNodeId) +{ + (void)srcDevId; + (void)sinkDevId; + (void)sinkNodeId; +} + HWTEST_F(DistributedInputSourceInjectTest, RegisterDistributedHardware01, testing::ext::TestSize.Level1) { InputDevice pBuffer; @@ -230,6 +247,20 @@ HWTEST_F(DistributedInputSourceInjectTest, RegisterDistributedEvent03, testing:: int32_t ret = DistributedInputInject::GetInstance().RegisterDistributedEvent(writeBuffer, count); EXPECT_EQ(DH_SUCCESS, ret); } + +HWTEST_F(DistributedInputSourceInjectTest, RegisterInputNodeListener, testing::ext::TestSize.Level1) +{ + inputNodelistener_ = (std::make_unique()).release(); + int32_t ret = DistributedInputInject::GetInstance().RegisterInputNodeListener(inputNodelistener_); + EXPECT_EQ(DH_SUCCESS, ret); +} + +HWTEST_F(DistributedInputSourceInjectTest, UnRegisterInputNodeListener, testing::ext::TestSize.Level1) +{ + int32_t ret = DistributedInputInject::GetInstance().UnregisterInputNodeListener(inputNodelistener_); + EXPECT_EQ(DH_SUCCESS, ret); +} + } // namespace DistributedInput } // namespace DistributedHardware } // namespace OHOS diff --git a/services/source/inputinject/test/sourceinjectunittest/distributed_input_sourceinject_test.h b/services/source/inputinject/test/sourceinjectunittest/distributed_input_sourceinject_test.h index 53e78a9..16e3d44 100644 --- a/services/source/inputinject/test/sourceinjectunittest/distributed_input_sourceinject_test.h +++ b/services/source/inputinject/test/sourceinjectunittest/distributed_input_sourceinject_test.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef DISRIBUTED_INPUT_INNER_TEST_H -#define DISRIBUTED_INPUT_INNER_TEST_H +#ifndef DISRIBUTED_INPUT_SOURCEINJECT_TEST_H +#define DISRIBUTED_INPUT_SOURCEINJECT_TEST_H #include #include @@ -25,6 +25,7 @@ #include "constants_dinput.h" #include "distributed_input_inject.h" +#include "input_node_listener_stub.h" namespace OHOS { namespace DistributedHardware { @@ -35,9 +36,19 @@ public: static void TearDownTestCase(); virtual void SetUp() override; virtual void TearDown() override; + class TestInputNodeListener : public OHOS::DistributedHardware::DistributedInput::InputNodeListenerStub { + public: + TestInputNodeListener() = default; + virtual ~TestInputNodeListener() = default; + void OnNodeOnLine(const std::string srcDevId, const std::string sinkDevId, const std::string sinkNodeId, + const std::string sinkNodeDesc); + void OnNodeOffLine(const std::string srcDevId, const std::string sinkDevId, const std::string sinkNodeId); + }; +private: + sptr inputNodelistener_; }; } // namespace DistributedInput } // namespace DistributedHardware } // namespace OHOS -#endif // DISRIBUTED_INPUT_INNER_TEST_H +#endif // DISRIBUTED_INPUT_SOURCEINJECT_TEST_H diff --git a/services/source/sourcemanager/src/distributed_input_source_manager.cpp b/services/source/sourcemanager/src/distributed_input_source_manager.cpp index b6f4565..f9708ec 100644 --- a/services/source/sourcemanager/src/distributed_input_source_manager.cpp +++ b/services/source/sourcemanager/src/distributed_input_source_manager.cpp @@ -1193,6 +1193,10 @@ int32_t DistributedInputSourceManager::StartRemoteInput(const std::string &srcId HisyseventUtil::GetInstance().SysEventWriteBehavior(DINPUT_START_USE, sinkId, "dinput start use call"); DHLOGI("StartRemoteInput called, srcId: %s, sinkId: %s, inputTypes: %d", GetAnonyString(srcId).c_str(), GetAnonyString(sinkId).c_str(), inputTypes); + if (callback == nullptr) { + DHLOGE("StartRemoteInput called, callback is null."); + return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL; + } std::string localNetworkId = GetLocalNetworkId(); if (localNetworkId.empty()) { DHLOGE("StartRemoteInput called, Could not get local device id."); @@ -1209,8 +1213,7 @@ int32_t DistributedInputSourceManager::StartRemoteInput(const std::string &srcId for (auto iter : staCallbacks_) { if (iter.devId == sinkId && iter.inputTypes == inputTypes) { - DHLOGE("StartRemoteInput called, srcId: %s, sinkId: %s repeat call.", - GetAnonyString(srcId).c_str(), GetAnonyString(sinkId).c_str()); + DHLOGE("StartRemoteInput called, repeat call."); HisyseventUtil::GetInstance().SysEventWriteFault(DINPUT_OPT_FAIL, sinkId, ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL, "dinput start use failed in already started"); FinishAsyncTrace(DINPUT_HITRACE_LABEL, DINPUT_START_START, DINPUT_START_TASK); @@ -1228,7 +1231,7 @@ int32_t DistributedInputSourceManager::StartRemoteInput(const std::string &srcId ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL, "dinput start use failed in transport start"); FinishAsyncTrace(DINPUT_HITRACE_LABEL, DINPUT_START_START, DINPUT_START_TASK); DHLOGE("StartRemoteInput called, start fail."); - for (std::vector::iterator it = staCallbacks_.begin(); it != staCallbacks_.end(); it++) { + for (auto it = staCallbacks_.begin(); it != staCallbacks_.end(); it++) { if (it->devId == sinkId && it->inputTypes == inputTypes) { staCallbacks_.erase(it); return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL; @@ -1246,6 +1249,10 @@ int32_t DistributedInputSourceManager::StopRemoteInput(const std::string &srcId, HisyseventUtil::GetInstance().SysEventWriteBehavior(DINPUT_STOP_USE, sinkId, "dinput stop use call"); DHLOGI("StopRemoteInput called, srcId: %s, sinkId: %s, inputTypes: %d", GetAnonyString(srcId).c_str(), GetAnonyString(sinkId).c_str(), inputTypes); + if (callback == nullptr) { + DHLOGE("StopRemoteInput called, callback is null."); + return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL; + } std::string localNetworkId = GetLocalNetworkId(); if (localNetworkId.empty()) { DHLOGE("StopRemoteInput called, Could not get local device id."); @@ -1278,7 +1285,7 @@ int32_t DistributedInputSourceManager::StopRemoteInput(const std::string &srcId, HisyseventUtil::GetInstance().SysEventWriteFault(DINPUT_OPT_FAIL, sinkId, ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL, "dinput stop use failed in transport stop"); FinishAsyncTrace(DINPUT_HITRACE_LABEL, DINPUT_STOP_START, DINPUT_STOP_TASK); - for (std::vector::iterator it = stpCallbacks_.begin(); it != stpCallbacks_.end(); it++) { + for (auto it = stpCallbacks_.begin(); it != stpCallbacks_.end(); it++) { if (it->devId == sinkId && it->inputTypes == inputTypes) { stpCallbacks_.erase(it); return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL; @@ -1469,6 +1476,10 @@ int32_t DistributedInputSourceManager::StartRemoteInput(const std::string &sinkI StartAsyncTrace(DINPUT_HITRACE_LABEL, DINPUT_START_START, DINPUT_START_TASK); HisyseventUtil::GetInstance().SysEventWriteBehavior(DINPUT_START_USE, sinkId, "dinput start use call"); DHLOGI("sinkId: %s, vector.string.size: %d", GetAnonyString(sinkId).c_str(), dhIds.size()); + if (callback == nullptr) { + DHLOGE("StartRemoteInput called, callback is null."); + return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL; + } std::string localNetworkId = GetLocalNetworkId(); if (localNetworkId.empty()) { DHLOGE("Could not get local device id."); @@ -1505,8 +1516,7 @@ int32_t DistributedInputSourceManager::StartRemoteInput(const std::string &sinkI ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL, "dinput start use failed in transport start"); FinishAsyncTrace(DINPUT_HITRACE_LABEL, DINPUT_START_START, DINPUT_START_TASK); DHLOGE("StartRemoteInput start fail."); - for (std::vector::iterator iter = staStringCallbacks_.begin(); - iter != staStringCallbacks_.end(); iter++) { + for (auto iter = staStringCallbacks_.begin(); iter != staStringCallbacks_.end(); iter++) { if (iter->sinkId == sinkId && IsStringDataSame(iter->dhIds, dhIds)) { staStringCallbacks_.erase(iter); return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL; @@ -1523,6 +1533,10 @@ int32_t DistributedInputSourceManager::StopRemoteInput(const std::string &sinkId StartAsyncTrace(DINPUT_HITRACE_LABEL, DINPUT_STOP_START, DINPUT_STOP_TASK); HisyseventUtil::GetInstance().SysEventWriteBehavior(DINPUT_STOP_USE, sinkId, "dinput stop use call"); DHLOGI("sinkId: %s, vector.string.size: %d", GetAnonyString(sinkId).c_str(), dhIds.size()); + if (callback == nullptr) { + DHLOGE("StopRemoteInput called, callback is null."); + return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL; + } std::string localNetworkId = GetLocalNetworkId(); if (localNetworkId.empty()) { DHLOGE("Could not get local device id."); @@ -1555,8 +1569,7 @@ int32_t DistributedInputSourceManager::StopRemoteInput(const std::string &sinkId ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL, "dinput stop use failed in transport stop"); FinishAsyncTrace(DINPUT_HITRACE_LABEL, DINPUT_STOP_START, DINPUT_STOP_TASK); DHLOGE("StopRemoteInput stop fail."); - for (std::vector::iterator iter = stpStringCallbacks_.begin(); - iter != stpStringCallbacks_.end(); iter++) { + for (auto iter = stpStringCallbacks_.begin(); iter != stpStringCallbacks_.end(); iter++) { if (iter->sinkId == sinkId && IsStringDataSame(iter->dhIds, dhIds)) { stpStringCallbacks_.erase(iter); return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL; @@ -1574,6 +1587,10 @@ int32_t DistributedInputSourceManager::StartRemoteInput(const std::string &srcId HisyseventUtil::GetInstance().SysEventWriteBehavior(DINPUT_START_USE, sinkId, "dinput start use call"); DHLOGI("srcId: %s, sinkId: %s, dhids size: %d", GetAnonyString(srcId).c_str(), GetAnonyString(sinkId).c_str(), dhIds.size()); + if (callback == nullptr) { + DHLOGE("StartRemoteInput called, callback is null."); + return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL; + } std::string localNetworkId = GetLocalNetworkId(); if (localNetworkId.empty()) { DHLOGE("Could not get local device id."); @@ -1610,8 +1627,7 @@ int32_t DistributedInputSourceManager::StartRemoteInput(const std::string &srcId ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL, "dinput start use failed in transport start"); FinishAsyncTrace(DINPUT_HITRACE_LABEL, DINPUT_START_START, DINPUT_START_TASK); DHLOGE("StartRemoteInput start fail."); - for (std::vector::iterator iter = staStringCallbacks_.begin(); - iter != staStringCallbacks_.end(); iter++) { + for (auto iter = staStringCallbacks_.begin(); iter != staStringCallbacks_.end(); iter++) { if (iter->srcId == srcId && iter->sinkId == sinkId && IsStringDataSame(iter->dhIds, dhIds)) { staStringCallbacks_.erase(iter); return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL; @@ -1629,6 +1645,10 @@ int32_t DistributedInputSourceManager::StopRemoteInput(const std::string &srcId, HisyseventUtil::GetInstance().SysEventWriteBehavior(DINPUT_STOP_USE, sinkId, "dinput stop use call"); DHLOGI("srcId: %s, sinkId: %s, vector.string.size: %d", GetAnonyString(srcId).c_str(), GetAnonyString(sinkId).c_str(), dhIds.size()); + if (callback == nullptr) { + DHLOGE("StopRemoteInput called, callback is null."); + return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL; + } std::string localNetworkId = GetLocalNetworkId(); if (localNetworkId.empty()) { DHLOGE("Could not get local device id."); @@ -1653,21 +1673,15 @@ int32_t DistributedInputSourceManager::StopRemoteInput(const std::string &srcId, } } - DInputClientStopDhidInfo info; - info.srcId = srcId; - info.sinkId = sinkId; - info.dhIds = dhIds; - info.callback = callback; + DInputClientStopDhidInfo info{srcId, sinkId, dhIds, callback}; stpStringCallbacks_.push_back(info); - int32_t ret = DistributedInputSourceTransport::GetInstance().StopRemoteInput(sinkId, dhIds); if (ret != DH_SUCCESS) { HisyseventUtil::GetInstance().SysEventWriteFault(DINPUT_OPT_FAIL, sinkId, ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL, "dinput stop use failed in transport stop"); FinishAsyncTrace(DINPUT_HITRACE_LABEL, DINPUT_STOP_START, DINPUT_STOP_TASK); DHLOGE("StopRemoteInput stop fail."); - for (std::vector::iterator iter = stpStringCallbacks_.begin(); - iter != stpStringCallbacks_.end(); iter++) { + for (auto iter = stpStringCallbacks_.begin(); iter != stpStringCallbacks_.end(); iter++) { if (iter->srcId == srcId && iter->sinkId == sinkId && IsStringDataSame(iter->dhIds, dhIds)) { stpStringCallbacks_.erase(iter); return ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL; diff --git a/services/source/sourcemanager/test/sourcemanagerunittest/BUILD.gn b/services/source/sourcemanager/test/sourcemanagerunittest/BUILD.gn index b87a689..5b1c1c4 100755 --- a/services/source/sourcemanager/test/sourcemanagerunittest/BUILD.gn +++ b/services/source/sourcemanager/test/sourcemanagerunittest/BUILD.gn @@ -55,6 +55,7 @@ ohos_unittest("distributed_input_sourcemanager_test") { "${fwk_interfaces_path}/include", "${fwk_interfaces_path}/include/ipc", "//base/hiviewdfx/hisysevent/interfaces/native/innerkits/hisysevent/include", + "${common_path}/mock", ] sources = [ @@ -94,6 +95,8 @@ ohos_unittest("distributed_input_sourcemanager_test") { "//foundation/distributedhardware/distributed_input/services/source/sourcemanager/src/distributed_input_source_sa_cli_mgr.cpp", "//foundation/distributedhardware/distributed_input/services/source/transport/src/distributed_input_source_transport.cpp", "distributed_input_sourcemanager_test.cpp", + "${common_path}/mock/session_mock.cpp", + "${common_path}/mock/softbus_bus_center_mock.cpp", ] cflags = [ @@ -120,7 +123,6 @@ ohos_unittest("distributed_input_sourcemanager_test") { "${low_latency_path}:libdinput_low_latency", "${utils_path}:libdinput_utils", "//base/notification/eventhandler/frameworks/eventhandler:libeventhandler", - "//foundation/communication/dsoftbus/sdk:softbus_client", "//third_party/openssl:libcrypto_static", "${fwk_interfaces_path}:libdhfwk_sdk", "${innerkits_path}:libdinput_sdk", diff --git a/services/source/sourcemanager/test/sourcemanagerunittest/distributed_input_sourcemanager_test.cpp b/services/source/sourcemanager/test/sourcemanagerunittest/distributed_input_sourcemanager_test.cpp index 42fb609..8db5890 100644 --- a/services/source/sourcemanager/test/sourcemanagerunittest/distributed_input_sourcemanager_test.cpp +++ b/services/source/sourcemanager/test/sourcemanagerunittest/distributed_input_sourcemanager_test.cpp @@ -165,6 +165,15 @@ void DistributedInputSourceManagerTest::TestInputNodeListenerCb::OnNodeOffLine(c return; } +int32_t DistributedInputSourceManagerTest::TestSimulationEventCb::OnSimulationEvent(uint32_t type, uint32_t code, + int32_t value) +{ + (void)type; + (void)code; + (void)value; + return DH_SUCCESS; +} + int32_t DistributedInputSourceManagerTest::StructTransJson(const InputDevice& pBuf, std::string& strDescriptor) const { nlohmann::json tmpJson; @@ -187,7 +196,7 @@ int32_t DistributedInputSourceManagerTest::StructTransJson(const InputDevice& pB HWTEST_F(DistributedInputSourceManagerTest, Init01, testing::ext::TestSize.Level0) { int32_t ret = sourceManager_->Init(); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_INIT_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } HWTEST_F(DistributedInputSourceManagerTest, RegisterDistributedHardware01, testing::ext::TestSize.Level0) @@ -263,7 +272,7 @@ HWTEST_F(DistributedInputSourceManagerTest, PrepareRemoteInput01, testing::ext:: std::string devId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback = new TestPrepareDInputCallback(); int32_t ret = sourceManager_->PrepareRemoteInput(devId, callback); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_PREPARE_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } HWTEST_F(DistributedInputSourceManagerTest, PrepareRemoteInput02, testing::ext::TestSize.Level0) @@ -290,11 +299,11 @@ HWTEST_F(DistributedInputSourceManagerTest, PrepareRemoteInput03, testing::ext:: */ HWTEST_F(DistributedInputSourceManagerTest, PrepareRemoteInput04, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91eb"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback = new TestPrepareDInputCallback(); int32_t ret = sourceManager_->PrepareRemoteInput(srcId, sinkId, callback); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_PREPARE_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } /** @@ -305,7 +314,7 @@ HWTEST_F(DistributedInputSourceManagerTest, PrepareRemoteInput04, testing::ext:: */ HWTEST_F(DistributedInputSourceManagerTest, PrepareRemoteInput05, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91eb"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback; int32_t ret = sourceManager_->PrepareRemoteInput(srcId, sinkId, callback); @@ -332,7 +341,7 @@ HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput01, testing::ext::Te std::string devId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback = new TestStartDInputCallback(); int32_t ret = sourceManager_->StartRemoteInput(devId, static_cast(DInputDeviceType::ALL), callback); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput02, testing::ext::TestSize.Level0) @@ -352,30 +361,30 @@ HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput03, testing::ext::Te } /** - * @tc.name: StartRemoteInput06 + * @tc.name: StartRemoteInput04 * @tc.desc: verify the function of starting distributed input on InputDeviceType. * @tc.type: FUNC * @tc.require: SR000H9J75 */ HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput04, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91eb"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback = new TestStartDInputCallback(); int32_t ret = sourceManager_->StartRemoteInput(srcId, sinkId, static_cast(DInputDeviceType::ALL), callback); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } /** - * @tc.name: StartRemoteInput06 + * @tc.name: StartRemoteInput05 * @tc.desc: verify the function of starting distributed input on InputDeviceType. * @tc.type: FUNC * @tc.require: SR000H9J75 */ HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput05, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91eb"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback; int32_t ret = @@ -405,26 +414,26 @@ HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput06, testing::ext::Te * @tc.type: FUNC * @tc.require: SR000H9J76 */ -HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput10, testing::ext::TestSize.Level0) +HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput07, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91eb"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; std::vector dhIds; dhIds.push_back("Input_slkdiek3kddkeojfe"); sptr callback = new TestStartStopVectorCallbackStub(); int32_t ret = sourceManager_->StartRemoteInput(srcId, sinkId, dhIds, callback); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_START_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } /** - * @tc.name: StartRemoteInput10 + * @tc.name: StartRemoteInput08 * @tc.desc: verify the function of transferring mouse button status. * @tc.type: FUNC * @tc.require: SR000H9J76 */ -HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput11, testing::ext::TestSize.Level0) +HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput08, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91eb"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; std::vector dhIds; sptr callback; @@ -433,12 +442,12 @@ HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput11, testing::ext::Te } /** - * @tc.name: StartRemoteInput12 + * @tc.name: StartRemoteInput09 * @tc.desc: verify the low-latency transmission capability of distributed input * @tc.type: FUNC * @tc.require: SR000H9J78 */ -HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput12, testing::ext::TestSize.Level0) +HWTEST_F(DistributedInputSourceManagerTest, StartRemoteInput09, testing::ext::TestSize.Level0) { std::string srcId = ""; std::string sinkId = ""; @@ -454,7 +463,7 @@ HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput01, testing::ext::Tes std::string devId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback = new TestStopDInputCallback(); int32_t ret = sourceManager_->StopRemoteInput(devId, static_cast(DInputDeviceType::ALL), callback); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput02, testing::ext::TestSize.Level0) @@ -481,12 +490,12 @@ HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput03, testing::ext::Tes */ HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput04, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91ev"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback = new TestStopDInputCallback(); int32_t ret = sourceManager_->StopRemoteInput(srcId, sinkId, static_cast(DInputDeviceType::ALL), callback); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } /** @@ -513,7 +522,7 @@ HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput05, testing::ext::Tes */ HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput06, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91ev"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback; int32_t ret = @@ -522,31 +531,31 @@ HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput06, testing::ext::Tes } /** - * @tc.name: StopRemoteInput10 + * @tc.name: StopRemoteInput07 * @tc.desc: verify the function of stoping distributed input with dhid. * @tc.type: FUNC * @tc.require: SR000H9J74 */ -HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput10, testing::ext::TestSize.Level0) +HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput07, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91eb"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; std::vector dhIds; dhIds.push_back("Input_slkdiek3kddkeojfe"); sptr callback = new TestStartStopVectorCallbackStub(); int32_t ret = sourceManager_->StopRemoteInput(srcId, sinkId, dhIds, callback); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_STOP_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } /** - * @tc.name: StopRemoteInput11 + * @tc.name: StopRemoteInput08 * @tc.desc: verify the function of stoping distributed input with dhid. * @tc.type: FUNC * @tc.require: SR000H9J74 */ -HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput11, testing::ext::TestSize.Level0) +HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput08, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91eb"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; std::vector dhIds; sptr callback; @@ -555,12 +564,12 @@ HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput11, testing::ext::Tes } /** - * @tc.name: StopRemoteInput12 + * @tc.name: StopRemoteInput09 * @tc.desc: verify the function of stoping distributed input with dhid. * @tc.type: FUNC * @tc.require: SR000H9J74 */ -HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput12, testing::ext::TestSize.Level0) +HWTEST_F(DistributedInputSourceManagerTest, StopRemoteInput09, testing::ext::TestSize.Level0) { std::string srcId = ""; std::string sinkId = ""; @@ -576,7 +585,7 @@ HWTEST_F(DistributedInputSourceManagerTest, UnprepareRemoteInput01, testing::ext std::string devId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback = new TestUnprepareDInputCallback(); int32_t ret = sourceManager_->UnprepareRemoteInput(devId, callback); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_UNPREPARE_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } HWTEST_F(DistributedInputSourceManagerTest, UnprepareRemoteInput02, testing::ext::TestSize.Level0) @@ -603,11 +612,11 @@ HWTEST_F(DistributedInputSourceManagerTest, UnprepareRemoteInput03, testing::ext */ HWTEST_F(DistributedInputSourceManagerTest, UnprepareRemoteInput04, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91eb"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback = new TestUnprepareDInputCallback(); int32_t ret = sourceManager_->UnprepareRemoteInput(srcId, sinkId, callback); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_UNPREPARE_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } /** @@ -633,7 +642,7 @@ HWTEST_F(DistributedInputSourceManagerTest, UnprepareRemoteInput05, testing::ext */ HWTEST_F(DistributedInputSourceManagerTest, UnprepareRemoteInput06, testing::ext::TestSize.Level0) { - std::string srcId = "umkyu1b165e1be98151891erbe8r91eb"; + std::string srcId = "networkidc08647073e02e7a78f09473aa122ff57fc81c00"; std::string sinkId = "umkyu1b165e1be98151891erbe8r91ev"; sptr callback; int32_t ret = sourceManager_->UnprepareRemoteInput(srcId, sinkId, callback); @@ -641,7 +650,7 @@ HWTEST_F(DistributedInputSourceManagerTest, UnprepareRemoteInput06, testing::ext } /** - * @tc.name: UnprepareRemoteInput06 + * @tc.name: UnprepareRemoteInput01 * @tc.desc: verify the function of disabling a peripheral device. * @tc.type: FUNC * @tc.require: SR000H9J77 @@ -656,7 +665,7 @@ HWTEST_F(DistributedInputSourceManagerTest, UnregisterDistributedHardware01, tes } /** - * @tc.name: UnprepareRemoteInput06 + * @tc.name: UnprepareRemoteInput02 * @tc.desc: verify the function of disabling a peripheral device. * @tc.type: FUNC * @tc.require: SR000H9J77 @@ -665,7 +674,7 @@ HWTEST_F(DistributedInputSourceManagerTest, UnregisterDistributedHardware02, tes { std::string devId = "umkyu1b165e1be98151891erbe8r91ev"; std::string dhId = "rt12r1nr81n521be8rb1erbe1w8bg1erb18"; - sptr callback = new TestUnregisterDInputCb(); + sptr callback; int32_t ret = sourceManager_->UnregisterDistributedHardware(devId, dhId, callback); EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_MANAGER_UNREGISTER_FAIL, ret); } @@ -707,19 +716,27 @@ HWTEST_F(DistributedInputSourceManagerTest, RegisterDelWhiteListCallback02, test EXPECT_EQ(DH_SUCCESS, ret); } -HWTEST_F(DistributedInputSourceManagerTest, RegisterInputNodeListener01, testing::ext::TestSize.Level0) -{ - sptr callback = new TestInputNodeListenerCb(); - int32_t ret = sourceManager_->RegisterInputNodeListener(callback); - EXPECT_EQ(DH_SUCCESS, ret); -} - HWTEST_F(DistributedInputSourceManagerTest, UnRegisterInputNodeListener01, testing::ext::TestSize.Level0) { sptr callback = new TestInputNodeListenerCb(); int32_t ret = sourceManager_->UnregisterInputNodeListener(callback); EXPECT_EQ(DH_SUCCESS, ret); } + +HWTEST_F(DistributedInputSourceManagerTest, RegisterSimulationEventListener, testing::ext::TestSize.Level0) +{ + sptr callback = new TestSimulationEventCb(); + int32_t ret = sourceManager_->RegisterSimulationEventListener(callback); + EXPECT_EQ(DH_SUCCESS, ret); +} + +HWTEST_F(DistributedInputSourceManagerTest, UnregisterSimulationEventListener, testing::ext::TestSize.Level0) +{ + sptr callback = new TestSimulationEventCb(); + int32_t ret = sourceManager_->UnregisterSimulationEventListener(callback); + EXPECT_EQ(DH_SUCCESS, ret); + sourceManager_->Release(); +} } } } diff --git a/services/source/sourcemanager/test/sourcemanagerunittest/distributed_input_sourcemanager_test.h b/services/source/sourcemanager/test/sourcemanagerunittest/distributed_input_sourcemanager_test.h index f59778a..45a09a7 100644 --- a/services/source/sourcemanager/test/sourcemanagerunittest/distributed_input_sourcemanager_test.h +++ b/services/source/sourcemanager/test/sourcemanagerunittest/distributed_input_sourcemanager_test.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef DISRIBUTED_INPUT_INNER_TEST_H -#define DISRIBUTED_INPUT_INNER_TEST_H +#ifndef DISRIBUTED_INPUT_SOURCEMANAGER_TEST_H +#define DISRIBUTED_INPUT_SOURCEMANAGER_TEST_H #include #include @@ -36,6 +36,7 @@ #include "start_stop_d_inputs_call_back_stub.h" #include "start_stop_result_call_back_stub.h" #include "input_node_listener_stub.h" +#include "simulation_event_listener_stub.h" namespace OHOS { namespace DistributedHardware { @@ -134,6 +135,13 @@ public: const std::string sinkNodeId); }; + class TestSimulationEventCb : public OHOS::DistributedHardware::DistributedInput::SimulationEventListenerStub { + public: + TestSimulationEventCb() = default; + virtual ~TestSimulationEventCb() = default; + int32_t OnSimulationEvent(uint32_t type, uint32_t code, int32_t value); + }; + private: int32_t StructTransJson(const InputDevice& pBuf, std::string& strDescriptor) const; DistributedInputSourceManager* sourceManager_; @@ -142,4 +150,4 @@ private: } // namespace DistributedHardware } // namespace OHOS -#endif // DISRIBUTED_INPUT_INNER_TEST_H +#endif // DISRIBUTED_INPUT_SOURCEMANAGER_TEST_H diff --git a/services/source/transport/test/sourcetransunittest/BUILD.gn b/services/source/transport/test/sourcetransunittest/BUILD.gn index 6e6a207..8e1cfcd 100755 --- a/services/source/transport/test/sourcetransunittest/BUILD.gn +++ b/services/source/transport/test/sourcetransunittest/BUILD.gn @@ -47,11 +47,14 @@ ohos_unittest("distributed_input_sourcetrans_test") { "${distributedinput_path}/inputdevicehandler/include", "//foundation/communication/ipc/interfaces/innerkits/ipc_core/include", "//base/notification/eventhandler/interfaces/inner_api", + "${common_path}/mock", ] sources = [ "//foundation/distributedhardware/distributed_input/services/source/transport/src/distributed_input_source_transport.cpp", "distributed_input_sourcetrans_test.cpp", + "${common_path}/mock/session_mock.cpp", + "${common_path}/mock/softbus_bus_center_mock.cpp", ] cflags = [ @@ -72,7 +75,6 @@ ohos_unittest("distributed_input_sourcetrans_test") { "${dfx_utils_path}:libdinput_dfx_utils", "${fwk_utils_path}:distributedhardwareutils", "${utils_path}:libdinput_utils", - "//foundation/communication/dsoftbus/sdk:softbus_client", "//foundation/distributedhardware/distributed_input/services/source/inputinject:libdinput_inject", ] diff --git a/services/source/transport/test/sourcetransunittest/distributed_input_sourcetrans_test.cpp b/services/source/transport/test/sourcetransunittest/distributed_input_sourcetrans_test.cpp index 58c2450..5115825 100644 --- a/services/source/transport/test/sourcetransunittest/distributed_input_sourcetrans_test.cpp +++ b/services/source/transport/test/sourcetransunittest/distributed_input_sourcetrans_test.cpp @@ -38,10 +38,28 @@ void DistributedInputSourceTransTest::TearDownTestCase() { } +HWTEST_F(DistributedInputSourceTransTest, OpenInputSoftbus01, testing::ext::TestSize.Level0) +{ + std::string remoteDevId = ""; + int32_t ret = DistributedInputSourceTransport::GetInstance().OpenInputSoftbus(remoteDevId); + + EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_OPEN_SESSION_FAIL, ret); +} + +HWTEST_F(DistributedInputSourceTransTest, OpenInputSoftbus02, testing::ext::TestSize.Level0) +{ + std::string remoteDevId = "f6d4c08647073e02e7a78f09473aa122ff57fc81c00981fcf5be989e7d112591"; + int32_t ret = DistributedInputSourceTransport::GetInstance().Init(); + EXPECT_EQ(DH_SUCCESS, ret); + ret = DistributedInputSourceTransport::GetInstance().OpenInputSoftbus(remoteDevId); + + EXPECT_EQ(DH_SUCCESS, ret); +} + HWTEST_F(DistributedInputSourceTransTest, Init, testing::ext::TestSize.Level0) { int32_t ret = DistributedInputSourceTransport::GetInstance().Init(); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_INIT_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } HWTEST_F(DistributedInputSourceTransTest, PrepareRemoteInput01, testing::ext::TestSize.Level0) @@ -62,7 +80,7 @@ HWTEST_F(DistributedInputSourceTransTest, PrepareRemoteInput03, testing::ext::Te { std::string deviceId = "f6d4c08647073e02e7a78f09473aa122ff57fc81c00981fcf5be989e7d112591"; int32_t ret = DistributedInputSourceTransport::GetInstance().PrepareRemoteInput(deviceId); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_PREPARE_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } HWTEST_F(DistributedInputSourceTransTest, UnprepareRemoteInput01, testing::ext::TestSize.Level0) @@ -83,7 +101,7 @@ HWTEST_F(DistributedInputSourceTransTest, UnprepareRemoteInput03, testing::ext:: { std::string deviceId = "f6d4c08647073e02e7a78f09473aa122ff57fc81c00981fcf5be989e7d112591"; int32_t ret = DistributedInputSourceTransport::GetInstance().UnprepareRemoteInput(deviceId); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_UNPREPARE_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } HWTEST_F(DistributedInputSourceTransTest, StartRemoteInput01, testing::ext::TestSize.Level0) @@ -99,7 +117,7 @@ HWTEST_F(DistributedInputSourceTransTest, StartRemoteInput02, testing::ext::Test std::string deviceId = "f6d4c08647073e02e7a78f09473aa122ff57fc81c00981fcf5be989e7d112591"; int32_t ret = DistributedInputSourceTransport::GetInstance().StartRemoteInput( deviceId, static_cast(DInputDeviceType::ALL)); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_START_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); } HWTEST_F(DistributedInputSourceTransTest, StopRemoteInput01, testing::ext::TestSize.Level0) @@ -115,7 +133,7 @@ HWTEST_F(DistributedInputSourceTransTest, StopRemoteInput02, testing::ext::TestS std::string deviceId = "f6d4c08647073e02e7a78f09473aa122ff57fc81c00981fcf5be989e7d112591"; int32_t ret = DistributedInputSourceTransport::GetInstance().StopRemoteInput( deviceId, static_cast(DInputDeviceType::ALL)); - EXPECT_EQ(ERR_DH_INPUT_SERVER_SOURCE_TRANSPORT_STOP_FAIL, ret); + EXPECT_EQ(DH_SUCCESS, ret); DistributedInputSourceTransport::GetInstance().CloseInputSoftbus(deviceId); } } // namespace DistributedInput diff --git a/services/source/transport/test/sourcetransunittest/distributed_input_sourcetrans_test.h b/services/source/transport/test/sourcetransunittest/distributed_input_sourcetrans_test.h index 335d4e9..7b44288 100644 --- a/services/source/transport/test/sourcetransunittest/distributed_input_sourcetrans_test.h +++ b/services/source/transport/test/sourcetransunittest/distributed_input_sourcetrans_test.h @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef DISRIBUTED_INPUT_INNER_TEST_H -#define DISRIBUTED_INPUT_INNER_TEST_H +#ifndef DISRIBUTED_INPUT_SOURCETRANS_TEST_H +#define DISRIBUTED_INPUT_SOURCETRANS_TEST_H #include #include @@ -40,4 +40,4 @@ public: } // namespace DistributedHardware } // namespace OHOS -#endif // DISRIBUTED_INPUT_INNER_TEST_H +#endif // DISRIBUTED_INPUT_SOURCETRANS_TEST_H