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_GNSS_SUPPORT
17 #include "gnss_ability_stub_test.h"
18
19 #include "ipc_types.h"
20 #include "message_option.h"
21 #include "message_parcel.h"
22
23 #include "common_utils.h"
24 #include "constant_definition.h"
25 #include "gnss_ability_proxy.h"
26 #include "location_log.h"
27 #include "subability_common.h"
28 #include "locationhub_ipc_interface_code.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Location {
35 const int UNKNOWN_CODE = -1;
SetUp()36 void GnssAbilityStubTest::SetUp()
37 {
38 }
39
TearDown()40 void GnssAbilityStubTest::TearDown()
41 {
42 }
43
44 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest001, TestSize.Level1)
45 {
46 GTEST_LOG_(INFO)
47 << "GnssAbilityStubTest, GnssAbilityStubTest001, TestSize.Level1";
48 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest001 begin");
49 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
50 EXPECT_CALL(*gnssAbilityStub, SendMessage(_, _, _)).WillOnce(DoAll(Return()));
51 MessageParcel parcel;
52 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
53 MessageParcel reply;
54 MessageOption option;
55 EXPECT_EQ(ERRCODE_SUCCESS,
56 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::SEND_LOCATION_REQUEST),
57 parcel, reply, option));
58 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest001 end");
59 }
60
61 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest002, TestSize.Level1)
62 {
63 GTEST_LOG_(INFO)
64 << "GnssAbilityStubTest, GnssAbilityStubTest002, TestSize.Level1";
65 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest002 begin");
66 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
67 EXPECT_CALL(*gnssAbilityStub, SendMessage(_, _, _)).WillOnce(DoAll(Return()));
68 MessageParcel parcel;
69 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
70 MessageParcel reply;
71 MessageOption option;
72 EXPECT_EQ(ERRCODE_SUCCESS,
73 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::SET_ENABLE),
74 parcel, reply, option));
75 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest002 end");
76 }
77
78 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest003, TestSize.Level1)
79 {
80 GTEST_LOG_(INFO)
81 << "GnssAbilityStubTest, GnssAbilityStubTest003, TestSize.Level1";
82 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest003 begin");
83 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
84 EXPECT_CALL(*gnssAbilityStub, RefrashRequirements()).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
85 MessageParcel parcel;
86 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
87 MessageParcel reply;
88 MessageOption option;
89 EXPECT_EQ(ERRCODE_SUCCESS,
90 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::REFRESH_REQUESTS),
91 parcel, reply, option));
92 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest003 end");
93 }
94
95 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest004, TestSize.Level1)
96 {
97 GTEST_LOG_(INFO)
98 << "GnssAbilityStubTest, GnssAbilityStubTest004, TestSize.Level1";
99 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest004 begin");
100 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
101 EXPECT_CALL(*gnssAbilityStub, RegisterGnssStatusCallback(_, _)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
102 MessageParcel parcel;
103 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
104 MessageParcel reply;
105 MessageOption option;
106 EXPECT_EQ(ERRCODE_SUCCESS,
107 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::REG_GNSS_STATUS),
108 parcel, reply, option));
109 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest004 end");
110 }
111
112 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest005, TestSize.Level1)
113 {
114 GTEST_LOG_(INFO)
115 << "GnssAbilityStubTest, GnssAbilityStubTest005, TestSize.Level1";
116 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest005 begin");
117 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
118 EXPECT_CALL(*gnssAbilityStub, UnregisterGnssStatusCallback(_)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
119 MessageParcel parcel;
120 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
121 MessageParcel reply;
122 MessageOption option;
123 EXPECT_EQ(ERRCODE_SUCCESS,
124 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::UNREG_GNSS_STATUS),
125 parcel, reply, option));
126 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest005 end");
127 }
128
129 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest006, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO)
132 << "GnssAbilityStubTest, GnssAbilityStubTest006, TestSize.Level1";
133 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest006 begin");
134 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
135 EXPECT_CALL(*gnssAbilityStub, RegisterNmeaMessageCallback(_, _)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
136 MessageParcel parcel;
137 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
138 MessageParcel reply;
139 MessageOption option;
140 EXPECT_EQ(ERRCODE_SUCCESS,
141 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::REG_NMEA),
142 parcel, reply, option));
143 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest006 end");
144 }
145
146 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest007, TestSize.Level1)
147 {
148 GTEST_LOG_(INFO)
149 << "GnssAbilityStubTest, GnssAbilityStubTest007, TestSize.Level1";
150 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest007 begin");
151 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
152 EXPECT_CALL(*gnssAbilityStub, RegisterCachedCallback(_, _)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
153 MessageParcel parcel;
154 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
155 MessageParcel reply;
156 MessageOption option;
157 EXPECT_EQ(ERRCODE_SUCCESS,
158 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::REG_CACHED),
159 parcel, reply, option));
160 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest007 end");
161 }
162
163 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest008, TestSize.Level1)
164 {
165 GTEST_LOG_(INFO)
166 << "GnssAbilityStubTest, GnssAbilityStubTest008, TestSize.Level1";
167 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest008 begin");
168 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
169 EXPECT_CALL(*gnssAbilityStub, UnregisterCachedCallback(_)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
170 MessageParcel parcel;
171 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
172 MessageParcel reply;
173 MessageOption option;
174 EXPECT_EQ(ERRCODE_SUCCESS,
175 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::UNREG_CACHED),
176 parcel, reply, option));
177 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest008 end");
178 }
179
180 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest009, TestSize.Level1)
181 {
182 GTEST_LOG_(INFO)
183 << "GnssAbilityStubTest, GnssAbilityStubTest009, TestSize.Level1";
184 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest009 begin");
185 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
186 EXPECT_CALL(*gnssAbilityStub, SendMessage(_, _, _)).WillOnce(DoAll(Return()));
187 MessageParcel parcel;
188 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
189 MessageParcel reply;
190 MessageOption option;
191 EXPECT_EQ(ERRCODE_SUCCESS,
192 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::SEND_COMMANDS),
193 parcel, reply, option));
194 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest009 end");
195 }
196
197 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest010, TestSize.Level1)
198 {
199 GTEST_LOG_(INFO)
200 << "GnssAbilityStubTest, GnssAbilityStubTest010, TestSize.Level1";
201 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest010 begin");
202 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
203 EXPECT_CALL(*gnssAbilityStub, EnableMock()).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
204 MessageParcel parcel;
205 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
206 MessageParcel reply;
207 MessageOption option;
208 EXPECT_EQ(ERRCODE_SUCCESS,
209 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::ENABLE_LOCATION_MOCK),
210 parcel, reply, option));
211 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest010 end");
212 }
213
214 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest011, TestSize.Level1)
215 {
216 GTEST_LOG_(INFO)
217 << "GnssAbilityStubTest, GnssAbilityStubTest011, TestSize.Level1";
218 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest011 begin");
219 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
220 EXPECT_CALL(*gnssAbilityStub, DisableMock()).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
221 MessageParcel parcel;
222 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
223 MessageParcel reply;
224 MessageOption option;
225 EXPECT_EQ(ERRCODE_SUCCESS,
226 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::DISABLE_LOCATION_MOCK),
227 parcel, reply, option));
228 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest011 end");
229 }
230
231 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest012, TestSize.Level1)
232 {
233 GTEST_LOG_(INFO)
234 << "GnssAbilityStubTest, GnssAbilityStubTest012, TestSize.Level1";
235 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest012 begin");
236 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
237 EXPECT_CALL(*gnssAbilityStub, SendMessage(_, _, _)).WillOnce(DoAll(Return()));
238 MessageParcel parcel;
239 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
240 MessageParcel reply;
241 MessageOption option;
242 EXPECT_EQ(ERRCODE_SUCCESS,
243 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::SET_MOCKED_LOCATIONS),
244 parcel, reply, option));
245 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest012 end");
246 }
247
248 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest013, TestSize.Level1)
249 {
250 GTEST_LOG_(INFO)
251 << "GnssAbilityStubTest, GnssAbilityStubTest013, TestSize.Level1";
252 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest013 begin");
253 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
254 EXPECT_CALL(*gnssAbilityStub, FlushCachedGnssLocations()).WillOnce(DoAll(Return(ERRCODE_NOT_SUPPORTED)));
255 MessageParcel parcel;
256 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
257 MessageParcel reply;
258 MessageOption option;
259 EXPECT_EQ(ERRCODE_SUCCESS,
260 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::FLUSH_CACHED),
261 parcel, reply, option));
262 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest013 end");
263 }
264
265 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest014, TestSize.Level1)
266 {
267 GTEST_LOG_(INFO)
268 << "GnssAbilityStubTest, GnssAbilityStubTest014, TestSize.Level1";
269 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest014 begin");
270 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
271 EXPECT_CALL(*gnssAbilityStub, GetCachedGnssLocationsSize(_)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
272 MessageParcel parcel;
273 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
274 MessageParcel reply;
275 MessageOption option;
276 EXPECT_EQ(ERRCODE_SUCCESS,
277 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::GET_CACHED_SIZE),
278 parcel, reply, option));
279 EXPECT_EQ(ERRCODE_SUCCESS, reply.ReadInt32());
280 EXPECT_EQ(-1, reply.ReadInt32());
281 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest014 end");
282 }
283
284 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest015, TestSize.Level1)
285 {
286 GTEST_LOG_(INFO)
287 << "GnssAbilityStubTest, GnssAbilityStubTest015, TestSize.Level1";
288 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest015 begin");
289 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
290 MessageParcel parcel;
291 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
292 MessageParcel reply;
293 MessageOption option;
294 EXPECT_EQ(IPC_STUB_UNKNOW_TRANS_ERR,
295 gnssAbilityStub->OnRemoteRequest(UNKNOWN_CODE, parcel, reply, option));
296 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest015 end");
297 }
298
299 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest016, TestSize.Level1)
300 {
301 GTEST_LOG_(INFO)
302 << "GnssAbilityStubTest, GnssAbilityStubTest016, TestSize.Level1";
303 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest016 begin");
304 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
305 MessageParcel parcel;
306 parcel.WriteInterfaceToken(u"UNKNOWN_DESCRIPTOR");
307 MessageParcel reply;
308 MessageOption option;
309 EXPECT_EQ(ERRCODE_SERVICE_UNAVAILABLE,
310 gnssAbilityStub->OnRemoteRequest(UNKNOWN_CODE, parcel, reply, option));
311 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest016 end");
312 }
313
314 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest017, TestSize.Level1)
315 {
316 GTEST_LOG_(INFO)
317 << "GnssAbilityStubTest, GnssAbilityStubTest017, TestSize.Level1";
318 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest017 begin");
319 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
320 ON_CALL(*gnssAbilityStub, AddFence(_)).WillByDefault(Return(ERRCODE_SUCCESS));
321 MessageParcel parcel;
322 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
323 MessageParcel reply;
324 MessageOption option;
325 EXPECT_EQ(ERRCODE_SUCCESS,
326 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::ADD_FENCE_INFO),
327 parcel, reply, option));
328 EXPECT_EQ(ERRCODE_SUCCESS, reply.ReadInt32());
329 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest017 end");
330 }
331
332 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest018, TestSize.Level1)
333 {
334 GTEST_LOG_(INFO)
335 << "GnssAbilityStubTest, GnssAbilityStubTest018, TestSize.Level1";
336 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest018 begin");
337 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
338 ON_CALL(*gnssAbilityStub, RemoveFence(_)).WillByDefault(Return(ERRCODE_SUCCESS));
339 MessageParcel parcel;
340 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
341 MessageParcel reply;
342 MessageOption option;
343 EXPECT_EQ(ERRCODE_SUCCESS,
344 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::REMOVE_FENCE_INFO),
345 parcel, reply, option));
346 EXPECT_EQ(ERRCODE_SUCCESS, reply.ReadInt32());
347 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest018 end");
348 }
349
350 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest019, TestSize.Level1)
351 {
352 GTEST_LOG_(INFO)
353 << "GnssAbilityStubTest, GnssAbilityStubTest019, TestSize.Level1";
354 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest019 begin");
355 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
356 ON_CALL(*gnssAbilityStub, AddGnssGeofence(_)).WillByDefault(Return(ERRCODE_SUCCESS));
357 MessageParcel parcel;
358 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
359 MessageParcel reply;
360 MessageOption option;
361 EXPECT_EQ(ERRCODE_SUCCESS,
362 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::ADD_GNSS_GEOFENCE),
363 parcel, reply, option));
364 EXPECT_EQ(ERRCODE_SUCCESS, reply.ReadInt32());
365 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest019 end");
366 }
367
368 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest020, TestSize.Level1)
369 {
370 GTEST_LOG_(INFO)
371 << "GnssAbilityStubTest, GnssAbilityStubTest020, TestSize.Level1";
372 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest020 begin");
373 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
374 ON_CALL(*gnssAbilityStub, RemoveGnssGeofence(_)).WillByDefault(Return(ERRCODE_SUCCESS));
375 MessageParcel parcel;
376 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
377 MessageParcel reply;
378 MessageOption option;
379 EXPECT_EQ(ERRCODE_SUCCESS,
380 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::REMOVE_GNSS_GEOFENCE),
381 parcel, reply, option));
382 EXPECT_EQ(ERRCODE_SUCCESS, reply.ReadInt32());
383 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest020 end");
384 }
385
386 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest021, TestSize.Level1)
387 {
388 GTEST_LOG_(INFO)
389 << "GnssAbilityStubTest, GnssAbilityStubTest021, TestSize.Level1";
390 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest021 begin");
391 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
392 EXPECT_CALL(*gnssAbilityStub, QuerySupportCoordinateSystemType(_)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
393 MessageParcel parcel;
394 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
395 MessageParcel reply;
396 MessageOption option;
397 EXPECT_EQ(ERRCODE_SUCCESS, gnssAbilityStub->OnRemoteRequest(
398 static_cast<uint32_t>(GnssInterfaceCode::GET_GEOFENCE_SUPPORT_COORDINATE_SYSTEM_TYPE),
399 parcel, reply, option));
400 EXPECT_EQ(ERRCODE_SUCCESS, reply.ReadInt32());
401 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest021 end");
402 }
403
404 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest022, TestSize.Level1)
405 {
406 GTEST_LOG_(INFO)
407 << "GnssAbilityStubTest, GnssAbilityStubTest022, TestSize.Level1";
408 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest022 begin");
409 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
410 ON_CALL(*gnssAbilityStub, SendNetworkLocation(_)).WillByDefault(Return(ERRCODE_SUCCESS));
411 MessageParcel parcel;
412 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
413 MessageParcel reply;
414 MessageOption option;
415 EXPECT_EQ(ERRCODE_SUCCESS,
416 gnssAbilityStub->OnRemoteRequest(static_cast<uint32_t>(GnssInterfaceCode::SEND_NETWORK_LOCATION),
417 parcel, reply, option));
418 EXPECT_EQ(ERRCODE_SUCCESS, reply.ReadInt32());
419 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest022 end");
420 }
421 } // namespace Location
422 } // namespace OHOS
423 #endif // FEATURE_GNSS_SUPPORT
424