From 354583e5905489b0cd85b423b1868a32a32fc364 Mon Sep 17 00:00:00 2001 From: l00635678 Date: Tue, 2 Sep 2025 10:20:02 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B5=8B=E8=AF=95=E7=94=A8=E4=BE=8B=E4=BF=AE?= =?UTF-8?q?=E5=A4=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: l00635678 --- services/netsyscontroller/BUILD.gn | 1 + .../src/netsys_controller.cpp | 2 + .../netsys_controller_regional_test.cpp | 68 +- .../netsys_native_client_regional_test.cpp | 52 +- .../unittest/netsys_manager_test/BUILD.gn | 7 + .../netsys_controller_test.cpp | 1207 +++++++++++------ .../netsys_native_client_test.cpp | 306 +++-- 7 files changed, 1023 insertions(+), 620 deletions(-) diff --git a/services/netsyscontroller/BUILD.gn b/services/netsyscontroller/BUILD.gn index 3289668ae..e29670ae0 100644 --- a/services/netsyscontroller/BUILD.gn +++ b/services/netsyscontroller/BUILD.gn @@ -149,6 +149,7 @@ ohos_static_library("netsys_controller_static") { defines = [ "NETMGR_LOG_TAG = \"NetConnManager\"", "LOG_DOMAIN = 0xD0015B0", + "NETMANAGER_TEST", ] if (enable_netmgr_debug) { diff --git a/services/netsyscontroller/src/netsys_controller.cpp b/services/netsyscontroller/src/netsys_controller.cpp index 4ed03af70..e7d9677f3 100644 --- a/services/netsyscontroller/src/netsys_controller.cpp +++ b/services/netsyscontroller/src/netsys_controller.cpp @@ -29,8 +29,10 @@ static constexpr uint32_t IPV4_MAX_LENGTH = 32; NetsysController::NetsysController() { NETMGR_LOG_I("netsys Init"); +#ifndef NETMANAGER_TEST netsysService_ = std::make_unique().release(); netsysService_->Init(); +#endif } NetsysController &NetsysController::GetInstance() diff --git a/test/netmanagernative/unittest/netsys_controller_test/netsys_controller_regional_test.cpp b/test/netmanagernative/unittest/netsys_controller_test/netsys_controller_regional_test.cpp index 705537d56..f30f21364 100644 --- a/test/netmanagernative/unittest/netsys_controller_test/netsys_controller_regional_test.cpp +++ b/test/netmanagernative/unittest/netsys_controller_test/netsys_controller_regional_test.cpp @@ -74,42 +74,42 @@ void NetsysControllerTest::TearDown() {} HWTEST_F(NetsysControllerTest, EnableDistributedClientNetTest001, TestSize.Level1) { - NetsysController netsysController; - netsysController.netsysService_ = nullptr; + auto netsysController = std::make_shared(); + netsysController->netsysService_ = nullptr; const std::string virnicAddr = "virnicAddr"; const std::string iif = "iif"; - int32_t result = netsysController.EnableDistributedClientNet(virnicAddr, iif); + int32_t result = netsysController->EnableDistributedClientNet(virnicAddr, iif); EXPECT_EQ(result, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, EnableDistributedServerNetTest001, TestSize.Level1) { - NetsysController netsysController; - netsysController.netsysService_ = nullptr; + auto netsysController = std::make_shared(); + netsysController->netsysService_ = nullptr; const std::string iif = "iif"; const std::string devIface = "devIface"; const std::string dstAddr = "172.0.0.1"; - int32_t result = netsysController.EnableDistributedServerNet(iif, devIface, dstAddr); + int32_t result = netsysController->EnableDistributedServerNet(iif, devIface, dstAddr); EXPECT_EQ(result, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, DisableDistributedNetTest001, TestSize.Level1) { - NetsysController netsysController; - netsysController.netsysService_ = nullptr; + auto netsysController = std::make_shared(); + netsysController->netsysService_ = nullptr; bool isServer = true; - int32_t result = netsysController.DisableDistributedNet(isServer); + int32_t result = netsysController->DisableDistributedNet(isServer); EXPECT_EQ(result, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, NetworkAddUidsTest001, TestSize.Level1) { - NetsysController netsysController; - netsysController.netsysService_ = nullptr; + auto netsysController = std::make_shared(); + netsysController->netsysService_ = nullptr; int32_t netId = 1; std::vector beginUids = {0, 1}; std::vector endUids = {1}; - int32_t result = netsysController.NetworkAddUids(netId, beginUids, endUids); + int32_t result = netsysController->NetworkAddUids(netId, beginUids, endUids); EXPECT_EQ(result, NETSYS_NETSYSSERVICE_NULL); } @@ -140,14 +140,14 @@ HWTEST_F(NetsysControllerTest, NetworkDelUidsTest001, TestSize.Level1) HWTEST_F(NetsysControllerTest, BindNetworkServiceVpnTest001, TestSize.Level1) { - NetsysController netsysController; - netsysController.netsysService_ = nullptr; + auto netsysController = std::make_shared(); + netsysController->netsysService_ = nullptr; int32_t socketFd = 0; - int32_t result = netsysController.BindNetworkServiceVpn(socketFd); + int32_t result = netsysController->BindNetworkServiceVpn(socketFd); EXPECT_EQ(result, NETSYS_ERR_VPN); socketFd = 1; - result = netsysController.BindNetworkServiceVpn(socketFd); + result = netsysController->BindNetworkServiceVpn(socketFd); EXPECT_EQ(result, NETSYS_NETSYSSERVICE_NULL); } @@ -160,48 +160,48 @@ HWTEST_F(NetsysControllerTest, BindNetworkServiceVpnTest002, TestSize.Level1) HWTEST_F(NetsysControllerTest, EnableVirtualNetIfaceCardTest001, TestSize.Level1) { - NetsysController netsysController; - netsysController.netsysService_ = nullptr; + auto netsysController = std::make_shared(); + netsysController->netsysService_ = nullptr; int32_t socketFd = 0; struct ifreq ifRequest = {}; int32_t ifaceFd = 1; - int32_t result = netsysController.EnableVirtualNetIfaceCard(socketFd, ifRequest, ifaceFd); + int32_t result = netsysController->EnableVirtualNetIfaceCard(socketFd, ifRequest, ifaceFd); EXPECT_EQ(result, NETSYS_ERR_VPN); socketFd = 1; - result = netsysController.EnableVirtualNetIfaceCard(socketFd, ifRequest, ifaceFd); + result = netsysController->EnableVirtualNetIfaceCard(socketFd, ifRequest, ifaceFd); EXPECT_EQ(result, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, SetIpAddressTest001, TestSize.Level1) { - NetsysController netsysController; - netsysController.netsysService_ = nullptr; + auto netsysController = std::make_shared(); + netsysController->netsysService_ = nullptr; int32_t socketFd = 0; std::string ipAddress = ""; int32_t prefixLen = 0; struct ifreq ifRequest = {}; - int32_t result = netsysController.SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); + int32_t result = netsysController->SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); EXPECT_EQ(result, NETSYS_ERR_VPN); socketFd = 1; - result = netsysController.SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); + result = netsysController->SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); EXPECT_EQ(result, NETSYS_ERR_VPN); ipAddress = "172.0.0.1.172.0.0.1.172.0.0.1.172.0.0.1"; - result = netsysController.SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); + result = netsysController->SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); EXPECT_EQ(result, NETSYS_ERR_VPN); ipAddress = "172.0.0.1"; - result = netsysController.SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); + result = netsysController->SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); EXPECT_EQ(result, NETSYS_ERR_VPN); prefixLen = 35; // prefixLen: 35 - result = netsysController.SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); + result = netsysController->SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); EXPECT_EQ(result, NETSYS_ERR_VPN); prefixLen = 1; - result = netsysController.SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); + result = netsysController->SetIpAddress(socketFd, ipAddress, prefixLen, ifRequest); EXPECT_EQ(result, NETSYS_NETSYSSERVICE_NULL); } @@ -234,21 +234,21 @@ HWTEST_F(NetsysControllerTest, SetIpCommandForResTest001, TestSize.Level1) HWTEST_F(NetsysControllerTest, SetNicTrafficAllowedTest001, TestSize.Level1) { - NetsysController netsysController; - netsysController.netsysService_ = nullptr; + auto netsysController = std::make_shared(); + netsysController->netsysService_ = nullptr; const std::vector ifaceNames = {"ifaceNames"}; bool status = true; - int32_t result = netsysController.SetNicTrafficAllowed(ifaceNames, status); + int32_t result = netsysController->SetNicTrafficAllowed(ifaceNames, status); EXPECT_EQ(result, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, CloseSocketsUidTest001, TestSize.Level1) { - NetsysController netsysController; - netsysController.netsysService_ = nullptr; + auto netsysController = std::make_shared(); + netsysController->netsysService_ = nullptr; const std::string ipAddr = "172.0.0.1"; uint32_t uid = 1; - int32_t result = netsysController.CloseSocketsUid(ipAddr, uid); + int32_t result = netsysController->CloseSocketsUid(ipAddr, uid); EXPECT_EQ(result, NETSYS_NETSYSSERVICE_NULL); } diff --git a/test/netmanagernative/unittest/netsys_controller_test/netsys_native_client_regional_test.cpp b/test/netmanagernative/unittest/netsys_controller_test/netsys_native_client_regional_test.cpp index 3f34a288f..b58b23303 100644 --- a/test/netmanagernative/unittest/netsys_controller_test/netsys_native_client_regional_test.cpp +++ b/test/netmanagernative/unittest/netsys_controller_test/netsys_native_client_regional_test.cpp @@ -44,8 +44,6 @@ public: void SetUp(); void TearDown(); - static inline std::shared_ptr nativeClientInstance_ = std::make_shared(); - static inline NetsysNativeClient &nativeClient_ = *nativeClientInstance_; }; void NetsysNativeClientTest::SetUpTestCase() {} @@ -58,7 +56,8 @@ void NetsysNativeClientTest::TearDown() {} HWTEST_F(NetsysNativeClientTest, OnInterfaceAddressUpdatedTest001, TestSize.Level1) { - NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient); const std::string addr = IP_ADDR; const std::string ifName = INTERFACE_NAME; int flags = 1; @@ -70,7 +69,8 @@ HWTEST_F(NetsysNativeClientTest, OnInterfaceAddressUpdatedTest001, TestSize.Leve HWTEST_F(NetsysNativeClientTest, OnInterfaceAddressRemovedTest001, TestSize.Level1) { - NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient); const std::string addr = IP_ADDR; const std::string ifName = INTERFACE_NAME; int flags = 1; @@ -82,7 +82,8 @@ HWTEST_F(NetsysNativeClientTest, OnInterfaceAddressRemovedTest001, TestSize.Leve HWTEST_F(NetsysNativeClientTest, OnInterfaceAddedTest001, TestSize.Level1) { - NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient); const std::string ifName = INTERFACE_NAME; notifyCallback.netsysNativeClient_.cbObjects_ = {nullptr}; int32_t ret = notifyCallback.OnInterfaceAdded(ifName); @@ -91,7 +92,8 @@ HWTEST_F(NetsysNativeClientTest, OnInterfaceAddedTest001, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, OnInterfaceRemovedTest001, TestSize.Level1) { - NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient); const std::string ifName = INTERFACE_NAME; notifyCallback.netsysNativeClient_.cbObjects_ = {nullptr}; int32_t ret = notifyCallback.OnInterfaceRemoved(ifName); @@ -100,7 +102,8 @@ HWTEST_F(NetsysNativeClientTest, OnInterfaceRemovedTest001, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, OnInterfaceChangedTest001, TestSize.Level1) { - NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient); const std::string ifName = INTERFACE_NAME; notifyCallback.netsysNativeClient_.cbObjects_ = {nullptr}; int32_t ret = notifyCallback.OnInterfaceChanged(ifName, true); @@ -109,7 +112,8 @@ HWTEST_F(NetsysNativeClientTest, OnInterfaceChangedTest001, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, OnInterfaceLinkStateChangedTest001, TestSize.Level1) { - NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient); const std::string ifName = INTERFACE_NAME; notifyCallback.netsysNativeClient_.cbObjects_ = {nullptr}; int32_t ret = notifyCallback.OnInterfaceLinkStateChanged(ifName, true); @@ -118,7 +122,8 @@ HWTEST_F(NetsysNativeClientTest, OnInterfaceLinkStateChangedTest001, TestSize.Le HWTEST_F(NetsysNativeClientTest, OnRouteChangedTest001, TestSize.Level1) { - NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient); bool updated = true; const std::string route = "route"; const std::string gateway = "gateway"; @@ -130,7 +135,8 @@ HWTEST_F(NetsysNativeClientTest, OnRouteChangedTest001, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, OnDnsResultReportTest001, TestSize.Level1) { - NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClient); uint32_t size = 1; OHOS::NetsysNative::NetDnsResultReport netDnsResultRepor{}; std::list res = {netDnsResultRepor}; @@ -141,7 +147,8 @@ HWTEST_F(NetsysNativeClientTest, OnDnsResultReportTest001, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, OnDnsQueryResultReportTest001, TestSize.Level1) { - NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClient); uint32_t size = 1; OHOS::NetsysNative::NetDnsQueryResultReport netDnsResultRepor{}; std::list res = {netDnsResultRepor}; @@ -152,7 +159,8 @@ HWTEST_F(NetsysNativeClientTest, OnDnsQueryResultReportTest001, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, OnDnsQueryAbnormalReportTest001, TestSize.Level1) { - NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClient); uint32_t eventfailcause = 1; OHOS::NetsysNative::NetDnsQueryResultReport netDnsResultRepor{}; notifyCallback.netsysNativeClient_.cbDnsQueryReportObjects_ = {nullptr}; @@ -162,38 +170,42 @@ HWTEST_F(NetsysNativeClientTest, OnDnsQueryAbnormalReportTest001, TestSize.Level HWTEST_F(NetsysNativeClientTest, DelInterfaceAddressTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); const std::string ifName = INTERFACE_NAME; const std::string ipAddr = IP_ADDR; int32_t prefixLength = 1; const std::string netCapabilities = "netCapabilities"; - int32_t ret = nativeClient_.DelInterfaceAddress(ifName, ipAddr, prefixLength, netCapabilities); + int32_t ret = nativeClient->DelInterfaceAddress(ifName, ipAddr, prefixLength, netCapabilities); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, InterfaceSetIffUpTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); const std::string ifName = INTERFACE_NAME; - int32_t ret = nativeClient_.InterfaceSetIffUp(ifName); + int32_t ret = nativeClient->InterfaceSetIffUp(ifName); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR); } HWTEST_F(NetsysNativeClientTest, ProcessDhcpResultTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); sptr dhcpResult = new (std::nothrow) OHOS::NetsysNative::DhcpResultParcel(); sptr netsysCallback = nullptr; - nativeClient_.cbObjects_.push_back(netsysCallback); - nativeClient_.ProcessDhcpResult(dhcpResult); - EXPECT_TRUE(nativeClient_.cbObjects_.empty()); + nativeClient->cbObjects_.push_back(netsysCallback); + nativeClient->ProcessDhcpResult(dhcpResult); + EXPECT_TRUE(nativeClient->cbObjects_.empty()); } HWTEST_F(NetsysNativeClientTest, ProcessBandwidthReachedLimitTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); const std::string limitName = "limitName"; const std::string iface = INTERFACE_NAME; sptr netsysCallback = nullptr; - nativeClient_.cbObjects_.push_back(netsysCallback); - nativeClient_.ProcessBandwidthReachedLimit(limitName, iface); - EXPECT_TRUE(nativeClient_.cbObjects_.empty()); + nativeClient->cbObjects_.push_back(netsysCallback); + nativeClient->ProcessBandwidthReachedLimit(limitName, iface); + EXPECT_TRUE(nativeClient->cbObjects_.empty()); } } // namespace NetManagerStandard } // namespace OHOS diff --git a/test/netmanagernative/unittest/netsys_manager_test/BUILD.gn b/test/netmanagernative/unittest/netsys_manager_test/BUILD.gn index 02b47f70d..66c327d5e 100644 --- a/test/netmanagernative/unittest/netsys_manager_test/BUILD.gn +++ b/test/netmanagernative/unittest/netsys_manager_test/BUILD.gn @@ -256,6 +256,12 @@ ohos_unittest("netsys_native_manager_netsys_native_service_test") { ohos_unittest("netsys_controller_test") { module_out_path = "netmanager_base/netmanager_base/netsys_controller_test" + sanitize = { + cfi = true + cfi_cross_dso = true + debug = false + } + branch_protector_ret = "pac_ret" sources = [ "$NETMANAGER_BASE_ROOT/test/security/netmanager_base_test_security.cpp", "netsys_controller_test.cpp", @@ -296,6 +302,7 @@ ohos_unittest("netsys_controller_test") { "bundle_framework:appexecfwk_core", "c_utils:utils", "ffrt:libffrt", + "googletest:gmock_main", "init:libbegetutil", "ipc:ipc_core", "safwk:system_ability_fwk", diff --git a/test/netmanagernative/unittest/netsys_manager_test/netsys_controller_test.cpp b/test/netmanagernative/unittest/netsys_manager_test/netsys_controller_test.cpp index 1d55efc52..786d4d998 100644 --- a/test/netmanagernative/unittest/netsys_manager_test/netsys_controller_test.cpp +++ b/test/netmanagernative/unittest/netsys_manager_test/netsys_controller_test.cpp @@ -20,7 +20,6 @@ #include #include "netmanager_base_test_security.h" -#include "netsys_controller_service_impl.h" #ifdef GTEST_API_ #define private public @@ -39,6 +38,8 @@ #include "netsys_controller.h" #include "netsys_ipc_interface_code.h" #include "netsys_net_diag_data.h" +#include "netsys_controller_service_impl.h" +#include "common_mock_netsys_service.h" namespace OHOS { namespace NetManagerStandard { @@ -91,15 +92,11 @@ public: void TearDown(); - static inline std::shared_ptr instance_ = nullptr; - sptr netDiagCallback = new NetsysNative::NetDiagCallbackStubTest(); + sptr mockNetsysService_ = sptr::MakeSptr(); }; -void NetsysControllerTest::SetUpTestCase() -{ - instance_ = std::make_shared(); -} +void NetsysControllerTest::SetUpTestCase() {} void NetsysControllerTest::TearDownTestCase() {} @@ -109,289 +106,369 @@ void NetsysControllerTest::TearDown() {} HWTEST_F(NetsysControllerTest, NetsysControllerTest001, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().NetworkCreatePhysical(NET_ID, PERMISSION); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->NetworkCreatePhysical(NET_ID, PERMISSION); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().NetworkDestroy(NET_ID); + ret = netsysController->NetworkDestroy(NET_ID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest002, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().NetworkAddInterface(NET_ID, WLAN, BEARER_DEFAULT); - EXPECT_EQ(ret, -1); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->NetworkAddInterface(NET_ID, WLAN, BEARER_DEFAULT); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().NetworkRemoveInterface(NET_ID, WLAN); + ret = netsysController->NetworkRemoveInterface(NET_ID, WLAN); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest003, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().NetworkAddRoute(NET_ID, ETH0, DESTINATION, NEXT_HOP); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->NetworkAddRoute(NET_ID, ETH0, DESTINATION, NEXT_HOP); EXPECT_LE(ret, 0); - ret = NetsysController::GetInstance().NetworkRemoveRoute(NET_ID, ETH0, DESTINATION, NEXT_HOP); + ret = netsysController->NetworkRemoveRoute(NET_ID, ETH0, DESTINATION, NEXT_HOP); EXPECT_LE(ret, 0); } HWTEST_F(NetsysControllerTest, NetsysControllerTest004, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + OHOS::nmd::InterfaceConfigurationParcel parcel; parcel.ifName = ETH0; parcel.ipv4Addr = PARCEL_IPV4_ADDR; - int32_t ret = NetsysController::GetInstance().SetInterfaceConfig(parcel); + int32_t ret = netsysController->SetInterfaceConfig(parcel); EXPECT_EQ(ret, 0); - ret = NetsysController::GetInstance().GetInterfaceConfig(parcel); + ret = netsysController->GetInterfaceConfig(parcel); EXPECT_EQ(ret, 0); } HWTEST_F(NetsysControllerTest, NetsysControllerTest005, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().SetInterfaceDown(ETH0); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->SetInterfaceDown(ETH0); EXPECT_EQ(ret, 0); - ret = NetsysController::GetInstance().SetInterfaceUp(ETH0); + ret = netsysController->SetInterfaceUp(ETH0); EXPECT_EQ(ret, 0); - NetsysController::GetInstance().ClearInterfaceAddrs(ETH0); + netsysController->ClearInterfaceAddrs(ETH0); } HWTEST_F(NetsysControllerTest, NetsysControllerTest006, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().SetInterfaceMtu(ETH0, TEST_MTU); - EXPECT_EQ(ret, -1); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; - ret = NetsysController::GetInstance().GetInterfaceMtu(ETH0); - EXPECT_EQ(ret, -1); + int32_t ret = netsysController->SetInterfaceMtu(ETH0, TEST_MTU); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().SetTcpBufferSizes(TCP_BUFFER_SIZES); - EXPECT_EQ(ret, 0); + ret = netsysController->GetInterfaceMtu(ETH0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + + ret = netsysController->SetTcpBufferSizes(TCP_BUFFER_SIZES); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest007, TestSize.Level1) { - auto ifaceList = NetsysController::GetInstance().InterfaceGetList(); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + auto ifaceList = netsysController->InterfaceGetList(); bool eth0NotExist = std::find(ifaceList.begin(), ifaceList.end(), std::string(ETH0)) == ifaceList.end(); if (eth0NotExist) { return; } - int32_t ret = NetsysController::GetInstance().AddInterfaceAddress(ETH0, IP_ADDR, PREFIX_LENGTH); + int32_t ret = netsysController->AddInterfaceAddress(ETH0, IP_ADDR, PREFIX_LENGTH); EXPECT_EQ(ret, 0); - ret = NetsysController::GetInstance().DelInterfaceAddress(ETH0, IP_ADDR, PREFIX_LENGTH); + ret = netsysController->DelInterfaceAddress(ETH0, IP_ADDR, PREFIX_LENGTH); EXPECT_EQ(ret, 0); } HWTEST_F(NetsysControllerTest, NetsysControllerTest008, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().SetResolverConfig(NET_ID, g_baseTimeoutMsec, g_retryCount, {}, {}); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->SetResolverConfig(NET_ID, g_baseTimeoutMsec, g_retryCount, {}, {}); EXPECT_EQ(ret, 0); std::vector servers; std::vector domains; - ret = NetsysController::GetInstance().GetResolverConfig(NET_ID, servers, domains, g_baseTimeoutMsec, g_retryCount); + ret = netsysController->GetResolverConfig(NET_ID, servers, domains, g_baseTimeoutMsec, g_retryCount); EXPECT_EQ(ret, 0); } HWTEST_F(NetsysControllerTest, NetsysControllerTest009, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().CreateNetworkCache(NET_ID); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->CreateNetworkCache(NET_ID); EXPECT_EQ(ret, 0); - ret = NetsysController::GetInstance().DestroyNetworkCache(NET_ID); + ret = netsysController->DestroyNetworkCache(NET_ID); EXPECT_EQ(ret, 0); } HWTEST_F(NetsysControllerTest, NetsysControllerTest010, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + nmd::NetworkSharingTraffic traffic; - int32_t ret = NetsysController::GetInstance().GetNetworkSharingTraffic(ETH0, ETH0, traffic); - EXPECT_EQ(ret, -1); + int32_t ret = netsysController->GetNetworkSharingTraffic(ETH0, ETH0, traffic); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest011, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().GetCellularRxBytes(); - EXPECT_EQ(ret, 0); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; - ret = NetsysController::GetInstance().GetCellularTxBytes(); - EXPECT_EQ(ret, 0); + int32_t ret = netsysController->GetCellularRxBytes(); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().GetAllRxBytes(); - EXPECT_GE(ret, 0); + ret = netsysController->GetCellularTxBytes(); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().GetAllTxBytes(); - EXPECT_GE(ret, 0); + ret = netsysController->GetAllRxBytes(); + EXPECT_GE(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().GetUidRxBytes(TEST_UID); - EXPECT_EQ(ret, -1); + ret = netsysController->GetAllTxBytes(); + EXPECT_GE(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().GetUidTxBytes(TEST_UID); - EXPECT_EQ(ret, -1); + ret = netsysController->GetUidRxBytes(TEST_UID); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().GetUidOnIfaceRxBytes(TEST_UID, INTERFACE_NAME); - EXPECT_GE(ret, 0); + ret = netsysController->GetUidTxBytes(TEST_UID); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().GetUidOnIfaceTxBytes(TEST_UID, INTERFACE_NAME); - EXPECT_GE(ret, 0); + ret = netsysController->GetUidOnIfaceRxBytes(TEST_UID, INTERFACE_NAME); + EXPECT_GE(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().GetIfaceRxBytes(INTERFACE_NAME); - EXPECT_EQ(ret, 0); + ret = netsysController->GetUidOnIfaceTxBytes(TEST_UID, INTERFACE_NAME); + EXPECT_GE(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().GetIfaceTxBytes(INTERFACE_NAME); - EXPECT_EQ(ret, 0); + ret = netsysController->GetIfaceRxBytes(INTERFACE_NAME); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + + ret = netsysController->GetIfaceTxBytes(INTERFACE_NAME); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest012, TestSize.Level1) { - std::vector getList = NetsysController::GetInstance().InterfaceGetList(); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + std::vector getList = netsysController->InterfaceGetList(); getList.clear(); - getList = NetsysController::GetInstance().UidGetList(); + getList = netsysController->UidGetList(); EXPECT_EQ(getList.size(), 0); - int64_t ret = NetsysController::GetInstance().GetIfaceRxPackets(INTERFACE_NAME); + int64_t ret = netsysController->GetIfaceRxPackets(INTERFACE_NAME); EXPECT_EQ(ret, 0); - ret = NetsysController::GetInstance().GetIfaceTxPackets(INTERFACE_NAME); + ret = netsysController->GetIfaceTxPackets(INTERFACE_NAME); EXPECT_EQ(ret, 0); - ret = NetsysController::GetInstance().SetDefaultNetWork(NET_ID); + ret = netsysController->SetDefaultNetWork(NET_ID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().ClearDefaultNetWorkNetId(); + ret = netsysController->ClearDefaultNetWorkNetId(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest013, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().BindSocket(SOCKET_FD, NET_ID); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->BindSocket(SOCKET_FD, NET_ID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().IpEnableForwarding(INTERFACE_NAME); - EXPECT_EQ(ret, 0); + ret = netsysController->IpEnableForwarding(INTERFACE_NAME); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().IpDisableForwarding(INTERFACE_NAME); - EXPECT_EQ(ret, 0); + ret = netsysController->IpDisableForwarding(INTERFACE_NAME); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().EnableNat(ETH0, ETH0); - EXPECT_NE(ret, 0); + ret = netsysController->EnableNat(ETH0, ETH0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().DisableNat(ETH0, ETH0); - EXPECT_NE(ret, 0); + ret = netsysController->DisableNat(ETH0, ETH0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().IpfwdAddInterfaceForward(ETH0, ETH0); - EXPECT_NE(ret, 0); + ret = netsysController->IpfwdAddInterfaceForward(ETH0, ETH0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().IpfwdRemoveInterfaceForward(ETH0, ETH0); - EXPECT_NE(ret, 0); + ret = netsysController->IpfwdRemoveInterfaceForward(ETH0, ETH0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest014, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().ShareDnsSet(NET_ID); - EXPECT_EQ(ret, 0); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; - ret = NetsysController::GetInstance().StartDnsProxyListen(); - EXPECT_EQ(ret, 0); + int32_t ret = netsysController->ShareDnsSet(NET_ID); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().StopDnsProxyListen(); - EXPECT_EQ(ret, 0); + ret = netsysController->StartDnsProxyListen(); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().BindNetworkServiceVpn(SOCKET_FD); - EXPECT_EQ(ret, 0); + ret = netsysController->StopDnsProxyListen(); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + + ret = netsysController->BindNetworkServiceVpn(SOCKET_FD); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); ifreq ifRequest; - ret = NetsysController::GetInstance().EnableVirtualNetIfaceCard(SOCKET_FD, ifRequest, g_ifaceFd); - EXPECT_EQ(ret, 0); + ret = netsysController->EnableVirtualNetIfaceCard(SOCKET_FD, ifRequest, g_ifaceFd); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); - ret = NetsysController::GetInstance().SetIpAddress(SOCKET_FD, IP_ADDR, PREFIX_LENGTH, ifRequest); - EXPECT_EQ(ret, 0); + ret = netsysController->SetIpAddress(SOCKET_FD, IP_ADDR, PREFIX_LENGTH, ifRequest); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); - ret = NetsysController::GetInstance().SetBlocking(g_ifaceFd, true); - EXPECT_EQ(ret, 0); + ret = netsysController->SetBlocking(g_ifaceFd, true); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); - ret = NetsysController::GetInstance().SetBlocking(g_ifaceFd, false); - EXPECT_EQ(ret, 0); + ret = netsysController->SetBlocking(g_ifaceFd, false); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); - ret = NetsysController::GetInstance().StartDhcpClient(INTERFACE_NAME, true); - EXPECT_EQ(ret, 0); + ret = netsysController->StartDhcpClient(INTERFACE_NAME, true); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().StartDhcpClient(INTERFACE_NAME, false); - EXPECT_EQ(ret, 0); + ret = netsysController->StartDhcpClient(INTERFACE_NAME, false); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().StopDhcpClient(INTERFACE_NAME, true); - EXPECT_EQ(ret, 0); + ret = netsysController->StopDhcpClient(INTERFACE_NAME, true); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().StopDhcpClient(INTERFACE_NAME, false); - EXPECT_EQ(ret, 0); + ret = netsysController->StopDhcpClient(INTERFACE_NAME, false); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().StartDhcpService(INTERFACE_NAME, IP_ADDR); - EXPECT_EQ(ret, 0); + ret = netsysController->StartDhcpService(INTERFACE_NAME, IP_ADDR); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().StopDhcpService(INTERFACE_NAME); - EXPECT_EQ(ret, 0); + ret = netsysController->StopDhcpService(INTERFACE_NAME); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest015, TestSize.Level1) { - NetsysController::GetInstance().BandwidthEnableDataSaver(false); - int32_t ret = NetsysController::GetInstance().BandwidthEnableDataSaver(true); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + netsysController->BandwidthEnableDataSaver(false); + int32_t ret = netsysController->BandwidthEnableDataSaver(true); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().BandwidthSetIfaceQuota(IF_NAME, BYTES); + ret = netsysController->BandwidthSetIfaceQuota(IF_NAME, BYTES); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().BandwidthSetIfaceQuota(WLAN, BYTES); + ret = netsysController->BandwidthSetIfaceQuota(WLAN, BYTES); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().BandwidthRemoveIfaceQuota(IF_NAME); + ret = netsysController->BandwidthRemoveIfaceQuota(IF_NAME); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().BandwidthRemoveIfaceQuota(WLAN); + ret = netsysController->BandwidthRemoveIfaceQuota(WLAN); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().BandwidthAddDeniedList(TEST_UID); + ret = netsysController->BandwidthAddDeniedList(TEST_UID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().BandwidthAddAllowedList(TEST_UID); + ret = netsysController->BandwidthAddAllowedList(TEST_UID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().BandwidthRemoveDeniedList(TEST_UID); + ret = netsysController->BandwidthRemoveDeniedList(TEST_UID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().BandwidthRemoveAllowedList(TEST_UID); + ret = netsysController->BandwidthRemoveAllowedList(TEST_UID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); std::vector uids; uids.push_back(TEST_UID); - ret = NetsysController::GetInstance().FirewallSetUidsAllowedListChain(TEST_UID, uids); - EXPECT_NE(ret, 0); - ret = NetsysController::GetInstance().FirewallSetUidsDeniedListChain(TEST_UID, uids); - EXPECT_NE(ret, 0); + ret = netsysController->FirewallSetUidsAllowedListChain(TEST_UID, uids); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->FirewallSetUidsDeniedListChain(TEST_UID, uids); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().FirewallEnableChain(TEST_UID, true); - EXPECT_NE(ret, 0); + ret = netsysController->FirewallEnableChain(TEST_UID, true); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().FirewallSetUidRule(TEST_UID, {TEST_UID}, FIREWALL_RULE); - EXPECT_EQ(ret, 0); + ret = netsysController->FirewallSetUidRule(TEST_UID, {TEST_UID}, FIREWALL_RULE); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest016, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().InterfaceSetIpAddress("ifaceName", "192.168.x.x"); - EXPECT_NE(ret, 0); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->InterfaceSetIpAddress("ifaceName", "192.168.x.x"); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().InterfaceSetIpAddress("ifaceName", "192.168.2.0"); - EXPECT_EQ(ret, -1); + ret = netsysController->InterfaceSetIpAddress("ifaceName", "192.168.2.0"); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().InterfaceSetIffUp(""); - EXPECT_NE(ret, 0); + ret = netsysController->InterfaceSetIffUp(""); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().InterfaceSetIffUp("ifaceName"); - EXPECT_EQ(ret, -1); + ret = netsysController->InterfaceSetIffUp("ifaceName"); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); std::string hostName = ""; std::string serverName = ""; @@ -399,66 +476,81 @@ HWTEST_F(NetsysControllerTest, NetsysControllerTest016, TestSize.Level1) uint16_t netId = 0; std::vector res; - ret = NetsysController::GetInstance().GetAddrInfo(hostName, serverName, hints, netId, res); - EXPECT_NE(ret, 0); + ret = netsysController->GetAddrInfo(hostName, serverName, hints, netId, res); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); auto callback = new NetsysControllerCallbackTestCb(); - ret = NetsysController::GetInstance().RegisterCallback(callback); - EXPECT_EQ(ret, 0); + ret = netsysController->RegisterCallback(callback); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest017, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint64_t stats = 0; - int32_t ret = NetsysController::GetInstance().GetTotalStats(stats, 0); + int32_t ret = netsysController->GetTotalStats(stats, 0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); stats = 0; - ret = NetsysController::GetInstance().GetUidStats(stats, 0, TEST_STATS_UID); - EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_READ_BPF_FAIL); + ret = netsysController->GetUidStats(stats, 0, TEST_STATS_UID); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); stats = 0; - ret = NetsysController::GetInstance().GetIfaceStats(stats, 0, IFACE); - EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_GET_IFACE_NAME_FAILED); + ret = netsysController->GetIfaceStats(stats, 0, IFACE); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().DeleteStatsInfo(TEST_UID_32); + ret = netsysController->DeleteStatsInfo(TEST_UID_32); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().DeleteSimStatsInfo(TEST_UID_32); + ret = netsysController->DeleteSimStatsInfo(TEST_UID_32); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); stats = 0; std::vector statsInfo; - ret = NetsysController::GetInstance().GetAllStatsInfo(statsInfo); + ret = netsysController->GetAllStatsInfo(statsInfo); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().GetAllSimStatsInfo(statsInfo); + ret = netsysController->GetAllSimStatsInfo(statsInfo); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest018, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string respond; - int32_t ret = NetsysController::GetInstance().SetIptablesCommandForRes("-L", respond); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PERMISSION_DENIED); + int32_t ret = netsysController->SetIptablesCommandForRes("-L", respond); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); NetManagerBaseAccessToken token; - ret = NetsysController::GetInstance().SetIptablesCommandForRes("abc", respond); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PERMISSION_DENIED); + ret = netsysController->SetIptablesCommandForRes("abc", respond); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().SetIptablesCommandForRes("-L", respond); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PERMISSION_DENIED); + ret = netsysController->SetIptablesCommandForRes("-L", respond); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerTest019, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string respond; - int32_t ret = NetsysController::GetInstance().SetIpCommandForRes("-L", respond); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PERMISSION_DENIED); + int32_t ret = netsysController->SetIpCommandForRes("-L", respond); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); NetManagerBaseAccessToken token; - ret = NetsysController::GetInstance().SetIpCommandForRes("abc", respond); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PERMISSION_DENIED); + ret = netsysController->SetIpCommandForRes("abc", respond); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, SetNetStatusMap002, TestSize.Level1) @@ -469,62 +561,72 @@ HWTEST_F(NetsysControllerTest, SetNetStatusMap002, TestSize.Level1) HWTEST_F(NetsysControllerTest, NetsysControllerErr001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::vector beginUids; std::vector endUids; std::string iface = "test"; OHOS::nmd::InterfaceConfigurationParcel Parcel; - int32_t ret = instance_->SetInternetPermission(0, 0); - EXPECT_EQ(ret, -1); + int32_t ret = netsysController->SetInternetPermission(0, 0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetworkCreateVirtual(0, false); + ret = netsysController->NetworkCreateVirtual(0, false); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetworkDestroy(0); + ret = netsysController->NetworkDestroy(0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetworkAddUids(0, beginUids, endUids); - EXPECT_EQ(ret, -1); + ret = netsysController->NetworkAddUids(0, beginUids, endUids); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetworkDelUids(0, beginUids, endUids); - EXPECT_EQ(ret, -1); + ret = netsysController->NetworkDelUids(0, beginUids, endUids); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetworkAddInterface(0, iface, BEARER_DEFAULT); - EXPECT_EQ(ret, -1); + ret = netsysController->NetworkAddInterface(0, iface, BEARER_DEFAULT); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetworkRemoveInterface(0, iface); + ret = netsysController->NetworkRemoveInterface(0, iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetworkAddRoute(0, iface, iface, iface); - EXPECT_EQ(ret, -1); + ret = netsysController->NetworkAddRoute(0, iface, iface, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetworkRemoveRoute(0, iface, iface, iface); - EXPECT_EQ(ret, -1); + ret = netsysController->NetworkRemoveRoute(0, iface, iface, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetInterfaceConfig(Parcel); + ret = netsysController->GetInterfaceConfig(Parcel); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->SetInterfaceConfig(Parcel); + ret = netsysController->SetInterfaceConfig(Parcel); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->SetInterfaceDown(iface); + ret = netsysController->SetInterfaceDown(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->SetInterfaceUp(iface); + ret = netsysController->SetInterfaceUp(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - instance_->ClearInterfaceAddrs(iface); + netsysController->ClearInterfaceAddrs(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetInterfaceMtu(iface); - EXPECT_EQ(ret, -1); + ret = netsysController->GetInterfaceMtu(iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->SetInterfaceMtu(iface, 0); - EXPECT_EQ(ret, -1); + ret = netsysController->SetInterfaceMtu(iface, 0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerErr002, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string iface = "test"; std::vector servers; uint16_t baseTimeoutMsec = 0; @@ -541,237 +643,262 @@ HWTEST_F(NetsysControllerTest, NetsysControllerErr002, TestSize.Level1) aihead->ai_canonname = static_cast(malloc(10)); } - int32_t ret = instance_->AddInterfaceAddress(iface, iface, 0); - EXPECT_NE(ret, 0); + int32_t ret = netsysController->AddInterfaceAddress(iface, iface, 0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->DelInterfaceAddress(iface, iface, 0); - EXPECT_NE(ret, 0); + ret = netsysController->DelInterfaceAddress(iface, iface, 0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->InterfaceSetIpAddress(iface, iface); - EXPECT_EQ(ret, -1); + ret = netsysController->InterfaceSetIpAddress(iface, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->InterfaceSetIffUp(iface); - EXPECT_EQ(ret, -1); + ret = netsysController->InterfaceSetIffUp(iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->SetResolverConfig(0, 0, 0, servers, servers); + ret = netsysController->SetResolverConfig(0, 0, 0, servers, servers); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetResolverConfig(0, servers, servers, baseTimeoutMsec, retryCount); + ret = netsysController->GetResolverConfig(0, servers, servers, baseTimeoutMsec, retryCount); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->CreateNetworkCache(0); + ret = netsysController->CreateNetworkCache(0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->DestroyNetworkCache(0); + ret = netsysController->DestroyNetworkCache(0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - instance_->FreeAddrInfo(aihead); + netsysController->FreeAddrInfo(aihead); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetAddrInfo(iface, iface, hints, 0, res); - EXPECT_GE(ret, 0); + ret = netsysController->GetAddrInfo(iface, iface, hints, 0, res); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetNetworkSharingTraffic(iface, iface, traffic); - EXPECT_EQ(ret, -1); + ret = netsysController->GetNetworkSharingTraffic(iface, iface, traffic); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerErr003, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string iface = "test"; - auto ret = instance_->GetCellularRxBytes(); + auto ret = netsysController->GetCellularRxBytes(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetCellularTxBytes(); + ret = netsysController->GetCellularTxBytes(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetAllRxBytes(); - EXPECT_GE(ret, 0); + ret = netsysController->GetAllRxBytes(); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetAllTxBytes(); - EXPECT_GE(ret, 0); + ret = netsysController->GetAllTxBytes(); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetUidRxBytes(0); - EXPECT_EQ(ret, -1); + ret = netsysController->GetUidRxBytes(0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetUidTxBytes(0); - EXPECT_EQ(ret, -1); + ret = netsysController->GetUidTxBytes(0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetUidOnIfaceRxBytes(0, iface); - EXPECT_GE(ret, 0); + ret = netsysController->GetUidOnIfaceRxBytes(0, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetUidOnIfaceTxBytes(0, iface); - EXPECT_GE(ret, 0); + ret = netsysController->GetUidOnIfaceTxBytes(0, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetIfaceRxBytes(iface); + ret = netsysController->GetIfaceRxBytes(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetIfaceTxBytes(iface); + ret = netsysController->GetIfaceTxBytes(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetIfaceRxPackets(iface); + ret = netsysController->GetIfaceRxPackets(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetIfaceTxPackets(iface); + ret = netsysController->GetIfaceTxPackets(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerErr004, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string iface = "test"; NetsysNotifyCallback callback; - auto faceList = instance_->InterfaceGetList(); + auto faceList = netsysController->InterfaceGetList(); - auto uidList = instance_->UidGetList(); + auto uidList = netsysController->UidGetList(); EXPECT_EQ(uidList.size(), 0); - auto ret = instance_->SetDefaultNetWork(0); + auto ret = netsysController->SetDefaultNetWork(0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->ClearDefaultNetWorkNetId(); + ret = netsysController->ClearDefaultNetWorkNetId(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->BindSocket(0, 0); + ret = netsysController->BindSocket(0, 0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->IpEnableForwarding(iface); + ret = netsysController->IpEnableForwarding(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->IpDisableForwarding(iface); + ret = netsysController->IpDisableForwarding(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->EnableNat(iface, iface); - EXPECT_EQ(ret, -1); + ret = netsysController->EnableNat(iface, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->DisableNat(iface, iface); - EXPECT_EQ(ret, -1); + ret = netsysController->DisableNat(iface, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->IpfwdAddInterfaceForward(iface, iface); - EXPECT_EQ(ret, -1); + ret = netsysController->IpfwdAddInterfaceForward(iface, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->IpfwdRemoveInterfaceForward(iface, iface); - EXPECT_EQ(ret, -1); + ret = netsysController->IpfwdRemoveInterfaceForward(iface, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->ShareDnsSet(0); + ret = netsysController->ShareDnsSet(0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->StartDnsProxyListen(); + ret = netsysController->StartDnsProxyListen(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->StopDnsProxyListen(); + ret = netsysController->StopDnsProxyListen(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->RegisterNetsysNotifyCallback(callback); + ret = netsysController->RegisterNetsysNotifyCallback(callback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerErr005, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string iface = "test"; struct ifreq ifRequest; int32_t ifaceFd = 0; sptr callback; - auto ret = instance_->BindNetworkServiceVpn(0); + auto ret = netsysController->BindNetworkServiceVpn(0); EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); - ret = instance_->BindNetworkServiceVpn(1); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->BindNetworkServiceVpn(1); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); - ret = instance_->EnableVirtualNetIfaceCard(0, ifRequest, ifaceFd); + ret = netsysController->EnableVirtualNetIfaceCard(0, ifRequest, ifaceFd); EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); - ret = instance_->EnableVirtualNetIfaceCard(1, ifRequest, ifaceFd); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->EnableVirtualNetIfaceCard(1, ifRequest, ifaceFd); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); - ret = instance_->SetIpAddress(0, iface, 0, ifRequest); + ret = netsysController->SetIpAddress(0, iface, 0, ifRequest); EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); - ret = instance_->SetIpAddress(1, iface, 1, ifRequest); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->SetIpAddress(1, iface, 1, ifRequest); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_ERR_VPN); - ret = instance_->SetBlocking(0, false); + ret = netsysController->SetBlocking(0, false); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->StartDhcpClient(iface, false); + ret = netsysController->StartDhcpClient(iface, false); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->StopDhcpClient(iface, false); + ret = netsysController->StopDhcpClient(iface, false); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->StartDhcpService(iface, iface); + ret = netsysController->StartDhcpService(iface, iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->StopDhcpService(iface); + ret = netsysController->StopDhcpService(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->BandwidthEnableDataSaver(false); + ret = netsysController->BandwidthEnableDataSaver(false); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->BandwidthSetIfaceQuota(iface, 0); + ret = netsysController->BandwidthSetIfaceQuota(iface, 0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->BandwidthRemoveIfaceQuota(iface); + ret = netsysController->BandwidthRemoveIfaceQuota(iface); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->BandwidthAddDeniedList(0); + ret = netsysController->BandwidthAddDeniedList(0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->BandwidthRemoveDeniedList(0); + ret = netsysController->BandwidthRemoveDeniedList(0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->BandwidthAddAllowedList(0); + ret = netsysController->BandwidthAddAllowedList(0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->BandwidthRemoveAllowedList(0); + ret = netsysController->BandwidthRemoveAllowedList(0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerErr006, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string iface = "test"; std::vector uids; uint64_t stats = 0; std::vector statsInfo; - auto ret = instance_->FirewallSetUidsAllowedListChain(0, uids); - EXPECT_EQ(ret, -1); + auto ret = netsysController->FirewallSetUidsAllowedListChain(0, uids); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->FirewallSetUidsDeniedListChain(0, uids); - EXPECT_EQ(ret, -1); + ret = netsysController->FirewallSetUidsDeniedListChain(0, uids); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->FirewallEnableChain(0, false); - ret = instance_->FirewallSetUidRule(0, uids, 0); + ret = netsysController->FirewallEnableChain(0, false); + ret = netsysController->FirewallSetUidRule(0, uids, 0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->ClearFirewallAllRules(); - ret = instance_->GetTotalStats(stats, 0); + ret = netsysController->ClearFirewallAllRules(); + ret = netsysController->GetTotalStats(stats, 0); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetUidStats(stats, 0, 0); - EXPECT_GE(ret, 0); + ret = netsysController->GetUidStats(stats, 0, 0); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetIfaceStats(stats, 0, iface); - EXPECT_GE(ret, 0); + ret = netsysController->GetIfaceStats(stats, 0, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->GetAllStatsInfo(statsInfo); + ret = netsysController->GetAllStatsInfo(statsInfo); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->SetIptablesCommandForRes(iface, iface); - EXPECT_NE(ret, 0); + ret = netsysController->SetIptablesCommandForRes(iface, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->SetIpCommandForRes(iface, iface); - EXPECT_NE(ret, 0); + ret = netsysController->SetIpCommandForRes(iface, iface); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->SetTcpBufferSizes(""); - EXPECT_NE(ret, 0); + ret = netsysController->SetTcpBufferSizes(""); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetDiagGetRouteTable001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::list diagrouteTable; - auto ret = NetsysController::GetInstance().NetDiagGetRouteTable(diagrouteTable); + auto ret = netsysController->NetDiagGetRouteTable(diagrouteTable); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); for (const auto < : diagrouteTable) { NETNATIVE_LOGI( @@ -805,47 +932,57 @@ void ShowSocketInfo(NetsysNative::NetDiagSocketsInfo &info) HWTEST_F(NetsysControllerTest, NetDiagGetSocketsInfo001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + OHOS::NetsysNative::NetDiagProtocolType socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_ALL; OHOS::NetsysNative::NetDiagSocketsInfo socketsInfo; - auto ret = NetsysController::GetInstance().NetDiagGetSocketsInfo(socketType, socketsInfo); + auto ret = netsysController->NetDiagGetSocketsInfo(socketType, socketsInfo); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); ShowSocketInfo(socketsInfo); socketsInfo.unixSocketsInfo_.clear(); socketsInfo.netProtoSocketsInfo_.clear(); socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_RAW; - ret = NetsysController::GetInstance().NetDiagGetSocketsInfo(socketType, socketsInfo); + ret = netsysController->NetDiagGetSocketsInfo(socketType, socketsInfo); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); ShowSocketInfo(socketsInfo); socketsInfo.unixSocketsInfo_.clear(); socketsInfo.netProtoSocketsInfo_.clear(); socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_TCP; - ret = NetsysController::GetInstance().NetDiagGetSocketsInfo(socketType, socketsInfo); + ret = netsysController->NetDiagGetSocketsInfo(socketType, socketsInfo); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); ShowSocketInfo(socketsInfo); socketsInfo.unixSocketsInfo_.clear(); socketsInfo.netProtoSocketsInfo_.clear(); socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_UDP; - ret = NetsysController::GetInstance().NetDiagGetSocketsInfo(socketType, socketsInfo); + ret = netsysController->NetDiagGetSocketsInfo(socketType, socketsInfo); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); ShowSocketInfo(socketsInfo); socketsInfo.unixSocketsInfo_.clear(); socketsInfo.netProtoSocketsInfo_.clear(); socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_UNIX; - ret = NetsysController::GetInstance().NetDiagGetSocketsInfo(socketType, socketsInfo); + ret = netsysController->NetDiagGetSocketsInfo(socketType, socketsInfo); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); ShowSocketInfo(socketsInfo); } HWTEST_F(NetsysControllerTest, NetDiagGetInterfaceConfig001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::list configs; std::string ifaceName = "eth0"; - auto ret = NetsysController::GetInstance().NetDiagGetInterfaceConfig(configs, ifaceName); + auto ret = netsysController->NetDiagGetInterfaceConfig(configs, ifaceName); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); for (const OHOS::NetsysNative::NetDiagIfaceConfig < : configs) { @@ -859,7 +996,7 @@ HWTEST_F(NetsysControllerTest, NetDiagGetInterfaceConfig001, TestSize.Level1) configs.clear(); ifaceName = "eth1"; - ret = NetsysController::GetInstance().NetDiagGetInterfaceConfig(configs, ifaceName); + ret = netsysController->NetDiagGetInterfaceConfig(configs, ifaceName); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); for (const OHOS::NetsysNative::NetDiagIfaceConfig < : configs) { @@ -874,20 +1011,30 @@ HWTEST_F(NetsysControllerTest, NetDiagGetInterfaceConfig001, TestSize.Level1) HWTEST_F(NetsysControllerTest, NetDiagSetInterfaceActiveState001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::list configs; std::string ifaceName = "eth0"; - auto ret = NetsysController::GetInstance().NetDiagSetInterfaceActiveState(ifaceName, false); + auto ret = netsysController->NetDiagSetInterfaceActiveState(ifaceName, false); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); configs.clear(); ifaceName = "eth1"; - ret = NetsysController::GetInstance().NetDiagSetInterfaceActiveState(ifaceName, false); + ret = netsysController->NetDiagSetInterfaceActiveState(ifaceName, false); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetDiagUpdateInterfaceConfig001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string ifaceName = "eth0"; OHOS::NetsysNative::NetDiagIfaceConfig config; config.ifaceName_ = ifaceName; @@ -895,22 +1042,27 @@ HWTEST_F(NetsysControllerTest, NetDiagUpdateInterfaceConfig001, TestSize.Level1) config.ipv4Mask_ = "255.255.255.0"; config.ipv4Bcast_ = "255.255.255.0"; bool add = true; - auto ret = NetsysController::GetInstance().NetDiagUpdateInterfaceConfig(config, ifaceName, add); + auto ret = netsysController->NetDiagUpdateInterfaceConfig(config, ifaceName, add); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); ifaceName = "eth1"; add = false; - ret = NetsysController::GetInstance().NetDiagUpdateInterfaceConfig(config, ifaceName, add); + ret = netsysController->NetDiagUpdateInterfaceConfig(config, ifaceName, add); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetDiagPing001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + OHOS::NetsysNative::NetDiagPingOption pingOption; pingOption.destination_ = "127.0.0.1"; const int maxWaitSecond = 10; g_isWaitAsync = true; - auto ret = NetsysController::GetInstance().NetDiagPingHost(pingOption, netDiagCallback); + auto ret = netsysController->NetDiagPingHost(pingOption, netDiagCallback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); std::chrono::steady_clock::time_point tp1 = std::chrono::steady_clock::now(); while (g_isWaitAsync) { @@ -925,6 +1077,11 @@ HWTEST_F(NetsysControllerTest, NetDiagPing001, TestSize.Level1) HWTEST_F(NetsysControllerTest, NetsysControllerErr007, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string ipAddr = "192.168.1.100"; std::string macAddr = "aa:bb:cc:dd:ee:ff"; std::string ifName = "wlan0"; @@ -933,83 +1090,93 @@ HWTEST_F(NetsysControllerTest, NetsysControllerErr007, TestSize.Level1) std::string macAddr1 = "aa:bb:cc:dd:ee:ff"; std::string ifName1 = "chba0"; - auto ret = instance_->AddStaticArp(ipAddr, macAddr, ifName); + auto ret = netsysController->AddStaticArp(ipAddr, macAddr, ifName); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->DelStaticArp(ipAddr, macAddr, ifName); + ret = netsysController->DelStaticArp(ipAddr, macAddr, ifName); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - auto ret1 = instance_->AddStaticIpv6Addr(ipAddr1, macAddr1, ifName1); + auto ret1 = netsysController->AddStaticIpv6Addr(ipAddr1, macAddr1, ifName1); EXPECT_EQ(ret1, NetManagerStandard::NETMANAGER_SUCCESS); - ret1 = instance_->DelStaticIpv6Addr(ipAddr1, macAddr1, ifName1); + ret1 = netsysController->DelStaticIpv6Addr(ipAddr1, macAddr1, ifName1); EXPECT_EQ(ret1, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetworkCreatePhysical(NET_ID, PERMISSION); + ret = netsysController->NetworkCreatePhysical(NET_ID, PERMISSION); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); std::string cmd = ""; std::string respond = ""; - ret = instance_->SetIptablesCommandForRes(cmd, respond); + ret = netsysController->SetIptablesCommandForRes(cmd, respond); EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->SetIpCommandForRes(cmd, respond); + ret = netsysController->SetIpCommandForRes(cmd, respond); EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); OHOS::NetsysNative::NetDiagPingOption pingOption = {}; - ret = instance_->NetDiagPingHost(pingOption, netDiagCallback); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->NetDiagPingHost(pingOption, netDiagCallback); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); std::list diagrouteTable; - ret = instance_->NetDiagGetRouteTable(diagrouteTable); + ret = netsysController->NetDiagGetRouteTable(diagrouteTable); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); OHOS::NetsysNative::NetDiagProtocolType socketType = OHOS::NetsysNative::NetDiagProtocolType::PROTOCOL_TYPE_ALL; OHOS::NetsysNative::NetDiagSocketsInfo socketsInfo = {}; - ret = instance_->NetDiagGetSocketsInfo(socketType, socketsInfo); + ret = netsysController->NetDiagGetSocketsInfo(socketType, socketsInfo); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); std::list configs; std::string ifaceName = "eth0"; - ret = instance_->NetDiagGetInterfaceConfig(configs, ifaceName); + ret = netsysController->NetDiagGetInterfaceConfig(configs, ifaceName); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); OHOS::NetsysNative::NetDiagIfaceConfig config; - ret = instance_->NetDiagUpdateInterfaceConfig(config, ifaceName, false); + ret = netsysController->NetDiagUpdateInterfaceConfig(config, ifaceName, false); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetDiagSetInterfaceActiveState(ifaceName, false); + ret = netsysController->NetDiagSetInterfaceActiveState(ifaceName, false); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerBranchTest001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::vector beginUids = {1}; std::vector endUids = {1}; int32_t netId = 0; - NetsysController::GetInstance().NetworkCreateVirtual(netId, false); + netsysController->NetworkCreateVirtual(netId, false); - auto ret = instance_->NetworkAddUids(netId, beginUids, endUids); + auto ret = netsysController->NetworkAddUids(netId, beginUids, endUids); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = instance_->NetworkDelUids(netId, beginUids, endUids); + ret = netsysController->NetworkDelUids(netId, beginUids, endUids); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); endUids = {1, 2}; - ret = instance_->NetworkAddUids(netId, beginUids, endUids); + ret = netsysController->NetworkAddUids(netId, beginUids, endUids); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL); - ret = instance_->NetworkDelUids(netId, beginUids, endUids); + ret = netsysController->NetworkDelUids(netId, beginUids, endUids); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL); } HWTEST_F(NetsysControllerTest, NetsysControllerBranchTest002, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint32_t uid = 0; uint8_t allow = 0; - auto ret = NetsysController::GetInstance().SetInternetPermission(uid, allow); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + auto ret = netsysController->SetInternetPermission(uid, allow); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); std::string ipAddr = "192.168.1.100"; std::string macAddr = "aa:bb:cc:dd:ee:ff"; @@ -1018,389 +1185,532 @@ HWTEST_F(NetsysControllerTest, NetsysControllerBranchTest002, TestSize.Level1) std::string ipAddr1 = "2001:0db8:85a3:0000:0000:8a2e:0370:7334"; std::string macAddr1 = "aa:bb:cc:dd:ee:ff"; std::string ifName1 = "chba0"; - ret = NetsysController::GetInstance().AddStaticArp(ipAddr, macAddr, ifName); + ret = netsysController->AddStaticArp(ipAddr, macAddr, ifName); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().DelStaticArp(ipAddr, macAddr, ifName); + ret = netsysController->DelStaticArp(ipAddr, macAddr, ifName); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().AddStaticIpv6Addr(ipAddr1, macAddr1, ifName1); + ret = netsysController->AddStaticIpv6Addr(ipAddr1, macAddr1, ifName1); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().DelStaticIpv6Addr(ipAddr1, macAddr1, ifName1); + ret = netsysController->DelStaticIpv6Addr(ipAddr1, macAddr1, ifName1); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); NetsysNotifyCallback callback; - ret = NetsysController::GetInstance().RegisterNetsysNotifyCallback(callback); + ret = netsysController->RegisterNetsysNotifyCallback(callback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); int32_t netId = 0; int32_t permission = 0; - ret = NetsysController::GetInstance().NetworkCreatePhysical(netId, permission); + ret = netsysController->NetworkCreatePhysical(netId, permission); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().NetworkCreateVirtual(netId, false); + ret = netsysController->NetworkCreateVirtual(netId, false); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, GetCookieStatsTest001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint64_t stats = 0; BpfMapper appCookieStatsMap(APP_COOKIE_STATS_MAP_PATH, BPF_ANY); - int32_t ret = NetsysController::GetInstance().GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL); + int32_t ret = netsysController->GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().GetCookieStats(stats, TEST_STATS_TYPE2, TEST_COOKIE); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL); + ret = netsysController->GetCookieStats(stats, TEST_STATS_TYPE2, TEST_COOKIE); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, GetNetworkSharingTypeTest001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::set sharingTypeIsOn; - int32_t ret = NetsysController::GetInstance().GetNetworkSharingType(sharingTypeIsOn); + int32_t ret = netsysController->GetNetworkSharingType(sharingTypeIsOn); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, UpdateNetworkSharingTypeTest001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint64_t type = 0; bool isOpen = true; - int32_t ret = NetsysController::GetInstance().UpdateNetworkSharingType(type, isOpen); + int32_t ret = netsysController->UpdateNetworkSharingType(type, isOpen); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerBranchTest003, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint32_t timeStep = 0; sptr callback = nullptr; - int32_t ret = NetsysController::GetInstance().RegisterDnsResultCallback(callback, timeStep); + int32_t ret = netsysController->RegisterDnsResultCallback(callback, timeStep); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL); - ret = NetsysController::GetInstance().UnregisterDnsResultCallback(callback); + ret = netsysController->UnregisterDnsResultCallback(callback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL); sptr queryCallback = nullptr; - ret = NetsysController::GetInstance().RegisterDnsQueryResultCallback(queryCallback); + ret = netsysController->RegisterDnsQueryResultCallback(queryCallback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL); - ret = NetsysController::GetInstance().UnregisterDnsQueryResultCallback(queryCallback); + ret = netsysController->UnregisterDnsQueryResultCallback(queryCallback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL); } HWTEST_F(NetsysControllerTest, SetEnableIpv6Test001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint32_t on = 0; std::string interface = "wlan0"; - int32_t ret = NetsysController::GetInstance().SetIpv6PrivacyExtensions(interface, on); + int32_t ret = netsysController->SetIpv6PrivacyExtensions(interface, on); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().SetEnableIpv6(interface, on); + ret = netsysController->SetEnableIpv6(interface, on); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, SetDnsCacheTest001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint16_t netId = 101; std::string testHost = "test"; AddrInfo info; - int32_t ret = NetsysController::GetInstance().SetDnsCache(netId, testHost, info); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->SetDnsCache(netId, testHost, info); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NetsysControllerBranchTest004, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = nullptr; + auto netsysController = std::make_shared(); + uint32_t timeStep = 0; sptr callback = nullptr; - int32_t ret = NetsysController::GetInstance().RegisterDnsResultCallback(callback, timeStep); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->RegisterDnsResultCallback(callback, timeStep); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); - ret = NetsysController::GetInstance().UnregisterDnsResultCallback(callback); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->UnregisterDnsResultCallback(callback); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); sptr queryCallback = nullptr; - ret = NetsysController::GetInstance().RegisterDnsQueryResultCallback(queryCallback); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->RegisterDnsQueryResultCallback(queryCallback); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); - ret = NetsysController::GetInstance().UnregisterDnsQueryResultCallback(queryCallback); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->UnregisterDnsQueryResultCallback(queryCallback); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); + + uint64_t stats = 0; + ret = netsysController->GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, SetIpv6PrivacyExtensionsTest001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint32_t on = 0; std::string interface = "wlan0"; - int32_t ret = NetsysController::GetInstance().SetIpv6PrivacyExtensions(interface, on); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().SetEnableIpv6(interface, on); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->SetIpv6PrivacyExtensions(interface, on); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->SetEnableIpv6(interface, on); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, SetNetworkAccessPolicy001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint32_t uid = 0; NetworkAccessPolicy netAccessPolicy; netAccessPolicy.wifiAllow = false; netAccessPolicy.cellularAllow = false; bool reconfirmFlag = true; - int32_t ret = NetsysController::GetInstance().SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, NotifyNetBearerTypeChange001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::set bearTypes; bearTypes.insert(NetManagerStandard::NetBearType::BEARER_CELLULAR); - int32_t ret = NetsysController::GetInstance().NotifyNetBearerTypeChange(bearTypes); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->NotifyNetBearerTypeChange(bearTypes); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, DeleteNetworkAccessPolicy001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint32_t uid = 0; - int32_t ret = NetsysController::GetInstance().DeleteNetworkAccessPolicy(uid); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->DeleteNetworkAccessPolicy(uid); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, CreateVnic001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint16_t mtu = 1500; std::string tunAddr = "192.168.1.100"; int32_t prefix = 24; std::set uids; - int32_t ret = NetsysController::GetInstance().CreateVnic(mtu, tunAddr, prefix, uids); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->CreateVnic(mtu, tunAddr, prefix, uids); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, DestroyVnic001, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().DestroyVnic(); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->DestroyVnic(); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, EnableDistributedClientNetTest001, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = nullptr; - int32_t ret = NetsysController::GetInstance().EnableDistributedClientNet("192.168.1.100", ETH0); + auto netsysController = std::make_shared(); + + int32_t ret = netsysController->EnableDistributedClientNet("192.168.1.100", ETH0); EXPECT_EQ(ret, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, EnableDistributedClientNetTest002, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = std::make_unique().release(); - int32_t ret = NetsysController::GetInstance().EnableDistributedClientNet("192.168.1.100", ETH0); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->EnableDistributedClientNet("192.168.1.100", ETH0); EXPECT_NE(ret, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, EnableDistributedServerNetTest001, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = nullptr; - int32_t ret = NetsysController::GetInstance().EnableDistributedServerNet(ETH0, WLAN, "192.168.1.100"); + auto netsysController = std::make_shared(); + + int32_t ret = netsysController->EnableDistributedServerNet(ETH0, WLAN, "192.168.1.100"); EXPECT_EQ(ret, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, EnableDistributedServerNetTest002, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = std::make_unique().release(); - int32_t ret = NetsysController::GetInstance().EnableDistributedServerNet(ETH0, WLAN, "192.168.1.100"); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->EnableDistributedServerNet(ETH0, WLAN, "192.168.1.100"); EXPECT_NE(ret, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, DisableDistributedNetTest001, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = nullptr; - int32_t ret = NetsysController::GetInstance().DisableDistributedNet(true); + auto netsysController = std::make_shared(); + + int32_t ret = netsysController->DisableDistributedNet(true); EXPECT_EQ(ret, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, DisableDistributedNetTest002, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = std::make_unique().release(); - int32_t ret = NetsysController::GetInstance().DisableDistributedNet(true); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->DisableDistributedNet(true); EXPECT_NE(ret, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, GetNetworkCellularSharingTrafficTest001, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = nullptr; + auto netsysController = std::make_shared(); + nmd::NetworkSharingTraffic traffic; std::string ifaceName; - int32_t ret = NetsysController::GetInstance().GetNetworkCellularSharingTraffic(traffic, ifaceName); + int32_t ret = netsysController->GetNetworkCellularSharingTraffic(traffic, ifaceName); EXPECT_EQ(ret, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, GetNetworkCellularSharingTrafficTest002, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = std::make_unique().release(); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + nmd::NetworkSharingTraffic traffic; std::string ifaceName; - int32_t ret = NetsysController::GetInstance().GetNetworkCellularSharingTraffic(traffic, ifaceName); + int32_t ret = netsysController->GetNetworkCellularSharingTraffic(traffic, ifaceName); EXPECT_NE(ret, NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, CloseSocketsUid002, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string ipAddr = ""; uint32_t uid = 1000; - int32_t result = NetsysController::GetInstance().CloseSocketsUid(ipAddr, uid); + int32_t result = netsysController->CloseSocketsUid(ipAddr, uid); EXPECT_NE(result, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); - NetsysController::GetInstance().netsysService_ = nullptr; } HWTEST_F(NetsysControllerTest, CloseSocketsUid001, TestSize.Level1) { + auto netsysController = std::make_shared(); + std::string ipAddr = ""; uint32_t uid = 1000; - int32_t result = NetsysController::GetInstance().CloseSocketsUid(ipAddr, uid); + int32_t result = netsysController->CloseSocketsUid(ipAddr, uid); EXPECT_EQ(result, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, SetBrokerUidAccessPolicyMapTest001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::unordered_map params; - int32_t ret = NetsysController::GetInstance().SetBrokerUidAccessPolicyMap(params); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->SetBrokerUidAccessPolicyMap(params); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, SetBrokerUidAccessPolicyMapTest002, TestSize.Level1) { + auto netsysController = std::make_shared(); + std::unordered_map params; params.emplace(TEST_UID_32, TEST_UID_32); - int32_t ret = NetsysController::GetInstance().SetBrokerUidAccessPolicyMap(params); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->SetBrokerUidAccessPolicyMap(params); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, DelBrokerUidAccessPolicyMapTest001, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().DelBrokerUidAccessPolicyMap(TEST_UID_32); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->DelBrokerUidAccessPolicyMap(TEST_UID_32); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, SetBrokerUidAccessPolicyMapTest003, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = std::make_unique().release(); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::unordered_map params; - int32_t ret = NetsysController::GetInstance().SetBrokerUidAccessPolicyMap(params); + int32_t ret = netsysController->SetBrokerUidAccessPolicyMap(params); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, DelBrokerUidAccessPolicyMapTest002, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = nullptr; - int32_t ret = NetsysController::GetInstance().DelBrokerUidAccessPolicyMap(TEST_UID_32); + auto netsysController = std::make_shared(); + + int32_t ret = netsysController->DelBrokerUidAccessPolicyMap(TEST_UID_32); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } #ifdef FEATURE_WEARABLE_DISTRIBUTED_NET_ENABLE HWTEST_F(NetsysControllerTest, EnableWearableDistributedNetForward, TestSize.Level1) { - int32_t ret = NetsysController::GetInstance().EnableWearableDistributedNetForward(8001, 8002); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + int32_t ret = netsysController->EnableWearableDistributedNetForward(8001, 8002); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); - ret = NetsysController::GetInstance().DisableWearableDistributedNetForward(); + ret = netsysController->DisableWearableDistributedNetForward(); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, DisableWearableDistributedNetForward, TestSize.Level1) { - NetsysController::GetInstance().initFlag_ = false; - NetsysController::GetInstance().Init(); - int32_t ret = NetsysController::GetInstance().EnableWearableDistributedNetForward(8001, 8002); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + netsysController->initFlag_ = false; + netsysController->Init(); + int32_t ret = netsysController->EnableWearableDistributedNetForward(8001, 8002); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = NetsysController::GetInstance().DisableWearableDistributedNetForward(); + ret = netsysController->DisableWearableDistributedNetForward(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } #endif HWTEST_F(NetsysControllerTest, EnableDistributedClientNet001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string virnicAddr = "1.189.55.61"; std::string iif = "lo"; - int32_t ret = NetsysController::GetInstance().EnableDistributedClientNet(virnicAddr, iif); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->EnableDistributedClientNet(virnicAddr, iif); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); bool isServer = false; - ret = NetsysController::GetInstance().DisableDistributedNet(isServer); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->DisableDistributedNet(isServer); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, EnableDistributedServerNet001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + std::string iif = "lo"; std::string devIface = "lo"; std::string dstAddr = "1.189.55.61"; - int32_t ret = NetsysController::GetInstance().EnableDistributedServerNet(iif, devIface, dstAddr); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->EnableDistributedServerNet(iif, devIface, dstAddr); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); bool isServer = true; - ret = NetsysController::GetInstance().DisableDistributedNet(isServer); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->DisableDistributedNet(isServer); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, GetNetworkCellularSharingTraffic001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + nmd::NetworkSharingTraffic traffic; std::string ifaceName = "virnic"; - int32_t ret = NetsysController::GetInstance().GetNetworkCellularSharingTraffic(traffic, ifaceName); - EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); + int32_t ret = netsysController->GetNetworkCellularSharingTraffic(traffic, ifaceName); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, SetGetClearNetStateTrafficMap001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint8_t flag = 1; uint64_t availableTraffic = 1000000; - int32_t ret = NetsysController::GetInstance().SetNetStateTrafficMap(flag, availableTraffic); - EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); - ret = NetsysController::GetInstance().GetNetStateTrafficMap(flag, availableTraffic); - EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); - ret = NetsysController::GetInstance().ClearIncreaseTrafficMap(); - EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); - ret = NetsysController::GetInstance().DeleteIncreaseTrafficMap(12); - EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); + int32_t ret = netsysController->SetNetStateTrafficMap(flag, availableTraffic); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->GetNetStateTrafficMap(flag, availableTraffic); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->ClearIncreaseTrafficMap(); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); + ret = netsysController->DeleteIncreaseTrafficMap(12); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, SetGetClearNetStateTrafficMap002, TestSize.Level1) { + auto netsysController = std::make_shared(); + uint8_t flag = 1; uint64_t availableTraffic = 1000000; - NetsysController::GetInstance().netsysService_ = nullptr; - - int32_t ret = NetsysController::GetInstance().SetNetStateTrafficMap(flag, availableTraffic); + int32_t ret = netsysController->SetNetStateTrafficMap(flag, availableTraffic); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); - ret = NetsysController::GetInstance().GetNetStateTrafficMap(flag, availableTraffic); + ret = netsysController->GetNetStateTrafficMap(flag, availableTraffic); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); - ret = NetsysController::GetInstance().ClearIncreaseTrafficMap(); + ret = netsysController->ClearIncreaseTrafficMap(); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); - ret = NetsysController::GetInstance().DeleteIncreaseTrafficMap(12); + ret = netsysController->DeleteIncreaseTrafficMap(12); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, UpdateIfIndexMap001, TestSize.Level1) { + auto netsysController = std::make_shared(); + uint8_t key = 1; uint64_t index = 10; - NetsysController::GetInstance().netsysService_ = nullptr; - int32_t ret = NetsysController::GetInstance().UpdateIfIndexMap(key, index); + int32_t ret = netsysController->UpdateIfIndexMap(key, index); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, RegisterNetsysTrafficCallback002, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = std::make_unique().release(); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + sptr callback = nullptr; - int32_t ret = NetsysController::GetInstance().RegisterNetsysTrafficCallback(callback); - EXPECT_TRUE(ret == NetManagerStandard::NETSYS_NETSYSSERVICE_NULL || - ret == NETMANAGER_ERR_LOCAL_PTR_NULL); + int32_t ret = netsysController->RegisterNetsysTrafficCallback(callback); + EXPECT_EQ(ret, NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, RegisterNetsysTrafficCallback001, TestSize.Level1) { + auto netsysController = std::make_shared(); + sptr callback = nullptr; - NetsysController::GetInstance().netsysService_ = nullptr; - int32_t ret = NetsysController::GetInstance().RegisterNetsysTrafficCallback(callback); + int32_t ret = netsysController->RegisterNetsysTrafficCallback(callback); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } @@ -1444,66 +1754,89 @@ HWTEST_F(NetsysControllerTest, DeleteIncreaseTrafficMap001, TestSize.Level1) HWTEST_F(NetsysControllerTest, UnRegisterNetsysTrafficCallback001, TestSize.Level1) { + auto netsysController = std::make_shared(); + sptr callback = nullptr; - NetsysController::GetInstance().netsysService_ = nullptr; - int32_t ret = NetsysController::GetInstance().UnRegisterNetsysTrafficCallback(callback); + int32_t ret = netsysController->UnRegisterNetsysTrafficCallback(callback); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, UnRegisterNetsysTrafficCallback002, TestSize.Level1) { - NetsysController::GetInstance().netsysService_ = std::make_unique().release(); + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + sptr callback = nullptr; - int32_t ret = NetsysController::GetInstance().UnRegisterNetsysTrafficCallback(callback); - EXPECT_TRUE(ret == NetManagerStandard::NETSYS_NETSYSSERVICE_NULL || - ret == NETMANAGER_ERR_LOCAL_PTR_NULL); + int32_t ret = netsysController->UnRegisterNetsysTrafficCallback(callback); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysControllerTest, SetUserDefinedServerFlag001, TestSize.Level1) { - uint16_t netId = 123; - bool isUserDefinedServer = true; - NetsysController::GetInstance().netsysService_ = nullptr; - int32_t ret = NetsysController::GetInstance().SetUserDefinedServerFlag(netId, isUserDefinedServer); + auto netsysController = std::make_shared(); + + std::string interfaceName = "eth0"; + int32_t netId = 1; + std::string nat64PrefixStr = "2001:db8::/64"; + int32_t ret = netsysController->StartClat(interfaceName, netId, nat64PrefixStr); + EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); + ret = netsysController->StopClat(interfaceName); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } HWTEST_F(NetsysControllerTest, SetDnsCacheTest02, TestSize.Level1) { - uint16_t netId = 101; - std::string testHost = "test"; - AddrInfo info; - NetsysController::GetInstance().netsysService_ = nullptr; - int32_t ret = NetsysController::GetInstance().SetDnsCache(netId, testHost, info); + auto netsysController = std::make_shared(); + + std::vector ifaceNames = {"eth0", "wlan0"}; + bool status = true; + int32_t ret = netsysController->SetNicTrafficAllowed(ifaceNames, status); EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } #ifdef FEATURE_ENTERPRISE_ROUTE_CUSTOM HWTEST_F(NetsysNativeClientTest, UpdateEnterpriseRouteTest001, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint32_t uid = 20000138; std::string ifname = "wlan0"; bool add = true; - auto ret = nativeClient_.UpdateEnterpriseRoute(ifname, uid, add); - EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); + auto ret = netsysController->UpdateEnterpriseRoute(ifname, uid, add); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, UpdateEnterpriseRouteTest002, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint32_t uid = 0; std::string ifname = "wlan0"; bool add = true; - auto ret = nativeClient_.UpdateEnterpriseRoute(ifname, uid, add); - EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); + auto ret = netsysController->UpdateEnterpriseRoute(ifname, uid, add); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, UpdateEnterpriseRouteTest003, TestSize.Level1) { + auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + uint32_t uid = 20000138; std::string ifname = "notexist"; bool add = true; - auto ret = nativeClient_.UpdateEnterpriseRoute(ifname, uid, add); - EXPECT_EQ(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); + auto ret = netsysController->UpdateEnterpriseRoute(ifname, uid, add); + EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } #endif @@ -1518,8 +1851,12 @@ HWTEST_F(NetsysControllerTest, FlushDnsCache001, TestSize.Level1) HWTEST_F(NetsysControllerTest, FlushDnsCache002, TestSize.Level1) { - uint16_t netId = 101; auto netsysController = std::make_shared(); + auto netsysControllerServiceImpl = sptr::MakeSptr(); + netsysControllerServiceImpl->netsysClient_->netsysNativeService_ = mockNetsysService_; + netsysController->netsysService_ = netsysControllerServiceImpl; + + uint16_t netId = 101; int32_t ret = netsysController->FlushDnsCache(netId); EXPECT_NE(ret, NetManagerStandard::NETSYS_NETSYSSERVICE_NULL); } diff --git a/test/netmanagernative/unittest/netsys_manager_test/netsys_native_client_test.cpp b/test/netmanagernative/unittest/netsys_manager_test/netsys_native_client_test.cpp index 1ce5f32e7..76e50f1fa 100644 --- a/test/netmanagernative/unittest/netsys_manager_test/netsys_native_client_test.cpp +++ b/test/netmanagernative/unittest/netsys_manager_test/netsys_native_client_test.cpp @@ -69,8 +69,6 @@ public: void SetUp(); void TearDown(); - static inline std::shared_ptr nativeClientInstance_ = std::make_shared(); - static inline NetsysNativeClient &nativeClient_ = *nativeClientInstance_; }; void NetsysNativeClientTest::SetUpTestCase() {} @@ -83,194 +81,200 @@ void NetsysNativeClientTest::TearDown() {} HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest001, TestSize.Level1) { - int32_t ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION); + auto nativeClient = std::make_shared(); + int32_t ret = nativeClient->NetworkCreatePhysical(NET_ID, PERMISSION); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION); + ret = nativeClient->NetworkCreatePhysical(NET_ID, PERMISSION); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.NetworkDestroy(NET_ID); + ret = nativeClient->NetworkDestroy(NET_ID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.NetworkAddInterface(NET_ID, IF_NAME, BEARER_DEFAULT); + ret = nativeClient->NetworkAddInterface(NET_ID, IF_NAME, BEARER_DEFAULT); EXPECT_EQ(ret, -1); - ret = nativeClient_.NetworkRemoveInterface(NET_ID, IF_NAME); + ret = nativeClient->NetworkRemoveInterface(NET_ID, IF_NAME); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.NetworkAddRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP, false); + ret = nativeClient->NetworkAddRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP, false); EXPECT_EQ(ret, INVALID_ARGUMENTS); - ret = nativeClient_.NetworkRemoveRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP); + ret = nativeClient->NetworkRemoveRoute(NET_ID, IF_NAME, DESTINATION, NEXT_HOP); EXPECT_EQ(ret, INVALID_ARGUMENTS); OHOS::nmd::InterfaceConfigurationParcel parcel; - ret = nativeClient_.GetInterfaceConfig(parcel); + ret = nativeClient->GetInterfaceConfig(parcel); EXPECT_EQ(ret, 0); - ret = nativeClient_.SetInterfaceDown(IF_NAME); + ret = nativeClient->SetInterfaceDown(IF_NAME); EXPECT_EQ(ret, 0); - ret = nativeClient_.SetInterfaceUp(IF_NAME); + ret = nativeClient->SetInterfaceUp(IF_NAME); EXPECT_EQ(ret, 0); - nativeClient_.ClearInterfaceAddrs(IF_NAME); + nativeClient->ClearInterfaceAddrs(IF_NAME); - ret = nativeClient_.GetInterfaceMtu(IF_NAME); + ret = nativeClient->GetInterfaceMtu(IF_NAME); EXPECT_EQ(ret, -1); - ret = nativeClient_.SetInterfaceMtu(IF_NAME, MTU); + ret = nativeClient->SetInterfaceMtu(IF_NAME, MTU); EXPECT_EQ(ret, -1); - ret = nativeClient_.SetTcpBufferSizes(TCP_BUFFER_SIZES); + ret = nativeClient->SetTcpBufferSizes(TCP_BUFFER_SIZES); EXPECT_EQ(ret, 0); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest002, TestSize.Level1) { - int32_t ret = nativeClient_.AddInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH); + auto nativeClient = std::make_shared(); + int32_t ret = nativeClient->AddInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH); EXPECT_EQ(ret, -19); - ret = nativeClient_.DelInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH); + ret = nativeClient->DelInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH); EXPECT_EQ(ret, -19); - ret = nativeClient_.SetResolverConfig(NET_ID, BASE_TIMEOUT_MSEC, RETRY_COUNT, {}, {}); + ret = nativeClient->SetResolverConfig(NET_ID, BASE_TIMEOUT_MSEC, RETRY_COUNT, {}, {}); EXPECT_EQ(ret, 0); std::vector servers; std::vector domains; - ret = nativeClient_.GetResolverConfig(NET_ID, servers, domains, BASE_TIMEOUT_MSEC, RETRY_COUNT); + ret = nativeClient->GetResolverConfig(NET_ID, servers, domains, BASE_TIMEOUT_MSEC, RETRY_COUNT); EXPECT_EQ(ret, 0); - ret = nativeClient_.CreateNetworkCache(NET_ID); + ret = nativeClient->CreateNetworkCache(NET_ID); EXPECT_EQ(ret, 0); - ret = nativeClient_.DestroyNetworkCache(NET_ID); + ret = nativeClient->DestroyNetworkCache(NET_ID); EXPECT_EQ(ret, 0); nmd::NetworkSharingTraffic traffic; - ret = nativeClient_.GetNetworkSharingTraffic(ETH0, ETH0, traffic); + ret = nativeClient->GetNetworkSharingTraffic(ETH0, ETH0, traffic); EXPECT_NE(ret, 0); - ret = nativeClient_.GetCellularRxBytes(); + ret = nativeClient->GetCellularRxBytes(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.GetCellularTxBytes(); + ret = nativeClient->GetCellularTxBytes(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.GetAllRxBytes(); + ret = nativeClient->GetAllRxBytes(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.GetAllTxBytes(); + ret = nativeClient->GetAllTxBytes(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest003, TestSize.Level1) { - int32_t ret = nativeClient_.GetUidRxBytes(NET_ID); + auto nativeClient = std::make_shared(); + int32_t ret = nativeClient->GetUidRxBytes(NET_ID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.GetUidTxBytes(NET_ID); + ret = nativeClient->GetUidTxBytes(NET_ID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.GetUidOnIfaceRxBytes(NET_ID, INTERFACE_NAME); + ret = nativeClient->GetUidOnIfaceRxBytes(NET_ID, INTERFACE_NAME); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.GetUidOnIfaceTxBytes(NET_ID, INTERFACE_NAME); + ret = nativeClient->GetUidOnIfaceTxBytes(NET_ID, INTERFACE_NAME); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.GetIfaceRxBytes(INTERFACE_NAME); + ret = nativeClient->GetIfaceRxBytes(INTERFACE_NAME); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.GetIfaceTxBytes(INTERFACE_NAME); + ret = nativeClient->GetIfaceTxBytes(INTERFACE_NAME); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - std::vector interFaceGetList = nativeClient_.InterfaceGetList(); + std::vector interFaceGetList = nativeClient->InterfaceGetList(); EXPECT_NE(interFaceGetList.size(), 0U); - std::vector uidGetList = nativeClient_.UidGetList(); + std::vector uidGetList = nativeClient->UidGetList(); EXPECT_EQ(uidGetList.size(), 0U); - ret = nativeClient_.GetIfaceRxPackets(INTERFACE_NAME); + ret = nativeClient->GetIfaceRxPackets(INTERFACE_NAME); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.GetIfaceTxPackets(INTERFACE_NAME); + ret = nativeClient->GetIfaceTxPackets(INTERFACE_NAME); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); std::vector uids; uids.push_back(UID); - ret = nativeClient_.FirewallSetUidsAllowedListChain(CHAIN, uids); + ret = nativeClient->FirewallSetUidsAllowedListChain(CHAIN, uids); EXPECT_EQ(ret, -1); - ret = nativeClient_.FirewallSetUidsDeniedListChain(CHAIN, uids); + ret = nativeClient->FirewallSetUidsDeniedListChain(CHAIN, uids); EXPECT_EQ(ret, -1); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest004, TestSize.Level1) { - int32_t ret = nativeClient_.SetDefaultNetWork(NET_ID); + auto nativeClient = std::make_shared(); + int32_t ret = nativeClient->SetDefaultNetWork(NET_ID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.ClearDefaultNetWorkNetId(); + ret = nativeClient->ClearDefaultNetWorkNetId(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.BindSocket(SOCKET_FD, NET_ID); + ret = nativeClient->BindSocket(SOCKET_FD, NET_ID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.IpEnableForwarding(REQUESTOR); + ret = nativeClient->IpEnableForwarding(REQUESTOR); EXPECT_EQ(ret, 0); - ret = nativeClient_.IpDisableForwarding(REQUESTOR); + ret = nativeClient->IpDisableForwarding(REQUESTOR); EXPECT_EQ(ret, 0); - ret = nativeClient_.EnableNat(ETH0, ETH0); + ret = nativeClient->EnableNat(ETH0, ETH0); EXPECT_EQ(ret, -1); - ret = nativeClient_.DisableNat(ETH0, ETH0); + ret = nativeClient->DisableNat(ETH0, ETH0); EXPECT_EQ(ret, -1); - ret = nativeClient_.IpfwdAddInterfaceForward(ETH0, ETH0); + ret = nativeClient->IpfwdAddInterfaceForward(ETH0, ETH0); EXPECT_EQ(ret, -1); - ret = nativeClient_.IpfwdRemoveInterfaceForward(ETH0, ETH0); + ret = nativeClient->IpfwdRemoveInterfaceForward(ETH0, ETH0); EXPECT_EQ(ret, -1); - ret = nativeClient_.ShareDnsSet(NET_ID); + ret = nativeClient->ShareDnsSet(NET_ID); EXPECT_EQ(ret, 0); - ret = nativeClient_.StartDnsProxyListen(); + ret = nativeClient->StartDnsProxyListen(); EXPECT_EQ(ret, 0); - ret = nativeClient_.StopDnsProxyListen(); + ret = nativeClient->StopDnsProxyListen(); EXPECT_EQ(ret, 0); - ret = nativeClient_.FirewallEnableChain(CHAIN, true); + ret = nativeClient->FirewallEnableChain(CHAIN, true); EXPECT_EQ(ret, -1); - ret = nativeClient_.FirewallSetUidRule(CHAIN, {NET_ID}, FIREWALL_RULE); + ret = nativeClient->FirewallSetUidRule(CHAIN, {NET_ID}, FIREWALL_RULE); EXPECT_EQ(ret, 0); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest005, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint64_t stats = 0; - int32_t ret = nativeClient_.GetTotalStats(stats, 0); + int32_t ret = nativeClient->GetTotalStats(stats, 0); EXPECT_EQ(ret, 0); - ret = nativeClient_.GetUidStats(stats, 0, APP_ID); + ret = nativeClient->GetUidStats(stats, 0, APP_ID); EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_READ_BPF_FAIL); - ret = nativeClient_.GetIfaceStats(stats, 0, IFACE); + ret = nativeClient->GetIfaceStats(stats, 0, IFACE); EXPECT_EQ(ret, NetStatsResultCode::STATS_ERR_GET_IFACE_NAME_FAILED); std::vector statsInfo; - ret = nativeClient_.GetAllStatsInfo(statsInfo); + ret = nativeClient->GetAllStatsInfo(statsInfo); EXPECT_EQ(ret, 0); - ret = nativeClient_.GetAllSimStatsInfo(statsInfo); + ret = nativeClient->GetAllSimStatsInfo(statsInfo); EXPECT_EQ(ret, 0); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest006, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::vector uidRanges; std::vector beginUids; std::vector endUids; @@ -279,41 +283,44 @@ HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest006, TestSize.Level1) for (size_t i = 0; i < beginUids.size(); i++) { uidRanges.emplace_back(UidRange(beginUids[i], endUids[i])); } - nativeClient_.NetworkAddUids(NET_ID, uidRanges); - nativeClient_.NetworkDelUids(NET_ID, uidRanges); - int32_t ret = nativeClient_.NetworkCreatePhysical(NET_ID, PERMISSION); + nativeClient->NetworkAddUids(NET_ID, uidRanges); + nativeClient->NetworkDelUids(NET_ID, uidRanges); + int32_t ret = nativeClient->NetworkCreatePhysical(NET_ID, PERMISSION); EXPECT_EQ(ret, 0); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest007, TestSize.Level1) { + auto nativeClient = std::make_shared(); NetsysNotifyCallback callback; struct ifreq ifreq = {}; - int32_t ret = nativeClient_.RegisterNetsysNotifyCallback(callback); + int32_t ret = nativeClient->RegisterNetsysNotifyCallback(callback); EXPECT_EQ(ret, 0); - ret = nativeClient_.BindNetworkServiceVpn(SOCKET_FD); + ret = nativeClient->BindNetworkServiceVpn(SOCKET_FD); int32_t ifacefd1 = 0; - nativeClient_.EnableVirtualNetIfaceCard(SOCKET_FD, ifreq, ifacefd1); + nativeClient->EnableVirtualNetIfaceCard(SOCKET_FD, ifreq, ifacefd1); int32_t sockfd = socket(AF_INET, SOCK_STREAM, 0); - ret = nativeClient_.BindNetworkServiceVpn(sockfd); + ret = nativeClient->BindNetworkServiceVpn(sockfd); int32_t ifacefd2 = 0; - nativeClient_.EnableVirtualNetIfaceCard(sockfd, ifreq, ifacefd2); + nativeClient->EnableVirtualNetIfaceCard(sockfd, ifreq, ifacefd2); EXPECT_EQ(ret, 0); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest008, TestSize.Level1) { - int32_t ret = nativeClient_.SetBlocking(IFACEFD, true); + auto nativeClient = std::make_shared(); + int32_t ret = nativeClient->SetBlocking(IFACEFD, true); EXPECT_EQ(ret, NETSYS_ERR_VPN); struct ifreq ifreq = {}; int32_t sockfd = socket(AF_INET, SOCK_STREAM, 0); - ret = nativeClient_.SetIpAddress(sockfd, LOCALIP, PREFIX_LENGTH, ifreq); + ret = nativeClient->SetIpAddress(sockfd, LOCALIP, PREFIX_LENGTH, ifreq); EXPECT_EQ(ret, NETSYS_ERR_VPN); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest009, TestSize.Level1) { - NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient); std::string ifName = "wlan"; bool up = true; int32_t ret = notifyCallback.OnInterfaceChanged(ifName, up); @@ -322,7 +329,8 @@ HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest009, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest010, TestSize.Level1) { - NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient); sptr dhcpResult = new (std::nothrow) OHOS::NetsysNative::DhcpResultParcel(); int32_t ret = notifyCallback.OnDhcpSuccess(dhcpResult); EXPECT_EQ(ret, NETMANAGER_SUCCESS); @@ -330,7 +338,8 @@ HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest010, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest011, TestSize.Level1) { - NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNotifyCallback notifyCallback(nativeClient); std::string limitName = "wlan"; std::string iface = "vpncard"; int32_t ret = notifyCallback.OnBandwidthReachedLimit(limitName, iface); @@ -339,244 +348,268 @@ HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest011, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest013, TestSize.Level1) { + auto nativeClient = std::make_shared(); wptr remote = nullptr; - nativeClient_.OnRemoteDied(remote); + nativeClient->OnRemoteDied(remote); int handle = 1; sptr result = nullptr; std::u16string descriptor = std::u16string(); result = new (std::nothrow) IPCObjectProxy(handle, descriptor); IRemoteObject *object = result.GetRefPtr(); remote = object; - nativeClient_.OnRemoteDied(remote); + nativeClient->OnRemoteDied(remote); uint32_t uid = 0; uint8_t allow = 0; - auto ret = nativeClient_.SetInternetPermission(uid, allow); + auto ret = nativeClient->SetInternetPermission(uid, allow); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERROR); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest014, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::string ipAddr = "192.168.1.100"; std::string macAddr = "aa:bb:cc:dd:ee:ff"; std::string ifName = "wlan0"; - auto ret = nativeClient_.AddStaticArp(ipAddr, macAddr, ifName); + auto ret = nativeClient->AddStaticArp(ipAddr, macAddr, ifName); EXPECT_EQ(ret, NETMANAGER_SUCCESS); - ret = nativeClient_.DelStaticArp(ipAddr, macAddr, ifName); + ret = nativeClient->DelStaticArp(ipAddr, macAddr, ifName); EXPECT_EQ(ret, NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest016, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::string ipAddr = "2001:0db8:85a3:0000:0000:8a2e:0370:7334"; std::string macAddr = "aa:bb:cc:dd:ee:ff"; std::string ifName = "chba0"; - auto ret = nativeClient_.AddStaticIpv6Addr(ipAddr, macAddr, ifName); + auto ret = nativeClient->AddStaticIpv6Addr(ipAddr, macAddr, ifName); EXPECT_EQ(ret, NETMANAGER_SUCCESS); - ret = nativeClient_.DelStaticIpv6Addr(ipAddr, macAddr, ifName); + ret = nativeClient->DelStaticIpv6Addr(ipAddr, macAddr, ifName); EXPECT_EQ(ret, NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, GetCookieStatsTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint64_t stats = 0; BpfMapper appCookieStatsMap(APP_COOKIE_STATS_MAP_PATH, BPF_ANY); - int32_t ret = nativeClient_.GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE); + int32_t ret = nativeClient->GetCookieStats(stats, TEST_STATS_TYPE1, TEST_COOKIE); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL); - ret = nativeClient_.GetCookieStats(stats, TEST_STATS_TYPE2, TEST_COOKIE); + ret = nativeClient->GetCookieStats(stats, TEST_STATS_TYPE2, TEST_COOKIE); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_INTERNAL); } HWTEST_F(NetsysNativeClientTest, GetNetworkSharingTypeTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::set sharingTypeIsOn; - int32_t ret = nativeClient_.GetNetworkSharingType(sharingTypeIsOn); + int32_t ret = nativeClient->GetNetworkSharingType(sharingTypeIsOn); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, UpdateNetworkSharingTypeTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint64_t type = 0; bool isOpen = true; - int32_t ret = nativeClient_.UpdateNetworkSharingType(type, isOpen); + int32_t ret = nativeClient->UpdateNetworkSharingType(type, isOpen); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, NetsysNativeClientBranchTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint32_t timeStep = 0; sptr callback = nullptr; - int32_t ret = nativeClient_.RegisterDnsResultCallback(callback, timeStep); + int32_t ret = nativeClient->RegisterDnsResultCallback(callback, timeStep); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL); - ret = nativeClient_.UnregisterDnsResultCallback(callback); + ret = nativeClient->UnregisterDnsResultCallback(callback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL); sptr queryCallback = nullptr; - ret = nativeClient_.RegisterDnsQueryResultCallback(queryCallback); + ret = nativeClient->RegisterDnsQueryResultCallback(queryCallback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL); - ret = nativeClient_.UnregisterDnsQueryResultCallback(queryCallback); + ret = nativeClient->UnregisterDnsQueryResultCallback(queryCallback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL); } HWTEST_F(NetsysNativeClientTest, SetIpv6PrivacyExtensionsTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint32_t on = 0; std::string interface = "wlan0"; - int32_t ret = nativeClient_.SetIpv6PrivacyExtensions(interface, on); + int32_t ret = nativeClient->SetIpv6PrivacyExtensions(interface, on); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.SetEnableIpv6(interface, on); + ret = nativeClient->SetEnableIpv6(interface, on); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, SetNetworkAccessPolicy001, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint32_t uid = 0; NetworkAccessPolicy netAccessPolicy; netAccessPolicy.wifiAllow = false; netAccessPolicy.cellularAllow = false; bool reconfirmFlag = true; - int32_t ret = nativeClient_.SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag); + int32_t ret = nativeClient->SetNetworkAccessPolicy(uid, netAccessPolicy, reconfirmFlag); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, NotifyNetBearerTypeChange001, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::set bearerTypes; bearerTypes.insert(NetManagerStandard::NetBearType::BEARER_CELLULAR); - int32_t ret = nativeClient_.NotifyNetBearerTypeChange(bearerTypes); + int32_t ret = nativeClient->NotifyNetBearerTypeChange(bearerTypes); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, DeleteNetworkAccessPolicy001, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint32_t uid = 0; - int32_t ret = nativeClient_.DeleteNetworkAccessPolicy(uid); + int32_t ret = nativeClient->DeleteNetworkAccessPolicy(uid); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, CloseSocketsUid001, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::string ipAddr = ""; uint32_t uid = 1000; - int32_t ret = nativeClient_.CloseSocketsUid(ipAddr, uid); + int32_t ret = nativeClient->CloseSocketsUid(ipAddr, uid); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, SetBrokerUidAccessPolicyMapTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::unordered_map params; - int32_t ret = nativeClient_.SetBrokerUidAccessPolicyMap(params); + int32_t ret = nativeClient->SetBrokerUidAccessPolicyMap(params); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, SetBrokerUidAccessPolicyMapTest002, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::unordered_map params; params.emplace(TEST_UID, TEST_UID); - int32_t ret = nativeClient_.SetBrokerUidAccessPolicyMap(params); + int32_t ret = nativeClient->SetBrokerUidAccessPolicyMap(params); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, DelBrokerUidAccessPolicyMapTest001, TestSize.Level1) { - int32_t ret = nativeClient_.DelBrokerUidAccessPolicyMap(TEST_UID); + auto nativeClient = std::make_shared(); + int32_t ret = nativeClient->DelBrokerUidAccessPolicyMap(TEST_UID); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } #ifdef FEATURE_WEARABLE_DISTRIBUTED_NET_ENABLE HWTEST_F(NetsysNativeClientTest, DisableWearableDistributedNetForward, TestSize.Level1) { - int32_t ret = nativeClient_.EnableWearableDistributedNetForward(8001, 8002); + auto nativeClient = std::make_shared(); + int32_t ret = nativeClient->EnableWearableDistributedNetForward(8001, 8002); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.DisableWearableDistributedNetForward(); + ret = nativeClient->DisableWearableDistributedNetForward(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } #endif HWTEST_F(NetsysNativeClientTest, EnableDistributedClientNet001, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::string virnicAddr = "1.189.55.61"; std::string iif = "lo"; - int32_t ret = nativeClient_.EnableDistributedClientNet(virnicAddr, iif); + int32_t ret = nativeClient->EnableDistributedClientNet(virnicAddr, iif); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); bool isServer = false; - ret = nativeClient_.DisableDistributedNet(isServer); + ret = nativeClient->DisableDistributedNet(isServer); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, EnableDistributedServerNet001, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::string iif = "lo"; std::string devIface = "lo"; std::string dstAddr = "1.189.55.61"; - int32_t ret = nativeClient_.EnableDistributedServerNet(iif, devIface, dstAddr); + int32_t ret = nativeClient->EnableDistributedServerNet(iif, devIface, dstAddr); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); bool isServer = true; - ret = nativeClient_.DisableDistributedNet(isServer); + ret = nativeClient->DisableDistributedNet(isServer); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, GetNetworkCellularSharingTraffic001, TestSize.Level1) { + auto nativeClient = std::make_shared(); nmd::NetworkSharingTraffic traffic; std::string ifaceName = "virnic"; - int32_t ret = nativeClient_.GetNetworkCellularSharingTraffic(traffic, ifaceName); + int32_t ret = nativeClient->GetNetworkCellularSharingTraffic(traffic, ifaceName); EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, SetGetClearNetStateTrafficMap001, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint8_t flag = 1; uint64_t availableTraffic = 1000000; - int32_t ret = nativeClient_.SetNetStateTrafficMap(flag, availableTraffic); + int32_t ret = nativeClient->SetNetStateTrafficMap(flag, availableTraffic); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.GetNetStateTrafficMap(flag, availableTraffic); + ret = nativeClient->GetNetStateTrafficMap(flag, availableTraffic); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.ClearIncreaseTrafficMap(); + ret = nativeClient->ClearIncreaseTrafficMap(); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.DeleteIncreaseTrafficMap(12); // 12:ifIndex + ret = nativeClient->DeleteIncreaseTrafficMap(12); // 12:ifIndex EXPECT_TRUE(ret == NetManagerStandard::NETMANAGER_SUCCESS || ret == NETMANAGER_ERROR); } HWTEST_F(NetsysNativeClientTest, UpdateIfIndexMap001, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint8_t key = 1; uint64_t index = 10; - int32_t ret = nativeClient_.UpdateIfIndexMap(key, index); + int32_t ret = nativeClient->UpdateIfIndexMap(key, index); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, RegisterNetsysTrafficCallback001, TestSize.Level1) { + auto nativeClient = std::make_shared(); sptr callback = nullptr; - int32_t ret = nativeClient_.RegisterNetsysTrafficCallback(callback); + int32_t ret = nativeClient->RegisterNetsysTrafficCallback(callback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL); } HWTEST_F(NetsysNativeClientTest, StartStopClat001, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::string interfaceName = "eth0"; int32_t netId = 1; std::string nat64PrefixStr = "2001:db8::/64"; - int32_t ret = nativeClient_.StartClat(interfaceName, netId, nat64PrefixStr); + int32_t ret = nativeClient->StartClat(interfaceName, netId, nat64PrefixStr); EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); - ret = nativeClient_.StopClat(interfaceName); + ret = nativeClient->StopClat(interfaceName); EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, SetNicTrafficAllowed001, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::vector ifaceNames = {"eth0", "wlan0"}; bool status = true; - int32_t ret = nativeClient_.SetNicTrafficAllowed(ifaceNames, status); + int32_t ret = nativeClient->SetNicTrafficAllowed(ifaceNames, status); EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); } @@ -590,59 +623,58 @@ HWTEST_F(NetsysNativeClientTest, NetsysNativeClientTest015, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, DelInterfaceAddressTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); std::string netCapabilities = ""; - auto ret = nativeClient_.DelInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH, netCapabilities); + auto ret = nativeClient->DelInterfaceAddress(IF_NAME, IP_ADDR, PREFIX_LENGTH, netCapabilities); EXPECT_EQ(ret, 0); } HWTEST_F(NetsysNativeClientTest, OnRemoteDiedTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); wptr remote = nullptr; - nativeClient_.OnRemoteDied(remote); + nativeClient->OnRemoteDied(remote); int handle = 1; sptr result = nullptr; std::u16string descriptor = std::u16string(); result = new (std::nothrow) IPCObjectProxy(handle, descriptor); IRemoteObject *object = result.GetRefPtr(); remote = object; - EXPECT_NE(nativeClient_.netsysNativeService_, nullptr); - nativeClient_.netsysNativeService_ = nullptr; - nativeClient_.OnRemoteDied(remote); + EXPECT_NE(nativeClient->netsysNativeService_, nullptr); + nativeClient->netsysNativeService_ = nullptr; + nativeClient->OnRemoteDied(remote); } HWTEST_F(NetsysNativeClientTest, UnRegisterNetsysTrafficCallback001, TestSize.Level1) { + auto nativeClient = std::make_shared(); sptr callback = nullptr; - int32_t ret = nativeClient_.UnRegisterNetsysTrafficCallback(callback); + int32_t ret = nativeClient->UnRegisterNetsysTrafficCallback(callback); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_LOCAL_PTR_NULL); } -HWTEST_F(NetsysNativeClientTest, FlushDnsCache001, TestSize.Level1) -{ - uint16_t netId = NET_ID; - int32_t ret = nativeClient_.FlushDnsCache(netId); - EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); -} - HWTEST_F(NetsysNativeClientTest, FlushDnsCache002, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint16_t netId = 0; - int32_t ret = nativeClient_.FlushDnsCache(netId); + int32_t ret = nativeClient->FlushDnsCache(netId); EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, SetDnsCacheTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint16_t netId = 101; std::string testHost = "test"; AddrInfo info; - int32_t ret = nativeClient_.SetDnsCache(netId, testHost, info); + int32_t ret = nativeClient->SetDnsCache(netId, testHost, info); EXPECT_TRUE(ret == NetManagerStandard::NETMANAGER_SUCCESS || ret == 400); } HWTEST_F(NetsysNativeClientTest, OnDnsQueryResultReportTest001, TestSize.Level1) { - NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClient); uint32_t size = 1; OHOS::NetsysNative::NetDnsQueryResultReport netDnsResultReport{}; std::list res = {netDnsResultReport}; @@ -652,7 +684,8 @@ HWTEST_F(NetsysNativeClientTest, OnDnsQueryResultReportTest001, TestSize.Level1) HWTEST_F(NetsysNativeClientTest, OnDnsQueryAbnormalReportTest001, TestSize.Level1) { - NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClientInstance_); + auto nativeClient = std::make_shared(); + NetsysNativeClient::NativeNetDnsResultCallback notifyCallback(nativeClient); uint32_t eventfailcause = 1; OHOS::NetsysNative::NetDnsQueryResultReport netDnsResultReport{}; int32_t ret = notifyCallback.OnDnsQueryAbnormalReport(eventfailcause, netDnsResultReport); @@ -662,30 +695,41 @@ HWTEST_F(NetsysNativeClientTest, OnDnsQueryAbnormalReportTest001, TestSize.Level #ifdef FEATURE_ENTERPRISE_ROUTE_CUSTOM HWTEST_F(NetsysNativeClientTest, UpdateEnterpriseRouteTest001, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint32_t uid = 20000138; std::string ifname = "wlan0"; bool add = true; - auto ret = nativeClient_.UpdateEnterpriseRoute(ifname, uid, add); + auto ret = nativeClient->UpdateEnterpriseRoute(ifname, uid, add); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, UpdateEnterpriseRouteTest002, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint32_t uid = 0; std::string ifname = "wlan0"; bool add = true; - auto ret = nativeClient_.UpdateEnterpriseRoute(ifname, uid, add); + auto ret = nativeClient->UpdateEnterpriseRoute(ifname, uid, add); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_SUCCESS); } HWTEST_F(NetsysNativeClientTest, UpdateEnterpriseRouteTest003, TestSize.Level1) { + auto nativeClient = std::make_shared(); uint32_t uid = 20000138; std::string ifname = "notexist"; bool add = true; - auto ret = nativeClient_.UpdateEnterpriseRoute(ifname, uid, add); + auto ret = nativeClient->UpdateEnterpriseRoute(ifname, uid, add); EXPECT_EQ(ret, NetManagerStandard::NETMANAGER_ERR_PARAMETER_ERROR); } #endif + +HWTEST_F(NetsysNativeClientTest, FlushDnsCache001, TestSize.Level1) +{ + auto nativeClient = std::make_shared(); + uint16_t netId = 101; + int32_t ret = nativeClient->FlushDnsCache(netId); + EXPECT_NE(ret, NetManagerStandard::NETMANAGER_SUCCESS); +} } // namespace NetManagerStandard } // namespace OHOS -- Gitee