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