1 /*
2 * Copyright (C) 2022 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 #ifdef FEATURE_NETWORK_SUPPORT
17 #include "network_ability_test.h"
18
19 #include <cstdlib>
20 #include "accesstoken_kit.h"
21 #include "if_system_ability_manager.h"
22 #include "ipc_skeleton.h"
23 #include "iservice_registry.h"
24 #include "message_parcel.h"
25 #include "nativetoken_kit.h"
26 #include "system_ability_definition.h"
27 #include "token_setproc.h"
28
29 #include "common_utils.h"
30 #include "constant_definition.h"
31 #include "location.h"
32 #include "location_dumper.h"
33 #include "location_log.h"
34 #include "network_ability_skeleton.h"
35
36 #include "network_callback_host.h"
37
38 using namespace testing::ext;
39 namespace OHOS {
40 namespace Location {
41 const int32_t LOCATION_PERM_NUM = 4;
42 const std::string ARGS_HELP = "-h";
SetUp()43 void NetworkAbilityTest::SetUp()
44 {
45 /*
46 * @tc.setup: Get system ability's pointer and get sa proxy object.
47 */
48 MockNativePermission();
49 ability_ = new (std::nothrow) NetworkAbility();
50 EXPECT_NE(nullptr, ability_);
51 proxy_ = new (std::nothrow) NetworkAbilityProxy(ability_);
52 EXPECT_NE(nullptr, proxy_);
53 }
54
TearDown()55 void NetworkAbilityTest::TearDown()
56 {
57 /*
58 * @tc.teardown: release memory.
59 */
60 proxy_ = nullptr;
61 }
62
MockNativePermission()63 void NetworkAbilityTest::MockNativePermission()
64 {
65 const char *perms[] = {
66 ACCESS_LOCATION.c_str(), ACCESS_APPROXIMATELY_LOCATION.c_str(),
67 ACCESS_BACKGROUND_LOCATION.c_str(), MANAGE_SECURE_SETTINGS.c_str(),
68 };
69 NativeTokenInfoParams infoInstance = {
70 .dcapsNum = 0,
71 .permsNum = LOCATION_PERM_NUM,
72 .aclsNum = 0,
73 .dcaps = nullptr,
74 .perms = perms,
75 .acls = nullptr,
76 .processName = "NetworkAbilityTest",
77 .aplStr = "system_basic",
78 };
79 uint64_t tokenId = GetAccessTokenId(&infoInstance);
80 SetSelfTokenID(tokenId);
81 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
82 }
83
84 /*
85 * @tc.name: SendLocationRequest001
86 * @tc.desc: Build Request, marshall and unmarshall data Then Send it
87 * @tc.type: FUNC
88 */
89 HWTEST_F(NetworkAbilityTest, SendLocationRequest001, TestSize.Level1)
90 {
91 GTEST_LOG_(INFO)
92 << "NetworkAbilityTest, SendLocationRequest001, TestSize.Level1";
93 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SendLocationRequest001 begin");
94 /*
95 * @tc.steps: step1. build location request data.
96 */
97 std::unique_ptr<WorkRecord> workRecord = std::make_unique<WorkRecord>();
98 int num = 2;
99 for (int i = 0; i < num; i++) {
100 int uid = i + 1;
101 int pid = i + 2;
102 int timeInterval = i;
103 std::string name = "nameForTest";
104 std::string uuid = std::to_string(CommonUtils::IntRandom(MIN_INT_RANDOM, MAX_INT_RANDOM));
105 workRecord->Add(uid, pid, name, timeInterval, uuid);
106 }
107 /*
108 * @tc.steps: step2. send location request
109 * @tc.expected: step2. no exception happens.
110 */
111 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SendLocationRequest(*workRecord));
112 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SendLocationRequest001 end");
113 }
114
115 /*
116 * @tc.name: SetEnableAndDisable001
117 * @tc.desc: Test disable and enable system ability
118 * @tc.type: FUNC
119 */
120 HWTEST_F(NetworkAbilityTest, SetEnableAndDisable001, TestSize.Level1)
121 {
122 GTEST_LOG_(INFO)
123 << "NetworkAbilityTest, SetEnableAndDisable001, TestSize.Level1";
124 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable001 begin");
125 /*
126 * @tc.steps: step1.remove SA
127 * @tc.expected: step1. object1 is null.
128 */
129 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(false)); // after mock, sa obj is nullptr
130
131 /*
132 * @tc.steps: step2. test enable SA
133 * @tc.expected: step2. object2 is not null.
134 */
135 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetEnable(true)); // after mock, sa obj is nullptr
136 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SetEnableAndDisable001 end");
137 }
138
139 /*
140 * @tc.name: SelfRequest001
141 * @tc.desc: test self request function
142 * @tc.type: FUNC
143 */
144 HWTEST_F(NetworkAbilityTest, SelfRequest001, TestSize.Level1)
145 {
146 GTEST_LOG_(INFO)
147 << "NetworkAbilityTest, SelfRequest001, TestSize.Level1";
148 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SelfRequest001 begin");
149 /*
150 * @tc.steps: step1. send location request
151 * @tc.expected: step1. no exception happens.
152 */
153 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SelfRequest(true));
154 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SelfRequest001 end");
155 }
156
157 /*
158 * @tc.name: SelfRequest002
159 * @tc.desc: test self request function
160 * @tc.type: FUNC
161 */
162 HWTEST_F(NetworkAbilityTest, SelfRequest002, TestSize.Level1)
163 {
164 GTEST_LOG_(INFO)
165 << "NetworkAbilityTest, SelfRequest002, TestSize.Level1";
166 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SelfRequest002 begin");
167 /*
168 * @tc.steps: step1. send location request
169 * @tc.expected: step1. no exception happens.
170 */
171 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SelfRequest(false));
172 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] SelfRequest002 end");
173 }
174
175 HWTEST_F(NetworkAbilityTest, NetworkLocationMock001, TestSize.Level1)
176 {
177 GTEST_LOG_(INFO)
178 << "NetworkAbilityTest, NetworkLocationMock001, TestSize.Level1";
179 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkLocationMock001 begin");
180 int timeInterval = 1;
181 std::vector<std::shared_ptr<Location>> locations;
182 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->EnableMock());
183 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetMocked(timeInterval, locations));
184
185 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->DisableMock());
186 EXPECT_EQ(ERRCODE_NOT_SUPPORTED, proxy_->SetMocked(timeInterval, locations));
187 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkLocationMock001 end");
188 }
189
190 HWTEST_F(NetworkAbilityTest, NetworkOnStartAndOnStop001, TestSize.Level1)
191 {
192 GTEST_LOG_(INFO)
193 << "NetworkAbilityTest, NetworkOnStartAndOnStop001, TestSize.Level1";
194 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop001 begin");
195 ability_->OnStart(); // start ability
196 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
197 (ServiceRunningState)ability_->QueryServiceState()); // after mock
198 ability_->OnStart(); // start ability again
199 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
200 (ServiceRunningState)ability_->QueryServiceState()); // after mock
201
202 ability_->OnStop(); // stop ability
203 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
204 (ServiceRunningState)ability_->QueryServiceState()); // after mock
205 ability_->OnStart(); // restart ability
206 EXPECT_EQ(ServiceRunningState::STATE_NOT_START,
207 (ServiceRunningState)ability_->QueryServiceState()); // after mock
208 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkOnStartAndOnStop001 end");
209 }
210
211
212 HWTEST_F(NetworkAbilityTest, NetworkDump001, TestSize.Level1)
213 {
214 GTEST_LOG_(INFO)
215 << "NetworkAbilityTest, NetworkDump001, TestSize.Level1";
216 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkDump001 begin");
217 int32_t fd = 0;
218 std::vector<std::u16string> args;
219 std::u16string arg1 = Str8ToStr16("arg1");
220 args.emplace_back(arg1);
221 std::u16string arg2 = Str8ToStr16("arg2");
222 args.emplace_back(arg2);
223 std::u16string arg3 = Str8ToStr16("arg3");
224 args.emplace_back(arg3);
225 std::u16string arg4 = Str8ToStr16("arg4");
226 args.emplace_back(arg4);
227 EXPECT_EQ(ERR_OK, ability_->Dump(fd, args));
228
229 std::vector<std::u16string> emptyArgs;
230 EXPECT_EQ(ERR_OK, ability_->Dump(fd, emptyArgs));
231
232 std::vector<std::u16string> helpArgs;
233 std::u16string helpArg1 = Str8ToStr16(ARGS_HELP);
234 helpArgs.emplace_back(helpArg1);
235 EXPECT_EQ(ERR_OK, ability_->Dump(fd, helpArgs));
236 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkDump001 end");
237 }
238
239 HWTEST_F(NetworkAbilityTest, NetworkSendReportMockLocationEvent001, TestSize.Level1)
240 {
241 GTEST_LOG_(INFO)
242 << "NetworkAbilityTest, NetworkSendReportMockLocationEvent001, TestSize.Level1";
243 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent001 begin");
244 ability_->SendReportMockLocationEvent(); // clear location mock
245
246 int timeInterval = 0;
247 std::vector<std::shared_ptr<Location>> locations;
248 Parcel parcel;
249 parcel.WriteDouble(10.6); // latitude
250 parcel.WriteDouble(10.5); // longitude
251 parcel.WriteDouble(10.4); // altitude
252 parcel.WriteDouble(1.0); // accuracy
253 parcel.WriteDouble(5.0); // speed
254 parcel.WriteDouble(10); // direction
255 parcel.WriteInt64(1611000000); // timestamp
256 parcel.WriteInt64(1611000000); // time since boot
257 parcel.WriteString16(u"additions"); // additions
258 parcel.WriteInt64(1); // additionSize
259 parcel.WriteBool(true); // isFromMock is true
260 parcel.WriteInt32(1); // source type
261 parcel.WriteInt32(0); // floor no.
262 parcel.WriteDouble(1000.0); // floor acc
263 locations.push_back(Location::UnmarshallingShared(parcel));
264 EXPECT_EQ(ERRCODE_SUCCESS, ability_->EnableMock());
265 EXPECT_EQ(ERRCODE_SUCCESS, ability_->SetMocked(timeInterval, locations));
266 sleep(2);
267 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent001 end");
268 }
269
270 HWTEST_F(NetworkAbilityTest, NetworkSendReportMockLocationEvent002, TestSize.Level1)
271 {
272 GTEST_LOG_(INFO)
273 << "NetworkAbilityTest, NetworkSendReportMockLocationEvent002, TestSize.Level1";
274 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent002 begin");
275 ability_->SendReportMockLocationEvent(); // clear location mock
276
277 int timeInterval = 0;
278 std::vector<std::shared_ptr<Location>> locations;
279 Parcel parcel;
280 parcel.WriteDouble(10.6); // latitude
281 parcel.WriteDouble(10.5); // longitude
282 parcel.WriteDouble(10.4); // altitude
283 parcel.WriteDouble(1.0); // accuracy
284 parcel.WriteDouble(5.0); // speed
285 parcel.WriteDouble(10); // direction
286 parcel.WriteInt64(1611000000); // timestamp
287 parcel.WriteInt64(1611000000); // time since boot
288 parcel.WriteString16(u"additions"); // additions
289 parcel.WriteInt64(1); // additionSize
290 parcel.WriteBool(false); // isFromMock is false
291 parcel.WriteInt32(1); // source type
292 parcel.WriteInt32(0); // floor no.
293 parcel.WriteDouble(1000.0); // floor acc
294 locations.push_back(Location::UnmarshallingShared(parcel));
295 EXPECT_EQ(ERRCODE_SUCCESS, ability_->EnableMock());
296 EXPECT_EQ(ERRCODE_SUCCESS, ability_->SetMocked(timeInterval, locations));
297 sleep(2);
298 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkSendReportMockLocationEvent002 end");
299 }
300
301 /*
302 * @tc.name: NetworkConnectNlpService001
303 * @tc.desc: connect nlp service
304 * @tc.type: FUNC
305 */
306 HWTEST_F(NetworkAbilityTest, NetworkConnectNlpService001, TestSize.Level1)
307 {
308 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService001 begin");
309 EXPECT_EQ(false, ability_->ReConnectNlpService());
310 LBSLOGI(NETWORK_TEST, "[NetworkAbilityTest] NetworkConnectNlpService001 end");
311 }
312
313 HWTEST_F(NetworkAbilityTest, ReConnectNlpService001, TestSize.Level1)
314 {
315 GTEST_LOG_(INFO)
316 << "NetworkAbilityTest, ReConnectNlpService001, TestSize.Level1";
317 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService001 begin");
318 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
319 ability->nlpServiceReady_ = true;
320 EXPECT_EQ(true, ability->ReConnectNlpService()); // Connect success
321 LBSLOGI(NETWORK, "[NetworkAbilityTest] ReConnectNlpService001 end");
322 }
323
324 HWTEST_F(NetworkAbilityTest, NotifyConnected001, TestSize.Level1)
325 {
326 GTEST_LOG_(INFO)
327 << "NetworkAbilityTest, NotifyConnected001, TestSize.Level1";
328 LBSLOGI(NETWORK, "[NetworkAbilityTest] NotifyConnected001 begin");
329 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
330 sptr<IRemoteObject> obj = nullptr;
331 ability->NotifyConnected(obj);
332 EXPECT_EQ(nullptr, ability->nlpServiceProxy_);
333 EXPECT_EQ(true, ability->nlpServiceReady_);
334
335 ability->NotifyDisConnected();
336 EXPECT_EQ(nullptr, ability->nlpServiceProxy_);
337 EXPECT_EQ(false, ability->nlpServiceReady_);
338 LBSLOGI(NETWORK, "[NetworkAbilityTest] NotifyConnected001 end");
339 }
340
341 HWTEST_F(NetworkAbilityTest, SendLocationRequest002, TestSize.Level1)
342 {
343 GTEST_LOG_(INFO)
344 << "NetworkAbilityTest, SendLocationRequest002, TestSize.Level1";
345 LBSLOGI(NETWORK, "[NetworkAbilityTest] SendLocationRequest002 begin");
346 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
347 WorkRecord workRecord;
348 ability->SendLocationRequest(workRecord);
349 LBSLOGI(NETWORK, "[NetworkAbilityTest] SendLocationRequest002 end");
350 }
351
352 HWTEST_F(NetworkAbilityTest, RequestRecord001, TestSize.Level1)
353 {
354 GTEST_LOG_(INFO)
355 << "NetworkAbilityTest, RequestRecord001, TestSize.Level1";
356 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestRecord001 begin");
357 auto ability = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
358 WorkRecord workRecord;
359 ability->nlpServiceReady_ = true;
360 ability->RequestRecord(workRecord, true);
361
362 ability->nlpServiceReady_ = true;
363 ability->RequestRecord(workRecord, false);
364 LBSLOGI(NETWORK, "[NetworkAbilityTest] RequestRecord001 end");
365 }
366
367 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest001, TestSize.Level1)
368 {
369 GTEST_LOG_(INFO)
370 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest001, TestSize.Level1";
371 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest001 begin");
372 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
373 uint32_t code = static_cast<uint32_t>(ILocatorCallback::RECEIVE_LOCATION_INFO_EVENT);
374 MessageParcel data;
375 data.WriteInterfaceToken(u"location.ILocatorCallback");
376 MessageParcel reply;
377 MessageOption option;
378 EXPECT_EQ(0, callback->OnRemoteRequest(code, data, reply, option));
379 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest001 end");
380 }
381
382 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest002, TestSize.Level1)
383 {
384 GTEST_LOG_(INFO)
385 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest002, TestSize.Level1";
386 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest002 begin");
387 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
388 uint32_t code = 0;
389 MessageParcel data;
390 data.WriteInterfaceToken(u"location.ILocatorCallback");
391 MessageParcel reply;
392 MessageOption option;
393 EXPECT_EQ(0, callback->OnRemoteRequest(code, data, reply, option));
394 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest002 end");
395 }
396
397 HWTEST_F(NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest003, TestSize.Level1)
398 {
399 GTEST_LOG_(INFO)
400 << "NetworkAbilityTest, NetworkCallbackHostOnRemoteRequest003, TestSize.Level1";
401 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest003 begin");
402 sptr<NetworkCallbackHost> callback = new (std::nothrow) NetworkCallbackHost();
403 uint32_t code = 0;
404 MessageParcel data;
405 data.WriteInterfaceToken(u"wrong.interface.token");
406 MessageParcel reply;
407 MessageOption option;
408 EXPECT_EQ(-1, callback->OnRemoteRequest(code, data, reply, option));
409 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkCallbackHostOnRemoteRequest003 end");
410 }
411
412 HWTEST_F(NetworkAbilityTest, NetworkAbilityInit001, TestSize.Level1)
413 {
414 GTEST_LOG_(INFO)
415 << "NetworkAbilityTest, NetworkAbilityInit001, TestSize.Level1";
416 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityInit001 begin");
417 ability_->registerToAbility_ = false;
418 bool ret = ability_->Init(); // after mock, sa obj is nullptr
419 EXPECT_EQ(false, ret);
420
421 ability_->registerToAbility_ = true;
422 ret = ability_->Init();
423 EXPECT_EQ(true, ret);
424 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityInit001 end");
425 }
426
427 HWTEST_F(NetworkAbilityTest, NetworkAbilityConnectNlpService001, TestSize.Level1)
428 {
429 GTEST_LOG_(INFO)
430 << "NetworkAbilityTest, NetworkAbilityConnectNlpService001, TestSize.Level1";
431 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityConnectNlpService001 begin");
432 ability_->nlpServiceReady_ = true;
433 bool ret = ability_->ConnectNlpService();
434 EXPECT_EQ(true, ret);
435 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityConnectNlpService001 end");
436 }
437
438 HWTEST_F(NetworkAbilityTest, NetworkAbilityReConnectNlpService001, TestSize.Level1)
439 {
440 GTEST_LOG_(INFO)
441 << "NetworkAbilityTest, NetworkAbilityReConnectNlpService001, TestSize.Level1";
442 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityReConnectNlpService001 begin");
443 ability_->nlpServiceReady_ = true;
444 bool ret = ability_->ReConnectNlpService();
445 EXPECT_EQ(true, ret);
446 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityReConnectNlpService001 end");
447 }
448
449 HWTEST_F(NetworkAbilityTest, NetworkAbilityProcessReportLocationMock001, TestSize.Level1)
450 {
451 GTEST_LOG_(INFO)
452 << "NetworkAbilityTest, NetworkAbilityProcessReportLocationMock001, TestSize.Level1";
453 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock001 begin");
454 ability_->mockLocationIndex_ = -1;
455 ability_->networkHandler_ = nullptr;
456 ability_->ProcessReportLocationMock();
457 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilityProcessReportLocationMock001 end");
458 }
459
460 HWTEST_F(NetworkAbilityTest, NetworkAbilitySendReportMockLocationEvent001, TestSize.Level1)
461 {
462 GTEST_LOG_(INFO)
463 << "NetworkAbilityTest, NetworkAbilitySendReportMockLocationEvent001, TestSize.Level1";
464 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilitySendReportMockLocationEvent001 begin");
465 ability_->networkHandler_ = nullptr;
466 ability_->SendReportMockLocationEvent();
467
468 ability_->networkHandler_ = std::make_shared<NetworkHandler>(AppExecFwk::EventRunner::Create(true));;
469 ability_->SendReportMockLocationEvent();
470 LBSLOGI(NETWORK, "[NetworkAbilityTest] NetworkAbilitySendReportMockLocationEvent001 end");
471 }
472
473 HWTEST_F(NetworkAbilityTest, NetworkAbilitySendMessage001, TestSize.Level1)
474 {
475 GTEST_LOG_(INFO)
476 << "NetworkAbilityStubTest, NetworkAbilitySendMessage001, TestSize.Level1";
477 LBSLOGI(NETWORK, "[NetworkAbilityStubTest] NetworkAbilitySendMessage001 begin");
478 MessageParcel requestParcel;
479 requestParcel.WriteInterfaceToken(u"location.INetworkAbility");
480 requestParcel.WriteBuffer("data", 4);
481 requestParcel.RewindRead(0);
482
483 MessageParcel reply;
484 ability_->networkHandler_ = nullptr;
485 ability_->SendMessage(0, requestParcel, reply);
486
487 ability_->networkHandler_ = std::make_shared<NetworkHandler>(AppExecFwk::EventRunner::Create(true));;
488 ability_->SendMessage(0, requestParcel, reply);
489 LBSLOGI(NETWORK, "[NetworkAbilityStubTest] NetworkAbilitySendMessage001 end");
490 }
491 } // namespace Location
492 } // namespace OHOS
493 #endif // FEATURE_NETWORK_SUPPORT