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 "callback_test.h"
17
18 #include "message_parcel.h"
19
20 #ifdef FEATURE_GNSS_SUPPORT
21 #include "cached_locations_callback_host.h"
22 #endif
23 #include "country_code.h"
24 #include "country_code_callback_host.h"
25 #ifdef FEATURE_GNSS_SUPPORT
26 #include "gnss_status_callback_host.h"
27 #endif
28 #include "location.h"
29 #include "location_switch_callback_host.h"
30 #include "locator_callback_host.h"
31 #ifdef FEATURE_GNSS_SUPPORT
32 #include "nmea_message_callback_host.h"
33 #include "satellite_status.h"
34 #endif
35
36 using namespace testing;
37 using namespace testing::ext;
38 namespace OHOS {
39 namespace Location {
SetUp()40 void CallbackTest::SetUp()
41 {
42 }
43
TearDown()44 void CallbackTest::TearDown()
45 {
46 }
47
48 #ifdef FEATURE_GNSS_SUPPORT
49 HWTEST_F(CallbackTest, OnCacheLocationsReport001, TestSize.Level1)
50 {
51 GTEST_LOG_(INFO)
52 << "CallbackTest, OnCacheLocationsReport001, TestSize.Level1";
53 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] OnCacheLocationsReport001 begin");
54 auto cachedLocationsCallbackHost =
55 sptr<CachedLocationsCallbackHost>(new (std::nothrow) CachedLocationsCallbackHost());
56 EXPECT_NE(nullptr, cachedLocationsCallbackHost);
57 auto cachedLocationsCallbackProxy =
58 new (std::nothrow) CachedLocationsCallbackProxy(cachedLocationsCallbackHost);
59 EXPECT_NE(nullptr, cachedLocationsCallbackProxy);
60 std::vector<std::unique_ptr<Location>> locations;
61 auto location =
62 std::make_unique<Location>();
63 MessageParcel parcel;
64 parcel.WriteDouble(1.0); // latitude
65 parcel.WriteDouble(2.0); // longitude
66 parcel.WriteDouble(3.0); // altitude
67 parcel.WriteDouble(1000.0); // accuracy
68 parcel.WriteDouble(10.0); // speed
69 parcel.WriteDouble(6.0); // direction
70 parcel.WriteInt64(1000000000); // timeStamp
71 parcel.WriteInt64(1000000000); // timeSinceBoot
72 parcel.WriteString("additions"); // additions
73 parcel.WriteInt64(1); // additionSize
74 parcel.WriteBool(true); // isFromMock
75 parcel.WriteInt32(1); // source type
76 parcel.WriteInt32(0); // floor no.
77 parcel.WriteDouble(1000.0); // floor acc
78 EXPECT_NE(nullptr, location);
79 location->ReadFromParcel(parcel);
80 locations.emplace_back(std::move(location));
81 cachedLocationsCallbackProxy->OnCacheLocationsReport(locations);
82 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] OnCacheLocationsReport001 end");
83 }
84 #endif
85
86 HWTEST_F(CallbackTest, OnSwitchChange001, TestSize.Level1)
87 {
88 GTEST_LOG_(INFO)
89 << "CallbackTest, OnSwitchChange001, TestSize.Level1";
90 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] OnSwitchChange001 begin");
91 auto switchCallbackHost =
92 sptr<LocationSwitchCallbackHost>(new (std::nothrow) LocationSwitchCallbackHost());
93 EXPECT_NE(nullptr, switchCallbackHost);
94 auto switchCallbackProxy =
95 new (std::nothrow) SwitchCallbackProxy(switchCallbackHost);
96 EXPECT_NE(nullptr, switchCallbackProxy);
97 int state = 1;
98 switchCallbackProxy->OnSwitchChange(state);
99 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] OnSwitchChange001 end");
100 }
101
102 #ifdef FEATURE_GNSS_SUPPORT
103 HWTEST_F(CallbackTest, OnMessageChange001, TestSize.Level1)
104 {
105 GTEST_LOG_(INFO)
106 << "CallbackTest, OnMessageChange001, TestSize.Level1";
107 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] OnMessageChange001 begin");
108 auto nmeaCallbackHost =
109 sptr<NmeaMessageCallbackHost>(new (std::nothrow) NmeaMessageCallbackHost());
110 EXPECT_NE(nullptr, nmeaCallbackHost);
111 auto nmeaCallbackProxy =
112 new (std::nothrow) NmeaMessageCallbackProxy(nmeaCallbackHost);
113 EXPECT_NE(nullptr, nmeaCallbackProxy);
114 std::string msg = "msg";
115 int64_t timestamp = 0;
116 nmeaCallbackProxy->OnMessageChange(timestamp, msg);
117 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] OnMessageChange001 end");
118 }
119 #endif
120
121 HWTEST_F(CallbackTest, LocationCallbackProxy001, TestSize.Level1)
122 {
123 GTEST_LOG_(INFO)
124 << "CallbackTest, LocationCallbackProxy001, TestSize.Level1";
125 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationCallbackProxy001 begin");
126 auto locatorCallbackHost =
127 sptr<LocatorCallbackHost>(new (std::nothrow) LocatorCallbackHost());
128 EXPECT_NE(nullptr, locatorCallbackHost);
129 auto locatorCallbackProxy =
130 new (std::nothrow) LocatorCallbackProxy(locatorCallbackHost);
131 EXPECT_NE(nullptr, locatorCallbackProxy);
132 locatorCallbackProxy->OnLocationReport(nullptr); // nullptr error
133 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationCallbackProxy001 end");
134 }
135
136 HWTEST_F(CallbackTest, LocationCallbackProxy002, TestSize.Level1)
137 {
138 GTEST_LOG_(INFO)
139 << "CallbackTest, LocationCallbackProxy002, TestSize.Level1";
140 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationCallbackProxy002 begin");
141 auto locatorCallbackHost =
142 sptr<LocatorCallbackHost>(new (std::nothrow) LocatorCallbackHost());
143 EXPECT_NE(nullptr, locatorCallbackHost);
144 auto locatorCallbackProxy =
145 new (std::nothrow) LocatorCallbackProxy(locatorCallbackHost);
146 EXPECT_NE(nullptr, locatorCallbackProxy);
147 int status = 1;
148 locatorCallbackProxy->OnLocatingStatusChange(status);
149 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationCallbackProxy002 end");
150 }
151
152 HWTEST_F(CallbackTest, LocationCallbackProxy003, TestSize.Level1)
153 {
154 GTEST_LOG_(INFO)
155 << "CallbackTest, LocationCallbackProxy003, TestSize.Level1";
156 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationCallbackProxy003 begin");
157 auto locatorCallbackHost =
158 sptr<LocatorCallbackHost>(new (std::nothrow) LocatorCallbackHost());
159 EXPECT_NE(nullptr, locatorCallbackHost);
160 auto locatorCallbackProxy =
161 new (std::nothrow) LocatorCallbackProxy(locatorCallbackHost);
162 EXPECT_NE(nullptr, locatorCallbackProxy);
163 int errorCode = 0;
164 locatorCallbackProxy->OnErrorReport(errorCode);
165 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationCallbackProxy003 end");
166 }
167
168 #ifdef FEATURE_GNSS_SUPPORT
169 HWTEST_F(CallbackTest, GnssStatusCallbackProxy001, TestSize.Level1)
170 {
171 GTEST_LOG_(INFO)
172 << "CallbackTest, GnssStatusCallbackProxy001, TestSize.Level1";
173 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackProxy001 begin");
174 auto gnssStatusCallbackHost =
175 sptr<GnssStatusCallbackHost>(new (std::nothrow) GnssStatusCallbackHost());
176 EXPECT_NE(nullptr, gnssStatusCallbackHost);
177 auto gnssStatusCallbackProxy =
178 new (std::nothrow) GnssStatusCallbackProxy(gnssStatusCallbackHost);
179 EXPECT_NE(nullptr, gnssStatusCallbackProxy);
180 auto statusInfo = std::make_unique<SatelliteStatus>();
181 MessageParcel parcel;
182 parcel.WriteInt64(2);
183 for (int i = 0; i < 2; i++) {
184 parcel.WriteInt64(i + 1);
185 parcel.WriteDouble(i + 1.0);
186 parcel.WriteDouble(i + 2.0);
187 parcel.WriteDouble(i + 3.0);
188 parcel.WriteDouble(i + 4.0);
189 parcel.WriteInt64(i + 5.0);
190 }
191 statusInfo->ReadFromParcel(parcel);
192 EXPECT_NE(nullptr, statusInfo);
193 gnssStatusCallbackProxy->OnStatusChange(statusInfo);
194 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackProxy001 end");
195 }
196 #endif
197
198 #ifdef FEATURE_GNSS_SUPPORT
199 HWTEST_F(CallbackTest, GnssStatusCallbackProxy002, TestSize.Level1)
200 {
201 GTEST_LOG_(INFO)
202 << "CallbackTest, GnssStatusCallbackProxy002, TestSize.Level1";
203 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackProxy002 begin");
204 auto gnssStatusCallbackHost =
205 sptr<GnssStatusCallbackHost>(new (std::nothrow) GnssStatusCallbackHost());
206 EXPECT_NE(nullptr, gnssStatusCallbackHost);
207 auto gnssStatusCallbackProxy =
208 new (std::nothrow) GnssStatusCallbackProxy(gnssStatusCallbackHost);
209 EXPECT_NE(nullptr, gnssStatusCallbackProxy);
210 gnssStatusCallbackProxy->OnStatusChange(nullptr);
211 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackProxy002 end");
212 }
213 #endif
214
215 HWTEST_F(CallbackTest, CountryCodeCallbackProxy001, TestSize.Level1)
216 {
217 GTEST_LOG_(INFO)
218 << "CallbackTest, CountryCodeCallbackProxy001, TestSize.Level1";
219 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackProxy001 begin");
220 auto countryCodeCallbackHost =
221 sptr<CountryCodeCallbackHost>(new (std::nothrow) CountryCodeCallbackHost());
222 EXPECT_NE(nullptr, countryCodeCallbackHost);
223 auto countryCodeCallbackProxy =
224 new (std::nothrow) CountryCodeCallbackProxy(countryCodeCallbackHost);
225 EXPECT_NE(nullptr, countryCodeCallbackProxy);
226 auto country = std::make_shared<CountryCode>();
227 MessageParcel parcel;
228 parcel.WriteString("countryCodeStr");
229 parcel.WriteInt64(1);
230 country->ReadFromParcel(parcel);
231 EXPECT_NE(nullptr, country);
232 countryCodeCallbackProxy->OnCountryCodeChange(country);
233 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackProxy001 end");
234 }
235
236 #ifdef FEATURE_GNSS_SUPPORT
237 HWTEST_F(CallbackTest, CachedLocationsCallbackHost001, TestSize.Level1)
238 {
239 GTEST_LOG_(INFO)
240 << "CallbackTest, CachedLocationsCallbackHost001, TestSize.Level1";
241 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CachedLocationsCallbackHost001 begin");
242 auto cachedCallbackHost =
243 sptr<CachedLocationsCallbackHost>(new (std::nothrow) CachedLocationsCallbackHost());
244 EXPECT_NE(nullptr, cachedCallbackHost);
245 EXPECT_NE(true, cachedCallbackHost->IsRemoteDied());
246
247 std::vector<std::unique_ptr<Location>> locationsForReport;
248 cachedCallbackHost->OnCacheLocationsReport(locationsForReport);
249 EXPECT_EQ(0, locationsForReport.size());
250 cachedCallbackHost->DeleteHandler();
251 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CachedLocationsCallbackHost001 end");
252 }
253 #endif
254
255 HWTEST_F(CallbackTest, CountryCodeCallbackHost001, TestSize.Level1)
256 {
257 GTEST_LOG_(INFO)
258 << "CallbackTest, CountryCodeCallbackHost001, TestSize.Level1";
259 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackHost001 begin");
260 auto callbackHost =
261 sptr<CountryCodeCallbackHost>(new (std::nothrow) CountryCodeCallbackHost());
262 EXPECT_NE(nullptr, callbackHost);
263 callbackHost->SetEnv(nullptr);
264 callbackHost->SetCallback(nullptr);
265 callbackHost->DeleteHandler();
266 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackHost001 end");
267 }
268
269 #ifdef FEATURE_GNSS_SUPPORT
270 HWTEST_F(CallbackTest, GnssStatusCallbackHost001, TestSize.Level1)
271 {
272 GTEST_LOG_(INFO)
273 << "CallbackTest, GnssStatusCallbackHost001, TestSize.Level1";
274 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackHost001 begin");
275 auto gnssCallbackHost =
276 sptr<GnssStatusCallbackHost>(new (std::nothrow) GnssStatusCallbackHost());
277 EXPECT_NE(true, gnssCallbackHost->IsRemoteDied());
278 gnssCallbackHost->OnStatusChange(nullptr);
279 gnssCallbackHost->DeleteHandler();
280 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackHost001 end");
281 }
282 #endif
283
284 HWTEST_F(CallbackTest, LocationSwitchCallbackHost001, TestSize.Level1)
285 {
286 GTEST_LOG_(INFO)
287 << "CallbackTest, LocationSwitchCallbackHost001, TestSize.Level1";
288 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationSwitchCallbackHost001 begin");
289 auto switchCallbackHost =
290 sptr<LocationSwitchCallbackHost>(new (std::nothrow) LocationSwitchCallbackHost());
291 EXPECT_NE(true, switchCallbackHost->IsRemoteDied());
292 switchCallbackHost->PackResult(true);
293 switchCallbackHost->DeleteHandler();
294 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationSwitchCallbackHost001 end");
295 }
296
297 HWTEST_F(CallbackTest, LocationCallbackHost001, TestSize.Level1)
298 {
299 GTEST_LOG_(INFO)
300 << "CallbackTest, LocationCallbackHost001, TestSize.Level1";
301 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationCallbackHost001 begin");
302 auto callbackHost =
303 sptr<LocatorCallbackHost>(new (std::nothrow) LocatorCallbackHost());
304
305 std::unique_ptr<Location> location = std::make_unique<Location>();
306 EXPECT_NE(true, callbackHost->IsSystemGeoLocationApi());
307 EXPECT_NE(true, callbackHost->IsSingleLocationRequest());
308 callbackHost->CountDown();
309 callbackHost->Wait(1);
310 callbackHost->SetCount(1);
311 EXPECT_EQ(0, callbackHost->GetCount());
312 callbackHost->DeleteAllCallbacks();
313 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationCallbackHost001 end");
314 }
315
316 #ifdef FEATURE_GNSS_SUPPORT
317 HWTEST_F(CallbackTest, NmeaMessageCallbackHost001, TestSize.Level1)
318 {
319 GTEST_LOG_(INFO)
320 << "CallbackTest, NmeaMessageCallbackHost001, TestSize.Level1";
321 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] NmeaMessageCallbackHost001 begin");
322 auto nmeaCallbackHost =
323 sptr<NmeaMessageCallbackHost>(new (std::nothrow) NmeaMessageCallbackHost());
324 EXPECT_NE(true, nmeaCallbackHost->IsRemoteDied());
325 nmeaCallbackHost->PackResult("msg");
326 nmeaCallbackHost->DeleteHandler();
327 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] NmeaMessageCallbackHost001 end");
328 }
329 #endif
330
331 HWTEST_F(CallbackTest, CountryCodeCallbackProxy002, TestSize.Level1)
332 {
333 GTEST_LOG_(INFO)
334 << "CallbackTest, CountryCodeCallbackProxy002, TestSize.Level1";
335 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackProxy002 begin");
336 auto countryCodeCallbackHost =
337 sptr<CountryCodeCallbackHost>(new (std::nothrow) CountryCodeCallbackHost());
338 EXPECT_NE(nullptr, countryCodeCallbackHost);
339 auto countryCodeCallbackProxy =
340 new (std::nothrow) CountryCodeCallbackProxy(countryCodeCallbackHost);
341 EXPECT_NE(nullptr, countryCodeCallbackProxy);
342 countryCodeCallbackProxy->OnCountryCodeChange(nullptr);
343 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackProxy002 end");
344 }
345 } // namespace Location
346 } // namespace OHOS