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 "location_without_permission_test.h"
17
18 #include "accesstoken_kit.h"
19 #include "message_parcel.h"
20 #include "nativetoken_kit.h"
21 #include "token_setproc.h"
22
23 #ifdef FEATURE_GNSS_SUPPORT
24 #include "cached_locations_callback_host.h"
25 #endif
26 #include "constant_definition.h"
27 #ifdef FEATURE_GEOCODE_SUPPORT
28 #include "geo_address.h"
29 #endif
30 #ifdef FEATURE_GNSS_SUPPORT
31 #include "gnss_status_callback_host.h"
32 #include "i_cached_locations_callback.h"
33 #endif
34 #include "i_locator_callback.h"
35 #include "location_switch_callback_host.h"
36 #include "locator.h"
37 #include "location_log.h"
38 #include "locator_callback_proxy.h"
39 #include "locator_impl.h"
40 #ifdef FEATURE_GNSS_SUPPORT
41 #include "nmea_message_callback_host.h"
42 #endif
43 #include "request_config.h"
44
45 using namespace testing::ext;
46 namespace OHOS {
47 namespace Location {
48 const int32_t LOCATION_WITHOUT_PERM = 1;
SetUp()49 void LocationWithoutPermissionTest::SetUp()
50 {
51 MockNativePermission();
52 }
53
TearDown()54 void LocationWithoutPermissionTest::TearDown()
55 {
56 }
57
MockNativePermission()58 void LocationWithoutPermissionTest::MockNativePermission()
59 {
60 const char *perms[] = {
61 ACCESS_BACKGROUND_LOCATION.c_str(),
62 };
63 NativeTokenInfoParams infoInstance = {
64 .dcapsNum = 0,
65 .permsNum = LOCATION_WITHOUT_PERM,
66 .aclsNum = 0,
67 .dcaps = nullptr,
68 .perms = perms,
69 .acls = nullptr,
70 .processName = "LocatorPermissionTest",
71 .aplStr = "system_basic",
72 };
73 tokenId_ = GetAccessTokenId(&infoInstance);
74 SetSelfTokenID(tokenId_);
75 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
76 }
77
78 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutSettingsPermission001, TestSize.Level1)
79 {
80 GTEST_LOG_(INFO)
81 << "LocationWithoutPermissionTest, LocatorWithoutSettingsPermission001, TestSize.Level1";
82 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutSettingsPermission001 begin");
83 auto locatorImpl = Locator::GetInstance();
84 EXPECT_NE(nullptr, locatorImpl);
85 auto switchCallbackHost =
86 sptr<LocationSwitchCallbackHost>(new (std::nothrow) LocationSwitchCallbackHost());
87 EXPECT_NE(nullptr, switchCallbackHost);
88 EXPECT_EQ(true, locatorImpl->RegisterSwitchCallback(switchCallbackHost->AsObject(), 1000));
89 EXPECT_EQ(true, locatorImpl->UnregisterSwitchCallback(switchCallbackHost->AsObject()));
90 locatorImpl->EnableAbility(true);
91 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutSettingsPermission001 end");
92 }
93
94 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermission001, TestSize.Level1)
95 {
96 GTEST_LOG_(INFO)
97 << "LocationWithoutPermissionTest, LocatorWithoutLocationPermission001, TestSize.Level1";
98 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission001 begin");
99 auto locatorImpl = Locator::GetInstance();
100 EXPECT_NE(nullptr, locatorImpl);
101
102 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
103 requestConfig->SetPriority(PRIORITY_ACCURACY);
104 sptr<ILocatorCallback> callbackStub = new (std::nothrow) LocatorCallbackStub();
105 locatorImpl->StartLocating(requestConfig, callbackStub);
106 locatorImpl->StopLocating(callbackStub);
107
108 EXPECT_EQ(nullptr, locatorImpl->GetCachedLocation());
109 #ifdef FEATURE_GEOCODE_SUPPORT
110 locatorImpl->IsGeoServiceAvailable();
111 MessageParcel request001;
112 std::list<std::shared_ptr<GeoAddress>> geoAddressList001;
113 locatorImpl->GetAddressByCoordinate(request001, geoAddressList001);
114 MessageParcel request002;
115 std::list<std::shared_ptr<GeoAddress>> geoAddressList002;
116 locatorImpl->GetAddressByLocationName(request002, geoAddressList002);
117 #endif
118 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission001 end");
119 }
120
121 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermission002, TestSize.Level1)
122 {
123 GTEST_LOG_(INFO)
124 << "LocationWithoutPermissionTest, LocatorWithoutLocationPermission002, TestSize.Level1";
125 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission002 begin");
126 auto locatorImpl = Locator::GetInstance();
127 EXPECT_NE(nullptr, locatorImpl);
128 bool state = false;
129 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl->IsLocationEnabledV9(state));
130 #ifdef FEATURE_GNSS_SUPPORT
131 auto gnssCallbackHost =
132 sptr<GnssStatusCallbackHost>(new (std::nothrow) GnssStatusCallbackHost());
133 EXPECT_NE(nullptr, gnssCallbackHost);
134 EXPECT_EQ(true, locatorImpl->RegisterGnssStatusCallback(gnssCallbackHost->AsObject(), 1000));
135 EXPECT_EQ(true, locatorImpl->UnregisterGnssStatusCallback(gnssCallbackHost->AsObject()));
136
137 auto nmeaCallbackHost =
138 sptr<NmeaMessageCallbackHost>(new (std::nothrow) NmeaMessageCallbackHost());
139 EXPECT_NE(nullptr, nmeaCallbackHost);
140 EXPECT_EQ(true, locatorImpl->RegisterNmeaMessageCallback(nmeaCallbackHost->AsObject(), 1000));
141 EXPECT_EQ(true, locatorImpl->UnregisterNmeaMessageCallback(nmeaCallbackHost->AsObject()));
142 #endif
143 EXPECT_EQ(false, locatorImpl->IsLocationPrivacyConfirmed(1));
144 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->SetLocationPrivacyConfirmStatus(1, true));
145 #ifdef FEATURE_GNSS_SUPPORT
146 if (state) {
147 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->FlushCachedGnssLocations());
148 } else {
149 EXPECT_EQ(ERRCODE_SWITCH_OFF, locatorImpl->FlushCachedGnssLocations());
150 }
151 #endif
152
153 EXPECT_EQ(false, locatorImpl->ProxyUidForFreeze(1000, false));
154 EXPECT_EQ(false, locatorImpl->ResetAllProxy());
155 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission002 end");
156 }
157
158 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermission003, TestSize.Level1)
159 {
160 GTEST_LOG_(INFO)
161 << "LocationWithoutPermissionTest, LocatorWithoutLocationPermission003, TestSize.Level1";
162 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission003 begin");
163 auto locatorImpl = Locator::GetInstance();
164 EXPECT_NE(nullptr, locatorImpl);
165 #ifdef FEATURE_GNSS_SUPPORT
166 std::unique_ptr<GeofenceRequest> fenceRequest = std::make_unique<GeofenceRequest>();
167 fenceRequest->scenario = SCENE_NAVIGATION;
168 GeoFence geofence;
169 geofence.latitude = 1.0;
170 geofence.longitude = 2.0;
171 geofence.radius = 3.0;
172 geofence.expiration = 4.0;
173 fenceRequest->geofence = geofence;
174 EXPECT_EQ(true, locatorImpl->AddFence(fenceRequest));
175 EXPECT_EQ(true, locatorImpl->RemoveFence(fenceRequest));
176
177 locatorImpl->GetCachedGnssLocationsSize();
178
179 auto cachedLocationsCallbackHost =
180 sptr<CachedLocationsCallbackHost>(new (std::nothrow) CachedLocationsCallbackHost());
181 EXPECT_NE(nullptr, cachedLocationsCallbackHost);
182 auto cachedCallback = sptr<ICachedLocationsCallback>(cachedLocationsCallbackHost);
183 EXPECT_NE(nullptr, cachedCallback);
184 auto request = std::make_unique<CachedGnssLocationsRequest>();
185 EXPECT_NE(nullptr, request);
186 request->reportingPeriodSec = 10;
187 request->wakeUpCacheQueueFull = true;
188 locatorImpl->RegisterCachedLocationCallback(request, cachedCallback);
189 locatorImpl->UnregisterCachedLocationCallback(cachedCallback);
190 #endif
191 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission003 end");
192 }
193
194 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutSettingsPermissionV9001, TestSize.Level1)
195 {
196 GTEST_LOG_(INFO)
197 << "LocationWithoutPermissionTest, LocatorWithoutSettingsPermissionV9001, TestSize.Level1";
198 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutSettingsPermissionV9001 begin");
199 auto locatorImpl = Locator::GetInstance();
200 EXPECT_NE(nullptr, locatorImpl);
201 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->EnableAbilityV9(true));
202 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->SetLocationPrivacyConfirmStatusV9(1, true));
203 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutSettingsPermissionV9001 end");
204 }
205
206 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9001, TestSize.Level1)
207 {
208 GTEST_LOG_(INFO)
209 << "LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9001, TestSize.Level1";
210 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9001 begin");
211 auto locatorImpl = Locator::GetInstance();
212 EXPECT_NE(nullptr, locatorImpl);
213
214 bool state = false;
215 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl->IsLocationEnabledV9(state));
216
217 std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
218 requestConfig->SetPriority(PRIORITY_ACCURACY);
219 sptr<ILocatorCallback> callbackStub = new (std::nothrow) LocatorCallbackStub();
220 if (state) {
221 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->StartLocatingV9(requestConfig, callbackStub));
222 } else {
223 EXPECT_EQ(ERRCODE_SWITCH_OFF, locatorImpl->StartLocatingV9(requestConfig, callbackStub));
224 }
225 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->StopLocatingV9(callbackStub));
226
227 std::unique_ptr loc = std::make_unique<Location>();
228 if (state) {
229 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->GetCachedLocationV9(loc));
230 } else {
231 EXPECT_EQ(ERRCODE_SWITCH_OFF, locatorImpl->GetCachedLocationV9(loc));
232 }
233 EXPECT_EQ(nullptr, loc);
234 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9001 end");
235 }
236
237 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9002, TestSize.Level1)
238 {
239 GTEST_LOG_(INFO)
240 << "LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9002, TestSize.Level1";
241 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9002 begin");
242 auto locatorImpl = Locator::GetInstance();
243 EXPECT_NE(nullptr, locatorImpl);
244
245 bool state = false;
246 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl->IsLocationEnabledV9(state));
247 #ifdef FEATURE_GNSS_SUPPORT
248 auto gnssCallbackHost =
249 sptr<GnssStatusCallbackHost>(new (std::nothrow) GnssStatusCallbackHost());
250 EXPECT_NE(nullptr, gnssCallbackHost);
251 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->RegisterGnssStatusCallbackV9(gnssCallbackHost->AsObject()));
252 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->UnregisterGnssStatusCallbackV9(gnssCallbackHost->AsObject()));
253
254 auto nmeaCallbackHost =
255 sptr<NmeaMessageCallbackHost>(new (std::nothrow) NmeaMessageCallbackHost());
256 EXPECT_NE(nullptr, nmeaCallbackHost);
257 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->RegisterNmeaMessageCallbackV9(nmeaCallbackHost->AsObject()));
258 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->UnregisterNmeaMessageCallbackV9(nmeaCallbackHost->AsObject()));
259 if (state) {
260 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->FlushCachedGnssLocationsV9());
261 } else {
262 EXPECT_EQ(ERRCODE_SWITCH_OFF, locatorImpl->FlushCachedGnssLocationsV9());
263 }
264 #endif
265 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->ProxyUidForFreezeV9(1000, false));
266 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->ResetAllProxyV9());
267 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9002 end");
268 }
269
270 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9003, TestSize.Level1)
271 {
272 GTEST_LOG_(INFO)
273 << "LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9003, TestSize.Level1";
274 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9003 begin");
275 auto locatorImpl = Locator::GetInstance();
276 EXPECT_NE(nullptr, locatorImpl);
277
278 bool state = false;
279 EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl->IsLocationEnabledV9(state));
280 #ifdef FEATURE_GNSS_SUPPORT
281 std::unique_ptr<GeofenceRequest> fenceRequest = std::make_unique<GeofenceRequest>();
282 fenceRequest->scenario = SCENE_NAVIGATION;
283 GeoFence geofence;
284 geofence.latitude = 1.0;
285 geofence.longitude = 2.0;
286 geofence.radius = 3.0;
287 geofence.expiration = 4.0;
288 fenceRequest->geofence = geofence;
289 if (state) {
290 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->AddFenceV9(fenceRequest));
291 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->RemoveFenceV9(fenceRequest));
292 } else {
293 EXPECT_EQ(ERRCODE_SWITCH_OFF, locatorImpl->AddFenceV9(fenceRequest));
294 EXPECT_EQ(ERRCODE_SWITCH_OFF, locatorImpl->RemoveFenceV9(fenceRequest));
295 }
296
297 int size = -1;
298 if (state) {
299 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->GetCachedGnssLocationsSizeV9(size));
300 } else {
301 EXPECT_EQ(ERRCODE_SWITCH_OFF, locatorImpl->GetCachedGnssLocationsSizeV9(size));
302 }
303 EXPECT_EQ(0, size);
304
305 auto cachedLocationsCallbackHost =
306 sptr<CachedLocationsCallbackHost>(new (std::nothrow) CachedLocationsCallbackHost());
307 EXPECT_NE(nullptr, cachedLocationsCallbackHost);
308 auto cachedCallback = sptr<ICachedLocationsCallback>(cachedLocationsCallbackHost);
309 EXPECT_NE(nullptr, cachedCallback);
310 auto request = std::make_unique<CachedGnssLocationsRequest>();
311 EXPECT_NE(nullptr, request);
312 request->reportingPeriodSec = 10;
313 request->wakeUpCacheQueueFull = true;
314 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->RegisterCachedLocationCallbackV9(request, cachedCallback));
315 EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->UnregisterCachedLocationCallbackV9(cachedCallback));
316 #endif
317 LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9003 end");
318 }
319 } // namespace Location
320 } // namespace OHOS