1 /* 2 * Copyright (c) 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 <gtest/gtest.h> 17 18 #include "surface_draw.h" 19 #include "display.h" 20 #include "display_info.h" 21 #include "display_manager.h" 22 #include "display_manager_proxy.h" 23 #include "window_impl.h" 24 25 using namespace testing; 26 using namespace testing::ext; 27 28 namespace OHOS { 29 namespace Rosen { 30 namespace { 31 const std::string IMAGE_PLACE_HOLDER_PNG_PATH = "/etc/window/resources/bg_place_holder.png"; 32 const int WAIT_FOR_SYNC_US = 1000 * 500; // 500ms 33 } 34 class SurfaceDrawTest : public testing::Test { 35 public: 36 static void SetUpTestCase(); 37 static void TearDownTestCase(); 38 void SetUp() override; 39 void TearDown() override; 40 41 public: 42 struct WindowTestInfo { 43 std::string name; 44 Rect rect; 45 WindowType type; 46 WindowMode mode; 47 bool needAvoid; 48 bool parentLimit; 49 bool forbidSplitMove {false}; 50 bool showWhenLocked; 51 uint32_t parentId; 52 }; 53 sptr<Window> CreateTestWindow(const std::string& name); 54 55 static inline DisplayId displayId_; 56 static inline int32_t displayWidth_; 57 static inline int32_t displayHeight_; 58 WindowTestInfo windowInfo_; 59 }; 60 SetUpTestCase()61 void SurfaceDrawTest::SetUpTestCase() 62 { 63 displayId_ = DisplayManager::GetInstance().GetDefaultDisplayId(); 64 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplay(); 65 if (display == nullptr) { 66 return; 67 } 68 displayWidth_ = display->GetWidth(); 69 displayHeight_ = display->GetHeight(); 70 } 71 TearDownTestCase()72 void SurfaceDrawTest::TearDownTestCase() 73 { 74 } 75 SetUp()76 void SurfaceDrawTest::SetUp() 77 { 78 windowInfo_ = { 79 .name = "main", 80 .rect = {100, 100, 250, 300}, 81 .type = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, 82 .mode = WindowMode::WINDOW_MODE_FLOATING, 83 .needAvoid = true, 84 .parentLimit = false, 85 .parentId = INVALID_WINDOW_ID, 86 }; 87 } 88 TearDown()89 void SurfaceDrawTest::TearDown() 90 { 91 } 92 CreateTestWindow(const std::string & name)93 sptr<Window> SurfaceDrawTest::CreateTestWindow(const std::string& name) 94 { 95 sptr<WindowOption> option = new (std::nothrow)WindowOption(); 96 if (option == nullptr) { 97 return nullptr; 98 } 99 option->SetDisplayId(displayId_); 100 option->SetWindowType(windowInfo_.type); 101 option->SetWindowRect(windowInfo_.rect); 102 option->SetWindowMode(windowInfo_.mode); 103 option->SetWindowName(name); 104 sptr<Window> window = Window::Create(option->GetWindowName(), option); 105 if (window == nullptr) { 106 return nullptr; 107 } 108 window->AddWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED); 109 return window; 110 } 111 112 namespace { 113 /** 114 * @tc.name: DrawImage 115 * @tc.desc: SurfaceDraw::DrawImage test 116 * @tc.type: FUNC 117 */ 118 HWTEST_F(SurfaceDrawTest, DrawImage01, Function | SmallTest | Level1) 119 { 120 ASSERT_FALSE(SurfaceDraw::DrawImage(nullptr, 0, 0, "")); 121 sptr<Window> window = CreateTestWindow("testDrawImage"); 122 if (window == nullptr) { 123 return; 124 } 125 ASSERT_NE(nullptr, window); 126 window->Show(); 127 usleep(WAIT_FOR_SYNC_US / 20); // wait for rect updated 128 129 auto surfaceNode = window->GetSurfaceNode(); 130 ASSERT_NE(surfaceNode, nullptr); 131 usleep(WAIT_FOR_SYNC_US / 20); // wait for rect updated 132 uint32_t width = window->GetRect().width_; 133 uint32_t height = window->GetRect().height_; 134 SurfaceDraw::DrawImage(surfaceNode, width, height, IMAGE_PLACE_HOLDER_PNG_PATH); 135 ASSERT_FALSE(SurfaceDraw::DrawImage(surfaceNode, -1, -1, IMAGE_PLACE_HOLDER_PNG_PATH)); 136 window->Destroy(); 137 } 138 /** 139 * @tc.name: DecodeImageToPixelMap 140 * @tc.desc: SurfaceDraw::DecodeImageToPixelMap test 141 * @tc.type: FUNC 142 */ 143 HWTEST_F(SurfaceDrawTest, DecodeImageToPixelMap01, Function | SmallTest | Level1) 144 { 145 ASSERT_EQ(SurfaceDraw::DecodeImageToPixelMap(""), nullptr); 146 ASSERT_NE(SurfaceDraw::DecodeImageToPixelMap(IMAGE_PLACE_HOLDER_PNG_PATH), nullptr); 147 } 148 /** 149 * @tc.name: DrawMasking 150 * @tc.desc: SurfaceDraw::DrawMasking test 151 * @tc.type: FUNC 152 */ 153 HWTEST_F(SurfaceDrawTest, DrawMasking01, Function | SmallTest | Level1) 154 { 155 OHOS::Rosen::Rect screenRect = {0, 0, 0, 0}; 156 OHOS::Rosen::Rect transRect = {0, 0, 0, 0}; 157 ASSERT_FALSE(SurfaceDraw::DrawMasking(nullptr, screenRect, transRect)); 158 159 sptr<Window> window = CreateTestWindow("testDrawMasking"); 160 if (window == nullptr) { 161 return; 162 } 163 ASSERT_NE(nullptr, window); 164 window->Show(); 165 usleep(WAIT_FOR_SYNC_US / 20); // wait for rect updated 166 167 auto surfaceNode = window->GetSurfaceNode(); 168 ASSERT_NE(surfaceNode, nullptr); 169 ASSERT_FALSE(SurfaceDraw::DrawMasking(surfaceNode, screenRect, transRect)); 170 171 screenRect.width_ = displayWidth_; 172 screenRect.height_ = displayHeight_; 173 transRect.width_ = displayWidth_; 174 transRect.height_ = displayHeight_; 175 SurfaceDraw::DrawMasking(surfaceNode, screenRect, transRect); 176 window->Destroy(); 177 } 178 /** 179 * @tc.name: DoDrawImageRect 180 * @tc.desc: SurfaceDraw::DoDrawImageRect test 181 * @tc.type: FUNC 182 */ 183 HWTEST_F(SurfaceDrawTest, DoDrawImageRect01, Function | SmallTest | Level1) 184 { 185 sptr<Window> window = CreateTestWindow("testDoDrawImageRect"); 186 if (window == nullptr) { 187 return; 188 } 189 ASSERT_NE(window, nullptr); 190 window->Show(); 191 usleep(WAIT_FOR_SYNC_US / 20); // wait for rect updated 192 193 OHOS::Rosen::Rect rect = window->GetRect(); 194 uint32_t color = 0x00660000; 195 196 auto surfaceNode = window->GetSurfaceNode(); 197 ASSERT_NE(surfaceNode, nullptr); 198 sptr<OHOS::Surface> layer = SurfaceDraw::GetLayer(surfaceNode); 199 ASSERT_NE(layer, nullptr); 200 sptr<OHOS::SurfaceBuffer> buffer = SurfaceDraw::GetSurfaceBuffer(layer, rect.width_, rect.height_); 201 if (buffer == nullptr) { 202 return; 203 } 204 205 ASSERT_FALSE(SurfaceDraw::DoDrawImageRect(buffer, rect, nullptr, color, false)); 206 207 std::shared_ptr<Media::PixelMap> pixelMap = SurfaceDraw::DecodeImageToPixelMap(IMAGE_PLACE_HOLDER_PNG_PATH); 208 ASSERT_NE(pixelMap, nullptr); 209 210 ASSERT_TRUE(SurfaceDraw::DoDrawImageRect(buffer, rect, pixelMap, color, false)); 211 window->Destroy(); 212 } 213 /** 214 * @tc.name: GetSurfaceSnapshot 215 * @tc.desc: SurfaceDraw::GetSurfaceSnapshot test 216 * @tc.type: FUNC 217 */ 218 HWTEST_F(SurfaceDrawTest, GetSurfaceSnapshot01, Function | SmallTest | Level1) 219 { 220 sptr<Window> window = CreateTestWindow("testDoDrawImageRect"); 221 if (window == nullptr) { 222 return; 223 } 224 ASSERT_NE(window, nullptr); 225 window->Show(); 226 usleep(WAIT_FOR_SYNC_US / 20); // wait for rect updated 227 228 auto surfaceNode = window->GetSurfaceNode(); 229 ASSERT_NE(surfaceNode, nullptr); 230 231 std::shared_ptr<Media::PixelMap> pixelMap = SurfaceDraw::DecodeImageToPixelMap(IMAGE_PLACE_HOLDER_PNG_PATH); 232 ASSERT_NE(pixelMap, nullptr); 233 234 ASSERT_FALSE(SurfaceDraw::GetSurfaceSnapshot(nullptr, pixelMap, 0, 0, 0)); 235 ASSERT_FALSE(SurfaceDraw::GetSurfaceSnapshot(surfaceNode, pixelMap, 0, 0, 0)); 236 window->Destroy(); 237 } 238 239 /** 240 * @tc.name: DrawColor 241 * @tc.desc: SurfaceDraw::DrawColor test 242 * @tc.type: FUNC 243 */ 244 HWTEST_F(SurfaceDrawTest, DrawColor01, Function | SmallTest | Level1) 245 { 246 ASSERT_FALSE(SurfaceDraw::DrawColor(nullptr, 0, 0, 0)); 247 sptr<Window> window = CreateTestWindow("DrawColor"); 248 if (window == nullptr) { 249 return; 250 } 251 ASSERT_NE(nullptr, window); 252 window->Show(); 253 usleep(WAIT_FOR_SYNC_US / 20); // wait for rect updated 254 auto surfaceNode = window->GetSurfaceNode(); 255 ASSERT_NE(surfaceNode, nullptr); 256 uint32_t width = window->GetRect().width_; 257 uint32_t height = window->GetRect().height_; 258 uint32_t color = 0x00660000; 259 SurfaceDraw::DrawColor(surfaceNode, width, height, color); 260 SurfaceDraw::DrawColor(surfaceNode, -1, -1, color); 261 ASSERT_EQ(WMError::WM_OK, window->Destroy()); 262 } 263 264 /** 265 * @tc.name: DoDraw 266 * @tc.desc: SurfaceDraw::DoDraw test 267 * @tc.type: FUNC 268 */ 269 HWTEST_F(SurfaceDrawTest, DoDraw01, Function | SmallTest | Level1) 270 { 271 sptr<Window> window = CreateTestWindow("DoDrawTest01"); 272 if (window == nullptr) { 273 return; 274 } 275 ASSERT_NE(nullptr, window); 276 window->Show(); 277 usleep(WAIT_FOR_SYNC_US / 20); // wait for rect updated 278 OHOS::Rosen::Rect rect = window->GetRect(); 279 auto surfaceNode = window->GetSurfaceNode(); 280 ASSERT_NE(surfaceNode, nullptr); 281 sptr<OHOS::Surface> layer = SurfaceDraw::GetLayer(surfaceNode); 282 ASSERT_NE(layer, nullptr); 283 sptr<OHOS::SurfaceBuffer> buffer = SurfaceDraw::GetSurfaceBuffer(layer, rect.width_, rect.height_); 284 ASSERT_NE(buffer, nullptr); 285 ASSERT_FALSE(SurfaceDraw::DoDraw(nullptr, 0, 0, "")); 286 window->Destroy(); 287 } 288 289 /** 290 * @tc.name: DoDraw 291 * @tc.desc: SurfaceDraw::DoDraw02 test 292 * @tc.type: FUNC 293 */ 294 HWTEST_F(SurfaceDrawTest, DoDraw02, Function | SmallTest | Level1) 295 { 296 sptr<Window> window = CreateTestWindow("DoDraw02"); 297 if (window == nullptr) { 298 return; 299 } 300 ASSERT_NE(window, nullptr); 301 window->Show(); 302 usleep(WAIT_FOR_SYNC_US / 20); // wait for rect updated 303 OHOS::Rosen::Rect rect = window->GetRect(); 304 auto surfaceNode = window->GetSurfaceNode(); 305 ASSERT_NE(surfaceNode, nullptr); 306 sptr<OHOS::Surface> layer = SurfaceDraw::GetLayer(surfaceNode); 307 ASSERT_NE(layer, nullptr); 308 sptr<OHOS::SurfaceBuffer> buffer = SurfaceDraw::GetSurfaceBuffer(layer, rect.width_, rect.height_); 309 if (buffer == nullptr) { 310 return; 311 } 312 std::shared_ptr<Media::PixelMap> pixelMap = SurfaceDraw::DecodeImageToPixelMap(IMAGE_PLACE_HOLDER_PNG_PATH); 313 ASSERT_NE(pixelMap, nullptr); 314 ASSERT_FALSE(SurfaceDraw::DoDraw(nullptr, 0, 0, pixelMap)); 315 window->Destroy(); 316 } 317 318 /** 319 * @tc.name: DoDraw03 320 * @tc.desc: SurfaceDraw::DoDraw03 test 321 * @tc.type: FUNC 322 */ 323 HWTEST_F(SurfaceDrawTest, DoDraw03, Function | SmallTest | Level1) 324 { 325 sptr<Window> window = CreateTestWindow("DoDrawTest03"); 326 if (window == nullptr) { 327 return; 328 } 329 ASSERT_NE(nullptr, window); 330 window->Show(); 331 usleep(WAIT_FOR_SYNC_US / 20); // wait for rect updated 332 OHOS::Rosen::Rect rect = window->GetRect(); 333 uint32_t color = 0x00660000; 334 auto surfaceNode = window->GetSurfaceNode(); 335 ASSERT_NE(surfaceNode, nullptr); 336 sptr<OHOS::Surface> layer = SurfaceDraw::GetLayer(surfaceNode); 337 ASSERT_NE(layer, nullptr); 338 sptr<OHOS::SurfaceBuffer> buffer = SurfaceDraw::GetSurfaceBuffer(layer, rect.width_, rect.height_); 339 if (buffer == nullptr) { 340 return; 341 } 342 ASSERT_FALSE(SurfaceDraw::DoDraw(nullptr, 0, 0, color)); 343 window->Destroy(); 344 } 345 346 /** 347 * @tc.name: DrawImageRect 348 * @tc.desc: SurfaceDraw::DoDrawImageRect test 349 * @tc.type: FUNC 350 */ 351 HWTEST_F(SurfaceDrawTest, DrawImageRect01, Function | SmallTest | Level1) 352 { 353 sptr<Window> window = CreateTestWindow("DrawImageRect"); 354 if (window == nullptr) { 355 return; 356 } 357 ASSERT_NE(window, nullptr); 358 window->Show(); 359 usleep(WAIT_FOR_SYNC_US / 20); // wait for rect updated 360 OHOS::Rosen::Rect rect = window->GetRect(); 361 uint32_t color = 0x00660000; 362 auto surfaceNode = window->GetSurfaceNode(); 363 ASSERT_NE(surfaceNode, nullptr); 364 ASSERT_FALSE(SurfaceDraw::DrawImageRect(surfaceNode, rect, nullptr, color, false)); 365 std::shared_ptr<Media::PixelMap> pixelMap = SurfaceDraw::DecodeImageToPixelMap(IMAGE_PLACE_HOLDER_PNG_PATH); 366 ASSERT_NE(pixelMap, nullptr); 367 SurfaceDraw::DrawImageRect(surfaceNode, rect, pixelMap, color, false); 368 window->Destroy(); 369 } 370 } 371 } // namespace Rosen 372 } // namespace OHOS
