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