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
61using namespace testing;
62using namespace testing::ext;
63
64namespace OHOS {
65namespace Location {
66const int32_t LOCATION_PERM_NUM = 5;
67const std::string ARGS_HELP = "-h";
68void 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
78void GeoConvertServiceTest::TearDown()
79{
80}
81
82void 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
104bool GeoConvertServiceTest::Available()
105{
106    MessageParcel replyParcel;
107    proxy_->IsGeoConvertAvailable(replyParcel);
108    return replyParcel.ReadInt32() == ERRCODE_SUCCESS;
109}
110
111HWTEST_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 */
131HWTEST_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
160HWTEST_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 */
198HWTEST_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
234HWTEST_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
248HWTEST_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
275HWTEST_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
288HWTEST_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
301HWTEST_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
311HWTEST_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
326HWTEST_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
335HWTEST_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
344HWTEST_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
354HWTEST_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
363HWTEST_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
373HWTEST_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
382HWTEST_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
394HWTEST_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
404HWTEST_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
416HWTEST_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
426HWTEST_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
435HWTEST_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
464HWTEST_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
487HWTEST_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
539HWTEST_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
572HWTEST_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