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