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