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_GEOCODE_SUPPORT
17 #define private public
18 #include "geo_convert_service_test.h"
19 #include "geo_convert_service.h"
20 #undef private
21 
22 #include "parameters.h"
23 #include <string>
24 #include "string_ex.h"
25 
26 #include "accesstoken_kit.h"
27 #include "if_system_ability_manager.h"
28 #include "ipc_skeleton.h"
29 #include "iservice_registry.h"
30 #include "nativetoken_kit.h"
31 #include "system_ability_definition.h"
32 #include "token_setproc.h"
33 
34 #include <file_ex.h>
35 #include <thread>
36 #include "ability_connect_callback_interface.h"
37 #include "ability_connect_callback_stub.h"
38 #include "ability_manager_client.h"
39 #include "geo_address.h"
40 #include "location_config_manager.h"
41 #include "location_sa_load_manager.h"
42 
43 #include "common_utils.h"
44 #include "constant_definition.h"
45 #include "geo_coding_mock_info.h"
46 #include "geo_convert_service.h"
47 #include "geo_convert_skeleton.h"
48 #include "location_dumper.h"
49 #include "location_log.h"
50 #include "permission_manager.h"
51 #include <gtest/gtest.h>
52 #include "mock_geo_convert_service.h"
53 
54 #include "locationhub_ipc_interface_code.h"
55 #include "location_sa_load_manager.h"
56 #include "system_ability_definition.h"
57 #include "if_system_ability_manager.h"
58 #include "iservice_registry.h"
59 #include "location_log.h"
60 
61 using namespace testing;
62 using namespace testing::ext;
63 
64 namespace OHOS {
65 namespace Location {
66 const int32_t LOCATION_PERM_NUM = 5;
67 const std::string ARGS_HELP = "-h";
SetUp()68 void GeoConvertServiceTest::SetUp()
69 {
70     /*
71      * @tc.setup: Get system ability's pointer and get sa proxy object.
72      */
73     MockNativePermission();
74     service_ = new (std::nothrow) GeoConvertService();
75     proxy_ = std::make_shared<GeoConvertProxy>(service_);
76 }
77 
TearDown()78 void GeoConvertServiceTest::TearDown()
79 {
80 }
81 
MockNativePermission()82 void GeoConvertServiceTest::MockNativePermission()
83 {
84     const char *perms[] = {
85         ACCESS_LOCATION.c_str(), ACCESS_APPROXIMATELY_LOCATION.c_str(),
86         ACCESS_BACKGROUND_LOCATION.c_str(), MANAGE_SECURE_SETTINGS.c_str(),
87         ACCESS_CONTROL_LOCATION_SWITCH.c_str(),
88     };
89     NativeTokenInfoParams infoInstance = {
90         .dcapsNum = 0,
91         .permsNum = LOCATION_PERM_NUM,
92         .aclsNum = 0,
93         .dcaps = nullptr,
94         .perms = perms,
95         .acls = nullptr,
96         .processName = "GeoCodeServiceTest",
97         .aplStr = "system_basic",
98     };
99     uint64_t tokenId = GetAccessTokenId(&infoInstance);
100     SetSelfTokenID(tokenId);
101     Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
102 }
103 
Available()104 bool GeoConvertServiceTest::Available()
105 {
106     MessageParcel replyParcel;
107     proxy_->IsGeoConvertAvailable(replyParcel);
108     return replyParcel.ReadInt32() == ERRCODE_SUCCESS;
109 }
110 
111 HWTEST_F(GeoConvertServiceTest, GeoConvertAvailable001, TestSize.Level1)
112 {
113     GTEST_LOG_(INFO)
114         << "GeoConvertServiceTest, GeoConvertAvailable001, TestSize.Level1";
115     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertAvailable001 begin");
116     EXPECT_EQ(true, proxy_->EnableReverseGeocodingMock());
117 
118     /*
119      * @tc.steps: step1. Call system ability and check whether available.
120      * @tc.expected: step1. system ability is available.
121      */
122     Available();
123     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertAvailable001 end");
124 }
125 
126 /*
127  * @tc.name: GeoAddressByCoordinate001
128  * @tc.desc: Test get address from system ability by coordinate.
129  * @tc.type: FUNC
130  */
131 HWTEST_F(GeoConvertServiceTest, GetAddressByCoordinate001, TestSize.Level1)
132 {
133     GTEST_LOG_(INFO)
134         << "GeoConvertServiceTest, GetAddressByCoordinate001, TestSize.Level1";
135     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByCoordinate001 begin");
136     /*
137      * @tc.steps: step1.read test data.
138      */
139     MessageParcel dataParcel;
140     MessageParcel replyParcel;
141     dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
142     dataParcel.WriteDouble(39.92879); // latitude
143     dataParcel.WriteDouble(116.3709); // longitude
144     dataParcel.WriteInt32(5); // maxItem
145     dataParcel.WriteInt32(1); // geocoder param object tag
146     dataParcel.WriteString16(Str8ToStr16("ZH")); // language
147     dataParcel.WriteString16(Str8ToStr16("cn")); // country
148     dataParcel.WriteString16(Str8ToStr16("")); // description
149     dataParcel.WriteString16(Str8ToStr16("test")); // package name
150 
151     /*
152      * @tc.steps: step2. test get address by coordinate.
153      * @tc.expected: step2. no exception head info.
154      */
155     proxy_->GetAddressByCoordinate(dataParcel, replyParcel);
156     EXPECT_EQ(ERRCODE_REVERSE_GEOCODING_FAIL, replyParcel.ReadInt32());
157     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByCoordinate001 end");
158 }
159 
160 HWTEST_F(GeoConvertServiceTest, GetAddressByCoordinate002, TestSize.Level1)
161 {
162     GTEST_LOG_(INFO)
163         << "GeoConvertServiceTest, GetAddressByCoordinate002, TestSize.Level1";
164     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByCoordinate002 begin");
165     /*
166      * @tc.steps: step1.read test data.
167      */
168     MessageParcel dataParcel;
169     MessageParcel replyParcel;
170     dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
171     dataParcel.WriteDouble(39.92879); // latitude
172     dataParcel.WriteDouble(116.3709); // longitude
173     dataParcel.WriteInt32(5); // maxItem
174     dataParcel.WriteInt32(1); // geocoder param object tag
175     dataParcel.WriteString16(Str8ToStr16("ZH")); // language
176     dataParcel.WriteString16(Str8ToStr16("cn")); // country
177     dataParcel.WriteString16(Str8ToStr16("")); // description
178     dataParcel.WriteString16(Str8ToStr16("test")); // package name
179 
180     /*
181      * @tc.steps: step2. test get address by coordinate.
182      * @tc.expected: step2. no exception head info.
183      */
184     service_->mockEnabled_ = false;
185     sptr<IRemoteObject> serviceProxy =
186         CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID, CommonUtils::InitDeviceId());
187     service_->serviceProxy_ = serviceProxy;
188     service_->GetAddressByCoordinate(dataParcel, replyParcel);
189     EXPECT_EQ(ERRCODE_REVERSE_GEOCODING_FAIL, replyParcel.ReadInt32());
190     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByCoordinate002 end");
191 }
192 
193 /*
194  * @tc.name: GetAddressByLocationName001
195  * @tc.desc: Test get address from system ability by location name.
196  * @tc.type: FUNC
197  */
198 HWTEST_F(GeoConvertServiceTest, GetAddressByLocationName001, TestSize.Level1)
199 {
200     GTEST_LOG_(INFO)
201         << "GeoConvertServiceTest, GetAddressByLocationName001, TestSize.Level1";
202     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByLocationName001 begin");
203 
204     /*
205      * @tc.steps: step1.read test data.
206      */
207     MessageParcel dataParcel;
208     MessageParcel replyParcel;
209     dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
210     dataParcel.WriteString16(Str8ToStr16("北京")); // input description of a location
211     dataParcel.WriteDouble(0.0); // minLatitude
212     dataParcel.WriteDouble(0.0); // minLongitude
213     dataParcel.WriteDouble(0.0); // maxLatitude
214     dataParcel.WriteDouble(0.0); // maxLongitude
215     dataParcel.WriteInt32(5); // maxItem
216     dataParcel.WriteInt32(1); // description
217     dataParcel.WriteString16(Str8ToStr16("ZH")); // language
218     dataParcel.WriteString16(Str8ToStr16("cn")); // country
219     dataParcel.WriteString16(Str8ToStr16("")); // description
220     dataParcel.WriteString16(u"ohos"); // package name
221 
222     /*
223      * @tc.steps: step2. test get address by location's name.
224      * @tc.expected: step2. no exception head info.
225      */
226     sptr<IRemoteObject> serviceProxy =
227         CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID, CommonUtils::InitDeviceId());
228     service_->serviceProxy_ = serviceProxy;
229     proxy_->GetAddressByLocationName(dataParcel, replyParcel);
230     EXPECT_EQ(ERRCODE_GEOCODING_FAIL, replyParcel.ReadInt32());
231     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByLocationName001 end");
232 }
233 
234 HWTEST_F(GeoConvertServiceTest, ReverseGeocodingMock001, TestSize.Level1)
235 {
236     GTEST_LOG_(INFO)
237         << "GeoConvertServiceTest, ReverseGeocodingMock001, TestSize.Level1";
238     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] ReverseGeocodingMock001 begin");
239     EXPECT_EQ(true, proxy_->EnableReverseGeocodingMock());
240     std::vector<std::shared_ptr<GeocodingMockInfo>> mockInfo;
241     EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetReverseGeocodingMockInfo(mockInfo));
242 
243     EXPECT_EQ(true, proxy_->DisableReverseGeocodingMock());
244     EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetReverseGeocodingMockInfo(mockInfo));
245     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] ReverseGeocodingMock001 end");
246 }
247 
248 HWTEST_F(GeoConvertServiceTest, GeoConvertServiceDump001, TestSize.Level1)
249 {
250     GTEST_LOG_(INFO)
251         << "GeoConvertServiceTest, GeoConvertServiceDump001, TestSize.Level1";
252     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertServiceDump001 begin");
253     int32_t fd = 0;
254     std::vector<std::u16string> args;
255     std::u16string arg1 = Str8ToStr16("arg1");
256     args.emplace_back(arg1);
257     std::u16string arg2 = Str8ToStr16("arg2");
258     args.emplace_back(arg2);
259     std::u16string arg3 = Str8ToStr16("arg3");
260     args.emplace_back(arg3);
261     std::u16string arg4 = Str8ToStr16("arg4");
262     args.emplace_back(arg4);
263     EXPECT_EQ(ERR_OK, service_->Dump(fd, args));
264 
265     std::vector<std::u16string> emptyArgs;
266     EXPECT_EQ(ERR_OK, service_->Dump(fd, emptyArgs));
267 
268     std::vector<std::u16string> helpArgs;
269     std::u16string helpArg1 = Str8ToStr16(ARGS_HELP);
270     helpArgs.emplace_back(helpArg1);
271     EXPECT_EQ(ERR_OK, service_->Dump(fd, helpArgs));
272     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertServiceDump001 end");
273 }
274 
275 HWTEST_F(GeoConvertServiceTest, GeoConvertProxyGetAddressByCoordinate001, TestSize.Level1)
276 {
277     GTEST_LOG_(INFO)
278         << "GeoConvertServiceTest, GeoConvertProxyGetAddressByCoordinate001, TestSize.Level1";
279     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertProxyGetAddressByCoordinate001 begin");
280     MessageParcel parcel1;
281     MessageParcel reply1;
282     EXPECT_EQ(true, proxy_->EnableReverseGeocodingMock());
283     proxy_->GetAddressByCoordinate(parcel1, reply1);
284     EXPECT_EQ(ERRCODE_SUCCESS, reply1.ReadInt32());
285     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertProxyGetAddressByCoordinate001 end");
286 }
287 
288 HWTEST_F(GeoConvertServiceTest, GeoConvertProxyGetAddressByCoordinate002, TestSize.Level1)
289 {
290     GTEST_LOG_(INFO)
291         << "GeoConvertServiceTest, GeoConvertProxyGetAddressByCoordinate002, TestSize.Level1";
292     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertProxyGetAddressByCoordinate002 begin");
293     MessageParcel parcel2;
294     MessageParcel reply2;
295     EXPECT_EQ(true, proxy_->DisableReverseGeocodingMock());
296     proxy_->GetAddressByCoordinate(parcel2, reply2);
297     EXPECT_EQ(ERRCODE_REVERSE_GEOCODING_FAIL, reply2.ReadInt32());
298     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertProxyGetAddressByCoordinate002 end");
299 }
300 
301 HWTEST_F(GeoConvertServiceTest, GeoConvertInit001, TestSize.Level1)
302 {
303     GTEST_LOG_(INFO)
304         << "GeoConvertServiceTest, GeoConvertInit001, TestSize.Level1";
305     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertInit001 begin");
306     service_->registerToService_  = true;
307     service_->Init();
308     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnInit001 end");
309 }
310 
311 HWTEST_F(GeoConvertServiceTest, GeoConvertOnRemoteRequest001, TestSize.Level1)
312 {
313     GTEST_LOG_(INFO)
314         << "GeoConvertServiceTest, GeoConvertOnRemoteRequest001, TestSize.Level1";
315     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnRemoteRequest001 begin");
316     MessageParcel requestParcel;
317     requestParcel.WriteInterfaceToken(u"location.IGeoConvert");
318     requestParcel.WriteBuffer("data", 4);
319     requestParcel.RewindRead(0);
320     MessageParcel reply;
321     MessageOption option;
322     service_->OnRemoteRequest(0, requestParcel, reply, option);
323     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnRemoteRequest001 end");
324 }
325 
326 HWTEST_F(GeoConvertServiceTest, GeoConvertOnStop001, TestSize.Level1)
327 {
328     GTEST_LOG_(INFO)
329         << "GeoConvertServiceTest, GeoConvertOnStop001, TestSize.Level1";
330     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStop001 begin");
331     service_->OnStop();
332     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStop001 end");
333 }
334 
335 HWTEST_F(GeoConvertServiceTest, GeoConvertNotifyDisConnected001, TestSize.Level1)
336 {
337     GTEST_LOG_(INFO)
338         << "GeoConvertServiceTest, GeoConvertNotifyDisConnected001, TestSize.Level1";
339     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertNotifyDisConnected001 begin");
340     service_->NotifyDisConnected();
341     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertNotifyDisConnected001 end");
342 }
343 
344 HWTEST_F(GeoConvertServiceTest, GeoConvertSaDumpInfo001, TestSize.Level1)
345 {
346     GTEST_LOG_(INFO)
347         << "GeoConvertServiceTest, GeoConvertSaDumpInfo001, TestSize.Level1";
348     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertSaDumpInfo001 begin");
349     string result = "";
350     service_->SaDumpInfo(result);
351     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertSaDumpInfo001 end");
352 }
353 
354 HWTEST_F(GeoConvertServiceTest, GeoConvertResetServiceProxy001, TestSize.Level1)
355 {
356     GTEST_LOG_(INFO)
357         << "GeoConvertServiceTest, GeoConvertResetServiceProxy001, TestSize.Level1";
358     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertResetServiceProxy001 begin");
359     EXPECT_EQ(true, service_->ResetServiceProxy());
360     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertResetServiceProxy001 end");
361 }
362 
363 HWTEST_F(GeoConvertServiceTest, GeoConvertOnStart001, TestSize.Level1)
364 {
365     GTEST_LOG_(INFO)
366         << "GeoConvertServiceTest, GeoConvertOnStart001, TestSize.Level1";
367     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStart001 begin");
368     service_->state_ = ServiceRunningState::STATE_RUNNING;
369     service_->OnStart();
370     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStart001 end");
371 }
372 
373 HWTEST_F(GeoConvertServiceTest, GeoConvertOnStart002, TestSize.Level1)
374 {
375     GTEST_LOG_(INFO)
376         << "GeoConvertServiceTest, GeoConvertOnStart002, TestSize.Level1";
377     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStart002 begin");
378     service_->OnStart();
379     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStart002 end");
380 }
381 
382 HWTEST_F(GeoConvertServiceTest, GeoConvertConnectService001, TestSize.Level1)
383 {
384     GTEST_LOG_(INFO)
385         << "GeoConvertServiceTest, GeoConvertConnectService001, TestSize.Level1";
386     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertConnectService001 begin");
387     sptr<IRemoteObject> serviceProxy =
388         CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID, CommonUtils::InitDeviceId());
389     service_->serviceProxy_ = serviceProxy;
390     service_->ConnectService();
391     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertConnectService001 end");
392 }
393 
394 HWTEST_F(GeoConvertServiceTest, GeoConvertReConnectService001, TestSize.Level1)
395 {
396     GTEST_LOG_(INFO)
397         << "GeoConvertServiceTest, GeoConvertReConnectService001, TestSize.Level1";
398     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReConnectService001 begin");
399     service_->serviceProxy_ = nullptr;
400     service_->ConnectService();
401     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertConnectService002 end");
402 }
403 
404 HWTEST_F(GeoConvertServiceTest, GeoConvertReConnectService002, TestSize.Level1)
405 {
406     GTEST_LOG_(INFO)
407         << "GeoConvertServiceTest, GeoConvertReConnectService002, TestSize.Level1";
408     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReConnectService002 begin");
409     sptr<IRemoteObject> serviceProxy =
410         CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID, CommonUtils::InitDeviceId());
411     service_->serviceProxy_ = serviceProxy;
412     service_->ConnectService();
413     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertConnectService003 end");
414 }
415 
416 HWTEST_F(GeoConvertServiceTest, GeoConvertNotifyConnected001, TestSize.Level1)
417 {
418     GTEST_LOG_(INFO)
419         << "GeoConvertServiceTest, GeoConvertNotifyConnected001, TestSize.Level1";
420     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertNotifyConnected001 begin");
421     sptr<IRemoteObject> remoteObject;
422     service_->NotifyConnected(remoteObject);
423     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertNotifyConnected001 end");
424 }
425 
426 HWTEST_F(GeoConvertServiceTest, RegisterGeoServiceDeathRecipient001, TestSize.Level1)
427 {
428     GTEST_LOG_(INFO)
429         << "GeoConvertServiceTest, RegisterGeoServiceDeathRecipient001, TestSize.Level1";
430     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] RegisterGeoServiceDeathRecipient001 begin");
431     service_->RegisterGeoServiceDeathRecipient();
432     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] RegisterGeoServiceDeathRecipient001 end");
433 }
434 
435 HWTEST_F(GeoConvertServiceTest, RegisterGeoServiceSendGeocodeRequest001, TestSize.Level1)
436 {
437     GTEST_LOG_(INFO)
438         << "GeoConvertServiceTest, RegisterGeoServiceSendGeocodeRequest001, TestSize.Level1";
439     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] RegisterGeoServiceSendGeocodeRequest001 begin");
440     MessageParcel dataParcel;
441     MessageParcel replyParcel;
442     MessageOption option;
443     dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
444     dataParcel.WriteString16(Str8ToStr16("北京")); // input description of a location
445     dataParcel.WriteDouble(0.0); // minLatitude
446     dataParcel.WriteDouble(0.0); // minLongitude
447     dataParcel.WriteDouble(0.0); // maxLatitude
448     dataParcel.WriteDouble(0.0); // maxLongitude
449     dataParcel.WriteInt32(5); // maxItem
450     dataParcel.WriteInt32(1); // description
451     dataParcel.WriteString16(Str8ToStr16("ZH")); // language
452     dataParcel.WriteString16(Str8ToStr16("cn")); // country
453     dataParcel.WriteString16(Str8ToStr16("")); // description
454     dataParcel.WriteString16(u"ohos"); // package name
455     int code = 1;
456     service_->SendGeocodeRequest(code, dataParcel, replyParcel, option);
457     sptr<IRemoteObject> serviceProxy =
458         CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID, CommonUtils::InitDeviceId());
459     service_->serviceProxy_ = serviceProxy;
460     service_->SendGeocodeRequest(code, dataParcel, replyParcel, option);
461     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] RegisterGeoServiceSendGeocodeRequest001 end");
462 }
463 
464 HWTEST_F(GeoConvertServiceTest, GeoConvertReportAddressMock001, TestSize.Level1)
465 {
466     GTEST_LOG_(INFO)
467         << "GeoConvertServiceTest, GeoConvertReportAddressMock001, TestSize.Level1";
468     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReportAddressMock001 begin");
469     MessageParcel dataParcel;
470     MessageParcel replyParcel;
471     dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
472     dataParcel.WriteString16(Str8ToStr16("北京")); // input description of a location
473     dataParcel.WriteDouble(0.0); // minLatitude
474     dataParcel.WriteDouble(0.0); // minLongitude
475     dataParcel.WriteDouble(0.0); // maxLatitude
476     dataParcel.WriteDouble(0.0); // maxLongitude
477     dataParcel.WriteInt32(5); // maxItem
478     dataParcel.WriteInt32(1); // description
479     dataParcel.WriteString16(Str8ToStr16("ZH")); // language
480     dataParcel.WriteString16(Str8ToStr16("cn")); // country
481     dataParcel.WriteString16(Str8ToStr16("")); // description
482     dataParcel.WriteString16(u"ohos"); // package name
483     service_->ReportAddressMock(dataParcel, replyParcel);
484     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReportAddressMock001 end");
485 }
486 
487 HWTEST_F(GeoConvertServiceTest, GeoConvertReportAddressMock002, TestSize.Level1)
488 {
489     GTEST_LOG_(INFO)
490         << "GeoConvertServiceTest, GeoConvertReportAddressMock002, TestSize.Level1";
491     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReportAddressMock002 begin");
492     MessageParcel dataParcel;
493     MessageParcel replyParcel;
494     dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
495     dataParcel.WriteString16(Str8ToStr16("北京")); // input description of a location
496     dataParcel.WriteDouble(0.0); // minLatitude
497     dataParcel.WriteDouble(0.0); // minLongitude
498     dataParcel.WriteDouble(0.0); // maxLatitude
499     dataParcel.WriteDouble(0.0); // maxLongitude
500     dataParcel.WriteInt32(5); // maxItem
501     dataParcel.WriteInt32(1); // description
502     dataParcel.WriteString16(Str8ToStr16("ZH")); // language
503     dataParcel.WriteString16(Str8ToStr16("cn")); // country
504     dataParcel.WriteString16(Str8ToStr16("")); // description
505     dataParcel.WriteString16(u"ohos"); // package name
506     std::vector<std::shared_ptr<GeocodingMockInfo>> mockInfo;
507     std::shared_ptr<GeocodingMockInfo> info = std::make_shared<GeocodingMockInfo>();
508     mockInfo.push_back(info);
509     info->ReadFromParcel(dataParcel);
510     service_->mockInfo_ = mockInfo;
511     service_->ReportAddressMock(dataParcel, replyParcel);
512     MessageParcel dataParcel2;
513     dataParcel2.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
514     dataParcel2.WriteDouble(1.0); // minLatitude
515     dataParcel2.WriteDouble(0.0); // minLongitude
516     info->ReadFromParcel(dataParcel2);
517     mockInfo.push_back(info);
518     service_->mockInfo_ = mockInfo;
519     service_->ReportAddressMock(dataParcel, replyParcel);
520     MessageParcel dataParcel3;
521     dataParcel3.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
522     dataParcel3.WriteDouble(1.0); // minLatitude
523     dataParcel3.WriteDouble(1.0); // minLongitude
524     info->ReadFromParcel(dataParcel3);
525     mockInfo.push_back(info);
526     service_->mockInfo_ = mockInfo;
527     service_->ReportAddressMock(dataParcel, replyParcel);
528     MessageParcel dataParcel4;
529     dataParcel4.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
530     dataParcel4.WriteDouble(0.0); // minLatitude
531     dataParcel4.WriteDouble(1.0); // minLongitude
532     info->ReadFromParcel(dataParcel4);
533     mockInfo.push_back(info);
534     service_->mockInfo_ = mockInfo;
535     service_->ReportAddressMock(dataParcel, replyParcel);
536     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReportAddressMock002 end");
537 }
538 
539 HWTEST_F(GeoConvertServiceTest, GetAddressByLocationName002, TestSize.Level1)
540 {
541     GTEST_LOG_(INFO)
542         << "GeoConvertServiceTest, GetAddressByLocationName002, TestSize.Level1";
543     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByLocationName002 begin");
544 
545     /*
546      * @tc.steps: step1.read test data.
547      */
548     MessageParcel dataParcel;
549     MessageParcel replyParcel;
550     dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
551     dataParcel.WriteString16(Str8ToStr16("北京")); // input description of a location
552     dataParcel.WriteDouble(0.0); // minLatitude
553     dataParcel.WriteDouble(0.0); // minLongitude
554     dataParcel.WriteDouble(0.0); // maxLatitude
555     dataParcel.WriteDouble(0.0); // maxLongitude
556     dataParcel.WriteInt32(5); // maxItem
557     dataParcel.WriteInt32(1); // description
558     dataParcel.WriteString16(Str8ToStr16("ZH")); // language
559     dataParcel.WriteString16(Str8ToStr16("cn")); // country
560     dataParcel.WriteString16(Str8ToStr16("")); // description
561     dataParcel.WriteString16(u"ohos"); // package name
562 
563     /*
564      * @tc.steps: step2. test get address by location's name.
565      * @tc.expected: step2. no exception head info.
566      */
567     proxy_->GetAddressByLocationName(dataParcel, replyParcel);
568     EXPECT_EQ(ERRCODE_GEOCODING_FAIL, replyParcel.ReadInt32());
569     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByLocationName002 end");
570 }
571 
572 HWTEST_F(GeoConvertServiceTest, GeoServiceDeathRecipientOnRemoteDied001, TestSize.Level1)
573 {
574     GTEST_LOG_(INFO)
575         << "GeoConvertServiceTest, GeoServiceDeathRecipientOnRemoteDied001, TestSize.Level1";
576     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoServiceDeathRecipientOnRemoteDied001 begin");
577     auto recipient = new (std::nothrow) GeoServiceDeathRecipient();
578     wptr<IRemoteObject> remote;
579     recipient->OnRemoteDied(remote);
580     LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoServiceDeathRecipientOnRemoteDied001 end");
581 }
582 }  // namespace Location
583 } // namespace OHOS
584 #endif // FEATURE_GEOCODE_SUPPORT
585