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 "geocoding_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 #include "mock_i_remote_object.h"
54
55 #include "locationhub_ipc_interface_code.h"
56 #include "location_sa_load_manager.h"
57 #include "system_ability_definition.h"
58 #include "if_system_ability_manager.h"
59 #include "iservice_registry.h"
60 #include "location_log.h"
61
62 using namespace testing;
63 using namespace testing::ext;
64
65 namespace OHOS {
66 namespace Location {
67 const int32_t LOCATION_PERM_NUM = 5;
68 const std::string ARGS_HELP = "-h";
SetUp()69 void GeoConvertServiceTest::SetUp()
70 {
71 /*
72 * @tc.setup: Get system ability's pointer and get sa proxy object.
73 */
74 MockNativePermission();
75 service_ = new (std::nothrow) GeoConvertService();
76 proxy_ = std::make_shared<GeoConvertProxy>(service_);
77 }
78
TearDown()79 void GeoConvertServiceTest::TearDown()
80 {
81 }
82
MockNativePermission()83 void GeoConvertServiceTest::MockNativePermission()
84 {
85 const char *perms[] = {
86 ACCESS_LOCATION.c_str(), ACCESS_APPROXIMATELY_LOCATION.c_str(),
87 ACCESS_BACKGROUND_LOCATION.c_str(), MANAGE_SECURE_SETTINGS.c_str(),
88 ACCESS_CONTROL_LOCATION_SWITCH.c_str(),
89 };
90 NativeTokenInfoParams infoInstance = {
91 .dcapsNum = 0,
92 .permsNum = LOCATION_PERM_NUM,
93 .aclsNum = 0,
94 .dcaps = nullptr,
95 .perms = perms,
96 .acls = nullptr,
97 .processName = "GeoCodeServiceTest",
98 .aplStr = "system_basic",
99 };
100 uint64_t tokenId = GetAccessTokenId(&infoInstance);
101 SetSelfTokenID(tokenId);
102 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
103 }
104
Available()105 bool GeoConvertServiceTest::Available()
106 {
107 MessageParcel replyParcel;
108 proxy_->IsGeoConvertAvailable(replyParcel);
109 return replyParcel.ReadInt32() == ERRCODE_SUCCESS;
110 }
111
112 HWTEST_F(GeoConvertServiceTest, GeoConvertAvailable001, TestSize.Level1)
113 {
114 GTEST_LOG_(INFO)
115 << "GeoConvertServiceTest, GeoConvertAvailable001, TestSize.Level1";
116 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertAvailable001 begin");
117 EXPECT_EQ(true, proxy_->EnableReverseGeocodingMock());
118
119 /*
120 * @tc.steps: step1. Call system ability and check whether available.
121 * @tc.expected: step1. system ability is available.
122 */
123 Available();
124 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertAvailable001 end");
125 }
126
127 /*
128 * @tc.name: GeoAddressByCoordinate001
129 * @tc.desc: Test get address from system ability by coordinate.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(GeoConvertServiceTest, GetAddressByCoordinate001, TestSize.Level0)
133 {
134 GTEST_LOG_(INFO)
135 << "GeoConvertServiceTest, GetAddressByCoordinate001, TestSize.Level1";
136 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByCoordinate001 begin");
137 /*
138 * @tc.steps: step1.read test data.
139 */
140 MessageParcel dataParcel;
141 MessageParcel replyParcel;
142 dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
143 dataParcel.WriteDouble(39.92879); // latitude
144 dataParcel.WriteDouble(116.3709); // longitude
145 dataParcel.WriteInt32(5); // maxItem
146 dataParcel.WriteInt32(1); // geocoder param object tag
147 dataParcel.WriteString16(Str8ToStr16("ZH")); // language
148 dataParcel.WriteString16(Str8ToStr16("cn")); // country
149 dataParcel.WriteString16(Str8ToStr16("")); // description
150 dataParcel.WriteString16(Str8ToStr16("test")); // package name
151
152 /*
153 * @tc.steps: step2. test get address by coordinate.
154 * @tc.expected: step2. no exception head info.
155 */
156 proxy_->GetAddressByCoordinate(dataParcel, replyParcel);
157 EXPECT_EQ(ERRCODE_REVERSE_GEOCODING_FAIL, replyParcel.ReadInt32());
158 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByCoordinate001 end");
159 }
160
161 HWTEST_F(GeoConvertServiceTest, GetAddressByCoordinate002, TestSize.Level0)
162 {
163 GTEST_LOG_(INFO)
164 << "GeoConvertServiceTest, GetAddressByCoordinate002, TestSize.Level1";
165 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByCoordinate002 begin");
166 /*
167 * @tc.steps: step1.read test data.
168 */
169 MessageParcel dataParcel;
170 MessageParcel replyParcel;
171 dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
172 dataParcel.WriteDouble(39.92879); // latitude
173 dataParcel.WriteDouble(116.3709); // longitude
174 dataParcel.WriteInt32(5); // maxItem
175 dataParcel.WriteInt32(1); // geocoder param object tag
176 dataParcel.WriteString16(Str8ToStr16("ZH")); // language
177 dataParcel.WriteString16(Str8ToStr16("cn")); // country
178 dataParcel.WriteString16(Str8ToStr16("")); // description
179 dataParcel.WriteString16(Str8ToStr16("test")); // package name
180
181 /*
182 * @tc.steps: step2. test get address by coordinate.
183 * @tc.expected: step2. no exception head info.
184 */
185 service_->mockEnabled_ = false;
186 sptr<IRemoteObject> serviceProxy =
187 CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID, CommonUtils::InitDeviceId());
188 service_->serviceProxy_ = serviceProxy;
189 service_->GetAddressByCoordinate(dataParcel, replyParcel);
190 EXPECT_EQ(ERRCODE_REVERSE_GEOCODING_FAIL, replyParcel.ReadInt32());
191 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByCoordinate002 end");
192 }
193
194 /*
195 * @tc.name: GetAddressByLocationName001
196 * @tc.desc: Test get address from system ability by location name.
197 * @tc.type: FUNC
198 */
199 HWTEST_F(GeoConvertServiceTest, GetAddressByLocationName001, TestSize.Level0)
200 {
201 GTEST_LOG_(INFO)
202 << "GeoConvertServiceTest, GetAddressByLocationName001, TestSize.Level0";
203 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByLocationName001 begin");
204
205 /*
206 * @tc.steps: step1.read test data.
207 */
208 MessageParcel dataParcel;
209 MessageParcel replyParcel;
210 dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
211 dataParcel.WriteString16(Str8ToStr16("北京")); // input description of a location
212 dataParcel.WriteDouble(0.0); // minLatitude
213 dataParcel.WriteDouble(0.0); // minLongitude
214 dataParcel.WriteDouble(0.0); // maxLatitude
215 dataParcel.WriteDouble(0.0); // maxLongitude
216 dataParcel.WriteInt32(5); // maxItem
217 dataParcel.WriteInt32(1); // description
218 dataParcel.WriteString16(Str8ToStr16("ZH")); // language
219 dataParcel.WriteString16(Str8ToStr16("cn")); // country
220 dataParcel.WriteString16(Str8ToStr16("")); // description
221 dataParcel.WriteString16(u"ohos"); // package name
222
223 /*
224 * @tc.steps: step2. test get address by location's name.
225 * @tc.expected: step2. no exception head info.
226 */
227 sptr<IRemoteObject> serviceProxy =
228 CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID, CommonUtils::InitDeviceId());
229 service_->serviceProxy_ = serviceProxy;
230 proxy_->GetAddressByLocationName(dataParcel, replyParcel);
231 EXPECT_EQ(ERRCODE_GEOCODING_FAIL, replyParcel.ReadInt32());
232 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByLocationName001 end");
233 }
234
235 HWTEST_F(GeoConvertServiceTest, ReverseGeocodingMock001, TestSize.Level1)
236 {
237 GTEST_LOG_(INFO)
238 << "GeoConvertServiceTest, ReverseGeocodingMock001, TestSize.Level1";
239 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] ReverseGeocodingMock001 begin");
240 EXPECT_EQ(true, proxy_->EnableReverseGeocodingMock());
241 std::vector<std::shared_ptr<GeocodingMockInfo>> mockInfo;
242 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetReverseGeocodingMockInfo(mockInfo));
243
244 EXPECT_EQ(true, proxy_->DisableReverseGeocodingMock());
245 EXPECT_EQ(ERRCODE_SUCCESS, proxy_->SetReverseGeocodingMockInfo(mockInfo));
246 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] ReverseGeocodingMock001 end");
247 }
248
249 HWTEST_F(GeoConvertServiceTest, GeoConvertServiceDump001, TestSize.Level1)
250 {
251 GTEST_LOG_(INFO)
252 << "GeoConvertServiceTest, GeoConvertServiceDump001, TestSize.Level1";
253 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertServiceDump001 begin");
254 int32_t fd = 0;
255 std::vector<std::u16string> args;
256 std::u16string arg1 = Str8ToStr16("arg1");
257 args.emplace_back(arg1);
258 std::u16string arg2 = Str8ToStr16("arg2");
259 args.emplace_back(arg2);
260 std::u16string arg3 = Str8ToStr16("arg3");
261 args.emplace_back(arg3);
262 std::u16string arg4 = Str8ToStr16("arg4");
263 args.emplace_back(arg4);
264 EXPECT_EQ(ERR_OK, service_->Dump(fd, args));
265
266 std::vector<std::u16string> emptyArgs;
267 EXPECT_EQ(ERR_OK, service_->Dump(fd, emptyArgs));
268
269 std::vector<std::u16string> helpArgs;
270 std::u16string helpArg1 = Str8ToStr16(ARGS_HELP);
271 helpArgs.emplace_back(helpArg1);
272 EXPECT_EQ(ERR_OK, service_->Dump(fd, helpArgs));
273 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertServiceDump001 end");
274 }
275
276 HWTEST_F(GeoConvertServiceTest, GeoConvertProxyGetAddressByCoordinate001, TestSize.Level1)
277 {
278 GTEST_LOG_(INFO)
279 << "GeoConvertServiceTest, GeoConvertProxyGetAddressByCoordinate001, TestSize.Level1";
280 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertProxyGetAddressByCoordinate001 begin");
281 MessageParcel parcel1;
282 MessageParcel reply1;
283 EXPECT_EQ(true, proxy_->EnableReverseGeocodingMock());
284 proxy_->GetAddressByCoordinate(parcel1, reply1);
285 EXPECT_EQ(ERRCODE_SUCCESS, reply1.ReadInt32());
286 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertProxyGetAddressByCoordinate001 end");
287 }
288
289 HWTEST_F(GeoConvertServiceTest, GeoConvertProxyGetAddressByCoordinate002, TestSize.Level1)
290 {
291 GTEST_LOG_(INFO)
292 << "GeoConvertServiceTest, GeoConvertProxyGetAddressByCoordinate002, TestSize.Level1";
293 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertProxyGetAddressByCoordinate002 begin");
294 MessageParcel parcel2;
295 MessageParcel reply2;
296 EXPECT_EQ(true, proxy_->DisableReverseGeocodingMock());
297 proxy_->GetAddressByCoordinate(parcel2, reply2);
298 EXPECT_EQ(ERRCODE_REVERSE_GEOCODING_FAIL, reply2.ReadInt32());
299 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertProxyGetAddressByCoordinate002 end");
300 }
301
302 HWTEST_F(GeoConvertServiceTest, GeoConvertInit001, TestSize.Level0)
303 {
304 GTEST_LOG_(INFO)
305 << "GeoConvertServiceTest, GeoConvertInit001, TestSize.Level0";
306 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertInit001 begin");
307 service_->registerToService_ = true;
308 service_->Init();
309 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnInit001 end");
310 }
311
312 HWTEST_F(GeoConvertServiceTest, GeoConvertOnRemoteRequest001, TestSize.Level1)
313 {
314 GTEST_LOG_(INFO)
315 << "GeoConvertServiceTest, GeoConvertOnRemoteRequest001, TestSize.Level1";
316 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnRemoteRequest001 begin");
317 MessageParcel requestParcel;
318 requestParcel.WriteInterfaceToken(u"location.IGeoConvert");
319 requestParcel.WriteBuffer("data", 4);
320 requestParcel.RewindRead(0);
321 MessageParcel reply;
322 MessageOption option;
323 service_->OnRemoteRequest(0, requestParcel, reply, option);
324 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnRemoteRequest001 end");
325 }
326
327 HWTEST_F(GeoConvertServiceTest, GeoConvertOnStop001, TestSize.Level1)
328 {
329 GTEST_LOG_(INFO)
330 << "GeoConvertServiceTest, GeoConvertOnStop001, TestSize.Level1";
331 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStop001 begin");
332 service_->OnStop();
333 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStop001 end");
334 }
335
336 HWTEST_F(GeoConvertServiceTest, GeoConvertNotifyDisConnected001, TestSize.Level1)
337 {
338 GTEST_LOG_(INFO)
339 << "GeoConvertServiceTest, GeoConvertNotifyDisConnected001, TestSize.Level1";
340 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertNotifyDisConnected001 begin");
341 service_->NotifyDisConnected();
342 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertNotifyDisConnected001 end");
343 }
344
345 HWTEST_F(GeoConvertServiceTest, GeoConvertSaDumpInfo001, TestSize.Level1)
346 {
347 GTEST_LOG_(INFO)
348 << "GeoConvertServiceTest, GeoConvertSaDumpInfo001, TestSize.Level1";
349 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertSaDumpInfo001 begin");
350 string result = "";
351 service_->SaDumpInfo(result);
352 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertSaDumpInfo001 end");
353 }
354
355 HWTEST_F(GeoConvertServiceTest, GeoConvertResetServiceProxy001, TestSize.Level1)
356 {
357 GTEST_LOG_(INFO)
358 << "GeoConvertServiceTest, GeoConvertResetServiceProxy001, TestSize.Level1";
359 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertResetServiceProxy001 begin");
360 EXPECT_EQ(true, service_->ResetServiceProxy());
361 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertResetServiceProxy001 end");
362 }
363
364 HWTEST_F(GeoConvertServiceTest, GeoConvertOnStart001, TestSize.Level1)
365 {
366 GTEST_LOG_(INFO)
367 << "GeoConvertServiceTest, GeoConvertOnStart001, TestSize.Level1";
368 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStart001 begin");
369 service_->state_ = ServiceRunningState::STATE_RUNNING;
370 service_->OnStart();
371 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStart001 end");
372 }
373
374 HWTEST_F(GeoConvertServiceTest, GeoConvertOnStart002, TestSize.Level1)
375 {
376 GTEST_LOG_(INFO)
377 << "GeoConvertServiceTest, GeoConvertOnStart002, TestSize.Level1";
378 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStart002 begin");
379 service_->OnStart();
380 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertOnStart002 end");
381 }
382
383 HWTEST_F(GeoConvertServiceTest, GeoConvertConnectService001, TestSize.Level1)
384 {
385 GTEST_LOG_(INFO)
386 << "GeoConvertServiceTest, GeoConvertConnectService001, TestSize.Level1";
387 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertConnectService001 begin");
388 sptr<IRemoteObject> serviceProxy =
389 CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID, CommonUtils::InitDeviceId());
390 service_->serviceProxy_ = serviceProxy;
391 service_->ConnectService();
392 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertConnectService001 end");
393 }
394
395 HWTEST_F(GeoConvertServiceTest, GeoConvertReConnectService001, TestSize.Level1)
396 {
397 GTEST_LOG_(INFO)
398 << "GeoConvertServiceTest, GeoConvertReConnectService001, TestSize.Level1";
399 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReConnectService001 begin");
400 service_->serviceProxy_ = nullptr;
401 service_->ConnectService();
402 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertConnectService002 end");
403 }
404
405 HWTEST_F(GeoConvertServiceTest, GeoConvertReConnectService002, TestSize.Level1)
406 {
407 GTEST_LOG_(INFO)
408 << "GeoConvertServiceTest, GeoConvertReConnectService002, TestSize.Level1";
409 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReConnectService002 begin");
410 sptr<IRemoteObject> serviceProxy =
411 CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID, CommonUtils::InitDeviceId());
412 service_->serviceProxy_ = serviceProxy;
413 service_->ConnectService();
414 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertConnectService003 end");
415 }
416
417 HWTEST_F(GeoConvertServiceTest, GeoConvertNotifyConnected001, TestSize.Level1)
418 {
419 GTEST_LOG_(INFO)
420 << "GeoConvertServiceTest, GeoConvertNotifyConnected001, TestSize.Level1";
421 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertNotifyConnected001 begin");
422 sptr<IRemoteObject> remoteObject;
423 service_->NotifyConnected(remoteObject);
424 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertNotifyConnected001 end");
425 }
426
427 HWTEST_F(GeoConvertServiceTest, RegisterGeoServiceDeathRecipient001, TestSize.Level1)
428 {
429 GTEST_LOG_(INFO)
430 << "GeoConvertServiceTest, RegisterGeoServiceDeathRecipient001, TestSize.Level1";
431 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] RegisterGeoServiceDeathRecipient001 begin");
432 service_->RegisterGeoServiceDeathRecipient();
433 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] RegisterGeoServiceDeathRecipient001 end");
434 }
435
436 HWTEST_F(GeoConvertServiceTest, RegisterGeoServiceSendGeocodeRequest001, TestSize.Level1)
437 {
438 GTEST_LOG_(INFO)
439 << "GeoConvertServiceTest, RegisterGeoServiceSendGeocodeRequest001, TestSize.Level1";
440 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] RegisterGeoServiceSendGeocodeRequest001 begin");
441 MessageParcel dataParcel;
442 MessageParcel replyParcel;
443 MessageOption option;
444 dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
445 dataParcel.WriteString16(Str8ToStr16("北京")); // input description of a location
446 dataParcel.WriteDouble(0.0); // minLatitude
447 dataParcel.WriteDouble(0.0); // minLongitude
448 dataParcel.WriteDouble(0.0); // maxLatitude
449 dataParcel.WriteDouble(0.0); // maxLongitude
450 dataParcel.WriteInt32(5); // maxItem
451 dataParcel.WriteInt32(1); // description
452 dataParcel.WriteString16(Str8ToStr16("ZH")); // language
453 dataParcel.WriteString16(Str8ToStr16("cn")); // country
454 dataParcel.WriteString16(Str8ToStr16("")); // description
455 dataParcel.WriteString16(u"ohos"); // package name
456 int code = 1;
457 service_->SendGeocodeRequest(code, dataParcel, replyParcel, option);
458 sptr<IRemoteObject> serviceProxy =
459 CommonUtils::GetRemoteObject(LOCATION_GEO_CONVERT_SA_ID, CommonUtils::InitDeviceId());
460 service_->serviceProxy_ = serviceProxy;
461 service_->SendGeocodeRequest(code, dataParcel, replyParcel, option);
462 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] RegisterGeoServiceSendGeocodeRequest001 end");
463 }
464
465 HWTEST_F(GeoConvertServiceTest, GeoConvertReportAddressMock001, TestSize.Level1)
466 {
467 GTEST_LOG_(INFO)
468 << "GeoConvertServiceTest, GeoConvertReportAddressMock001, TestSize.Level1";
469 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReportAddressMock001 begin");
470 MessageParcel dataParcel;
471 MessageParcel replyParcel;
472 dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
473 dataParcel.WriteString16(Str8ToStr16("北京")); // input description of a location
474 dataParcel.WriteDouble(0.0); // minLatitude
475 dataParcel.WriteDouble(0.0); // minLongitude
476 dataParcel.WriteDouble(0.0); // maxLatitude
477 dataParcel.WriteDouble(0.0); // maxLongitude
478 dataParcel.WriteInt32(5); // maxItem
479 dataParcel.WriteInt32(1); // description
480 dataParcel.WriteString16(Str8ToStr16("ZH")); // language
481 dataParcel.WriteString16(Str8ToStr16("cn")); // country
482 dataParcel.WriteString16(Str8ToStr16("")); // description
483 dataParcel.WriteString16(u"ohos"); // package name
484 service_->ReportAddressMock(dataParcel, replyParcel);
485 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReportAddressMock001 end");
486 }
487
488 HWTEST_F(GeoConvertServiceTest, GeoConvertReportAddressMock002, TestSize.Level1)
489 {
490 GTEST_LOG_(INFO)
491 << "GeoConvertServiceTest, GeoConvertReportAddressMock002, TestSize.Level1";
492 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReportAddressMock002 begin");
493 MessageParcel dataParcel;
494 MessageParcel replyParcel;
495 dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
496 dataParcel.WriteString16(Str8ToStr16("北京")); // input description of a location
497 dataParcel.WriteDouble(0.0); // minLatitude
498 dataParcel.WriteDouble(0.0); // minLongitude
499 dataParcel.WriteDouble(0.0); // maxLatitude
500 dataParcel.WriteDouble(0.0); // maxLongitude
501 dataParcel.WriteInt32(5); // maxItem
502 dataParcel.WriteInt32(1); // description
503 dataParcel.WriteString16(Str8ToStr16("ZH")); // language
504 dataParcel.WriteString16(Str8ToStr16("cn")); // country
505 dataParcel.WriteString16(Str8ToStr16("")); // description
506 dataParcel.WriteString16(u"ohos"); // package name
507 std::vector<std::shared_ptr<GeocodingMockInfo>> mockInfo;
508 std::shared_ptr<GeocodingMockInfo> info = std::make_shared<GeocodingMockInfo>();
509 mockInfo.push_back(info);
510 info->ReadFromParcel(dataParcel);
511 service_->mockInfo_ = mockInfo;
512 service_->ReportAddressMock(dataParcel, replyParcel);
513 MessageParcel dataParcel2;
514 dataParcel2.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
515 dataParcel2.WriteDouble(1.0); // minLatitude
516 dataParcel2.WriteDouble(0.0); // minLongitude
517 info->ReadFromParcel(dataParcel2);
518 mockInfo.push_back(info);
519 service_->mockInfo_ = mockInfo;
520 service_->ReportAddressMock(dataParcel, replyParcel);
521 MessageParcel dataParcel3;
522 dataParcel3.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
523 dataParcel3.WriteDouble(1.0); // minLatitude
524 dataParcel3.WriteDouble(1.0); // minLongitude
525 info->ReadFromParcel(dataParcel3);
526 mockInfo.push_back(info);
527 service_->mockInfo_ = mockInfo;
528 service_->ReportAddressMock(dataParcel, replyParcel);
529 MessageParcel dataParcel4;
530 dataParcel4.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
531 dataParcel4.WriteDouble(0.0); // minLatitude
532 dataParcel4.WriteDouble(1.0); // minLongitude
533 info->ReadFromParcel(dataParcel4);
534 mockInfo.push_back(info);
535 service_->mockInfo_ = mockInfo;
536 service_->ReportAddressMock(dataParcel, replyParcel);
537 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoConvertReportAddressMock002 end");
538 }
539
540 HWTEST_F(GeoConvertServiceTest, GetAddressByLocationName002, TestSize.Level1)
541 {
542 GTEST_LOG_(INFO)
543 << "GeoConvertServiceTest, GetAddressByLocationName002, TestSize.Level1";
544 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByLocationName002 begin");
545
546 /*
547 * @tc.steps: step1.read test data.
548 */
549 MessageParcel dataParcel;
550 MessageParcel replyParcel;
551 dataParcel.WriteInterfaceToken(GeoConvertProxy::GetDescriptor());
552 dataParcel.WriteString16(Str8ToStr16("北京")); // input description of a location
553 dataParcel.WriteDouble(0.0); // minLatitude
554 dataParcel.WriteDouble(0.0); // minLongitude
555 dataParcel.WriteDouble(0.0); // maxLatitude
556 dataParcel.WriteDouble(0.0); // maxLongitude
557 dataParcel.WriteInt32(5); // maxItem
558 dataParcel.WriteInt32(1); // description
559 dataParcel.WriteString16(Str8ToStr16("ZH")); // language
560 dataParcel.WriteString16(Str8ToStr16("cn")); // country
561 dataParcel.WriteString16(Str8ToStr16("")); // description
562 dataParcel.WriteString16(u"ohos"); // package name
563
564 /*
565 * @tc.steps: step2. test get address by location's name.
566 * @tc.expected: step2. no exception head info.
567 */
568 proxy_->GetAddressByLocationName(dataParcel, replyParcel);
569 EXPECT_EQ(ERRCODE_GEOCODING_FAIL, replyParcel.ReadInt32());
570 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GetAddressByLocationName002 end");
571 }
572
573 HWTEST_F(GeoConvertServiceTest, GeoServiceDeathRecipientOnRemoteDied001, TestSize.Level1)
574 {
575 GTEST_LOG_(INFO)
576 << "GeoConvertServiceTest, GeoServiceDeathRecipientOnRemoteDied001, TestSize.Level1";
577 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoServiceDeathRecipientOnRemoteDied001 begin");
578 auto recipient = new (std::nothrow) GeoServiceDeathRecipient();
579 wptr<IRemoteObject> remote;
580 recipient->OnRemoteDied(remote);
581 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] GeoServiceDeathRecipientOnRemoteDied001 end");
582 }
583
584 HWTEST_F(GeoConvertServiceTest, UnRegisterGeoServiceDeathRecipient001, TestSize.Level1)
585 {
586 GTEST_LOG_(INFO)
587 << "GeoConvertServiceTest, UnRegisterGeoServiceDeathRecipient001, TestSize.Level1";
588 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] UnRegisterGeoServiceDeathRecipient001 begin");
589 ASSERT_TRUE(service_ != nullptr);
590 service_->UnRegisterGeoServiceDeathRecipient();
591 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] UnRegisterGeoServiceDeathRecipient001 end");
592 }
593
594 HWTEST_F(GeoConvertServiceTest, SendGeocodeRequest001, TestSize.Level1)
595 {
596 GTEST_LOG_(INFO)
597 << "GeoConvertServiceTest, SendGeocodeRequest001, TestSize.Level1";
598 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] SendGeocodeRequest001 begin");
599 auto mockGeoConvertRequest = std::make_unique<GeoConvertRequest>();
600 mockGeoConvertRequest->SetLocale("test");
601 mockGeoConvertRequest->GetLocale();
602 mockGeoConvertRequest->SetLatitude(30);
603 mockGeoConvertRequest->GetLatitude();
604 mockGeoConvertRequest->SetLongitude(40);
605 mockGeoConvertRequest->GetLongitude();
606 mockGeoConvertRequest->SetMaxItems(99);
607 mockGeoConvertRequest->GetMaxItems();
608 mockGeoConvertRequest->SetDescription("test");
609 mockGeoConvertRequest->GetDescription();
610 mockGeoConvertRequest->SetMaxLatitude(180);
611 mockGeoConvertRequest->GetMaxLatitude();
612 mockGeoConvertRequest->SetMaxLongitude(90);
613 mockGeoConvertRequest->GetMaxLongitude();
614 mockGeoConvertRequest->SetMinLongitude(0);
615 mockGeoConvertRequest->GetMinLongitude();
616 mockGeoConvertRequest->SetBundleName("test");
617 mockGeoConvertRequest->GetBundleName();
618 sptr<IRemoteObject> callback = nullptr;
619 mockGeoConvertRequest->SetCallback(callback);
620 mockGeoConvertRequest->GetCallback();
621 mockGeoConvertRequest->SetCountry("Shanghai");
622 mockGeoConvertRequest->GetCountry();
623 mockGeoConvertRequest->SetMinLatitude(0);
624 mockGeoConvertRequest->GetMinLatitude();
625 mockGeoConvertRequest->SetTransId("Shanghai");
626 mockGeoConvertRequest->GetTransId();
627 AppExecFwk::InnerEvent::Pointer event = AppExecFwk::InnerEvent::Get(0x0100, mockGeoConvertRequest);
628 ASSERT_TRUE(service_ != nullptr);
629 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] SendGeocodeRequest001 end");
630 }
631
632 HWTEST_F(GeoConvertServiceTest, Marshalling001, TestSize.Level1)
633 {
634 GTEST_LOG_(INFO)
635 << "GeoConvertServiceTest, Marshalling001, TestSize.Level1";
636 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] Marshalling001 begin");
637 MessageParcel parcel;
638 auto mockGeoConvertRequest = std::make_unique<GeoConvertRequest>();
639 mockGeoConvertRequest->SetRequestType(GeoCodeType::REQUEST_GEOCODE);
640 mockGeoConvertRequest->Marshalling(parcel);
641 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] Marshalling001 end");
642 }
643
644 HWTEST_F(GeoConvertServiceTest, ReadFromParcel001, TestSize.Level1)
645 {
646 GTEST_LOG_(INFO)
647 << "GeoConvertServiceTest, ReadFromParcel001, TestSize.Level1";
648 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] ReadFromParcel001 begin");
649 MessageParcel parcel;
650 auto mockGeoConvertRequest = std::make_unique<GeoConvertRequest>();
651 mockGeoConvertRequest->SetRequestType(GeoCodeType::REQUEST_GEOCODE);
652 mockGeoConvertRequest->ReadFromParcel(parcel);
653 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] ReadFromParcel001 end");
654 }
655
656 HWTEST_F(GeoConvertServiceTest, OrderParcel001, TestSize.Level1)
657 {
658 GTEST_LOG_(INFO)
659 << "GeoConvertServiceTest, OrderParcel001, TestSize.Level1";
660 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] OrderParcel001 begin");
661 MessageParcel parcelIn;
662 MessageParcel parcelOut;
663 auto mockGeoConvertRequest = std::make_unique<GeoConvertRequest>();
664 auto cb = sptr<MockIRemoteObject>(new (std::nothrow) MockIRemoteObject());
665 std::string bundleName = "test";
666 GeoCodeType requestType = GeoCodeType::REQUEST_GEOCODE;
667 mockGeoConvertRequest->SetRequestType(GeoCodeType::REQUEST_GEOCODE);
668 mockGeoConvertRequest->OrderParcel(parcelIn, parcelOut, cb, requestType, bundleName);
669 LBSLOGI(GEO_CONVERT, "[GeoConvertServiceTest] OrderParcel001 end");
670 }
671
672 } // namespace Location
673 } // namespace OHOS
674 #endif // FEATURE_GEOCODE_SUPPORT
675