1 /*
2 * Copyright (c) 2024 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 <gtest/gtest.h>
17
18 #include "fold_screen_controller/fold_screen_policy.h"
19 #include "fold_screen_controller/sensor_fold_state_manager/sensor_fold_state_manager.h"
20 #include "fold_screen_state_internel.h"
21 #include "screen_session_manager/include/screen_session_manager.h"
22 #include "window_manager_hilog.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 namespace {
30 constexpr uint32_t SLEEP_TIME_US = 100000;
31 std::string g_errLog;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)32 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char *tag,
33 const char *msg)
34 {
35 g_errLog = msg;
36 }
37 }
38
39 class SensorFoldStateManagerTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp() override;
44 void TearDown() override;
45 };
46
SetUpTestCase()47 void SensorFoldStateManagerTest::SetUpTestCase()
48 {
49 }
50
TearDownTestCase()51 void SensorFoldStateManagerTest::TearDownTestCase()
52 {
53 }
54
SetUp()55 void SensorFoldStateManagerTest::SetUp()
56 {
57 }
58
TearDown()59 void SensorFoldStateManagerTest::TearDown()
60 {
61 usleep(SLEEP_TIME_US);
62 }
63
64 namespace {
65
66 /**
67 * @tc.name: HandleSensorChange
68 * @tc.desc: HandleSensorChange
69 * @tc.type: FUNC
70 */
71 HWTEST_F(SensorFoldStateManagerTest, HandleSensorChange, TestSize.Level1)
72 {
73 g_errLog.clear();
74 LOG_SetCallback(MyLogCallback);
75 SensorFoldStateManager mgr = SensorFoldStateManager();
76 FoldStatus nextState = FoldStatus::UNKNOWN;
77 float angle = 0.0f;
78 sptr<FoldScreenPolicy> foldScreenPolicy = sptr<FoldScreenPolicy>::MakeSptr();
79 mgr.HandleSensorChange(nextState, angle, foldScreenPolicy);
80 EXPECT_TRUE(g_errLog.find("fold state is UNKNOWN") != std::string::npos);
81
82 mgr.mState_ = FoldStatus::EXPAND;
83 mgr.HandleSensorChange(nextState, angle, foldScreenPolicy);
84 EXPECT_FALSE(g_errLog.find("current state: %{public}d, next state: %{public}d.") != std::string::npos);
85
86 nextState = FoldStatus::EXPAND;
87 mgr.HandleSensorChange(nextState, angle, foldScreenPolicy);
88 LOG_SetCallback(nullptr);
89 }
90
91 /**
92 * @tc.name: HandleSensorChange1
93 * @tc.desc: HandleSensorChange1
94 * @tc.type: FUNC
95 */
96 HWTEST_F(SensorFoldStateManagerTest, HandleSensorChange1, TestSize.Level1)
97 {
98 g_errLog.clear();
99 LOG_SetCallback(MyLogCallback);
100 SensorFoldStateManager mgr = SensorFoldStateManager();
101 mgr.isInOneStep_ = true;
102 mgr.mState_ = FoldStatus::FOLDED;
103 FoldStatus nextState = FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND;
104 std::vector<float> angles = {0.0f, 0.0f, 0.0f};
105 std::vector<uint16_t> halls = {0, 0};
106 sptr<FoldScreenPolicy> foldScreenPolicy = sptr<FoldScreenPolicy>::MakeSptr();
107 mgr.HandleSensorChange(nextState, angles, halls, foldScreenPolicy);
108 EXPECT_TRUE(g_errLog.find("fold state is UNKNOWN") == std::string::npos);
109 LOG_SetCallback(nullptr);
110 }
111
112 /**
113 * @tc.name: HandleSensorChange2
114 * @tc.desc: HandleSensorChange2
115 * @tc.type: FUNC
116 */
117 HWTEST_F(SensorFoldStateManagerTest, HandleSensorChange2, TestSize.Level1)
118 {
119 g_errLog.clear();
120 LOG_SetCallback(MyLogCallback);
121 SensorFoldStateManager mgr = SensorFoldStateManager();
122 mgr.isInOneStep_ = true;
123 mgr.mState_ = FoldStatus::FOLDED;
124 FoldStatus nextState = FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_EXPAND;
125 std::vector<float> angles = {0.0f, 0.0f, 0.0f};
126 std::vector<uint16_t> halls = {0, 0};
127 sptr<FoldScreenPolicy> foldScreenPolicy = sptr<FoldScreenPolicy>::MakeSptr();
128 mgr.HandleSensorChange(nextState, angles, halls, foldScreenPolicy);
129 EXPECT_TRUE(g_errLog.find("fold state is UNKNOWN") == std::string::npos);
130 LOG_SetCallback(nullptr);
131 }
132
133 /**
134 * @tc.name: HandleSensorChange3
135 * @tc.desc: HandleSensorChange3
136 * @tc.type: FUNC
137 */
138 HWTEST_F(SensorFoldStateManagerTest, HandleSensorChange3, TestSize.Level1)
139 {
140 g_errLog.clear();
141 LOG_SetCallback(MyLogCallback);
142 SensorFoldStateManager mgr = SensorFoldStateManager();
143 mgr.isInOneStep_ = false;
144 mgr.mState_ = FoldStatus::FOLDED;
145 FoldStatus nextState = FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND;
146 std::vector<float> angles = {0.0f, 0.0f, 0.0f};
147 std::vector<uint16_t> halls = {0, 0};
148 sptr<FoldScreenPolicy> foldScreenPolicy = sptr<FoldScreenPolicy>::MakeSptr();
149 mgr.HandleSensorChange(nextState, angles, halls, foldScreenPolicy);
150 EXPECT_TRUE(g_errLog.find("fold state is UNKNOWN") == std::string::npos);
151 LOG_SetCallback(nullptr);
152 }
153
154 /**
155 * @tc.name: ReportNotifyFoldStatusChange
156 * @tc.desc: ReportNotifyFoldStatusChange
157 * @tc.type: FUNC
158 */
159 HWTEST_F(SensorFoldStateManagerTest, ReportNotifyFoldStatusChange, TestSize.Level1)
160 {
161 SensorFoldStateManager mgr = SensorFoldStateManager();
162 int32_t currentStatus = 0;
163 int32_t nextStatus = 1;
164 float postureAngle = 0.0f;
165 mgr.ReportNotifyFoldStatusChange(currentStatus, nextStatus, postureAngle);
166 ASSERT_EQ(mgr.GetCurrentState(), FoldStatus::UNKNOWN);
167 }
168
169 /**
170 * @tc.name: ClearState
171 * @tc.desc: ClearState
172 * @tc.type: FUNC
173 */
174 HWTEST_F(SensorFoldStateManagerTest, ClearState, TestSize.Level1)
175 {
176 SensorFoldStateManager mgr = SensorFoldStateManager();
177 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
178 mgr.ClearState(foldScreenPolicy);
179 ASSERT_EQ(mgr.GetCurrentState(), FoldStatus::UNKNOWN);
180 }
181
182 /**
183 * @tc.name: NotifyReportFoldStatusToScb
184 * @tc.desc: NotifyReportFoldStatusToScb
185 * @tc.type: FUNC
186 */
187 HWTEST_F(SensorFoldStateManagerTest, NotifyReportFoldStatusToScb, TestSize.Level1)
188 {
189 SensorFoldStateManager mgr = SensorFoldStateManager();
190 FoldStatus currentStatus = FoldStatus::UNKNOWN;
191 FoldStatus nextStatus = FoldStatus::EXPAND;
192 float postureAngle = 0.0f;
193 mgr.NotifyReportFoldStatusToScb(currentStatus, nextStatus, postureAngle);
194 ASSERT_EQ(mgr.GetCurrentState(), FoldStatus::UNKNOWN);
195 }
196
197 /**
198 * @tc.name: IsTentMode
199 * @tc.desc: IsTentMode
200 * @tc.type: FUNC
201 */
202 HWTEST_F(SensorFoldStateManagerTest, IsTentMode, TestSize.Level1)
203 {
204 SensorFoldStateManager mgr = SensorFoldStateManager();
205 mgr.tentModeType_ = 1;
206 bool ret = mgr.IsTentMode();
207 ASSERT_EQ(ret, true);
208 }
209
210 /**
211 * @tc.name: SetTentMode
212 * @tc.desc: SetTentMode
213 * @tc.type: FUNC
214 */
215 HWTEST_F(SensorFoldStateManagerTest, SetTentMode, TestSize.Level1)
216 {
217 SensorFoldStateManager mgr = SensorFoldStateManager();
218 mgr.tentModeType_ = 0;
219 mgr.SetTentMode(0);
220 bool ret = mgr.IsTentMode();
221 ASSERT_EQ(ret, false);
222 }
223 }
224 } // namespace Rosen
225 } // namespace OHOS