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 <cstring>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 
20 #define private public
21 #include "location_proxy_adapter_impl.h"
22 
23 using namespace testing;
24 using namespace testing::ext;
25 
26 namespace OHOS::NWeb {
27 namespace {
28 static constexpr double MIN_LATITUDE = -90.0;
29 static constexpr double MIN_LONGITUDE = -180.0;
30 } // namespace
31 
32 class LocationProxyAdapterTest : public testing::Test {
33 public:
34     static void SetUpTestCase(void);
35     static void TearDownTestCase(void);
36     void SetUp();
37     void TearDown();
38 };
39 
SetUpTestCase(void)40 void LocationProxyAdapterTest::SetUpTestCase(void)
41 {}
42 
TearDownTestCase(void)43 void LocationProxyAdapterTest::TearDownTestCase(void)
44 {}
45 
SetUp(void)46 void LocationProxyAdapterTest::SetUp(void)
47 {}
48 
TearDown(void)49 void LocationProxyAdapterTest::TearDown(void)
50 {}
51 
52 class LocationCallbackAdapterMock : public LocationCallbackAdapter {
53 public:
54     LocationCallbackAdapterMock() = default;
55 
OnLocationReport(const std::shared_ptr<LocationInfo> location)56     void OnLocationReport(
57         const std::shared_ptr<LocationInfo> location)  override
58     {}
59 
OnLocatingStatusChange(const int status)60     void OnLocatingStatusChange(const int status) override
61     {}
62 
OnErrorReport(const int errorCode)63     void OnErrorReport(const int errorCode) override
64     {}
65 };
66 
67 /**
68  * @tc.name: LocationProxyAdapterTest_LocationInstance_001
69  * @tc.desc: LocationInstance.
70  * @tc.type: FUNC
71  * @tc.require:
72  */
73 HWTEST_F(LocationProxyAdapterTest, LocationProxyAdapterTest_LocationInstance_001, TestSize.Level1)
74 {
75     std::shared_ptr<LocationProxyAdapter> proxyAdapter = LocationInstance::GetInstance().CreateLocationProxyAdapter();
76     EXPECT_NE(proxyAdapter, nullptr);
77     std::shared_ptr<LocationRequestConfig> requestConfig =
78         LocationInstance::GetInstance().CreateLocationRequestConfig();
79     EXPECT_NE(requestConfig, nullptr);
80 }
81 
82 /**
83  * @tc.name: LocationProxyAdapterTest_SetScenario_002
84  * @tc.desc: SetScenario.
85  * @tc.type: FUNC
86  * @tc.require:
87  */
88 HWTEST_F(LocationProxyAdapterTest, LocationProxyAdapterTest_SetScenario_002, TestSize.Level1)
89 {
90     auto requestConfigImpl = std::make_shared<LocationRequestConfigImpl>();
91     EXPECT_NE(requestConfigImpl, nullptr);
92     int32_t scenario = -1;
93     requestConfigImpl->SetScenario(scenario);
94     scenario = OHOS::NWeb::LocationRequestConfig::Scenario::UNSET;
95     requestConfigImpl->SetScenario(scenario);
96     scenario = OHOS::NWeb::LocationRequestConfig::Scenario::NAVIGATION;
97     requestConfigImpl->SetScenario(scenario);
98     scenario = OHOS::NWeb::LocationRequestConfig::Scenario::TRAJECTORY_TRACKING;
99     requestConfigImpl->SetScenario(scenario);
100     scenario = OHOS::NWeb::LocationRequestConfig::Scenario::CAR_HAILING;
101     requestConfigImpl->SetScenario(scenario);
102     scenario = OHOS::NWeb::LocationRequestConfig::Scenario::DAILY_LIFE_SERVICE;
103     requestConfigImpl->SetScenario(scenario);
104     scenario = OHOS::NWeb::LocationRequestConfig::Scenario::NO_POWER;
105     requestConfigImpl->SetScenario(scenario);
106 
107     requestConfigImpl->SetFixNumber(0);
108     requestConfigImpl->SetMaxAccuracy(0);
109     requestConfigImpl->SetDistanceInterval(0);
110     requestConfigImpl->SetTimeInterval(0);
111     int32_t priority = -1;
112     requestConfigImpl->SetPriority(priority);
113     priority = OHOS::NWeb::LocationRequestConfig::Priority::PRIORITY_UNSET;
114     requestConfigImpl->SetPriority(priority);
115     priority = OHOS::NWeb::LocationRequestConfig::Priority::PRIORITY_ACCURACY;
116     requestConfigImpl->SetPriority(priority);
117     priority = OHOS::NWeb::LocationRequestConfig::Priority::PRIORITY_LOW_POWER;
118     requestConfigImpl->SetPriority(priority);
119     priority = OHOS::NWeb::LocationRequestConfig::Priority::PRIORITY_FAST_FIRST_FIX;
120     requestConfigImpl->SetPriority(priority);
121     std::unique_ptr<OHOS::Location::RequestConfig>& requestConfig = requestConfigImpl->GetConfig();
122     EXPECT_NE(requestConfig, nullptr);
123 }
124 
125 /**
126  * @tc.name: LocationProxyAdapterTest_SetScenario_003
127  * @tc.desc: SetScenario.
128  * @tc.type: FUNC
129  * @tc.require:
130  */
131 HWTEST_F(LocationProxyAdapterTest, LocationProxyAdapterTest_SetScenario_003, TestSize.Level1)
132 {
133     auto requestConfigImpl = std::make_shared<LocationRequestConfigImpl>();
134     EXPECT_NE(requestConfigImpl, nullptr);
135     requestConfigImpl->config_ = nullptr;
136     requestConfigImpl->SetScenario(0);
137     requestConfigImpl->SetFixNumber(0);
138     requestConfigImpl->SetMaxAccuracy(0);
139     requestConfigImpl->SetDistanceInterval(0);
140     requestConfigImpl->SetTimeInterval(0);
141     requestConfigImpl->SetPriority(0);
142 }
143 
144 /**
145  * @tc.name: LocationProxyAdapterTest_LocationInfoImpl_004
146  * @tc.desc: LocationInfoImpl.
147  * @tc.type: FUNC
148  * @tc.require:
149  */
150 HWTEST_F(LocationProxyAdapterTest, LocationProxyAdapterTest_LocationInfoImpl_004, TestSize.Level1)
151 {
152     std::unique_ptr<OHOS::Location::Location> location = std::make_unique<OHOS::Location::Location>();
153     EXPECT_NE(location, nullptr);
154     auto locationInfoImpl = std::make_shared<LocationInfoImpl>(location);
155     EXPECT_NE(locationInfoImpl, nullptr);
156     double latitude = locationInfoImpl->GetLatitude();
157     EXPECT_NEAR(latitude, MIN_LATITUDE - 1, 0.01);
158     latitude = locationInfoImpl->GetLongitude();
159     EXPECT_NEAR(latitude, MIN_LONGITUDE - 1, 0.01);
160     latitude = locationInfoImpl->GetAltitude();
161     EXPECT_NEAR(latitude, 0.0, 0.01);
162     float accuracy = locationInfoImpl->GetAccuracy();
163     EXPECT_NEAR(accuracy, 0.0, 0.01);
164     accuracy = locationInfoImpl->GetSpeed();
165     EXPECT_NEAR(accuracy, 0.0, 0.01);
166     double direction = locationInfoImpl->GetDirection();
167     EXPECT_NEAR(direction, 0.0, 0.01);
168     int64_t timeStamp = locationInfoImpl->GetTimeStamp();
169     EXPECT_EQ(timeStamp, 0);
170     timeStamp = locationInfoImpl->GetTimeSinceBoot();
171     EXPECT_EQ(timeStamp, 0);
172     std::unique_ptr<OHOS::Location::Location>& locationInfo = locationInfoImpl->GetLocation();
173     EXPECT_NE(locationInfo, nullptr);
174     locationInfoImpl->GetAdditions();
175     EXPECT_NE(locationInfoImpl->location_, nullptr);
176 }
177 
178 /**
179  * @tc.name: LocationProxyAdapterTest_LocationInfoImpl_005
180  * @tc.desc: LocationInfoImpl.
181  * @tc.type: FUNC
182  * @tc.require:
183  */
184 HWTEST_F(LocationProxyAdapterTest, LocationProxyAdapterTest_LocationInfoImpl_005, TestSize.Level1)
185 {
186     std::unique_ptr<OHOS::Location::Location> location = nullptr;
187     auto locationInfoImpl = std::make_shared<LocationInfoImpl>(location);
188     EXPECT_NE(locationInfoImpl, nullptr);
189     double latitude = locationInfoImpl->GetLatitude();
190     EXPECT_NEAR(latitude, 0.0, 0.01);
191     latitude = locationInfoImpl->GetLongitude();
192     EXPECT_NEAR(latitude, 0.0, 0.01);
193     latitude = locationInfoImpl->GetAltitude();
194     EXPECT_NEAR(latitude, 0.0, 0.01);
195     float accuracy = locationInfoImpl->GetAccuracy();
196     EXPECT_NEAR(accuracy, 0.0, 0.01);
197     accuracy = locationInfoImpl->GetSpeed();
198     EXPECT_NEAR(accuracy, 0.0, 0.01);
199     double direction = locationInfoImpl->GetDirection();
200     EXPECT_NEAR(direction, 0.0, 0.01);
201     int64_t timeStamp = locationInfoImpl->GetTimeStamp();
202     EXPECT_EQ(timeStamp, 0);
203     timeStamp = locationInfoImpl->GetTimeSinceBoot();
204     EXPECT_EQ(timeStamp, 0);
205     locationInfoImpl->GetAdditions();
206     EXPECT_EQ(locationInfoImpl->location_, nullptr);
207 }
208 
209 /**
210  * @tc.name: LocationProxyAdapterTest_EnableAbility_006
211  * @tc.desc: EnableAbility.
212  * @tc.type: FUNC
213  * @tc.require:
214  */
215 HWTEST_F(LocationProxyAdapterTest, LocationProxyAdapterTest_EnableAbility_006, TestSize.Level1)
216 {
217     auto proxyAdapterImpl = std::make_shared<LocationProxyAdapterImpl>();
218     EXPECT_NE(proxyAdapterImpl, nullptr);
219     std::shared_ptr<LocationRequestConfig> requestConfig = std::make_shared<LocationRequestConfigImpl>();
220     EXPECT_NE(requestConfig, nullptr);
221     std::shared_ptr<LocationCallbackAdapter> callback = std::make_shared<LocationCallbackAdapterMock>();
222     EXPECT_NE(callback, nullptr);
223     bool result = proxyAdapterImpl->EnableAbility(true);
224     EXPECT_FALSE(result);
225     bool enabled = proxyAdapterImpl->IsLocationEnabled();
226     if (enabled) {
227         EXPECT_TRUE(enabled);
228     } else {
229         EXPECT_FALSE(enabled);
230     }
231 
232     int32_t id = proxyAdapterImpl->StartLocating(requestConfig, nullptr);
233     EXPECT_EQ(id, -1);
234     id = proxyAdapterImpl->StartLocating(requestConfig, callback);
235     EXPECT_EQ(id, -1);
236 
237     result = proxyAdapterImpl->StopLocating(-1);
238     EXPECT_FALSE(result);
239     result = proxyAdapterImpl->StopLocating(0);
240     EXPECT_FALSE(result);
241     result = proxyAdapterImpl->StopLocating(0);
242     EXPECT_FALSE(result);
243 }
244 
245 /**
246  * @tc.name: LocationProxyAdapterTest_EnableAbility_007
247  * @tc.desc: EnableAbility.
248  * @tc.type: FUNC
249  * @tc.require:
250  */
251 HWTEST_F(LocationProxyAdapterTest, LocationProxyAdapterTest_EnableAbility_007, TestSize.Level1)
252 {
253     auto proxyAdapterImpl = std::make_shared<LocationProxyAdapterImpl>();
254     EXPECT_NE(proxyAdapterImpl, nullptr);
255     proxyAdapterImpl->enableAbilityFunc_ = nullptr;
256     bool result = proxyAdapterImpl->EnableAbility(true);
257     EXPECT_FALSE(result);
258     proxyAdapterImpl->isEnableLocationFunc_ = nullptr;
259     result = proxyAdapterImpl->IsLocationEnabled();
260     EXPECT_FALSE(result);
261     proxyAdapterImpl->startLocatingFunc_ = nullptr;
262     std::shared_ptr<LocationRequestConfig> requestConfig = std::make_shared<LocationRequestConfigImpl>();
263     EXPECT_NE(requestConfig, nullptr);
264     std::shared_ptr<LocationCallbackAdapter> callback = std::make_shared<LocationCallbackAdapterMock>();
265     EXPECT_NE(callback, nullptr);
266     int32_t id = proxyAdapterImpl->StartLocating(requestConfig, callback);
267     EXPECT_EQ(id, -1);
268     proxyAdapterImpl->stopLocatingFunc_ = nullptr;
269     result = proxyAdapterImpl->StopLocating(id);
270     EXPECT_FALSE(result);
271 }
272 } // namespace OHOS::NWeb
273