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