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 "future.h"
22 #include "pixel_map.h"
23 #include "screenshot_listener_future.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 namespace {
31 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "ScreenshotTest"};
32 }
33 using Utils = DisplayTestUtils;
34 class ScreenshotListener;
35 class ScreenshotTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 virtual void SetUp() override;
40 virtual void TearDown() override;
41 static DisplayId defaultId_;
42 static Media::Rect defaultScreen_;
43 static Media::Size defaultImage_;
44 DisplayId invalidId_ = DISPLAY_ID_INVALID;
45 Media::Rect invalidRect_ = {-1, -1, -1, -1};
46 uint32_t defaultRot_ = 0;
47 };
48
49 DisplayId ScreenshotTest::defaultId_ = DISPLAY_ID_INVALID;
50 Media::Rect ScreenshotTest::defaultScreen_ = {0, 0, 0, 0};
51 Media::Size ScreenshotTest::defaultImage_ = {0, 0};
52
SetUpTestCase()53 void ScreenshotTest::SetUpTestCase()
54 {
55 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
56 if (display == nullptr) {
57 WLOGFE("GetDefaultDisplay: failed!\n");
58 return;
59 }
60 WLOGFI("GetDefaultDisplay: id %" PRIu64", w %d, h %d, fps %u\n", display->GetId(), display->GetWidth(),
61 display->GetHeight(), display->GetRefreshRate());
62
63 defaultId_ = display->GetId();
64 defaultScreen_ = {0, 0, display->GetWidth(), display->GetHeight()};
65 defaultImage_ = {display->GetWidth(), display->GetHeight()};
66
67 CommonTestUtils::InjectTokenInfoByHapName(0, "com.ohos.systemui", 0);
68 }
69
TearDownTestCase()70 void ScreenshotTest::TearDownTestCase()
71 {
72 }
73
SetUp()74 void ScreenshotTest::SetUp()
75 {
76 }
77
TearDown()78 void ScreenshotTest::TearDown()
79 {
80 }
81
82 namespace {
83 /**
84 * @tc.name: ScreenShotValid
85 * @tc.desc: Check if screenshot of default display's ID is valid
86 * @tc.type: FUNC
87 */
88 HWTEST_F(ScreenshotTest, ScreenShotValid01, Function | MediumTest | Level2)
89 {
90 ASSERT_NE(nullptr, DisplayManager::GetInstance().GetScreenshot(defaultId_));
91 }
92
93 /**
94 * @tc.name: ScreenShotValid
95 * @tc.desc: Check if screenshot of invalid display's ID is nullptr
96 * @tc.type: FUNC
97 */
98 HWTEST_F(ScreenshotTest, ScreenShotValid02, Function | MediumTest | Level2)
99 {
100 ASSERT_EQ(nullptr, DisplayManager::GetInstance().GetScreenshot(invalidId_));
101 }
102
103 /**
104 * @tc.name: ScreenShotValid
105 * @tc.desc: Check if screenshot of default display's ID match default display's Media::Size
106 * @tc.type: FUNC
107 */
108 HWTEST_F(ScreenshotTest, ScreenShotValid03, Function | MediumTest | Level2)
109 {
110 auto& dm = DisplayManager::GetInstance();
111 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_);
112 ASSERT_NE(nullptr, screenshot);
113
114 Media::Size screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
115 ASSERT_TRUE(Utils::SizeEqualToDisplay(dm.GetDefaultDisplay(), screenSize));
116 }
117
118 /**
119 * @tc.name: ScreenShotValid
120 * @tc.desc: Check if screenshot created by default parameters is valid
121 * @tc.type: FUNC
122 */
123 HWTEST_F(ScreenshotTest, ScreenShotValid04, Function | MediumTest | Level2)
124 {
125 auto& dm = DisplayManager::GetInstance();
126 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, defaultScreen_,
127 defaultImage_, defaultRot_);
128 ASSERT_NE(nullptr, screenshot);
129 }
130
131 /**
132 * @tc.name: ScreenShotValid
133 * @tc.desc: Check if screenshot match default imageSize
134 * @tc.type: FUNC
135 */
136 HWTEST_F(ScreenshotTest, ScreenShotValid05, Function | MediumTest | Level2)
137 {
138 auto& dm = DisplayManager::GetInstance();
139 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, defaultScreen_,
140 defaultImage_, defaultRot_);
141 ASSERT_NE(nullptr, screenshot);
142 Media::Size screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
143 ASSERT_TRUE(Utils::SizeEqual(defaultImage_, screenSize));
144
145 Media::Size halfDefault_ = {defaultImage_.width / 2, defaultImage_.height / 2};
146 Media::Rect halfRect = {defaultScreen_.left, defaultScreen_.top, halfDefault_.width, halfDefault_.height};
147 screenshot = dm.GetScreenshot(defaultId_, halfRect, defaultImage_, defaultRot_);
148 ASSERT_NE(nullptr, screenshot);
149 screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
150 ASSERT_TRUE(Utils::SizeEqual(defaultImage_, screenSize));
151
152 Media::Size halfSize = {halfDefault_.width, halfDefault_.height};
153 screenshot = dm.GetScreenshot(defaultId_, defaultScreen_, halfSize, defaultRot_);
154 ASSERT_NE(nullptr, screenshot);
155 screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
156 ASSERT_TRUE(Utils::SizeEqual(halfSize, screenSize));
157 }
158
159 /**
160 * @tc.name: ScreenShotValid
161 * @tc.desc: Check if screenshot created by default parameters match default display's Media::Size
162 * @tc.type: FUNC
163 */
164 HWTEST_F(ScreenshotTest, ScreenShotValid06, Function | MediumTest | Level2)
165 {
166 auto& dm = DisplayManager::GetInstance();
167 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, defaultScreen_,
168 defaultImage_, defaultRot_);
169 ASSERT_NE(nullptr, screenshot);
170 Media::Size screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
171 ASSERT_TRUE(Utils::SizeEqualToDisplay(dm.GetDefaultDisplay(), screenSize));
172 }
173
174 /**
175 * @tc.name: ScreenShotValid
176 * @tc.desc: Check if screenshot created by invalid display ID is nullptr
177 * @tc.type: FUNC
178 */
179 HWTEST_F(ScreenshotTest, ScreenShot07, Function | MediumTest | Level2)
180 {
181 auto& dm = DisplayManager::GetInstance();
182 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(invalidId_, defaultScreen_,
183 defaultImage_, defaultRot_);
184 ASSERT_EQ(nullptr, screenshot);
185 }
186
187 /**
188 * @tc.name: ScreenShotValid
189 * @tc.desc: Check if screenshot created by invalid screenRect is nullptr
190 * @tc.type: FUNC
191 */
192 HWTEST_F(ScreenshotTest, ScreenShot08, Function | MediumTest | Level2)
193 {
194 auto& dm = DisplayManager::GetInstance();
195 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, invalidRect_,
196 defaultImage_, defaultRot_);
197 ASSERT_EQ(nullptr, screenshot);
198 Media::Rect invalidScreen = {invalidRect_.left, defaultScreen_.top, defaultScreen_.width, defaultScreen_.height};
199 screenshot = dm.GetScreenshot(defaultId_, invalidScreen, defaultImage_, defaultRot_);
200 ASSERT_EQ(nullptr, screenshot);
201 invalidScreen = {defaultScreen_.left, defaultScreen_.top, invalidRect_.width, defaultScreen_.height};
202 screenshot = dm.GetScreenshot(defaultId_, invalidScreen, defaultImage_, defaultRot_);
203 ASSERT_EQ(nullptr, screenshot);
204 }
205
206 /**
207 * @tc.name: ScreenShotValid
208 * @tc.desc: Check if screenshot created by invalid imageSize is nullptr
209 * @tc.type: FUNC
210 */
211 HWTEST_F(ScreenshotTest, ScreenShot09, Function | MediumTest | Level2)
212 {
213 auto& dm = DisplayManager::GetInstance();
214 Media::Size invalidSize = {invalidRect_.width, invalidRect_.height};
215 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, defaultScreen_,
216 invalidSize, defaultRot_);
217 ASSERT_EQ(nullptr, screenshot);
218 invalidSize = {invalidRect_.width, defaultScreen_.height};
219 screenshot = dm.GetScreenshot(defaultId_, defaultScreen_, invalidSize, defaultRot_);
220 ASSERT_EQ(nullptr, screenshot);
221 invalidSize = {defaultScreen_.width, invalidRect_.height};
222 screenshot = dm.GetScreenshot(defaultId_, defaultScreen_, invalidSize, defaultRot_);
223 ASSERT_EQ(nullptr, screenshot);
224 }
225
226 /**
227 * @tc.name: ScreenShotListener01
228 * @tc.desc: Check if screenshot listener info valid
229 * @tc.type: FUNC
230 * @tc.require: issueI5G62O
231 */
232 HWTEST_F(ScreenshotTest, ScreenShotListener01, Function | MediumTest | Level2)
233 {
234 sptr<ScreenshotListenerFuture> screenShotListener = new ScreenshotListenerFuture();
235
236 auto& dm = DisplayManager::GetInstance();
237 dm.RegisterScreenshotListener(screenShotListener);
238 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_);
239 auto info = screenShotListener->future_.GetResult(1000);
240
241 ASSERT_NE(nullptr, screenshot);
242 ASSERT_EQ(info.GetDisplayId(), defaultId_);
243 ASSERT_GT(info.GetTrigger().size(), 0UL);
244
245 dm.UnregisterScreenshotListener(screenShotListener);
246 }
247 } // namespace
248 } // namespace Rosen
249 } // namespace OHOS