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
49using namespace testing;
50using namespace testing::ext;
51
52namespace OHOS {
53namespace Location {
54
55std::string g_gnssIpcCode = "GNSS";
56std::string g_networkIpcCode = "NETWORK";
57std::string g_passiveIpcCode = "PASSIVE";
58std::string g_geoIpcCode = "GEO_CONVERT";
59const int32_t WAIT_RESPONSE_SEC = 2;
60
61void 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
107void LocationMockIpcTest::TearDown()
108{
109    ipcMap_.clear();
110}
111
112#ifdef FEATURE_GNSS_SUPPORT
113HWTEST_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
138HWTEST_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
162HWTEST_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
187HWTEST_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