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 #include "gnss_ability_stub_test.h"
17
18 #include "ipc_types.h"
19 #include "message_option.h"
20 #include "message_parcel.h"
21
22 #include "common_utils.h"
23 #include "constant_definition.h"
24 #include "gnss_ability_proxy.h"
25 #include "location_log.h"
26 #include "subability_common.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Location {
33 const int UNKNOWN_CODE = -1;
SetUp()34 void GnssAbilityStubTest::SetUp()
35 {
36 }
37
TearDown()38 void GnssAbilityStubTest::TearDown()
39 {
40 }
41
42 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest001, TestSize.Level1)
43 {
44 GTEST_LOG_(INFO)
45 << "GnssAbilityStubTest, GnssAbilityStubTest001, TestSize.Level1";
46 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest001 begin");
47 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
48 EXPECT_CALL(*gnssAbilityStub, SendMessage(_, _, _)).WillOnce(DoAll(Return()));
49 MessageParcel parcel;
50 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
51 MessageParcel reply;
52 MessageOption option;
53 EXPECT_EQ(ERRCODE_SUCCESS,
54 gnssAbilityStub->OnRemoteRequest(ISubAbility::SEND_LOCATION_REQUEST, parcel, reply, option));
55 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest001 end");
56 }
57
58 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest002, TestSize.Level1)
59 {
60 GTEST_LOG_(INFO)
61 << "GnssAbilityStubTest, GnssAbilityStubTest002, TestSize.Level1";
62 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest002 begin");
63 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
64 EXPECT_CALL(*gnssAbilityStub, SetEnable(_)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
65 MessageParcel parcel;
66 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
67 MessageParcel reply;
68 MessageOption option;
69 EXPECT_EQ(ERRCODE_SUCCESS,
70 gnssAbilityStub->OnRemoteRequest(ISubAbility::SET_ENABLE, parcel, reply, option));
71 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest002 end");
72 }
73
74 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest003, TestSize.Level1)
75 {
76 GTEST_LOG_(INFO)
77 << "GnssAbilityStubTest, GnssAbilityStubTest003, TestSize.Level1";
78 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest003 begin");
79 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
80 EXPECT_CALL(*gnssAbilityStub, RefrashRequirements()).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
81 MessageParcel parcel;
82 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
83 MessageParcel reply;
84 MessageOption option;
85 EXPECT_EQ(ERRCODE_SUCCESS,
86 gnssAbilityStub->OnRemoteRequest(ISubAbility::REFRESH_REQUESTS, parcel, reply, option));
87 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest003 end");
88 }
89
90 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest004, TestSize.Level1)
91 {
92 GTEST_LOG_(INFO)
93 << "GnssAbilityStubTest, GnssAbilityStubTest004, TestSize.Level1";
94 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest004 begin");
95 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
96 EXPECT_CALL(*gnssAbilityStub, RegisterGnssStatusCallback(_, _)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
97 MessageParcel parcel;
98 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
99 MessageParcel reply;
100 MessageOption option;
101 EXPECT_EQ(ERRCODE_SUCCESS,
102 gnssAbilityStub->OnRemoteRequest(ISubAbility::REG_GNSS_STATUS, parcel, reply, option));
103 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest004 end");
104 }
105
106 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest005, TestSize.Level1)
107 {
108 GTEST_LOG_(INFO)
109 << "GnssAbilityStubTest, GnssAbilityStubTest005, TestSize.Level1";
110 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest005 begin");
111 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
112 EXPECT_CALL(*gnssAbilityStub, UnregisterGnssStatusCallback(_)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
113 MessageParcel parcel;
114 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
115 MessageParcel reply;
116 MessageOption option;
117 EXPECT_EQ(ERRCODE_SUCCESS,
118 gnssAbilityStub->OnRemoteRequest(ISubAbility::UNREG_GNSS_STATUS, parcel, reply, option));
119 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest005 end");
120 }
121
122 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest006, TestSize.Level1)
123 {
124 GTEST_LOG_(INFO)
125 << "GnssAbilityStubTest, GnssAbilityStubTest006, TestSize.Level1";
126 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest006 begin");
127 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
128 EXPECT_CALL(*gnssAbilityStub, RegisterNmeaMessageCallback(_, _)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
129 MessageParcel parcel;
130 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
131 MessageParcel reply;
132 MessageOption option;
133 EXPECT_EQ(ERRCODE_SUCCESS,
134 gnssAbilityStub->OnRemoteRequest(ISubAbility::REG_NMEA, parcel, reply, option));
135 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest006 end");
136 }
137
138 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest007, TestSize.Level1)
139 {
140 GTEST_LOG_(INFO)
141 << "GnssAbilityStubTest, GnssAbilityStubTest007, TestSize.Level1";
142 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest007 begin");
143 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
144 EXPECT_CALL(*gnssAbilityStub, RegisterCachedCallback(_, _)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
145 MessageParcel parcel;
146 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
147 MessageParcel reply;
148 MessageOption option;
149 EXPECT_EQ(ERRCODE_SUCCESS,
150 gnssAbilityStub->OnRemoteRequest(ISubAbility::REG_CACHED, parcel, reply, option));
151 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest007 end");
152 }
153
154 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest008, TestSize.Level1)
155 {
156 GTEST_LOG_(INFO)
157 << "GnssAbilityStubTest, GnssAbilityStubTest008, TestSize.Level1";
158 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest008 begin");
159 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
160 EXPECT_CALL(*gnssAbilityStub, UnregisterCachedCallback(_)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
161 MessageParcel parcel;
162 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
163 MessageParcel reply;
164 MessageOption option;
165 EXPECT_EQ(ERRCODE_SUCCESS,
166 gnssAbilityStub->OnRemoteRequest(ISubAbility::UNREG_CACHED, parcel, reply, option));
167 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest008 end");
168 }
169
170 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest009, TestSize.Level1)
171 {
172 GTEST_LOG_(INFO)
173 << "GnssAbilityStubTest, GnssAbilityStubTest009, TestSize.Level1";
174 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest009 begin");
175 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
176 EXPECT_CALL(*gnssAbilityStub, SendCommand(_)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
177 MessageParcel parcel;
178 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
179 MessageParcel reply;
180 MessageOption option;
181 EXPECT_EQ(ERRCODE_SUCCESS,
182 gnssAbilityStub->OnRemoteRequest(ISubAbility::SEND_COMMANDS, parcel, reply, option));
183 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest009 end");
184 }
185
186 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest010, TestSize.Level1)
187 {
188 GTEST_LOG_(INFO)
189 << "GnssAbilityStubTest, GnssAbilityStubTest010, TestSize.Level1";
190 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest010 begin");
191 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
192 EXPECT_CALL(*gnssAbilityStub, EnableMock()).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
193 MessageParcel parcel;
194 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
195 MessageParcel reply;
196 MessageOption option;
197 EXPECT_EQ(ERRCODE_SUCCESS,
198 gnssAbilityStub->OnRemoteRequest(ISubAbility::ENABLE_LOCATION_MOCK, parcel, reply, option));
199 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest010 end");
200 }
201
202 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest011, TestSize.Level1)
203 {
204 GTEST_LOG_(INFO)
205 << "GnssAbilityStubTest, GnssAbilityStubTest011, TestSize.Level1";
206 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest011 begin");
207 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
208 EXPECT_CALL(*gnssAbilityStub, DisableMock()).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
209 MessageParcel parcel;
210 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
211 MessageParcel reply;
212 MessageOption option;
213 EXPECT_EQ(ERRCODE_SUCCESS,
214 gnssAbilityStub->OnRemoteRequest(ISubAbility::DISABLE_LOCATION_MOCK, parcel, reply, option));
215 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest011 end");
216 }
217
218 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest012, TestSize.Level1)
219 {
220 GTEST_LOG_(INFO)
221 << "GnssAbilityStubTest, GnssAbilityStubTest012, TestSize.Level1";
222 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest012 begin");
223 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
224 EXPECT_CALL(*gnssAbilityStub, SendMessage(_, _, _)).WillOnce(DoAll(Return()));
225 MessageParcel parcel;
226 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
227 MessageParcel reply;
228 MessageOption option;
229 EXPECT_EQ(ERRCODE_SUCCESS,
230 gnssAbilityStub->OnRemoteRequest(ISubAbility::SET_MOCKED_LOCATIONS, parcel, reply, option));
231 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest012 end");
232 }
233
234 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest013, TestSize.Level1)
235 {
236 GTEST_LOG_(INFO)
237 << "GnssAbilityStubTest, GnssAbilityStubTest013, TestSize.Level1";
238 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest013 begin");
239 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
240 EXPECT_CALL(*gnssAbilityStub, FlushCachedGnssLocations()).WillOnce(DoAll(Return(ERRCODE_NOT_SUPPORTED)));
241 MessageParcel parcel;
242 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
243 MessageParcel reply;
244 MessageOption option;
245 EXPECT_EQ(ERRCODE_SUCCESS,
246 gnssAbilityStub->OnRemoteRequest(ISubAbility::FLUSH_CACHED, parcel, reply, option));
247 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest013 end");
248 }
249
250 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest014, TestSize.Level1)
251 {
252 GTEST_LOG_(INFO)
253 << "GnssAbilityStubTest, GnssAbilityStubTest014, TestSize.Level1";
254 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest014 begin");
255 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
256 EXPECT_CALL(*gnssAbilityStub, GetCachedGnssLocationsSize(_)).WillOnce(DoAll(Return(ERRCODE_SUCCESS)));
257 MessageParcel parcel;
258 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
259 MessageParcel reply;
260 MessageOption option;
261 EXPECT_EQ(ERRCODE_SUCCESS,
262 gnssAbilityStub->OnRemoteRequest(ISubAbility::GET_CACHED_SIZE, parcel, reply, option));
263 EXPECT_EQ(ERRCODE_SUCCESS, reply.ReadInt32());
264 EXPECT_EQ(-1, reply.ReadInt32());
265 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest014 end");
266 }
267
268 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest015, TestSize.Level1)
269 {
270 GTEST_LOG_(INFO)
271 << "GnssAbilityStubTest, GnssAbilityStubTest015, TestSize.Level1";
272 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest015 begin");
273 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
274 MessageParcel parcel;
275 parcel.WriteInterfaceToken(GnssAbilityProxy::GetDescriptor());
276 MessageParcel reply;
277 MessageOption option;
278 EXPECT_EQ(IPC_STUB_UNKNOW_TRANS_ERR,
279 gnssAbilityStub->OnRemoteRequest(UNKNOWN_CODE, parcel, reply, option));
280 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest015 end");
281 }
282
283 HWTEST_F(GnssAbilityStubTest, GnssAbilityStubTest016, TestSize.Level1)
284 {
285 GTEST_LOG_(INFO)
286 << "GnssAbilityStubTest, GnssAbilityStubTest016, TestSize.Level1";
287 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest016 begin");
288 auto gnssAbilityStub = sptr<MockGnssAbilityStub>(new (std::nothrow) MockGnssAbilityStub());
289 MessageParcel parcel;
290 parcel.WriteInterfaceToken(u"UNKNOWN_DESCRIPTOR");
291 MessageParcel reply;
292 MessageOption option;
293 EXPECT_EQ(ERRCODE_SERVICE_UNAVAILABLE,
294 gnssAbilityStub->OnRemoteRequest(UNKNOWN_CODE, parcel, reply, option));
295 LBSLOGI(GNSS, "[GnssAbilityStubTest] GnssAbilityStubTest016 end");
296 }
297 } // namespace Location
298 } // namespace OHOS