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 "locator_skeleton.h"
42 #include "locationhub_ipc_interface_code.h"
43 #include "location_log.h"
44 #include "constant_definition.h"
45 #include "subability_common.h"
46 
47 #include "iremote_broker.h"
48 
49 using namespace testing;
50 using namespace testing::ext;
51 
52 namespace OHOS {
53 namespace Location {
54 
55 std::string g_gnssIpcCode = "GNSS";
56 std::string g_networkIpcCode = "NETWORK";
57 std::string g_passiveIpcCode = "PASSIVE";
58 std::string g_geoIpcCode = "GEO_CONVERT";
59 const int32_t WAIT_RESPONSE_SEC = 2;
60 
SetUp()61 void LocationMockIpcTest::SetUp()
62 {
63 #ifdef FEATURE_GNSS_SUPPORT
64     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::SEND_LOCATION_REQUEST)] = g_gnssIpcCode;
65     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::SET_MOCKED_LOCATIONS)] = g_gnssIpcCode;
66     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::SET_ENABLE)] = g_gnssIpcCode;
67     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::REFRESH_REQUESTS)] = g_gnssIpcCode;
68     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::REG_GNSS_STATUS)] = g_gnssIpcCode;
69     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::UNREG_GNSS_STATUS)] = g_gnssIpcCode;
70     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::REG_NMEA)] = g_gnssIpcCode;
71     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::UNREG_NMEA)] = g_gnssIpcCode;
72     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::REG_CACHED)] = g_gnssIpcCode;
73     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::UNREG_CACHED)] = g_gnssIpcCode;
74     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::GET_CACHED_SIZE)] = g_gnssIpcCode;
75     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::FLUSH_CACHED)] = g_gnssIpcCode;
76     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::SEND_COMMANDS)] = g_gnssIpcCode;
77     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::ENABLE_LOCATION_MOCK)] = g_gnssIpcCode;
78     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::DISABLE_LOCATION_MOCK)] = g_gnssIpcCode;
79     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::ADD_FENCE_INFO)] = g_gnssIpcCode;
80     ipcMap_[static_cast<uint32_t>(GnssInterfaceCode::REMOVE_FENCE_INFO)] = g_gnssIpcCode;
81 #endif
82 #ifdef FEATURE_NETWORK_SUPPORT
83     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::SEND_LOCATION_REQUEST)] = g_networkIpcCode;
84     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::SET_MOCKED_LOCATIONS)] = g_networkIpcCode;
85     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::SELF_REQUEST)] = g_networkIpcCode;
86     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::SET_ENABLE)] = g_networkIpcCode;
87     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::ENABLE_LOCATION_MOCK)] = g_networkIpcCode;
88     ipcMap_[static_cast<uint32_t>(NetworkInterfaceCode::DISABLE_LOCATION_MOCK)] = g_networkIpcCode;
89 #endif
90 #ifdef FEATURE_GEOCODE_SUPPORT
91     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::IS_AVAILABLE)] = g_geoIpcCode;
92     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::GET_FROM_COORDINATE)] = g_geoIpcCode;
93     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::GET_FROM_LOCATION_NAME_BY_BOUNDARY)] = g_geoIpcCode;
94     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::ENABLE_REVERSE_GEOCODE_MOCK)] = g_geoIpcCode;
95     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::DISABLE_REVERSE_GEOCODE_MOCK)] = g_geoIpcCode;
96     ipcMap_[static_cast<uint32_t>(GeoConvertInterfaceCode::SET_REVERSE_GEOCODE_MOCKINFO)] = g_geoIpcCode;
97 #endif
98 #ifdef FEATURE_PASSIVE_SUPPORT
99     ipcMap_[static_cast<uint32_t>(PassiveInterfaceCode::SEND_LOCATION_REQUEST)] = g_passiveIpcCode;
100     ipcMap_[static_cast<uint32_t>(PassiveInterfaceCode::SET_ENABLE)] = g_passiveIpcCode;
101     ipcMap_[static_cast<uint32_t>(PassiveInterfaceCode::ENABLE_LOCATION_MOCK)] = g_passiveIpcCode;
102     ipcMap_[static_cast<uint32_t>(PassiveInterfaceCode::DISABLE_LOCATION_MOCK)] = g_passiveIpcCode;
103     ipcMap_[static_cast<uint32_t>(PassiveInterfaceCode::SET_MOCKED_LOCATIONS)] = g_passiveIpcCode;
104 #endif
105 }
106 
TearDown()107 void LocationMockIpcTest::TearDown()
108 {
109     ipcMap_.clear();
110 }
111 
112 #ifdef FEATURE_GNSS_SUPPORT
HWTEST_F(LocationMockIpcTest, MockGnssStubCallingPermission001, TestSize.Level1)113 HWTEST_F(LocationMockIpcTest, MockGnssStubCallingPermission001, TestSize.Level1)
114 {
115     GTEST_LOG_(INFO)
116         << "LocationMockIpcTest, MockGnssStubCallingPermission001, TestSize.Level1";
117     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGnssStubCallingPermission001 begin");
118 
119     auto gnssAbilityStub = sptr<GnssAbility>(new (std::nothrow) GnssAbility());
120     for (auto iter = ipcMap_.begin(); iter != ipcMap_.end(); iter++) {
121         if (iter->second != g_gnssIpcCode) {
122             continue;
123         }
124         MessageParcel parcel;
125         parcel.WriteInterfaceToken(u"location.IGnssAbility");
126         MessageParcel reply;
127         MessageOption option;
128         EXPECT_EQ(ERRCODE_PERMISSION_DENIED,
129             gnssAbilityStub->OnRemoteRequest(iter->first, parcel, reply, option));
130     }
131     sleep(WAIT_RESPONSE_SEC);
132     gnssAbilityStub->gnssHandler_->TaskCancelAndWait();
133     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGnssStubCallingPermission001 end");
134 }
135 #endif
136 
137 #ifdef FEATURE_NETWORK_SUPPORT
HWTEST_F(LocationMockIpcTest, MockNetworkStubCallingPermission001, TestSize.Level1)138 HWTEST_F(LocationMockIpcTest, MockNetworkStubCallingPermission001, TestSize.Level1)
139 {
140     GTEST_LOG_(INFO)
141         << "LocationMockIpcTest, MockNetworkStubCallingPermission001, TestSize.Level1";
142     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockNetworkStubCallingPermission001 begin");
143 
144     auto networkAbilityStub = sptr<NetworkAbility>(new (std::nothrow) NetworkAbility());
145     for (auto iter = ipcMap_.begin(); iter != ipcMap_.end(); iter++) {
146         if (iter->second != g_networkIpcCode) {
147             continue;
148         }
149         MessageParcel parcel;
150         parcel.WriteInterfaceToken(u"location.INetworkAbility");
151         MessageParcel reply;
152         MessageOption option;
153         networkAbilityStub->OnRemoteRequest(iter->first, parcel, reply, option);
154     }
155     sleep(WAIT_RESPONSE_SEC);
156     networkAbilityStub->networkHandler_->TaskCancelAndWait();
157     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockNetworkStubCallingPermission001 end");
158 }
159 #endif
160 
161 #ifdef FEATURE_PASSIVE_SUPPORT
HWTEST_F(LocationMockIpcTest, MockPassiveStubCallingPermission001, TestSize.Level1)162 HWTEST_F(LocationMockIpcTest, MockPassiveStubCallingPermission001, TestSize.Level1)
163 {
164     GTEST_LOG_(INFO)
165         << "LocationMockIpcTest, MockPassiveStubCallingPermission001, TestSize.Level1";
166     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockPassiveStubCallingPermission001 begin");
167 
168     auto passiveAbilityStub = sptr<PassiveAbility>(new (std::nothrow) PassiveAbility());
169     for (auto iter = ipcMap_.begin(); iter != ipcMap_.end(); iter++) {
170         if (iter->second != g_passiveIpcCode) {
171             continue;
172         }
173         MessageParcel parcel;
174         parcel.WriteInterfaceToken(u"location.IPassiveAbility");
175         MessageParcel reply;
176         MessageOption option;
177         EXPECT_EQ(ERRCODE_PERMISSION_DENIED,
178             passiveAbilityStub->OnRemoteRequest(iter->first, parcel, reply, option));
179     }
180     sleep(WAIT_RESPONSE_SEC);
181     passiveAbilityStub->passiveHandler_->TaskCancelAndWait();
182     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockPassiveStubCallingPermission001 end");
183 }
184 #endif
185 
186 #ifdef FEATURE_GEOCODE_SUPPORT
HWTEST_F(LocationMockIpcTest, MockGeoCodeStubCallingPermission001, TestSize.Level1)187 HWTEST_F(LocationMockIpcTest, MockGeoCodeStubCallingPermission001, TestSize.Level1)
188 {
189     GTEST_LOG_(INFO)
190         << "LocationMockIpcTest, MockGeoCodeStubCallingPermission001, TestSize.Level1";
191     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGeoCodeStubCallingPermission001 begin");
192 
193     auto geoConvertServiceStub = sptr<GeoConvertService>(new (std::nothrow) GeoConvertService());
194     for (auto iter = ipcMap_.begin(); iter != ipcMap_.end(); iter++) {
195         if (iter->second != g_geoIpcCode) {
196             continue;
197         }
198         MessageParcel parcel;
199         parcel.WriteInterfaceToken(u"location.IGeoConvert");
200         MessageParcel reply;
201         MessageOption option;
202         EXPECT_EQ(ERRCODE_PERMISSION_DENIED,
203             geoConvertServiceStub->OnRemoteRequest(iter->first, parcel, reply, option));
204     }
205     sleep(WAIT_RESPONSE_SEC);
206     geoConvertServiceStub->geoConvertHandler_->TaskCancelAndWait();
207     LBSLOGI(LOCATOR, "[LocationMockIpcTest] MockGeoCodeStubCallingPermission001 end");
208 }
209 #endif
210 }  // namespace Location
211 }  // namespace OHOS
212