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
16 #include <gtest/gtest.h>
17 #include <parameter.h>
18 #include <parameters.h>
19
20 #include "screen_session_manager/include/screen_session_manager.h"
21 #include "screen_scene_config.h"
22 #include "scene_board_judgement.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_IN_US = 100000; // 100ms
31 }
32 class ScreenSessionManagerTest : public testing::Test {
33 public:
34 static void SetUpTestCase();
35 static void TearDownTestCase();
36 void SetUp() override;
37 void TearDown() override;
38
39 static sptr<ScreenSessionManager> ssm_;
40 };
41
42 sptr<ScreenSessionManager> ScreenSessionManagerTest::ssm_ = nullptr;
43
SetUpTestCase()44 void ScreenSessionManagerTest::SetUpTestCase()
45 {
46 ssm_ = new ScreenSessionManager();
47 }
48
TearDownTestCase()49 void ScreenSessionManagerTest::TearDownTestCase()
50 {
51 ssm_ = nullptr;
52 }
53
SetUp()54 void ScreenSessionManagerTest::SetUp()
55 {
56 }
57
TearDown()58 void ScreenSessionManagerTest::TearDown()
59 {
60 usleep(SLEEP_TIME_IN_US);
61 }
62
63 namespace {
64 /**
65 * @tc.name: SwitchScrollParam01
66 * @tc.desc: SwitchScrollParam test
67 * @tc.type: FUNC
68 */
69 HWTEST_F(ScreenSessionManagerTest, SwitchScrollParam01, Function | SmallTest | Level3)
70 {
71 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
72 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
73 }
74 ScreenSceneConfig::scrollableParams_.clear();
75 vector<FoldDisplayMode> displayModeALL = {
76 FoldDisplayMode::SUB,
77 FoldDisplayMode::MAIN,
78 FoldDisplayMode::FULL,
79 FoldDisplayMode::UNKNOWN,
80 FoldDisplayMode::COORDINATION,
81 };
82 std::map<FoldDisplayMode, std::string> scrollVelocityScaleParam = {
83 pair<FoldDisplayMode, std::string>(FoldDisplayMode::SUB, "1.0"),
84 pair<FoldDisplayMode, std::string>(FoldDisplayMode::MAIN, "1.1"),
85 pair<FoldDisplayMode, std::string>(FoldDisplayMode::FULL, "1.2"),
86 pair<FoldDisplayMode, std::string>(FoldDisplayMode::UNKNOWN, "1.3"),
87 pair<FoldDisplayMode, std::string>(FoldDisplayMode::COORDINATION, "1.4")
88 };
89 std::map<FoldDisplayMode, std::string> scrollFrictionParam = {
90 pair<FoldDisplayMode, std::string>(FoldDisplayMode::SUB, "1.0"),
91 pair<FoldDisplayMode, std::string>(FoldDisplayMode::MAIN, "2.0"),
92 pair<FoldDisplayMode, std::string>(FoldDisplayMode::FULL, "3.0"),
93 pair<FoldDisplayMode, std::string>(FoldDisplayMode::UNKNOWN, "4.0"),
94 pair<FoldDisplayMode, std::string>(FoldDisplayMode::COORDINATION, "5.0"),
95 };
96 ScreenSessionManager* ssm = new ScreenSessionManager();
97 ASSERT_NE(ssm, nullptr);
98 std::string ret1, ret2;
99 for (FoldDisplayMode displayMode : displayModeALL) {
100 ScrollableParam scrollableParam;
101 scrollableParam.velocityScale_ = scrollVelocityScaleParam.count(displayMode) ?
102 scrollVelocityScaleParam[displayMode] : "";
103 scrollableParam.friction_ = scrollFrictionParam.count(displayMode) ?
104 scrollFrictionParam[displayMode] : "";
105 ScreenSceneConfig::scrollableParams_[displayMode] = scrollableParam;
106 ssm->SwitchScrollParam(displayMode);
107 ret1 = system::GetParameter("persist.scrollable.velocityScale", "0");
108 ret2 = system::GetParameter("persist.scrollable.friction", "0");
109 EXPECT_EQ(ret1, scrollVelocityScaleParam[displayMode]);
110 EXPECT_EQ(ret2, scrollFrictionParam[displayMode]);
111 }
112 }
113
114 /**
115 * @tc.name: SwitchScrollParam02
116 * @tc.desc: SwitchScrollParam test
117 * @tc.type: FUNC
118 */
119 HWTEST_F(ScreenSessionManagerTest, SwitchScrollParam02, Function | SmallTest | Level3)
120 {
121 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
122 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
123 }
124 ScreenSceneConfig::scrollableParams_.clear();
125 vector<FoldDisplayMode> displayModeALL = {
126 FoldDisplayMode::SUB,
127 FoldDisplayMode::MAIN,
128 FoldDisplayMode::FULL,
129 FoldDisplayMode::UNKNOWN,
130 FoldDisplayMode::COORDINATION,
131 };
132 std::map<FoldDisplayMode, std::string> scrollVelocityScaleParam = {
133 pair<FoldDisplayMode, std::string>(FoldDisplayMode::FULL, "2.0"),
134 pair<FoldDisplayMode, std::string>(FoldDisplayMode::MAIN, "main"),
135 pair<FoldDisplayMode, std::string>(FoldDisplayMode::UNKNOWN, "!!"),
136 };
137 std::map<FoldDisplayMode, std::string> scrollFrictionParam;
138 ScreenSessionManager* ssm = new ScreenSessionManager();
139 ASSERT_NE(ssm, nullptr);
140 std::string ret1, ret2;
141 for (FoldDisplayMode displayMode : displayModeALL) {
142 ScrollableParam scrollableParam;
143 scrollableParam.velocityScale_ = scrollVelocityScaleParam.count(displayMode) ?
144 scrollVelocityScaleParam[displayMode] : "";
145 scrollableParam.friction_ = scrollFrictionParam.count(displayMode) ?
146 scrollFrictionParam[displayMode] : "";
147 ScreenSceneConfig::scrollableParams_[displayMode] = scrollableParam;
148 ssm->SwitchScrollParam(displayMode);
149 ret1 = system::GetParameter("persist.scrollable.velocityScale", "0");
150 ret2 = system::GetParameter("persist.scrollable.friction", "0");
151 EXPECT_EQ(ret1, scrollVelocityScaleParam[displayMode]);
152 EXPECT_EQ(ret2, scrollFrictionParam[displayMode]);
153 }
154 }
155
156 /**
157 * @tc.name: WakeUpPictureFrameBlock
158 * @tc.desc: WakeUpPictureFrameBlock test
159 * @tc.type: FUNC
160 */
161 HWTEST_F(ScreenSessionManagerTest, WakeUpPictureFrameBlock, Function | SmallTest | Level3)
162 {
163 ssm_->WakeUpPictureFrameBlock(DisplayEvent::SCREEN_LOCK_OFF);
164 ASSERT_EQ(ssm_->pictureFrameBreak_, false);
165 ASSERT_NE(ssm_, nullptr);
166 ssm_->pictureFrameReady_ = false;
167 ssm_->pictureFrameBreak_ = false;
168 ssm_->WakeUpPictureFrameBlock(DisplayEvent::SCREEN_LOCK_START_DREAM);
169 ASSERT_EQ(ssm_->pictureFrameReady_, true);
170 ssm_->WakeUpPictureFrameBlock(DisplayEvent::SCREEN_LOCK_END_DREAM);
171 ASSERT_EQ(ssm_->pictureFrameBreak_, true);
172 }
173
174 /**
175 * @tc.name: AddVirtualScreenBlockList
176 * @tc.desc: AddVirtualScreenBlockList test
177 * @tc.type: FUNC
178 */
179 HWTEST_F(ScreenSessionManagerTest, AddVirtualScreenBlockList, Function | SmallTest | Level3)
180 {
181 ASSERT_NE(ssm_, nullptr);
182 std::vector<int32_t> persistentIds {0, 1, 2};
183 ASSERT_EQ(DMError::DM_OK, ssm_->AddVirtualScreenBlockList(persistentIds));
184 }
185
186 /**
187 * @tc.name: RemoveVirtualScreenBlockList
188 * @tc.desc: RemoveVirtualScreenBlockList test
189 * @tc.type: FUNC
190 */
191 HWTEST_F(ScreenSessionManagerTest, RemoveVirtualScreenBlockList, Function | SmallTest | Level3)
192 {
193 ASSERT_NE(ssm_, nullptr);
194 std::vector<int32_t> persistentIds {0, 1, 2};
195 ASSERT_EQ(DMError::DM_OK, ssm_->RemoveVirtualScreenBlockList(persistentIds));
196 }
197
198 /**
199 * @tc.name: BlockScreenWaitPictureFrameByCV
200 * @tc.desc: BlockScreenWaitPictureFrameByCV test
201 * @tc.type: FUNC
202 */
203 HWTEST_F(ScreenSessionManagerTest, BlockScreenWaitPictureFrameByCV, Function | SmallTest | Level3)
204 {
205 ASSERT_NE(ssm_, nullptr);
206 ssm_->pictureFrameReady_ = true;
207 ssm_->pictureFrameBreak_ = true;
208 bool result = ssm_->BlockScreenWaitPictureFrameByCV(true);
209 ASSERT_EQ(result, true);
210 result = ssm_->BlockScreenWaitPictureFrameByCV(false);
211 ASSERT_EQ(result, true);
212
213 ASSERT_EQ(ssm_->pictureFrameReady_, false);
214 ASSERT_EQ(ssm_->pictureFrameBreak_, false);
215 }
216 }
217 }
218 }