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, screenGroupId);
81 EXPECT_EQ(screenGroupId, 0);
82 }
83
84 /**
85 * @tc.name: VirtualScreenMirrorSwitch
86 * @tc.desc: mainScreen is not nullptr
87 * @tc.type: FUNC
88 */
89 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch02, Function | SmallTest | Level1)
90 {
91 ScreenId mainScreenId = 1002;
92 std::vector<ScreenId> ScreenIds = {2, 3};
93 ScreenId screenGroupId;
94 sptr<ScreenSession> session = new ScreenSession();
95 ScreenSessionManager::GetInstance().screenSessionMap_[mainScreenId] = session;
96 auto ret = MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, screenGroupId);
97 EXPECT_EQ(ret, DMError::DM_OK);
98 }
99
100 /**
101 * @tc.name: VirtualScreenMirrorSwitch
102 * @tc.desc: ret != DMError::DM_OK
103 * @tc.type: FUNC
104 */
105 HWTEST_F(MultiScreenManagerTest, VirtualScreenMirrorSwitch03, Function | SmallTest | Level1)
106 {
107 ScreenId mainScreenId = 1002;
108 std::vector<ScreenId> ScreenIds = {2, 3};
109 ScreenId screenGroupId;
110 sptr<ScreenSession> session = new ScreenSession();
111 ScreenSessionManager::GetInstance().screenSessionMap_[mainScreenId] = session;
112 ScreenId rsId = 1002;
113 std::string name = "ok";
114 ScreenCombination combination = ScreenCombination::SCREEN_ALONE;
115 sptr<ScreenSessionGroup> sessiongroup = new ScreenSessionGroup(mainScreenId, rsId, name, combination);
116 ScreenSessionManager::GetInstance().smsScreenGroupMap_[mainScreenId] = sessiongroup;
117 auto ret = MultiScreenManager::GetInstance().VirtualScreenMirrorSwitch(mainScreenId, ScreenIds, screenGroupId);
118 EXPECT_EQ(ret, DMError::DM_OK);
119 }
120
121 /**
122 * @tc.name: PhysicalScreenMirrorSwitch
123 * @tc.desc: PhysicalScreenMirrorSwitch func
124 * @tc.type: FUNC
125 */
126 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch01, Function | SmallTest | Level1)
127 {
128 std::vector<ScreenId> screenIds = {2, 3};
129 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds);
130 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
131 }
132
133 /**
134 * @tc.name: PhysicalScreenMirrorSwitch
135 * @tc.desc: defaultSession != nullptr
136 * @tc.type: FUNC
137 */
138 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch02, Function | SmallTest | Level1)
139 {
140 std::vector<ScreenId> screenIds = {1002, 1003};
141 sptr<ScreenSession> session = new ScreenSession();
142 ScreenSessionManager::GetInstance().screenSessionMap_[
143 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
144 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds);
145 EXPECT_EQ(ret, DMError::DM_OK);
146 }
147
148 /**
149 * @tc.name: PhysicalScreenMirrorSwitch
150 * @tc.desc: defaultSession != nullptr
151 * @tc.type: FUNC
152 */
153 HWTEST_F(MultiScreenManagerTest, PhysicalScreenMirrorSwitch03, Function | SmallTest | Level1)
154 {
155 std::vector<ScreenId> screenIds = {1002, 1003};
156 sptr<ScreenSession> session = new ScreenSession();
157 ScreenSessionManager::GetInstance().screenSessionMap_[
158 ScreenSessionManager::GetInstance().defaultScreenId_] = session;
159 sptr<ScreenSession> session1 = new ScreenSession();
160 ScreenSessionManager::GetInstance().screenSessionMap_[1002] = session1;
161 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenMirrorSwitch(screenIds);
162 EXPECT_EQ(ret, DMError::DM_OK);
163 }
164
165 /**
166 * @tc.name: PhysicalScreenUniqueSwitch
167 * @tc.desc: PhysicalScreenUniqueSwitch func
168 * @tc.type: FUNC
169 */
170 HWTEST_F(MultiScreenManagerTest, PhysicalScreenUniqueSwitch, Function | SmallTest | Level1)
171 {
172 std::vector<ScreenId> screenIds = {2, 3};
173 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenUniqueSwitch(screenIds);
174 EXPECT_EQ(ret, DMError::DM_OK);
175 }
176
177 /**
178 * @tc.name: PhysicalScreenUniqueSwitch
179 * @tc.desc: screenSession != nullptr
180 * @tc.type: FUNC
181 */
182 HWTEST_F(MultiScreenManagerTest, PhysicalScreenUniqueSwitch02, Function | SmallTest | Level1)
183 {
184 std::vector<ScreenId> screenIds = {1002, 1003};
185 sptr<ScreenSession> session = new ScreenSession();
186 ScreenSessionManager::GetInstance().screenSessionMap_[
187 1002] = session;
188 sptr<ScreenSession> session1 = new ScreenSession();
189 ScreenSessionManager::GetInstance().screenSessionMap_[
190 1003] = session1;
191 DMError ret = MultiScreenManager::GetInstance().PhysicalScreenUniqueSwitch(screenIds);
192 EXPECT_EQ(ret, DMError::DM_OK);
193 }
194
195 /**
196 * @tc.name: VirtualScreenUniqueSwitch01
197 * @tc.desc: VirtualScreenUniqueSwitch func
198 * @tc.type: FUNC
199 */
200 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch01, Function | SmallTest | Level1)
201 {
202 sptr<ScreenSession> screenSession =new ScreenSession();
203 std::vector<ScreenId> screenIds = {2, 3};
204 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
205 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
206 }
207
208 /**
209 * @tc.name: VirtualScreenUniqueSwitch02
210 * @tc.desc: VirtualScreenUniqueSwitch func
211 * @tc.type: FUNC
212 */
213 HWTEST_F(MultiScreenManagerTest, VirtualScreenUniqueSwitch02, Function | SmallTest | Level1)
214 {
215 sptr<ScreenSession> screenSession =nullptr;
216 std::vector<ScreenId> screenIds = {2, 3};
217 DMError ret = MultiScreenManager::GetInstance().VirtualScreenUniqueSwitch(screenSession, screenIds);
218 EXPECT_EQ(ret, DMError::DM_ERROR_NULLPTR);
219 }
220
221 /**
222 * @tc.name: UniqueSwitch
223 * @tc.desc: UniqueSwitch func
224 * @tc.type: FUNC
225 */
226 HWTEST_F(MultiScreenManagerTest, UniqueSwitch01, Function | SmallTest | Level1)
227 {
228 std::vector<ScreenId> screenIds = {};
229 DMError ret = MultiScreenManager::GetInstance().UniqueSwitch(screenIds);
230 EXPECT_EQ(ret, DMError::DM_OK);
231 }
232
233 /**
234 * @tc.name: UniqueSwitch
235 * @tc.desc: screenIds is not empty
236 * @tc.type: FUNC
237 */
238 HWTEST_F(MultiScreenManagerTest, UniqueSwitch02, Function | SmallTest | Level1)
239 {
240 std::vector<ScreenId> screenIds = {1001, 1002};
241 DMError ret = MultiScreenManager::GetInstance().UniqueSwitch(screenIds);
242 EXPECT_EQ(ret, DMError::DM_OK);
243 }
244
245 /**
246 * @tc.name: MirrorSwitch
247 * @tc.desc: MirrorSwitch func
248 * @tc.type: FUNC
249 */
250 HWTEST_F(MultiScreenManagerTest, MirrorSwitch, Function | SmallTest | Level1)
251 {
252 std::vector<ScreenId> screenIds = {};
253 ScreenId screenGroupId = 0;
254 DMError ret = MultiScreenManager::GetInstance().MirrorSwitch(1, screenIds, screenGroupId);
255 EXPECT_EQ(ret, DMError::DM_OK);
256 }
257 }
258 } // namespace Rosen
259 } // namespace OHOS