1 /*
2 * Copyright (c) 2021-2022 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 <cinttypes>
17 #include <gtest/gtest.h>
18
19 #include "common_test_utils.h"
20 #include "display_test_utils.h"
21 #include "display_manager_proxy.h"
22 #include "future.h"
23 #include "pixel_map.h"
24 #include "screenshot_listener_future.h"
25 #include "mock_display_manager_adapter.h"
26 #include "singleton_mocker.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Rosen {
33 namespace {
34 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "ScreenshotTest"};
35 }
36 using Mocker = SingletonMocker<DisplayManagerAdapter, MockDisplayManagerAdapter>;
37 using Utils = DisplayTestUtils;
38 class ScreenshotListener;
39 class ScreenshotTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 virtual void SetUp() override;
44 virtual void TearDown() override;
45 static DisplayId defaultId_;
46 static Media::Rect defaultScreen_;
47 static Media::Size defaultImage_;
48 DisplayId invalidId_ = DISPLAY_ID_INVALID;
49 Media::Rect invalidRect_ = {-1, -1, -1, -1};
50 uint32_t defaultRot_ = 0;
51 };
52
53 DisplayId ScreenshotTest::defaultId_ = DISPLAY_ID_INVALID;
54 Media::Rect ScreenshotTest::defaultScreen_ = {0, 0, 0, 0};
55 Media::Size ScreenshotTest::defaultImage_ = {0, 0};
56
SetUpTestCase()57 void ScreenshotTest::SetUpTestCase()
58 {
59 CommonTestUtils::InjectTokenInfoByHapName(0, "com.ohos.systemui", 0);
60 const char** perms = new const char *[1];
61 perms[0] = "ohos.permission.CAPTURE_SCREEN";
62 CommonTestUtils::SetAceessTokenPermission("ScreenshotTest", perms, 1);
63
64 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
65 if (display == nullptr) {
66 WLOGFE("GetDefaultDisplay: failed!\n");
67 return;
68 }
69 WLOGI("GetDefaultDisplay: id %" PRIu64", w %d, h %d, fps %u\n", display->GetId(), display->GetWidth(),
70 display->GetHeight(), display->GetRefreshRate());
71
72 defaultId_ = display->GetId();
73 defaultScreen_ = {0, 0, display->GetWidth(), display->GetHeight()};
74 defaultImage_ = {display->GetWidth(), display->GetHeight()};
75 }
76
TearDownTestCase()77 void ScreenshotTest::TearDownTestCase()
78 {
79 }
80
SetUp()81 void ScreenshotTest::SetUp()
82 {
83 }
84
TearDown()85 void ScreenshotTest::TearDown()
86 {
87 }
88
89 namespace {
90 /**
91 * @tc.name: ScreenShotValid
92 * @tc.desc: Check if screenshot of default display's ID is valid
93 * @tc.type: FUNC
94 */
95 HWTEST_F(ScreenshotTest, ScreenShotValid01, TestSize.Level1)
96 {
97 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
98
99 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(1).WillOnce(Return(nullptr));
100 EXPECT_EQ(DISPLAY_ID_INVALID, DisplayManager::GetInstance().GetDefaultDisplayId());
101
102 Media::InitializationOptions opt;
103 opt.size.width = CommonTestUtils::TEST_IMAGE_WIDTH;
104 opt.size.height = CommonTestUtils::TEST_IMAGE_HEIGHT;
105 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(opt);
106 EXPECT_CALL(m->Mock(), GetDisplaySnapshot(_, _, _, _)).Times(1).WillOnce(Return(pixelMap));
107 ASSERT_NE(nullptr, DisplayManager::GetInstance().GetScreenshot(0));
108 }
109
110 /**
111 * @tc.name: ScreenShotValid
112 * @tc.desc: Check if screenshot of invalid display's ID is nullptr
113 * @tc.type: FUNC
114 */
115 HWTEST_F(ScreenshotTest, ScreenShotValid02, TestSize.Level1)
116 {
117 ASSERT_EQ(nullptr, DisplayManager::GetInstance().GetScreenshot(invalidId_));
118 }
119
120 /**
121 * @tc.name: ScreenShotValid
122 * @tc.desc: Check if screenshot of default display's ID match default display's Media::Size
123 * @tc.type: FUNC
124 */
125 HWTEST_F(ScreenshotTest, ScreenShotValid03, TestSize.Level1)
126 {
127 auto& dm = DisplayManager::GetInstance();
128 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
129 EXPECT_CALL(m->Mock(), GetDisplayInfo(_)).Times(2);
130
131 Media::InitializationOptions opt;
132 opt.size.width = CommonTestUtils::TEST_IMAGE_WIDTH;
133 opt.size.height = CommonTestUtils::TEST_IMAGE_HEIGHT;
134 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(opt);
135 EXPECT_CALL(m->Mock(), GetDisplaySnapshot(_, _, _, _)).Times(1).WillOnce(Return(pixelMap));
136 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(0);
137 ASSERT_NE(nullptr, screenshot);
138
139 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
140 displayInfo->SetWidth(CommonTestUtils::TEST_IMAGE_WIDTH);
141 displayInfo->SetHeight(CommonTestUtils::TEST_IMAGE_HEIGHT);
142 displayInfo->SetDisplayId(0);
143 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(1).WillOnce(Return(displayInfo));
144
145 Media::Size screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
146 ASSERT_TRUE(Utils::SizeEqualToDisplay(dm.GetDefaultDisplay(), screenSize));
147 }
148
149 /**
150 * @tc.name: ScreenShotValid
151 * @tc.desc: Check if screenshot created by default parameters is valid
152 * @tc.type: FUNC
153 */
154 HWTEST_F(ScreenshotTest, ScreenShotValid04, TestSize.Level1)
155 {
156 auto& dm = DisplayManager::GetInstance();
157 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
158
159 Media::InitializationOptions opt;
160 opt.size.width = CommonTestUtils::TEST_IMAGE_WIDTH;
161 opt.size.height = CommonTestUtils::TEST_IMAGE_HEIGHT;
162 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(opt);
163 EXPECT_CALL(m->Mock(), GetDisplaySnapshot(_, _, _, _)).Times(1).WillOnce(Return(pixelMap));
164 Media::Rect defaultScreen = {0, 0, CommonTestUtils::TEST_IMAGE_WIDTH, CommonTestUtils::TEST_IMAGE_HEIGHT};
165 Media::Size defaultImage = {CommonTestUtils::TEST_IMAGE_WIDTH, CommonTestUtils::TEST_IMAGE_HEIGHT};
166 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(0, defaultScreen, defaultImage, 0);
167 ASSERT_NE(nullptr, screenshot);
168 }
169
170 /**
171 * @tc.name: ScreenShotValid
172 * @tc.desc: Check if screenshot match default imageSize
173 * @tc.type: FUNC
174 */
175 HWTEST_F(ScreenshotTest, ScreenShotValid05, TestSize.Level1)
176 {
177 auto& dm = DisplayManager::GetInstance();
178 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
179
180 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(1).WillOnce(Return(nullptr));
181 EXPECT_EQ(DISPLAY_ID_INVALID, DisplayManager::GetInstance().GetDefaultDisplayId());
182
183 Media::InitializationOptions opt;
184 opt.size.width = CommonTestUtils::TEST_IMAGE_WIDTH;
185 opt.size.height = CommonTestUtils::TEST_IMAGE_HEIGHT;
186 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(opt);
187 EXPECT_CALL(m->Mock(), GetDisplaySnapshot(_, _, _, _)).Times(1).WillOnce(Return(pixelMap));
188 Media::Rect defaultScreen = {0, 0, CommonTestUtils::TEST_IMAGE_WIDTH, CommonTestUtils::TEST_IMAGE_HEIGHT};
189 Media::Size defaultImage = {CommonTestUtils::TEST_IMAGE_WIDTH, CommonTestUtils::TEST_IMAGE_HEIGHT};
190 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(0, defaultScreen, defaultImage, 0);
191 ASSERT_NE(nullptr, screenshot);
192
193 Media::Size screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
194 ASSERT_TRUE(Utils::SizeEqual(defaultImage, screenSize));
195
196 Media::Size halfDefault = {defaultImage.width / 2, defaultImage.height / 2};
197 Media::Rect halfRect = {defaultScreen.left, defaultScreen.top, halfDefault.width, halfDefault.height};
198 EXPECT_CALL(m->Mock(), GetDisplaySnapshot(_, _, _, _)).Times(1).WillOnce(Return(pixelMap));
199 screenshot = dm.GetScreenshot(0, halfRect, defaultImage, 0);
200 ASSERT_NE(nullptr, screenshot);
201 screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
202 ASSERT_TRUE(Utils::SizeEqual(defaultImage, screenSize));
203
204 Media::Size halfSize = {halfDefault.width, halfDefault.height};
205 EXPECT_CALL(m->Mock(), GetDisplaySnapshot(_, _, _, _)).Times(1).WillOnce(Return(pixelMap));
206 screenshot = dm.GetScreenshot(0, defaultScreen, halfSize, 0);
207 ASSERT_NE(nullptr, screenshot);
208 screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
209 ASSERT_TRUE(Utils::SizeEqual(halfSize, screenSize));
210 }
211
212 /**
213 * @tc.name: ScreenShotValid
214 * @tc.desc: Check if screenshot created by default parameters match default display's Media::Size
215 * @tc.type: FUNC
216 */
217 HWTEST_F(ScreenshotTest, ScreenShotValid06, TestSize.Level1)
218 {
219 auto& dm = DisplayManager::GetInstance();
220 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
221 EXPECT_CALL(m->Mock(), GetDisplayInfo(_)).Times(2);
222
223 Media::InitializationOptions opt;
224 opt.size.width = CommonTestUtils::TEST_IMAGE_WIDTH;
225 opt.size.height = CommonTestUtils::TEST_IMAGE_HEIGHT;
226 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(opt);
227 EXPECT_CALL(m->Mock(), GetDisplaySnapshot(_, _, _, _)).Times(1).WillOnce(Return(pixelMap));
228 Media::Rect defaultScreen = {0, 0, CommonTestUtils::TEST_IMAGE_WIDTH, CommonTestUtils::TEST_IMAGE_HEIGHT};
229 Media::Size defaultImage = {CommonTestUtils::TEST_IMAGE_WIDTH, CommonTestUtils::TEST_IMAGE_HEIGHT};
230 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(0, defaultScreen, defaultImage, 0);
231 ASSERT_NE(nullptr, screenshot);
232
233 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
234 displayInfo->SetWidth(CommonTestUtils::TEST_IMAGE_WIDTH);
235 displayInfo->SetHeight(CommonTestUtils::TEST_IMAGE_HEIGHT);
236 displayInfo->SetDisplayId(0);
237 EXPECT_CALL(m->Mock(), GetDefaultDisplayInfo()).Times(1).WillOnce(Return(displayInfo));
238 Media::Size screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
239 ASSERT_TRUE(Utils::SizeEqualToDisplay(dm.GetDefaultDisplay(), screenSize));
240 }
241
242 /**
243 * @tc.name: ScreenShotValid
244 * @tc.desc: Check if screenshot created by invalid display ID is nullptr
245 * @tc.type: FUNC
246 */
247 HWTEST_F(ScreenshotTest, ScreenShot07, TestSize.Level1)
248 {
249 auto& dm = DisplayManager::GetInstance();
250 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(invalidId_, defaultScreen_,
251 defaultImage_, defaultRot_);
252 ASSERT_EQ(nullptr, screenshot);
253 }
254
255 /**
256 * @tc.name: ScreenShotValid
257 * @tc.desc: Check if screenshot created by invalid screenRect is nullptr
258 * @tc.type: FUNC
259 */
260 HWTEST_F(ScreenshotTest, ScreenShot08, TestSize.Level1)
261 {
262 auto& dm = DisplayManager::GetInstance();
263 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, invalidRect_,
264 defaultImage_, defaultRot_);
265 ASSERT_EQ(nullptr, screenshot);
266 Media::Rect invalidScreen = {invalidRect_.left, defaultScreen_.top, defaultScreen_.width, defaultScreen_.height};
267 screenshot = dm.GetScreenshot(defaultId_, invalidScreen, defaultImage_, defaultRot_);
268 ASSERT_EQ(nullptr, screenshot);
269 invalidScreen = {defaultScreen_.left, defaultScreen_.top, invalidRect_.width, defaultScreen_.height};
270 screenshot = dm.GetScreenshot(defaultId_, invalidScreen, defaultImage_, defaultRot_);
271 ASSERT_EQ(nullptr, screenshot);
272 }
273
274 /**
275 * @tc.name: ScreenShotValid
276 * @tc.desc: Check if screenshot created by invalid imageSize is nullptr
277 * @tc.type: FUNC
278 */
279 HWTEST_F(ScreenshotTest, ScreenShot09, TestSize.Level1)
280 {
281 auto& dm = DisplayManager::GetInstance();
282 Media::Size invalidSize = {invalidRect_.width, invalidRect_.height};
283 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, defaultScreen_,
284 invalidSize, defaultRot_);
285 ASSERT_EQ(nullptr, screenshot);
286 invalidSize = {invalidRect_.width, defaultScreen_.height};
287 screenshot = dm.GetScreenshot(defaultId_, defaultScreen_, invalidSize, defaultRot_);
288 ASSERT_EQ(nullptr, screenshot);
289 invalidSize = {defaultScreen_.width, invalidRect_.height};
290 screenshot = dm.GetScreenshot(defaultId_, defaultScreen_, invalidSize, defaultRot_);
291 ASSERT_EQ(nullptr, screenshot);
292 }
293
294 /**
295 * @tc.name: ScreenShotListener01
296 * @tc.desc: Check if screenshot listener info valid
297 * @tc.type: FUNC
298 * @tc.require: issueI5G62O
299 */
300 HWTEST_F(ScreenshotTest, ScreenShotListener01, TestSize.Level1)
301 {
302 auto& dm = DisplayManager::GetInstance();
303 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
304
305 Media::InitializationOptions opt;
306 opt.size.width = CommonTestUtils::TEST_IMAGE_WIDTH;
307 opt.size.height = CommonTestUtils::TEST_IMAGE_HEIGHT;
308 std::shared_ptr<Media::PixelMap> pixelMap = Media::PixelMap::Create(opt);
309 EXPECT_CALL(m->Mock(), GetDisplaySnapshot(_, _, _, _)).Times(1).WillOnce(Return(pixelMap));
310 EXPECT_CALL(m->Mock(), RegisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
311 EXPECT_CALL(m->Mock(), UnregisterDisplayManagerAgent(_, _)).Times(1).WillOnce(Return(DMError::DM_OK));
312
313 sptr<ScreenshotListenerFuture> screenShotListener = new ScreenshotListenerFuture();
314 dm.RegisterScreenshotListener(screenShotListener);
315 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_);
316 auto info = screenShotListener->future_.GetResult(1000);
317
318 ASSERT_NE(nullptr, screenshot);
319
320 dm.UnregisterScreenshotListener(screenShotListener);
321 }
322 } // namespace
323 } // namespace Rosen
324 } // namespace OHOS