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 "screen_session_manager/include/fold_screen_controller/sensor_fold_state_manager/dual_display_sensor_fold_state_manager.h"
19 #include "screen_session_manager/include/screen_session_manager.h"
20 #include "fold_screen_controller/fold_screen_controller.h"
21 #include "parameters.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace Rosen {
28 namespace {
29 constexpr uint32_t SLEEP_TIME_US = 100000;
30 const float INWARD_FOLDED_THRESHOLD = static_cast<float>(system::GetIntParameter<int32_t>
31 ("const.fold.folded_threshold", 85));
32 const float INWARD_EXPAND_THRESHOLD = static_cast<float>(system::GetIntParameter<int32_t>
33 ("const.fold.expand_threshold", 145));
34 const float INWARD_HALF_FOLDED_MAX_THRESHOLD = static_cast<float>(system::GetIntParameter<int32_t>
35 ("const.half_folded_max_threshold", 135));
36 const float INWARD_HALF_FOLDED_MIN_THRESHOLD = static_cast<float>(system::GetIntParameter<int32_t>
37 ("const.fold.half_folded_min_threshold", 85));
38 constexpr int32_t HALL_THRESHOLD = 1;
39 constexpr float INWARD_FOLDED_LOWER_THRESHOLD = 10.0F;
40 constexpr float INWARD_FOLDED_UPPER_THRESHOLD = 20.0F;
41 constexpr float ANGLE_BUFFER = 0.001F;
42 }
43
44 class DualDisplaySensorFoldStateManagerTest : public testing::Test {
45 public:
46 static void SetUpTestCase();
47 static void TearDownTestCase();
48 void SetUp() override;
49 void TearDown() override;
50 };
51
SetUpTestCase()52 void DualDisplaySensorFoldStateManagerTest::SetUpTestCase()
53 {
54 }
55
TearDownTestCase()56 void DualDisplaySensorFoldStateManagerTest::TearDownTestCase()
57 {
58 }
59
SetUp()60 void DualDisplaySensorFoldStateManagerTest::SetUp()
61 {
62 }
63
TearDown()64 void DualDisplaySensorFoldStateManagerTest::TearDown()
65 {
66 usleep(SLEEP_TIME_US);
67 }
68
69 namespace {
70
71 /**
72 * @tc.name: DualDisplaySensorFoldStateManager
73 * @tc.desc: DualDisplaySensorFoldStateManager
74 * @tc.type: FUNC
75 */
76 HWTEST_F(DualDisplaySensorFoldStateManagerTest, DualDisplaySensorFoldStateManager, Function | SmallTest | Level3)
77 {
78 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager();
79 ASSERT_EQ(mgr.packageNames_.size(), 0);
80 }
81
82 /**
83 * @tc.name: HandleAngleChange
84 * @tc.desc: HandleAngleChange
85 * @tc.type: FUNC
86 */
87 HWTEST_F(DualDisplaySensorFoldStateManagerTest, HandleAngleChange, Function | SmallTest | Level3)
88 {
89 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager();
90 float angle = 0.0f;
91 int hall = 0;
92 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
93 mgr.HandleAngleChange(angle, hall, foldScreenPolicy);
94 ASSERT_TRUE(std::islessequal(angle, INWARD_FOLDED_THRESHOLD + ANGLE_BUFFER));
95 ASSERT_FALSE(hall == HALL_THRESHOLD);
96
97 hall = 1;
98 mgr.HandleAngleChange(angle, hall, foldScreenPolicy);
99 ASSERT_TRUE(std::islessequal(angle, INWARD_FOLDED_THRESHOLD + ANGLE_BUFFER));
100 ASSERT_TRUE(hall == HALL_THRESHOLD);
101
102 angle = 100.0f;
103 mgr.HandleAngleChange(angle, hall, foldScreenPolicy);
104 ASSERT_FALSE(std::islessequal(angle, INWARD_FOLDED_THRESHOLD + ANGLE_BUFFER));
105 ASSERT_TRUE(hall == HALL_THRESHOLD);
106
107 hall = 0;
108 mgr.HandleAngleChange(angle, hall, foldScreenPolicy);
109 ASSERT_FALSE(std::islessequal(angle, INWARD_FOLDED_THRESHOLD + ANGLE_BUFFER));
110 ASSERT_FALSE(hall == HALL_THRESHOLD);
111 }
112
113 /**
114 * @tc.name: HandleHallChange
115 * @tc.desc: HandleHallChange
116 * @tc.type: FUNC
117 */
118 HWTEST_F(DualDisplaySensorFoldStateManagerTest, HandleHallChange, Function | SmallTest | Level3)
119 {
120 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager();
121 float angle = 0.0f;
122 int hall = 1;
123 sptr<FoldScreenPolicy> foldScreenPolicy = new FoldScreenPolicy();
124 mgr.applicationStateObserver_ = nullptr;
125 mgr.HandleHallChange(angle, hall, foldScreenPolicy);
126 ASSERT_FALSE(mgr.applicationStateObserver_ != nullptr);
127 ASSERT_TRUE(hall == HALL_THRESHOLD);
128
129 mgr.applicationStateObserver_ = new ApplicationStateObserver();
130 mgr.HandleHallChange(angle, hall, foldScreenPolicy);
131 ASSERT_TRUE(mgr.applicationStateObserver_ != nullptr);
132 ASSERT_TRUE(hall == HALL_THRESHOLD);
133
134 mgr.applicationStateObserver_ = nullptr;
135 hall = 0;
136 mgr.HandleHallChange(angle, hall, foldScreenPolicy);
137 ASSERT_FALSE(mgr.applicationStateObserver_ != nullptr);
138 ASSERT_FALSE(hall == HALL_THRESHOLD);
139 }
140
141 /**
142 * @tc.name: GetNextFoldState
143 * @tc.desc: GetNextFoldState
144 * @tc.type: FUNC
145 */
146 HWTEST_F(DualDisplaySensorFoldStateManagerTest, GetNextFoldState, Function | SmallTest | Level3)
147 {
148 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager();
149 float angle = 200.0f;
150 int hall = 1;
151 FoldStatus ret = mgr.GetNextFoldState(angle, hall);
152 ASSERT_TRUE(std::isgreaterequal(angle, INWARD_EXPAND_THRESHOLD + ANGLE_BUFFER));
153 ASSERT_EQ(ret, FoldStatus::EXPAND);
154
155 angle = 0.0f;
156 ret = mgr.GetNextFoldState(angle, hall);
157 ASSERT_TRUE(std::islessequal
158 (angle, INWARD_FOLDED_LOWER_THRESHOLD + ANGLE_BUFFER));
159 ASSERT_EQ(ret, FoldStatus::FOLDED);
160
161 mgr.isHallSwitchApp_ = true;
162 angle = 30.0f;
163 ret = mgr.GetNextFoldState(angle, hall);
164 ASSERT_TRUE(std::isgreaterequal(angle, INWARD_FOLDED_UPPER_THRESHOLD + ANGLE_BUFFER));
165 ASSERT_TRUE(std::islessequal(angle, INWARD_HALF_FOLDED_MAX_THRESHOLD + ANGLE_BUFFER));
166 ASSERT_EQ(ret, FoldStatus::HALF_FOLD);
167
168 mgr.isHallSwitchApp_ = false;
169 angle = 120.0f;
170 ret = mgr.GetNextFoldState(angle, hall);
171 ASSERT_TRUE(std::isgreaterequal(angle, INWARD_HALF_FOLDED_MIN_THRESHOLD + ANGLE_BUFFER));
172 ASSERT_TRUE(std::islessequal(angle, INWARD_HALF_FOLDED_MAX_THRESHOLD + ANGLE_BUFFER));
173 ASSERT_EQ(ret, FoldStatus::HALF_FOLD);
174 }
175
176 /**
177 * @tc.name: RegisterApplicationStateObserver
178 * @tc.desc: RegisterApplicationStateObserver
179 * @tc.type: FUNC
180 */
181 HWTEST_F(DualDisplaySensorFoldStateManagerTest, RegisterApplicationStateObserver, Function | SmallTest | Level3)
182 {
183 DualDisplaySensorFoldStateManager mgr = DualDisplaySensorFoldStateManager();
184 mgr.RegisterApplicationStateObserver();
185 ASSERT_NE(mgr.applicationStateObserver_, nullptr);
186 }
187 }
188 } // namespace Rosen
189 } // namespace OHOS