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 }
190 statusInfo->ReadFromParcel(parcel);
191 EXPECT_NE(nullptr, statusInfo);
192 gnssStatusCallbackProxy->OnStatusChange(statusInfo);
193 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackProxy001 end");
194 }
195 #endif
196
197 #ifdef FEATURE_GNSS_SUPPORT
198 HWTEST_F(CallbackTest, GnssStatusCallbackProxy002, TestSize.Level1)
199 {
200 GTEST_LOG_(INFO)
201 << "CallbackTest, GnssStatusCallbackProxy002, TestSize.Level1";
202 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackProxy002 begin");
203 auto gnssStatusCallbackHost =
204 sptr<GnssStatusCallbackHost>(new (std::nothrow) GnssStatusCallbackHost());
205 EXPECT_NE(nullptr, gnssStatusCallbackHost);
206 auto gnssStatusCallbackProxy =
207 new (std::nothrow) GnssStatusCallbackProxy(gnssStatusCallbackHost);
208 EXPECT_NE(nullptr, gnssStatusCallbackProxy);
209 gnssStatusCallbackProxy->OnStatusChange(nullptr);
210 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackProxy002 end");
211 }
212 #endif
213
214 HWTEST_F(CallbackTest, CountryCodeCallbackProxy001, TestSize.Level1)
215 {
216 GTEST_LOG_(INFO)
217 << "CallbackTest, CountryCodeCallbackProxy001, TestSize.Level1";
218 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackProxy001 begin");
219 auto countryCodeCallbackHost =
220 sptr<CountryCodeCallbackHost>(new (std::nothrow) CountryCodeCallbackHost());
221 EXPECT_NE(nullptr, countryCodeCallbackHost);
222 auto countryCodeCallbackProxy =
223 new (std::nothrow) CountryCodeCallbackProxy(countryCodeCallbackHost);
224 EXPECT_NE(nullptr, countryCodeCallbackProxy);
225 auto country = std::make_shared<CountryCode>();
226 MessageParcel parcel;
227 parcel.WriteString("countryCodeStr");
228 parcel.WriteInt64(1);
229 country->ReadFromParcel(parcel);
230 EXPECT_NE(nullptr, country);
231 countryCodeCallbackProxy->OnCountryCodeChange(country);
232 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackProxy001 end");
233 }
234
235 #ifdef FEATURE_GNSS_SUPPORT
236 HWTEST_F(CallbackTest, CachedLocationsCallbackHost001, TestSize.Level1)
237 {
238 GTEST_LOG_(INFO)
239 << "CallbackTest, CachedLocationsCallbackHost001, TestSize.Level1";
240 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CachedLocationsCallbackHost001 begin");
241 auto cachedCallbackHost =
242 sptr<CachedLocationsCallbackHost>(new (std::nothrow) CachedLocationsCallbackHost());
243 EXPECT_NE(nullptr, cachedCallbackHost);
244 EXPECT_NE(true, cachedCallbackHost->IsRemoteDied());
245
246 std::vector<std::unique_ptr<Location>> locationsForReport;
247 cachedCallbackHost->OnCacheLocationsReport(locationsForReport);
248 EXPECT_EQ(0, locationsForReport.size());
249 cachedCallbackHost->DeleteHandler();
250 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CachedLocationsCallbackHost001 end");
251 }
252 #endif
253
254 HWTEST_F(CallbackTest, CountryCodeCallbackHost001, TestSize.Level1)
255 {
256 GTEST_LOG_(INFO)
257 << "CallbackTest, CountryCodeCallbackHost001, TestSize.Level1";
258 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackHost001 begin");
259 auto callbackHost =
260 sptr<CountryCodeCallbackHost>(new (std::nothrow) CountryCodeCallbackHost());
261 EXPECT_NE(nullptr, callbackHost);
262 callbackHost->SetEnv(nullptr);
263 callbackHost->SetCallback(nullptr);
264 callbackHost->DeleteHandler();
265 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackHost001 end");
266 }
267
268 #ifdef FEATURE_GNSS_SUPPORT
269 HWTEST_F(CallbackTest, GnssStatusCallbackHost001, TestSize.Level1)
270 {
271 GTEST_LOG_(INFO)
272 << "CallbackTest, GnssStatusCallbackHost001, TestSize.Level1";
273 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackHost001 begin");
274 auto gnssCallbackHost =
275 sptr<GnssStatusCallbackHost>(new (std::nothrow) GnssStatusCallbackHost());
276 EXPECT_NE(true, gnssCallbackHost->IsRemoteDied());
277 gnssCallbackHost->OnStatusChange(nullptr);
278 gnssCallbackHost->DeleteHandler();
279 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] GnssStatusCallbackHost001 end");
280 }
281 #endif
282
283 HWTEST_F(CallbackTest, LocationSwitchCallbackHost001, TestSize.Level1)
284 {
285 GTEST_LOG_(INFO)
286 << "CallbackTest, LocationSwitchCallbackHost001, TestSize.Level1";
287 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationSwitchCallbackHost001 begin");
288 auto switchCallbackHost =
289 sptr<LocationSwitchCallbackHost>(new (std::nothrow) LocationSwitchCallbackHost());
290 EXPECT_NE(true, switchCallbackHost->IsRemoteDied());
291 switchCallbackHost->PackResult(true);
292 switchCallbackHost->DeleteHandler();
293 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationSwitchCallbackHost001 end");
294 }
295
296 HWTEST_F(CallbackTest, LocationCallbackHost001, TestSize.Level1)
297 {
298 GTEST_LOG_(INFO)
299 << "CallbackTest, LocationCallbackHost001, TestSize.Level1";
300 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationCallbackHost001 begin");
301 auto callbackHost =
302 sptr<LocatorCallbackHost>(new (std::nothrow) LocatorCallbackHost());
303
304 std::unique_ptr<Location> location = std::make_unique<Location>();
305 EXPECT_NE(true, callbackHost->IsSystemGeoLocationApi());
306 EXPECT_NE(true, callbackHost->IsSingleLocationRequest());
307 callbackHost->CountDown();
308 callbackHost->Wait(1);
309 callbackHost->SetCount(1);
310 EXPECT_EQ(0, callbackHost->GetCount());
311 callbackHost->DeleteAllCallbacks();
312 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] LocationCallbackHost001 end");
313 }
314
315 #ifdef FEATURE_GNSS_SUPPORT
316 HWTEST_F(CallbackTest, NmeaMessageCallbackHost001, TestSize.Level1)
317 {
318 GTEST_LOG_(INFO)
319 << "CallbackTest, NmeaMessageCallbackHost001, TestSize.Level1";
320 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] NmeaMessageCallbackHost001 begin");
321 auto nmeaCallbackHost =
322 sptr<NmeaMessageCallbackHost>(new (std::nothrow) NmeaMessageCallbackHost());
323 EXPECT_NE(true, nmeaCallbackHost->IsRemoteDied());
324 nmeaCallbackHost->PackResult("msg");
325 nmeaCallbackHost->DeleteHandler();
326 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] NmeaMessageCallbackHost001 end");
327 }
328 #endif
329
330 HWTEST_F(CallbackTest, CountryCodeCallbackProxy002, TestSize.Level1)
331 {
332 GTEST_LOG_(INFO)
333 << "CallbackTest, CountryCodeCallbackProxy002, TestSize.Level1";
334 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackProxy002 begin");
335 auto countryCodeCallbackHost =
336 sptr<CountryCodeCallbackHost>(new (std::nothrow) CountryCodeCallbackHost());
337 EXPECT_NE(nullptr, countryCodeCallbackHost);
338 auto countryCodeCallbackProxy =
339 new (std::nothrow) CountryCodeCallbackProxy(countryCodeCallbackHost);
340 EXPECT_NE(nullptr, countryCodeCallbackProxy);
341 countryCodeCallbackProxy->OnCountryCodeChange(nullptr);
342 LBSLOGI(LOCATOR_CALLBACK, "[CallbackTest] CountryCodeCallbackProxy002 end");
343 }
344 } // namespace Location
345 } // namespace OHOS