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 "net_stats_callback_proxy.h"
20 #include "common_net_stats_callback_test.h"
21
22 namespace OHOS {
23 namespace NetManagerStandard {
24 namespace {
25 using namespace testing::ext;
26 constexpr const char *TEST_IFACE = "TEST_IFACE";
27 constexpr uint32_t TEST_UID = 4454;
28
29 class MockNetIRemoteObject : public IRemoteObject {
30 public:
MockNetIRemoteObject()31 MockNetIRemoteObject() : IRemoteObject(u"mock_i_remote_object") {}
~MockNetIRemoteObject()32 ~MockNetIRemoteObject() {}
33
GetObjectRefCount()34 int32_t GetObjectRefCount() override
35 {
36 return 0;
37 }
38
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)39 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override
40 {
41 return 0;
42 }
43
IsProxyObject() const44 bool IsProxyObject() const override
45 {
46 return true;
47 }
48
CheckObjectLegality() const49 bool CheckObjectLegality() const override
50 {
51 return true;
52 }
53
AddDeathRecipient(const sptr<DeathRecipient> & recipient)54 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) override
55 {
56 return true;
57 }
58
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)59 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) override
60 {
61 return true;
62 }
63
Marshalling(Parcel & parcel) const64 bool Marshalling(Parcel &parcel) const override
65 {
66 return true;
67 }
68
AsInterface()69 sptr<IRemoteBroker> AsInterface() override
70 {
71 return nullptr;
72 }
73
Dump(int fd,const std::vector<std::u16string> & args)74 int Dump(int fd, const std::vector<std::u16string> &args) override
75 {
76 return 0;
77 }
78
GetObjectDescriptor() const79 std::u16string GetObjectDescriptor() const
80 {
81 std::u16string descriptor = std::u16string();
82 return descriptor;
83 }
84 };
85
86 class NetStatsCallbackNotifyTest {
87 public:
88 NetStatsCallbackNotifyTest() = default;
89 ~NetStatsCallbackNotifyTest() = default;
90
RegisterNetStatsCbChanged(sptr<NetStatsCallbackStub> & callback)91 void RegisterNetStatsCbChanged(sptr<NetStatsCallbackStub> &callback)
92 {
93 netStatsCb_ = callback;
94 }
95
NotifyNetIfaceStatsChangedNoString()96 int32_t NotifyNetIfaceStatsChangedNoString()
97 {
98 MessageParcel dataErr;
99 if (!dataErr.WriteInterfaceToken(NetStatsCallbackStub::GetDescriptor())) {
100 return NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
101 }
102 MessageParcel reply;
103 MessageOption option;
104 int32_t ret = netStatsCb_->OnRemoteRequest(
105 static_cast<uint32_t>(StatsCallBackInterfaceCode::NET_STATS_IFACE_CHANGED), dataErr, reply, option);
106 std::cout << "thread HandleIfaceChangedThread 001 ret:" << ret << std::endl;
107 return ret;
108 }
109
NotifyNetIfaceStatsChanged(const std::string & iface)110 int32_t NotifyNetIfaceStatsChanged(const std::string &iface)
111 {
112 MessageParcel data;
113 if (!data.WriteInterfaceToken(NetStatsCallbackStub::GetDescriptor())) {
114 return NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
115 }
116 if (!data.WriteString(iface)) {
117 return NETMANAGER_ERR_WRITE_DATA_FAIL;
118 }
119 MessageParcel reply;
120 MessageOption option;
121 int32_t ret = netStatsCb_->OnRemoteRequest(
122 static_cast<uint32_t>(StatsCallBackInterfaceCode::NET_STATS_IFACE_CHANGED), data, reply, option);
123 std::cout << "thread HandleIfaceChangedThread 002 ret:" << ret << std::endl;
124 return ret;
125 }
126
NotifyNetUidStatsChangedNoString()127 int32_t NotifyNetUidStatsChangedNoString()
128 {
129 MessageParcel dataNoStr;
130 if (!dataNoStr.WriteInterfaceToken(NetStatsCallbackStub::GetDescriptor())) {
131 return NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
132 }
133 MessageParcel reply;
134 MessageOption option;
135 int32_t ret = netStatsCb_->OnRemoteRequest(
136 static_cast<uint32_t>(StatsCallBackInterfaceCode::NET_STATS_UID_CHANGED), dataNoStr, reply, option);
137 std::cout << "thread NetUidStatsChanged 001 ret:" << ret << std::endl;
138 return ret;
139 }
140
NotifyNetUidStatsChangedNoInt(const std::string & iface)141 int32_t NotifyNetUidStatsChangedNoInt(const std::string &iface)
142 {
143 MessageParcel dataNoInt;
144 if (!dataNoInt.WriteInterfaceToken(NetStatsCallbackStub::GetDescriptor())) {
145 return NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
146 }
147 if (!dataNoInt.WriteString(iface)) {
148 return NETMANAGER_ERR_WRITE_DATA_FAIL;
149 }
150 MessageParcel reply;
151 MessageOption option;
152 int32_t ret = netStatsCb_->OnRemoteRequest(
153 static_cast<uint32_t>(StatsCallBackInterfaceCode::NET_STATS_UID_CHANGED), dataNoInt, reply, option);
154 std::cout << "thread NetUidStatsChanged 002 ret:" << ret << std::endl;
155 return ret;
156 }
157
NotifyNetUidStatsChanged(const std::string & iface,uint32_t uid)158 int32_t NotifyNetUidStatsChanged(const std::string &iface, uint32_t uid)
159 {
160 MessageParcel data;
161 if (!data.WriteInterfaceToken(NetStatsCallbackStub::GetDescriptor())) {
162 return NETMANAGER_ERR_WRITE_DESCRIPTOR_TOKEN_FAIL;
163 }
164 if (!data.WriteString(iface)) {
165 return NETMANAGER_ERR_WRITE_DATA_FAIL;
166 }
167 if (!data.WriteUint32(uid)) {
168 return NETMANAGER_ERR_WRITE_DATA_FAIL;
169 }
170 MessageParcel reply;
171 MessageOption option;
172 int32_t ret = netStatsCb_->OnRemoteRequest(
173 static_cast<uint32_t>(StatsCallBackInterfaceCode::NET_STATS_UID_CHANGED), data, reply, option);
174 std::cout << "thread NetUidStatsChanged 003 ret:" << ret << std::endl;
175 return ret;
176 }
177
178 sptr<NetStatsCallbackStub> netStatsCb_ = nullptr;
179 };
180 } // namespace
181
182 class NetStatsCallbackInterfaceTest : public testing::Test {
183 public:
184 static void SetUpTestCase();
185 static void TearDownTestCase();
186 void SetUp();
187 void TearDown();
188
189 static inline std::shared_ptr<NetStatsCallbackNotifyTest> instance_ = nullptr;
190 };
191
SetUpTestCase()192 void NetStatsCallbackInterfaceTest::SetUpTestCase()
193 {
194 instance_ = std::make_shared<NetStatsCallbackNotifyTest>();
195 sptr<NetStatsCallbackStub> callback = new (std::nothrow) NetStatsCallbackTestCb();
196 instance_->RegisterNetStatsCbChanged(callback);
197 }
198
TearDownTestCase()199 void NetStatsCallbackInterfaceTest::TearDownTestCase() {}
200
SetUp()201 void NetStatsCallbackInterfaceTest::SetUp() {}
202
TearDown()203 void NetStatsCallbackInterfaceTest::TearDown() {}
204
205 HWTEST_F(NetStatsCallbackInterfaceTest, NotifyNetIfaceStatsChangedTest001, TestSize.Level1)
206 {
207 int32_t ret = instance_->NotifyNetIfaceStatsChangedNoString();
208 EXPECT_NE(ret, NETMANAGER_SUCCESS);
209 ret = instance_->NotifyNetIfaceStatsChanged(TEST_IFACE);
210 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
211 }
212
213 HWTEST_F(NetStatsCallbackInterfaceTest, NotifyNetUidStatsChangedTest001, TestSize.Level1)
214 {
215 int32_t ret = instance_->NotifyNetUidStatsChangedNoString();
216 EXPECT_NE(ret, NETMANAGER_SUCCESS);
217 ret = instance_->NotifyNetUidStatsChangedNoInt(TEST_IFACE);
218 EXPECT_NE(ret, NETMANAGER_SUCCESS);
219 ret = instance_->NotifyNetUidStatsChanged(TEST_IFACE, TEST_UID);
220 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
221 }
222
223 HWTEST_F(NetStatsCallbackInterfaceTest, NetIfaceStatsChangedTest001, TestSize.Level1)
224 {
225 sptr<IRemoteObject> impl = new (std::nothrow) MockNetIRemoteObject();
226 sptr<NetStatsCallbackProxy> netCbProxy = new (std::nothrow) NetStatsCallbackProxy(impl);
227 int32_t ret = netCbProxy->NetIfaceStatsChanged(TEST_IFACE);
228 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
229
230 ret = netCbProxy->NetUidStatsChanged(TEST_IFACE, TEST_UID);
231 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
232 }
233 } // namespace NetManagerStandard
234 } // namespace OHOS
235