• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2023 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 #include "location_mock_ipc.h"
16 #include <map>
17 #define private public
18 #ifdef FEATURE_GNSS_SUPPORT
19 #include "gnss_ability.h"
20 #include "gnss_ability_proxy.h"
21 #include "gnss_ability_skeleton.h"
22 #endif
23 #ifdef FEATURE_NETWORK_SUPPORT
24 #include "network_ability.h"
25 #include "network_ability_proxy.h"
26 #include "network_ability_skeleton.h"
27 #endif
28 #ifdef FEATURE_PASSIVE_SUPPORT
29 #include "passive_ability.h"
30 #include "passive_ability_proxy.h"
31 #include "passive_ability_skeleton.h"
32 #endif
33 #ifdef FEATURE_GEOCODE_SUPPORT
34 #include "geo_convert_service.h"
35 #include "geo_convert_proxy.h"
36 #include "geo_convert_skeleton.h"
37 #endif
38 #undef private
39 #include "locator_ability.h"
40 #include "locator_proxy.h"
41 #include "locationhub_ipc_interface_code.h"
42 #include "location_log.h"
43 #include "constant_definition.h"
44 #include "subability_common.h"
45 
46 #include "iremote_broker.h"
47 
48 using namespace testing;
49 using namespace testing::ext;
50 
51 namespace OHOS {
52 namespace Location {
53 
54 std::string g_gnssIpcCode = "GNSS";
55 std::string g_networkIpcCode = "NETWORK";
56 std::string g_passiveIpcCode = "PASSIVE";
57 std::string g_geoIpcCode = "GEO_CONVERT";
58 const int32_t WAIT_RESPONSE_SEC = 2;
59 
SetUp()60 void LocationMockIpcTest::SetUp()
61 {
62 #ifdef FEATURE_GNSS_SUPPORT
63     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::SEND_LOCATION_REQUEST)] = g_gnssIpcCode;
64     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::SET_MOCKED_LOCATIONS)] = g_gnssIpcCode;
65     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::SET_ENABLE)] = g_gnssIpcCode;
66     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::REFRESH_REQUESTS)] = g_gnssIpcCode;
67     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::REG_GNSS_STATUS)] = g_gnssIpcCode;
68     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::UNREG_GNSS_STATUS)] = g_gnssIpcCode;
69     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::REG_NMEA)] = g_gnssIpcCode;
70     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::UNREG_NMEA)] = g_gnssIpcCode;
71     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::REG_CACHED)] = g_gnssIpcCode;
72     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::UNREG_CACHED)] = g_gnssIpcCode;
73     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::GET_CACHED_SIZE)] = g_gnssIpcCode;
74     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::FLUSH_CACHED)] = g_gnssIpcCode;
75     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::SEND_COMMANDS)] = g_gnssIpcCode;
76     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::ENABLE_LOCATION_MOCK)] = g_gnssIpcCode;
77     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::DISABLE_LOCATION_MOCK)] = g_gnssIpcCode;
78     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::ADD_FENCE_INFO)] = g_gnssIpcCode;
79     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::REMOVE_FENCE_INFO)] = g_gnssIpcCode;
80 #endif
81 #ifdef FEATURE_NETWORK_SUPPORT
82     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::SEND_LOCATION_REQUEST)] = g_networkIpcCode;
83     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::SET_MOCKED_LOCATIONS)] = g_networkIpcCode;
84     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::SELF_REQUEST)] = g_networkIpcCode;
85     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::SET_ENABLE)] = g_networkIpcCode;
86     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::ENABLE_LOCATION_MOCK)] = g_networkIpcCode;
87     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::DISABLE_LOCATION_MOCK)] = g_networkIpcCode;
88 #endif
89 #ifdef FEATURE_GEOCODE_SUPPORT
90     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::IS_AVAILABLE)] = g_geoIpcCode;
91     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::GET_FROM_COORDINATE)] = g_geoIpcCode;
92     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::GET_FROM_LOCATION_NAME_BY_BOUNDARY)] = g_geoIpcCode;
93     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::ENABLE_REVERSE_GEOCODE_MOCK)] = g_geoIpcCode;
94     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::DISABLE_REVERSE_GEOCODE_MOCK)] = g_geoIpcCode;
95     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::SET_REVERSE_GEOCODE_MOCKINFO)] = g_geoIpcCode;
96 #endif
97 #ifdef FEATURE_PASSIVE_SUPPORT
98     ipcMap_[static_cast<uint32_t>(PassiveInterfaceCode::SEND_LOCATION_REQUEST)] = g_passiveIpcCode;
99     ipcMap_[static_cast<uint32_t>(PassiveInterfaceCode::SET_ENABLE)] = g_passiveIpcCode;
100     ipcMap_[static_cast<uint32_t>(PassiveInterfaceCode::ENABLE_LOCATION_MOCK)] = g_passiveIpcCode;
101     ipcMap_[static_cast<uint32_t>(PassiveInterfaceCode::DISABLE_LOCATION_MOCK)] = g_passiveIpcCode;
102     ipcMap_[static_cast<uint32_t>(PassiveInterfaceCode::SET_MOCKED_LOCATIONS)] = g_passiveIpcCode;
103 #endif
104 }
105 
TearDown()106 void LocationMockIpcTest::TearDown()
107 {
108     ipcMap_.clear();
109 }
110 
111 #ifdef FEATURE_NETWORK_SUPPORT
112 HWTEST_F(LocationMockIpcTest, MockNetworkStubCallingPermission001, TestSize.Level1)
113 {
114     GTEST_LOG_(INFO)
115         << "LocationMockIpcTest, MockNetworkStubCallingPermission001, TestSize.Level1";
116     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockNetworkStubCallingPermission001 begin");
117 
118     auto networkAbilityStub = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
119     networkAbilityStub->networkHandler_ =
120         std::make_shared<NetworkHandler>(AppExecFwk::EventRunner::Create(true, AppExecFwk::ThreadMode::FFRT));
121     for (auto iter = ipcMap_.begin(); iter != ipcMap_.end(); iter++) {
122         if (iter->second != g_networkIpcCode) {
123             continue;
124         }
125         MessageParcel parcel;
126         parcel.WriteInterfaceToken(u"location.INetworkAbility");
127         MessageParcel reply;
128         MessageOption option;
129         networkAbilityStub->OnRemoteRequest(iter->first, parcel, reply, option);
130     }
131     sleep(WAIT_RESPONSE_SEC);
132     networkAbilityStub->networkHandler_->TaskCancelAndWait();
133     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockNetworkStubCallingPermission001 end");
134 }
135 #endif
136 
137 #ifdef FEATURE_PASSIVE_SUPPORT
138 HWTEST_F(LocationMockIpcTest, MockPassiveStubCallingPermission001, TestSize.Level0)
139 {
140     GTEST_LOG_(INFO)
141         << "LocationMockIpcTest, MockPassiveStubCallingPermission001, TestSize.Level0";
142     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockPassiveStubCallingPermission001 begin");
143 
144     auto passiveAbilityStub = sptr<PassiveAbility>(new (std::nothrow) PassiveAbility());
145     for (auto iter = ipcMap_.begin(); iter != ipcMap_.end(); iter++) {
146         if (iter->second != g_passiveIpcCode) {
147             continue;
148         }
149         MessageParcel parcel;
150         parcel.WriteInterfaceToken(u"location.IPassiveAbility");
151         MessageParcel reply;
152         MessageOption option;
153         EXPECT_EQ(LOCATION_ERRCODE_PERMISSION_DENIED,
154             passiveAbilityStub->OnRemoteRequest(iter->first, parcel, reply, option));
155     }
156     sleep(WAIT_RESPONSE_SEC);
157     passiveAbilityStub->passiveHandler_->TaskCancelAndWait();
158     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockPassiveStubCallingPermission001 end");
159 }
160 #endif
161 
162 #ifdef FEATURE_GEOCODE_SUPPORT
163 HWTEST_F(LocationMockIpcTest, MockGeoCodeStubCallingPermission001, TestSize.Level1)
164 {
165     GTEST_LOG_(INFO)
166         << "LocationMockIpcTest, MockGeoCodeStubCallingPermission001, TestSize.Level1";
167     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGeoCodeStubCallingPermission001 begin");
168 
169     auto geoConvertServiceStub = sptr<GeoConvertService>(new (std::nothrow) GeoConvertService());
170     for (auto iter = ipcMap_.begin(); iter != ipcMap_.end(); iter++) {
171         if (iter->second != g_geoIpcCode) {
172             continue;
173         }
174         MessageParcel parcel;
175         parcel.WriteInterfaceToken(u"location.IGeoConvert");
176         MessageParcel reply;
177         MessageOption option;
178         EXPECT_EQ(LOCATION_ERRCODE_PERMISSION_DENIED,
179             geoConvertServiceStub->OnRemoteRequest(iter->first, parcel, reply, option));
180     }
181     sleep(WAIT_RESPONSE_SEC);
182     geoConvertServiceStub = nullptr;
183     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGeoCodeStubCallingPermission001 end");
184 }
185 #endif
186 
187 #ifdef FEATURE_GEOCODE_SUPPORT
188 HWTEST_F(LocationMockIpcTest, MockGeoConvertServiceStub001, TestSize.Level1)
189 {
190     GTEST_LOG_(INFO)
191         << "LocationMockIpcTest, MockGeoConvertServiceStub001, TestSize.Level1";
192     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGeoConvertServiceStub001 begin");
193     auto geoConvertServiceStub = sptr<GeoConvertService>(new (std::nothrow) GeoConvertService());
194     geoConvertServiceStub->InitGeoConvertHandleMap();
195     geoConvertServiceStub->InitGeoConvertHandleMap();
196     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGeoConvertServiceStub001 end");
197 }
198 #endif
199 
200 #ifdef FEATURE_GEOCODE_SUPPORT
201 HWTEST_F(LocationMockIpcTest, MockGeoConvertServiceStub002, TestSize.Level1)
202 {
203     GTEST_LOG_(INFO)
204         << "LocationMockIpcTest, MockGeoConvertServiceStub002, TestSize.Level1";
205     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGeoConvertServiceStub002 begin");
206     MessageParcel data;
207     auto geoConvertServiceStub = sptr<GeoConvertService>(new (std::nothrow) GeoConvertService());
208     std::vector<std::shared_ptr<GeocodingMockInfo>> mockInfo = geoConvertServiceStub->ParseGeocodingMockInfos(data);
209     data.WriteInt32(2);
210     mockInfo = geoConvertServiceStub->ParseGeocodingMockInfos(data);
211     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGeoConvertServiceStub002 end");
212 }
213 #endif
214 
215 #ifdef FEATURE_GEOCODE_SUPPORT
216 HWTEST_F(LocationMockIpcTest, MockGeoConvertServiceStub003, TestSize.Level1)
217 {
218     GTEST_LOG_(INFO)
219         << "LocationMockIpcTest, MockGeoConvertServiceStub003, TestSize.Level1";
220     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGeoConvertServiceStub003 begin");
221     MessageParcel data;
222     MessageParcel reply;
223     AppIdentity identity;
224     auto geoConvertServiceStub = sptr<GeoConvertService>(new (std::nothrow) GeoConvertService());
225     geoConvertServiceStub->IsGeoConvertAvailableInner(data, reply, identity);
226     geoConvertServiceStub->GetAddressByCoordinateInner(data, reply, identity);
227     geoConvertServiceStub->GetAddressByLocationNameInner(data, reply, identity);
228     geoConvertServiceStub->EnableReverseGeocodingMockInner(data, reply, identity);
229     geoConvertServiceStub->DisableReverseGeocodingMockInner(data, reply, identity);
230     geoConvertServiceStub->SetGeocodingMockInfoInner(data, reply, identity);
231     identity.uid_ = 1021;
232     identity.pid_ = 1494;
233     geoConvertServiceStub->IsGeoConvertAvailableInner(data, reply, identity);
234     geoConvertServiceStub->GetAddressByCoordinateInner(data, reply, identity);
235     geoConvertServiceStub->GetAddressByLocationNameInner(data, reply, identity);
236     geoConvertServiceStub->EnableReverseGeocodingMockInner(data, reply, identity);
237     geoConvertServiceStub->DisableReverseGeocodingMockInner(data, reply, identity);
238     geoConvertServiceStub->SetGeocodingMockInfoInner(data, reply, identity);
239     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGeoConvertServiceStub003 end");
240 }
241 #endif
242 }  // namespace Location
243 }  // namespace OHOS
244