1 /*
2  * Copyright (C) 2023-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include <iostream>
18 
19 #include "common_mock_net_remote_object_test.h"
20 #include "common_net_stats_callback_test.h"
21 #include "net_stats_callback_proxy.h"
22 
23 namespace OHOS {
24 namespace NetManagerStandard {
25 namespace {
26 using namespace testing::ext;
27 constexpr const char *TEST_IFACE = "TEST_IFACE";
28 constexpr uint32_t TEST_UID = 4454;
29 
30 class NetStatsCallbackNotifyTest {
31 public:
32     NetStatsCallbackNotifyTest() = default;
33     ~NetStatsCallbackNotifyTest() = default;
34 
RegisterNetStatsCbChanged(sptr<NetStatsCallbackStub> & callback)35     void RegisterNetStatsCbChanged(sptr<NetStatsCallbackStub> &callback)
36     {
37         netStatsCb_ = callback;
38     }
39 
NotifyNetIfaceStatsChangedNoString()40     int32_t NotifyNetIfaceStatsChangedNoString()
41     {
42         MessageParcel dataErr;
43         if (!dataErr.WriteInterfaceToken(NetStatsCallbackStub::GetDescriptor())) {
44             return NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
45         }
46         MessageParcel reply;
47         MessageOption option;
48         int32_t ret = netStatsCb_->OnRemoteRequest(
49             static_cast<uint32_t>(StatsCallBackInterfaceCode::NET_STATS_IFACE_CHANGED), dataErr, reply, option);
50         std::cout << "thread HandleIfaceChangedThread 001 ret:" << ret << std::endl;
51         return ret;
52     }
53 
NotifyNetIfaceStatsChanged(const std::string & iface)54     int32_t NotifyNetIfaceStatsChanged(const std::string &iface)
55     {
56         MessageParcel data;
57         if (!data.WriteInterfaceToken(NetStatsCallbackStub::GetDescriptor())) {
58             return NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
59         }
60         if (!data.WriteString(iface)) {
61             return NETMANAGER_ERR_WRITE_DATA_FAIL;
62         }
63         MessageParcel reply;
64         MessageOption option;
65         int32_t ret = netStatsCb_->OnRemoteRequest(
66             static_cast<uint32_t>(StatsCallBackInterfaceCode::NET_STATS_IFACE_CHANGED), data, reply, option);
67         std::cout << "thread HandleIfaceChangedThread 002 ret:" << ret << std::endl;
68         return ret;
69     }
70 
NotifyNetUidStatsChangedNoString()71     int32_t NotifyNetUidStatsChangedNoString()
72     {
73         MessageParcel dataNoStr;
74         if (!dataNoStr.WriteInterfaceToken(NetStatsCallbackStub::GetDescriptor())) {
75             return NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
76         }
77         MessageParcel reply;
78         MessageOption option;
79         int32_t ret = netStatsCb_->OnRemoteRequest(
80             static_cast<uint32_t>(StatsCallBackInterfaceCode::NET_STATS_UID_CHANGED), dataNoStr, reply, option);
81         std::cout << "thread NetUidStatsChanged 001 ret:" << ret << std::endl;
82         return ret;
83     }
84 
NotifyNetUidStatsChangedNoInt(const std::string & iface)85     int32_t NotifyNetUidStatsChangedNoInt(const std::string &iface)
86     {
87         MessageParcel dataNoInt;
88         if (!dataNoInt.WriteInterfaceToken(NetStatsCallbackStub::GetDescriptor())) {
89             return NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
90         }
91         if (!dataNoInt.WriteString(iface)) {
92             return NETMANAGER_ERR_WRITE_DATA_FAIL;
93         }
94         MessageParcel reply;
95         MessageOption option;
96         int32_t ret = netStatsCb_->OnRemoteRequest(
97             static_cast<uint32_t>(StatsCallBackInterfaceCode::NET_STATS_UID_CHANGED), dataNoInt, reply, option);
98         std::cout << "thread NetUidStatsChanged 002 ret:" << ret << std::endl;
99         return ret;
100     }
101 
NotifyNetUidStatsChanged(const std::string & iface,uint32_t uid)102     int32_t NotifyNetUidStatsChanged(const std::string &iface, uint32_t uid)
103     {
104         MessageParcel data;
105         if (!data.WriteInterfaceToken(NetStatsCallbackStub::GetDescriptor())) {
106             return NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
107         }
108         if (!data.WriteString(iface)) {
109             return NETMANAGER_ERR_WRITE_DATA_FAIL;
110         }
111         if (!data.WriteUint32(uid)) {
112             return NETMANAGER_ERR_WRITE_DATA_FAIL;
113         }
114         MessageParcel reply;
115         MessageOption option;
116         int32_t ret = netStatsCb_->OnRemoteRequest(
117             static_cast<uint32_t>(StatsCallBackInterfaceCode::NET_STATS_UID_CHANGED), data, reply, option);
118         std::cout << "thread NetUidStatsChanged 003 ret:" << ret << std::endl;
119         return ret;
120     }
121 
122     sptr<NetStatsCallbackStub> netStatsCb_ = nullptr;
123 };
124 } // namespace
125 
126 class NetStatsCallbackInterfaceTest : public testing::Test {
127 public:
128     static void SetUpTestCase();
129     static void TearDownTestCase();
130     void SetUp();
131     void TearDown();
132 
133     static inline std::shared_ptr<NetStatsCallbackNotifyTest> instance_ = nullptr;
134 };
135 
SetUpTestCase()136 void NetStatsCallbackInterfaceTest::SetUpTestCase()
137 {
138     instance_ = std::make_shared<NetStatsCallbackNotifyTest>();
139     sptr<NetStatsCallbackStub> callback = new (std::nothrow) NetStatsCallbackTestCb();
140     instance_->RegisterNetStatsCbChanged(callback);
141 }
142 
TearDownTestCase()143 void NetStatsCallbackInterfaceTest::TearDownTestCase() {}
144 
SetUp()145 void NetStatsCallbackInterfaceTest::SetUp() {}
146 
TearDown()147 void NetStatsCallbackInterfaceTest::TearDown() {}
148 
149 HWTEST_F(NetStatsCallbackInterfaceTest, NotifyNetIfaceStatsChangedTest001, TestSize.Level1)
150 {
151     int32_t ret = instance_->NotifyNetIfaceStatsChangedNoString();
152     EXPECT_NE(ret, NETMANAGER_SUCCESS);
153     ret = instance_->NotifyNetIfaceStatsChanged(TEST_IFACE);
154     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
155 }
156 
157 HWTEST_F(NetStatsCallbackInterfaceTest, NotifyNetUidStatsChangedTest001, TestSize.Level1)
158 {
159     int32_t ret = instance_->NotifyNetUidStatsChangedNoString();
160     EXPECT_NE(ret, NETMANAGER_SUCCESS);
161     ret = instance_->NotifyNetUidStatsChangedNoInt(TEST_IFACE);
162     EXPECT_NE(ret, NETMANAGER_SUCCESS);
163     ret = instance_->NotifyNetUidStatsChanged(TEST_IFACE, TEST_UID);
164     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
165 }
166 
167 HWTEST_F(NetStatsCallbackInterfaceTest, NetIfaceStatsChangedTest001, TestSize.Level1)
168 {
169     sptr<IRemoteObject> impl = new (std::nothrow) MockNetIRemoteObject();
170     sptr<NetStatsCallbackProxy> netCbProxy = new (std::nothrow) NetStatsCallbackProxy(impl);
171     int32_t ret = netCbProxy->NetIfaceStatsChanged(TEST_IFACE);
172     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
173 
174     ret = netCbProxy->NetUidStatsChanged(TEST_IFACE, TEST_UID);
175     EXPECT_EQ(ret, NETMANAGER_SUCCESS);
176 }
177 } // namespace NetManagerStandard
178 } // namespace OHOS
179