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 "multi_screen_manager.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace Rosen {
25 namespace {
26 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
27 }
28 class MultiScreenManagerTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 void SetUp() override;
33 void TearDown() override;
34 };
35
SetUpTestCase()36 void MultiScreenManagerTest::SetUpTestCase()
37 {
38 }
39
TearDownTestCase()40 void MultiScreenManagerTest::TearDownTestCase()
41 {
42 usleep(SLEEP_TIME_IN_US);
43 }
44
SetUp()45 void MultiScreenManagerTest::SetUp()
46 {
47 }
48
TearDown()49 void MultiScreenManagerTest::TearDown()
50 {
51 }
52
53 namespace {
54
55 /**
56 * @tc.name: FilterPhysicalAndVirtualScreen
57 * @tc.desc: FilterPhysicalAndVirtualScreen func
58 * @tc.type: FUNC
59 */
60 HWTEST_F(MultiScreenManagerTest, FilterPhysicalAndVirtualScreen, Function | SmallTest | Level1)
61 {
62 std::vector<ScreenId> allScreenIds = {1, 2, 3};
63 std::vector<ScreenId> physicalScreenIds;
64 std::vector<ScreenId> virtualScreenIds;
65 MultiScreenManager::GetInstance().FilterPhysicalAndVirtualScreen(allScreenIds,
66 physicalScreenIds, virtualScreenIds);
67 EXPECT_EQ(virtualScreenIds.size(), 0);
68 }
69
70 /**
71 * @tc.name: VirtualScreenMirrorSwitch
72 * @tc.desc: VirtualScreenMirrorSwitch func
73 * @tc.type: FUNC
74 */
75 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch01, Function | SmallTest | Level1)
76 {
77 ScreenId mainScreenId = 1;
78 std::vector<ScreenId> ScreenIds = {2, 3};
79 ScreenId screenGroupId;
80 MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, DMRect::NONE(),
81 screenGroupId);
82 EXPECT_EQ(screenGroupId, 0);
83 }
84
85 /**
86 * @tc.name: VirtualScreenMirrorSwitch
87 * @tc.desc: mainScreen is not nullptr
88 * @tc.type: FUNC
89 */
90 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch02, Function | SmallTest | Level1)
91 {
92 ScreenId mainScreenId = 1002;
93 std::vector<ScreenId> ScreenIds = {2, 3};
94 ScreenId screenGroupId;
95 sptr<ScreenSession> session = new ScreenSession();
96 ScreenSessionManager::GetInstance().screenSessionMap_[mainScreenId] = session;
97 auto ret = MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds,
98 DMRect::NONE(), screenGroupId);
99 EXPECT_EQ(ret, DMError::DM_OK);
100 }
101
102 /**
103 * @tc.name: VirtualScreenMirrorSwitch
104 * @tc.desc: ret != DMError::DM_OK
105 * @tc.type: FUNC
106 */
107 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch03, Function | SmallTest | Level1)
108 {
109 ScreenId mainScreenId = 1002;
110 std::vector<ScreenId> ScreenIds = {2, 3};
111 ScreenId screenGroupId;
112 sptr<ScreenSession> session = new ScreenSession();
113 ScreenSessionManager::GetInstance().screenSessionMap_[mainScreenId] = session;
114 ScreenId rsId = 1002;
115 std::string name = "ok";
116 ScreenCombination combination = ScreenCombination::SCREEN_ALONE;
117 sptr<ScreenSessionGroup> sessiongroup = new ScreenSessionGroup(mainScreenId, rsId, name, combination);
118 ScreenSessionManager::GetInstance().smsScreenGroupMap_[mainScreenId] = sessiongroup;
119 auto ret = MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, DMRect::NONE(),
120 screenGroupId);
121 EXPECT_EQ(ret, DMError::DM_OK);
122 }
123
124 /**
125 * @tc.name: PhysicalScreenMirrorSwitch
126 * @tc.desc: PhysicalScreenMirrorSwitch func
127 * @tc.type: FUNC
128 */
129 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch01, Function | SmallTest | Level1)
130 {
131 std::vector<ScreenId> screenIds = {2, 3};
132 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, DMRect::NONE());
133 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
134 }
135
136 /**
137 * @tc.name: PhysicalScreenMirrorSwitch
138 * @tc.desc: defaultSession != nullptr
139 * @tc.type: FUNC
140 */
141 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch02, Function | SmallTest | Level1)
142 {
143 std::vector<ScreenId> screenIds = {1002, 1003};
144 sptr<ScreenSession> session = new ScreenSession();
145 ScreenSessionManager::GetInstance().screenSessionMap_[
146 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
147 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, DMRect::NONE());
148 EXPECT_EQ(ret, DMError::DM_OK);
149 }
150
151 /**
152 * @tc.name: PhysicalScreenMirrorSwitch
153 * @tc.desc: defaultSession != nullptr
154 * @tc.type: FUNC
155 */
156 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch03, Function | SmallTest | Level1)
157 {
158 std::vector<ScreenId> screenIds = {1002, 1003};
159 sptr<ScreenSession> session = new ScreenSession();
160 ScreenSessionManager::GetInstance().screenSessionMap_[
161 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
162 sptr<ScreenSession> session1 = new ScreenSession();
163 ScreenSessionManager::GetInstance().screenSessionMap_[1002] = session1;
164 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds, DMRect::NONE());
165 EXPECT_EQ(ret, DMError::DM_OK);
166 }
167
168 /**
169 * @tc.name: PhysicalScreenUniqueSwitch
170 * @tc.desc: PhysicalScreenUniqueSwitch func
171 * @tc.type: FUNC
172 */
173 HWTEST_F(MultiScreenManagerTest, PhysicalScreenUniqueSwitch, Function | SmallTest | Level1)
174 {
175 std::vector<ScreenId> screenIds = {2, 3};
176 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenUniqueSwitch(screenIds);
177 EXPECT_EQ(ret, DMError::DM_OK);
178 }
179
180 /**
181 * @tc.name: PhysicalScreenUniqueSwitch
182 * @tc.desc: screenSession != nullptr
183 * @tc.type: FUNC
184 */
185 HWTEST_F(MultiScreenManagerTest, PhysicalScreenUniqueSwitch02, Function | SmallTest | Level1)
186 {
187 std::vector<ScreenId> screenIds = {1002, 1003};
188 sptr<ScreenSession> session = new ScreenSession();
189 ScreenSessionManager::GetInstance().screenSessionMap_[
190 1002] = session;
191 sptr<ScreenSession> session1 = new ScreenSession();
192 ScreenSessionManager::GetInstance().screenSessionMap_[
193 1003] = session1;
194 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenUniqueSwitch(screenIds);
195 EXPECT_EQ(ret, DMError::DM_OK);
196 }
197
198 /**
199 * @tc.name: VirtualScreenUniqueSwitch01
200 * @tc.desc: VirtualScreenUniqueSwitch func
201 * @tc.type: FUNC
202 */
203 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch01, Function | SmallTest | Level1)
204 {
205 sptr<ScreenSession> screenSession =new ScreenSession();
206 std::vector<ScreenId> screenIds = {2, 3};
207 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
208 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
209 }
210
211 /**
212 * @tc.name: VirtualScreenUniqueSwitch02
213 * @tc.desc: VirtualScreenUniqueSwitch func
214 * @tc.type: FUNC
215 */
216 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch02, Function | SmallTest | Level1)
217 {
218 sptr<ScreenSession> screenSession =nullptr;
219 std::vector<ScreenId> screenIds = {2, 3};
220 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
221 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
222 }
223
224 /**
225 * @tc.name: UniqueSwitch
226 * @tc.desc: UniqueSwitch func
227 * @tc.type: FUNC
228 */
229 HWTEST_F(MultiScreenManagerTest, UniqueSwitch01, Function | SmallTest | Level1)
230 {
231 std::vector<ScreenId> screenIds = {};
232 DMError ret = MultiScreenManager::GetInstance().UniqueSwitch(screenIds);
233 EXPECT_EQ(ret, DMError::DM_OK);
234 }
235
236 /**
237 * @tc.name: UniqueSwitch
238 * @tc.desc: screenIds is not empty
239 * @tc.type: FUNC
240 */
241 HWTEST_F(MultiScreenManagerTest, UniqueSwitch02, Function | SmallTest | Level1)
242 {
243 std::vector<ScreenId> screenIds = {1001, 1002};
244 DMError ret = MultiScreenManager::GetInstance().UniqueSwitch(screenIds);
245 EXPECT_EQ(ret, DMError::DM_OK);
246 }
247
248 /**
249 * @tc.name: MirrorSwitch
250 * @tc.desc: MirrorSwitch func
251 * @tc.type: FUNC
252 */
253 HWTEST_F(MultiScreenManagerTest, MirrorSwitch, Function | SmallTest | Level1)
254 {
255 std::vector<ScreenId> screenIds = {};
256 ScreenId screenGroupId = 0;
257 DMError ret = MultiScreenManager::GetInstance().MirrorSwitch(1, screenIds, DMRect::NONE(), screenGroupId);
258 EXPECT_EQ(ret, DMError::DM_OK);
259 }
260 }
261 } // namespace Rosen
262 } // namespace OHOS