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 "fusion_controller_test.h"
17 
18 #include "common_utils.h"
19 #include "constant_definition.h"
20 #include "fusion_controller.h"
21 
22 using namespace testing::ext;
23 namespace OHOS {
24 namespace Location {
25 const int UNKNOWN_TYPE = 0;
26 const int64_t NANOS_PER_MILLI = 1000000L;
27 const int64_t MILLI_PER_SECS = 1000L;
28 const uint32_t FUSION_DEFAULT_FLAG = 0;
29 const uint32_t FUSION_BASE_FLAG = 1;
30 const uint32_t REPORT_FUSED_LOCATION_FLAG = FUSION_BASE_FLAG;
SetUp()31 void FusionControllerTest::SetUp()
32 {
33     fusionController_ = FusionController::GetInstance();
34     EXPECT_NE(nullptr, fusionController_);
35 }
36 
TearDown()37 void FusionControllerTest::TearDown()
38 {
39     fusionController_->fusedFlag_ = 0;
40     fusionController_->needReset_ = true;
41     fusionController_ = nullptr;
42 }
43 
44 HWTEST_F(FusionControllerTest, ActiveFusionStrategies001, TestSize.Level1)
45 {
46     GTEST_LOG_(INFO)
47         << "FusionControllerTest, ActiveFusionStrategies001, TestSize.Level1";
48     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ActiveFusionStrategies001 begin");
49     fusionController_->ActiveFusionStrategies(SCENE_NAVIGATION);
50     EXPECT_EQ(FUSION_DEFAULT_FLAG, fusionController_->fusedFlag_);
51     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ActiveFusionStrategies001 end");
52 }
53 
54 HWTEST_F(FusionControllerTest, ActiveFusionStrategies002, TestSize.Level1)
55 {
56     GTEST_LOG_(INFO)
57         << "FusionControllerTest, ActiveFusionStrategies002, TestSize.Level1";
58     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ActiveFusionStrategies002 begin");
59     fusionController_->ActiveFusionStrategies(SCENE_TRAJECTORY_TRACKING);
60     EXPECT_EQ(FUSION_DEFAULT_FLAG, fusionController_->fusedFlag_);
61     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ActiveFusionStrategies002 end");
62 }
63 
64 HWTEST_F(FusionControllerTest, ActiveFusionStrategies003, TestSize.Level1)
65 {
66     GTEST_LOG_(INFO)
67         << "FusionControllerTest, ActiveFusionStrategies003, TestSize.Level1";
68     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ActiveFusionStrategies003 begin");
69     fusionController_->ActiveFusionStrategies(PRIORITY_FAST_FIRST_FIX);
70     EXPECT_EQ(REPORT_FUSED_LOCATION_FLAG, fusionController_->fusedFlag_);
71     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ActiveFusionStrategies003 end");
72 }
73 
74 HWTEST_F(FusionControllerTest, ActiveFusionStrategies004, TestSize.Level1)
75 {
76     GTEST_LOG_(INFO)
77         << "FusionControllerTest, ActiveFusionStrategies004, TestSize.Level1";
78     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ActiveFusionStrategies004 begin");
79     fusionController_->ActiveFusionStrategies(UNKNOWN_TYPE);
80     EXPECT_EQ(FUSION_DEFAULT_FLAG, fusionController_->fusedFlag_);
81     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ActiveFusionStrategies004 end");
82 }
83 
84 HWTEST_F(FusionControllerTest, ActiveFusionStrategies005, TestSize.Level1)
85 {
86     GTEST_LOG_(INFO)
87         << "FusionControllerTest, ActiveFusionStrategies005, TestSize.Level1";
88     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ActiveFusionStrategies005 begin");
89     EXPECT_EQ(true, fusionController_->needReset_);
90     fusionController_->ActiveFusionStrategies(SCENE_NAVIGATION); // when needReset is true
91     EXPECT_EQ(false, fusionController_->needReset_);
92     fusionController_->ActiveFusionStrategies(SCENE_NAVIGATION); // when needReset is false
93     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ActiveFusionStrategies005 end");
94 }
95 
96 HWTEST_F(FusionControllerTest, ChooseBestLocation001, TestSize.Level1)
97 {
98     GTEST_LOG_(INFO)
99         << "FusionControllerTest, ChooseBestLocation001, TestSize.Level1";
100     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ChooseBestLocation001 begin");
101     EXPECT_EQ(nullptr, fusionController_->chooseBestLocation(nullptr, nullptr));
102 
103     MessageParcel parcel;
104     parcel.WriteDouble(12.0);         // latitude
105     parcel.WriteDouble(13.0);         // longitude
106     parcel.WriteDouble(14.0);         // altitude
107     parcel.WriteDouble(1000.0);       // accuracy
108     parcel.WriteDouble(10.0);         // speed
109     parcel.WriteDouble(90.0);         // direction
110     parcel.WriteInt64(1000000000);    // timeStamp
111     parcel.WriteInt64(1000000000);    // timeSinceBoot
112     parcel.WriteString16(u"additions"); // additions
113     parcel.WriteInt64(1);             // additionSize
114     parcel.WriteInt32(0);          // isFromMock
115     std::unique_ptr<Location> location = std::make_unique<Location>();
116     location->ReadFromParcel(parcel);
117     EXPECT_EQ(nullptr, fusionController_->chooseBestLocation(nullptr, location));
118 
119     std::unique_ptr<Location> location_gnss = std::make_unique<Location>();
120     location_gnss->ReadFromParcel(parcel);
121     std::unique_ptr<Location> location_network = std::make_unique<Location>();
122     location_network->ReadFromParcel(parcel);
123     location_network->SetTimeSinceBoot(5000000000);
124     EXPECT_NE(nullptr, fusionController_->chooseBestLocation(location_gnss, location_network));
125 
126     location_gnss->SetAccuracy(20.0);
127     EXPECT_NE(nullptr, fusionController_->chooseBestLocation(location_gnss, location_network));
128 
129     location_gnss->SetTimeSinceBoot(10000000000);
130     EXPECT_NE(nullptr, fusionController_->chooseBestLocation(location_gnss, location_network));
131     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ChooseBestLocation001 end");
132 }
133 
134 HWTEST_F(FusionControllerTest, ChooseBestLocation002, TestSize.Level1)
135 {
136     GTEST_LOG_(INFO)
137         << "FusionControllerTest, ChooseBestLocation002, TestSize.Level1";
138     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ChooseBestLocation002 begin");
139     MessageParcel parcel;
140     parcel.WriteDouble(12.0);         // latitude
141     parcel.WriteDouble(13.0);         // longitude
142     parcel.WriteDouble(14.0);         // altitude
143     parcel.WriteDouble(1000.0);       // accuracy
144     parcel.WriteDouble(10.0);         // speed
145     parcel.WriteDouble(90.0);         // direction
146     parcel.WriteInt64(1000000000);    // timeStamp
147     parcel.WriteInt64(1000000000);    // timeSinceBoot
148     parcel.WriteString16(u"additions"); // additions
149     parcel.WriteInt64(1);             // additionSize
150     parcel.WriteInt32(0);          // isFromMock
151 
152     std::unique_ptr<Location> location_gnss = std::make_unique<Location>();
153     location_gnss->ReadFromParcel(parcel);
154     std::unique_ptr<Location> location_network = std::make_unique<Location>(*location_gnss);
155     auto bestLocation = fusionController_->chooseBestLocation(location_gnss, location_network);
156     location_gnss->SetAccuracy(20.0);
157     EXPECT_EQ(20.0, location_gnss->GetAccuracy());
158     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] ChooseBestLocation002 end");
159 }
160 
161 HWTEST_F(FusionControllerTest, GetFuseLocation001, TestSize.Level1)
162 {
163     GTEST_LOG_(INFO)
164         << "FusionControllerTest, GetFuseLocation001, TestSize.Level1";
165     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] GetFuseLocation001 begin");
166     std::unique_ptr<Location> location = std::make_unique<Location>();
167     sptr<Location> lastFuseLocation = new (std::nothrow) Location();
168     location->SetLocationSourceType(LocationSourceType::INDOOR_TYPE);
169     EXPECT_NE(nullptr, fusionController_->GetFuseLocation(location, lastFuseLocation));
170     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] GetFuseLocation001 end");
171 }
172 
173 HWTEST_F(FusionControllerTest, GetFuseLocation002, TestSize.Level1)
174 {
175     GTEST_LOG_(INFO)
176         << "FusionControllerTest, GetFuseLocation002, TestSize.Level1";
177     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] GetFuseLocation002 begin");
178     std::unique_ptr<Location> location = std::make_unique<Location>();
179     sptr<Location> lastFuseLocation = new (std::nothrow) Location();
180     location->SetLocationSourceType(LocationSourceType::GNSS_TYPE);
181     int64_t seconds1 = 1718276948;
182     int64_t seconds2 = 1718276945;
183     location->SetTimeSinceBoot(seconds1 * MILLI_PER_SECS * NANOS_PER_MILLI);
184     lastFuseLocation->SetLocationSourceType(LocationSourceType::INDOOR_TYPE);
185     lastFuseLocation->SetTimeSinceBoot(seconds2 * MILLI_PER_SECS * NANOS_PER_MILLI);
186     EXPECT_NE(nullptr, fusionController_->GetFuseLocation(location, lastFuseLocation));
187     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] GetFuseLocation002 end");
188 }
189 
190 HWTEST_F(FusionControllerTest, GetFuseLocation003, TestSize.Level1)
191 {
192     GTEST_LOG_(INFO)
193         << "FusionControllerTest, GetFuseLocation003, TestSize.Level1";
194     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] GetFuseLocation003 begin");
195     std::unique_ptr<Location> location = std::make_unique<Location>();
196     sptr<Location> lastFuseLocation = new (std::nothrow) Location();
197     location->SetLocationSourceType(LocationSourceType::NETWORK_TYPE);
198     int64_t seconds1 = 1718276948;
199     int64_t seconds2 = 1718276945;
200     location->SetTimeSinceBoot(seconds1 * MILLI_PER_SECS * NANOS_PER_MILLI);
201     lastFuseLocation->SetLocationSourceType(LocationSourceType::GNSS_TYPE);
202     lastFuseLocation->SetTimeSinceBoot(seconds2 * MILLI_PER_SECS * NANOS_PER_MILLI);
203     EXPECT_NE(nullptr, fusionController_->GetFuseLocation(location, lastFuseLocation));
204     LBSLOGI(FUSION_CONTROLLER, "[FusionControllerTest] GetFuseLocation003 end");
205 }
206 } // namespace Location
207 } // namespace OHOS