• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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