1/* 2 * Copyright (c) 2021 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#include <securec.h> 16#include <gtest/gtest.h> 17#include <surface.h> 18#include <buffer_queue_producer.h> 19#include <consumer_surface.h> 20#include "buffer_consumer_listener.h" 21#include "sync_fence.h" 22#include "producer_surface_delegator.h" 23#include "buffer_queue_consumer.h" 24#include "buffer_queue.h" 25#include "v1_1/buffer_handle_meta_key_type.h" 26 27using namespace testing; 28using namespace testing::ext; 29 30namespace OHOS::Rosen { 31class ConsumerSurfaceTest : public testing::Test { 32public: 33 static void SetUpTestCase(); 34 static void TearDownTestCase(); 35 void SetUp() override; 36 void TearDown() override; 37 38 static inline BufferRequestConfig requestConfig = { 39 .width = 0x100, 40 .height = 0x100, 41 .strideAlignment = 0x8, 42 .format = GRAPHIC_PIXEL_FMT_RGBA_8888, 43 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA, 44 .timeout = 0, 45 }; 46 static inline BufferFlushConfig flushConfig = { 47 .damage = { 48 .w = 0x100, 49 .h = 0x100, 50 }, 51 }; 52 static inline BufferFlushConfigWithDamages flushConfigWithDamages = { 53 .damages = { 54 { .x = 0x100, .y = 0x100, .w = 0x100, .h = 0x100, }, 55 { .x = 0x200, .y = 0x200, .w = 0x200, .h = 0x200, }, 56 }, 57 .timestamp = 0x300, 58 }; 59 static inline int64_t timestamp = 0; 60 static inline Rect damage = {}; 61 static inline std::vector<Rect> damages = {}; 62 static inline sptr<IConsumerSurface> cs = nullptr; 63 static inline sptr<Surface> ps = nullptr; 64 static inline sptr<BufferQueue> bq = nullptr; 65 static inline sptr<ProducerSurfaceDelegator> surfaceDelegator = nullptr; 66 static inline sptr<BufferQueueConsumer> consumer_ = nullptr; 67 static inline uint32_t firstSeqnum = 0; 68 sptr<ConsumerSurface> surface_ = nullptr; 69}; 70 71void ConsumerSurfaceTest::SetUpTestCase() 72{ 73 cs = IConsumerSurface::Create(); 74 sptr<IBufferConsumerListener> listener = new BufferConsumerListener(); 75 cs->RegisterConsumerListener(listener); 76 auto p = cs->GetProducer(); 77 bq = new BufferQueue("test"); 78 ps = Surface::CreateSurfaceAsProducer(p); 79 surfaceDelegator = ProducerSurfaceDelegator::Create(); 80} 81 82void ConsumerSurfaceTest::TearDownTestCase() 83{ 84 cs = nullptr; 85} 86 87void ConsumerSurfaceTest::SetUp() 88{ 89 surface_ = new ConsumerSurface("test", false); 90 ASSERT_NE(surface_, nullptr); 91 ASSERT_EQ(surface_->producer_, nullptr); 92 ASSERT_EQ(surface_->consumer_, nullptr); 93} 94 95void ConsumerSurfaceTest::TearDown() 96{ 97 surface_ = nullptr; 98} 99 100class TestConsumerListenerClazz : public IBufferConsumerListenerClazz { 101public: 102 void OnBufferAvailable() override 103 { 104 } 105}; 106 107/* 108* Function: GetProducer 109* Type: Function 110* Rank: Important(2) 111* EnvConditions: N/A 112* CaseDescription: 1. get ConsumerSurface and GetProducer 113* 2. check ret 114 */ 115HWTEST_F(ConsumerSurfaceTest, ConsumerSurface001, Function | MediumTest | Level2) 116{ 117 ASSERT_NE(cs, nullptr); 118 119 sptr<ConsumerSurface> qs = static_cast<ConsumerSurface*>(cs.GetRefPtr()); 120 ASSERT_NE(qs, nullptr); 121 ASSERT_NE(qs->GetProducer(), nullptr); 122} 123 124/* 125* Function: ConsumerSurface dtor 126* Type: Function 127* Rank: Important(2) 128* EnvConditions: N/A 129* CaseDescription: 1. new ConsumerSurface, only one nullptr for consumer_ and producer_ 130* 2. dtor and check ret 131 */ 132HWTEST_F(ConsumerSurfaceTest, ConsumerSurfaceDtor001, Function | MediumTest | Level2) 133{ 134 sptr<BufferQueue> queue = new BufferQueue("test", false); 135 surface_->producer_ = new BufferQueueProducer(queue); 136 ASSERT_NE(surface_->producer_, nullptr); 137 ASSERT_EQ(surface_->consumer_, nullptr); 138} 139 140/* 141* Function: ConsumerSurface dtor 142* Type: Function 143* Rank: Important(2) 144* EnvConditions: N/A 145* CaseDescription: 1. new ConsumerSurface, only one nullptr for consumer_ and producer_ 146* 2. dtor and check ret 147 */ 148HWTEST_F(ConsumerSurfaceTest, ConsumerSurfaceDtor002, Function | MediumTest | Level2) 149{ 150 sptr<BufferQueue> queue = new BufferQueue("test", false); 151 surface_->consumer_ = new BufferQueueConsumer(queue); 152 ASSERT_NE(surface_->consumer_, nullptr); 153} 154 155/* 156* Function: SetQueueSize and GetQueueSize 157* Type: Function 158* Rank: Important(2) 159* EnvConditions: N/A 160* CaseDescription: 1. call GetQueueSize and get default value 161* 2. call SetQueueSize 162* 3. call SetQueueSize again with abnormal value 163* 4. call GetQueueSize for BufferQueueProducer and BufferQueue 164* 5. check ret 165 */ 166HWTEST_F(ConsumerSurfaceTest, QueueSize001, Function | MediumTest | Level2) 167{ 168 ASSERT_EQ(cs->GetQueueSize(), (uint32_t)SURFACE_DEFAULT_QUEUE_SIZE); 169 GSError ret = cs->SetQueueSize(2); 170 ASSERT_EQ(ret, OHOS::GSERROR_OK); 171 172 ret = cs->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1); 173 ASSERT_NE(ret, OHOS::GSERROR_OK); 174 175 ASSERT_EQ(cs->GetQueueSize(), 2u); 176} 177 178/* 179* Function: SetQueueSize and GetQueueSize 180* Type: Function 181* Rank: Important(2) 182* EnvConditions: N/A 183* CaseDescription: 1. call GetQueueSize 184* 2. call SetQueueSize 2 times 185* 3. check ret 186 */ 187HWTEST_F(ConsumerSurfaceTest, QueueSize002, Function | MediumTest | Level2) 188{ 189 sptr<ConsumerSurface> qs = static_cast<ConsumerSurface*>(cs.GetRefPtr()); 190 sptr<BufferQueueProducer> bqp = static_cast<BufferQueueProducer*>(qs->GetProducer().GetRefPtr()); 191 ASSERT_EQ(bqp->GetQueueSize(), 2u); 192 193 GSError ret = cs->SetQueueSize(1); 194 ASSERT_EQ(ret, OHOS::GSERROR_OK); 195 196 ret = cs->SetQueueSize(2); 197 ASSERT_EQ(ret, OHOS::GSERROR_OK); 198} 199 200/* 201* Function: SetQueueSize and GetQueueSize 202* Type: Function 203* Rank: Important(2) 204* EnvConditions: N/A 205* CaseDescription: 1. call GetQueueSize with producer_ is nullptr 206* 2. call SetQueueSize with producer_ is nullptr 207* 3. check ret 208 */ 209HWTEST_F(ConsumerSurfaceTest, QueueSize003, Function | MediumTest | Level2) 210{ 211 uint32_t size = surface_->GetQueueSize(); 212 ASSERT_EQ(size, 0); 213 GSError ret = surface_->SetQueueSize(1); 214 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 215} 216 217/* 218* Function: SetDefaultWidthAndHeight, GetDefaultWidth and GetDefaultHeight 219* Type: Function 220* Rank: Important(2) 221* EnvConditions: N/A 222* CaseDescription: 1. call SetDefaultWidthAndHeight with consumer_ is nullptr 223* 2. call GetDefaultWidth with producer_ is nullptr 224* 3. call GetDefaultHeight with producer_ is nullptr 225* 4. check ret 226 */ 227HWTEST_F(ConsumerSurfaceTest, DefaultWidthAndHeight001, Function | MediumTest | Level2) 228{ 229 int32_t width = 0; 230 int32_t height = 0; 231 GSError ret = surface_->SetDefaultWidthAndHeight(width, height); 232 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 233 width = surface_->GetDefaultWidth(); 234 ASSERT_EQ(width, -1); 235 height = surface_->GetDefaultHeight(); 236 ASSERT_EQ(height, -1); 237} 238 239/* 240* Function: SetDefaultWidthAndHeight, GetDefaultWidth and GetDefaultHeight 241* Type: Function 242* Rank: Important(2) 243* EnvConditions: N/A 244* CaseDescription: 1. call SetDefaultWidthAndHeight with noraml value 245* 2. call GetDefaultWidth 246* 3. call GetDefaultHeight 247* 4. check ret 248 */ 249HWTEST_F(ConsumerSurfaceTest, DefaultWidthAndHeight002, Function | MediumTest | Level2) 250{ 251 ASSERT_NE(cs, nullptr); 252 int32_t width = 100; // 100 test value for width 253 int32_t height = 100; // 100 test value for height 254 GSError ret = cs->SetDefaultWidthAndHeight(width, height); 255 ASSERT_EQ(ret, OHOS::GSERROR_OK); 256 int32_t value = cs->GetDefaultWidth(); 257 ASSERT_EQ(value, width); 258 value = cs->GetDefaultHeight(); 259 ASSERT_EQ(value, height); 260} 261 262/* 263* Function: SetDefaultUsage and GetDefaultUsage 264* Type: Function 265* Rank: Important(2) 266* EnvConditions: N/A 267* CaseDescription: 1. call SetDefaultUsage with consumer_ is nullptr 268* 2. call GetDefaultUsage with producer_ is nullptr 269* 3. check ret 270 */ 271HWTEST_F(ConsumerSurfaceTest, DefaultUsage001, Function | MediumTest | Level2) 272{ 273 GSError ret = surface_->SetDefaultUsage(0); 274 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 275 uint64_t value = surface_->GetDefaultUsage(); 276 ASSERT_EQ(value, 0); 277} 278 279/* 280* Function: SetDefaultUsage and GetDefaultUsage 281* Type: Function 282* Rank: Important(2) 283* EnvConditions: N/A 284* CaseDescription: 1. call GetDefaultUsage with normal 285* 2. call SetDefaultUsage with normal 286* 3. call GetDefaultUsage agagin 287* 4. check ret 288 */ 289HWTEST_F(ConsumerSurfaceTest, DefaultUsage002, Function | MediumTest | Level2) 290{ 291 ASSERT_NE(cs, nullptr); 292 int32_t usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA; 293 uint32_t value = cs->GetDefaultUsage(); 294 ASSERT_EQ(value, 0); 295 GSError ret = cs->SetDefaultUsage(usage); 296 ASSERT_EQ(ret, OHOS::GSERROR_OK); 297 value = cs->GetDefaultUsage(); 298 ASSERT_EQ(value, usage); 299} 300 301/* 302* Function: AcquireBuffer 303* Type: Function 304* Rank: Important(2) 305* EnvConditions: N/A 306* CaseDescription: 1. call AcquireBuffer with consumer_ is nullptr 307* 2. check ret 308 */ 309HWTEST_F(ConsumerSurfaceTest, AcquireBuffer001, Function | MediumTest | Level2) 310{ 311 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create(); 312 sptr<OHOS::SyncFence> fence; 313 GSError ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage); 314 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 315} 316 317/* 318* Function: AcquireBuffer 319* Type: Function 320* Rank: Important(2) 321* EnvConditions: N/A 322* CaseDescription: 1. call AcquireBuffer with nullptr params 323* 2. check ret 324 */ 325HWTEST_F(ConsumerSurfaceTest, AcquireBuffer002, Function | MediumTest | Level2) 326{ 327 sptr<SurfaceBuffer> buffer = nullptr; 328 sptr<OHOS::SyncFence> fence; 329 GSError ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage); 330 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 331 buffer = SurfaceBuffer::Create(); 332 fence = nullptr; 333 ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage); 334 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 335} 336 337/* 338* Function: ReleaseBuffer 339* Type: Function 340* Rank: Important(2) 341* EnvConditions: N/A 342* CaseDescription: 1. call ReleaseBuffer with consumer_ is nullptr 343* 2. check ret 344 */ 345HWTEST_F(ConsumerSurfaceTest, ReleaseBuffer001, Function | MediumTest | Level2) 346{ 347 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create(); 348 sptr<OHOS::SyncFence> fence; 349 GSError ret = surface_->ReleaseBuffer(buffer, fence); 350 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 351} 352 353/* 354* Function: ReleaseBuffer 355* Type: Function 356* Rank: Important(2) 357* EnvConditions: N/A 358* CaseDescription: 1. call ReleaseBuffer with nullptr params 359* 2. check ret 360 */ 361HWTEST_F(ConsumerSurfaceTest, ReleaseBuffer002, Function | MediumTest | Level2) 362{ 363 sptr<SurfaceBuffer> buffer = nullptr; 364 sptr<OHOS::SyncFence> fence; 365 GSError ret = surface_->ReleaseBuffer(buffer, fence); 366 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 367} 368 369/* 370* Function: DetachBuffer 371* Type: Function 372* Rank: Important(2) 373* EnvConditions: N/A 374* CaseDescription: 1. call DetachBuffer with consumer_ is nullptr 375* 2. check ret 376 */ 377HWTEST_F(ConsumerSurfaceTest, DetachBuffer001, Function | MediumTest | Level2) 378{ 379 sptr<SurfaceBuffer> buffer; 380 GSError ret = surface_->DetachBuffer(buffer); 381 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 382} 383 384/* 385* Function: DetachBuffer 386* Type: Function 387* Rank: Important(2) 388* EnvConditions: N/A 389* CaseDescription: 1. call DetachBuffer with nullptr params 390* 2. check ret 391 */ 392HWTEST_F(ConsumerSurfaceTest, DetachBuffer002, Function | MediumTest | Level2) 393{ 394 sptr<SurfaceBuffer> buffer = nullptr; 395 GSError ret = surface_->DetachBuffer(buffer); 396 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 397} 398 399/* 400* Function: QueryIfBufferAvailable 401* Type: Function 402* Rank: Important(2) 403* EnvConditions: N/A 404* CaseDescription: 1. call QueryIfBufferAvailable with consumer_ is nullptr 405* 2. check ret 406 */ 407HWTEST_F(ConsumerSurfaceTest, QueryIfBufferAvailable001, Function | MediumTest | Level2) 408{ 409 bool ret = surface_->QueryIfBufferAvailable(); 410 ASSERT_EQ(ret, false); 411} 412 413/* 414* Function: QueryIfBufferAvailable 415* Type: Function 416* Rank: Important(2) 417* EnvConditions: N/A 418* CaseDescription: 1. call QueryIfBufferAvailable with normal 419* 2. check ret 420 */ 421HWTEST_F(ConsumerSurfaceTest, QueryIfBufferAvailable002, Function | MediumTest | Level2) 422{ 423 ASSERT_NE(cs, nullptr); 424 bool ret = cs->QueryIfBufferAvailable(); 425 ASSERT_EQ(ret, true); 426} 427 428/* 429* Function: RequestBuffer and FlushBuffer 430* Type: Function 431* Rank: Important(2) 432* EnvConditions: N/A 433* CaseDescription: 1. call RequestBuffer by cs and ps 434* 2. call FlushBuffer both 435* 3. check ret 436 */ 437HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel001, Function | MediumTest | Level2) 438{ 439 sptr<SurfaceBuffer> buffer; 440 int releaseFence = -1; 441 442 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig); 443 ASSERT_EQ(ret, OHOS::GSERROR_OK); 444 ASSERT_NE(buffer, nullptr); 445 firstSeqnum = buffer->GetSeqNum(); 446 447 ret = ps->FlushBuffer(buffer, -1, flushConfig); 448 ASSERT_EQ(ret, OHOS::GSERROR_OK); 449 450 ret = ps->RequestBuffer(buffer, releaseFence, requestConfig); 451 ASSERT_EQ(ret, OHOS::GSERROR_OK); 452 ret = ps->FlushBuffer(buffer, -1, flushConfig); 453 ASSERT_EQ(ret, OHOS::GSERROR_OK); 454} 455 456/* 457* Function: AcquireBuffer and ReleaseBuffer 458* Type: Function 459* Rank: Important(2) 460* EnvConditions: N/A 461* CaseDescription: 1. call AcquireBuffer 462* 2. call ReleaseBuffer 463* 3. check ret 464 */ 465HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel002, Function | MediumTest | Level2) 466{ 467 sptr<SurfaceBuffer> buffer; 468 int32_t flushFence; 469 470 GSError ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage); 471 ASSERT_EQ(ret, OHOS::GSERROR_OK); 472 ASSERT_NE(buffer, nullptr); 473 474 ret = cs->ReleaseBuffer(buffer, -1); 475 ASSERT_EQ(ret, OHOS::GSERROR_OK); 476} 477 478/* 479* Function: AcquireBuffer and ReleaseBuffer 480* Type: Function 481* Rank: Important(2) 482* EnvConditions: N/A 483* CaseDescription: 1. call AcquireBuffer 484* 2. call ReleaseBuffer 2 times 485* 3. check ret 486 */ 487HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel003, Function | MediumTest | Level2) 488{ 489 sptr<SurfaceBuffer> buffer; 490 int32_t flushFence; 491 492 GSError ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage); 493 ASSERT_EQ(ret, OHOS::GSERROR_OK); 494 ASSERT_NE(buffer, nullptr); 495 496 ret = cs->ReleaseBuffer(buffer, -1); 497 ASSERT_EQ(ret, OHOS::GSERROR_OK); 498 499 ret = cs->ReleaseBuffer(buffer, -1); 500 ASSERT_NE(ret, OHOS::GSERROR_OK); 501} 502 503/* 504* Function: RequestBuffer and CancelBuffer 505* Type: Function 506* Rank: Important(2) 507* EnvConditions: N/A 508* CaseDescription: 1. call RequestBuffer by cs and ps 509* 2. call CancelBuffer both 510* 3. check ret 511 */ 512HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel004, Function | MediumTest | Level2) 513{ 514 sptr<SurfaceBuffer> buffer; 515 int releaseFence = -1; 516 517 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig); 518 ASSERT_EQ(ret, OHOS::GSERROR_OK); 519 520 ret = ps->CancelBuffer(buffer); 521 ASSERT_EQ(ret, OHOS::GSERROR_OK); 522} 523 524/* 525* Function: SetUserData 526* Type: Function 527* Rank: Important(2) 528* EnvConditions: N/A 529* CaseDescription: 1. call SetUserData many times 530* 2. check ret 531 */ 532HWTEST_F(ConsumerSurfaceTest, UserData001, Function | MediumTest | Level2) 533{ 534 GSError ret; 535 536 std::string strs[SURFACE_MAX_USER_DATA_COUNT]; 537 constexpr int32_t stringLengthMax = 32; 538 char str[stringLengthMax] = {}; 539 for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) { 540 auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%d", i); 541 ASSERT_GT(secRet, 0); 542 543 strs[i] = str; 544 ret = cs->SetUserData(strs[i], "magic"); 545 ASSERT_EQ(ret, OHOS::GSERROR_OK); 546 } 547 548 ret = cs->SetUserData("-1", "error"); 549 ASSERT_NE(ret, OHOS::GSERROR_OK); 550 551 std::string retStr; 552 for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) { 553 retStr = cs->GetUserData(strs[i]); 554 ASSERT_EQ(retStr, "magic"); 555 } 556} 557 558/* 559* Function: UserDataChangeListen 560* Type: Function 561* Rank: Important(2) 562* EnvConditions: N/A 563* CaseDescription: 1. RegisterUserDataChangeListen 564* 2. SetUserData 565* 3. check ret 566 */ 567HWTEST_F(ConsumerSurfaceTest, UserDataChangeListen001, Function | MediumTest | Level2) 568{ 569 sptr<IConsumerSurface> csTestUserData = IConsumerSurface::Create(); 570 GSError ret1 = OHOS::GSERROR_INVALID_ARGUMENTS; 571 GSError ret2 = OHOS::GSERROR_INVALID_ARGUMENTS; 572 auto func1 = [&ret1](const std::string& key, const std::string& value) { 573 ret1 = OHOS::GSERROR_OK; 574 }; 575 auto func2 = [&ret2](const std::string& key, const std::string& value) { 576 ret2 = OHOS::GSERROR_OK; 577 }; 578 csTestUserData->RegisterUserDataChangeListener("func1", func1); 579 csTestUserData->RegisterUserDataChangeListener("func2", func2); 580 csTestUserData->RegisterUserDataChangeListener("func3", nullptr); 581 ASSERT_EQ(csTestUserData->RegisterUserDataChangeListener("func2", func2), OHOS::GSERROR_INVALID_ARGUMENTS); 582 583 if (csTestUserData->SetUserData("Regist", "OK") == OHOS::GSERROR_OK) { 584 ASSERT_EQ(ret1, OHOS::GSERROR_OK); 585 ASSERT_EQ(ret2, OHOS::GSERROR_OK); 586 } 587 588 ret1 = OHOS::GSERROR_INVALID_ARGUMENTS; 589 ret2 = OHOS::GSERROR_INVALID_ARGUMENTS; 590 csTestUserData->UnRegisterUserDataChangeListener("func1"); 591 ASSERT_EQ(csTestUserData->UnRegisterUserDataChangeListener("func1"), OHOS::GSERROR_INVALID_ARGUMENTS); 592 593 if (csTestUserData->SetUserData("UnRegist", "INVALID") == OHOS::GSERROR_OK) { 594 ASSERT_EQ(ret1, OHOS::GSERROR_INVALID_ARGUMENTS); 595 ASSERT_EQ(ret2, OHOS::GSERROR_OK); 596 } 597 598 ret1 = OHOS::GSERROR_INVALID_ARGUMENTS; 599 ret2 = OHOS::GSERROR_INVALID_ARGUMENTS; 600 csTestUserData->ClearUserDataChangeListener(); 601 csTestUserData->RegisterUserDataChangeListener("func1", func1); 602 if (csTestUserData->SetUserData("Clear", "OK") == OHOS::GSERROR_OK) { 603 ASSERT_EQ(ret1, OHOS::GSERROR_OK); 604 ASSERT_EQ(ret2, OHOS::GSERROR_INVALID_ARGUMENTS); 605 } 606} 607 608/* 609* Function: UserDataChangeListen 610* Type: Function 611* Rank: Important(2) 612* EnvConditions: N/A 613* CaseDescription: 1. RegisterUserDataChangeListen 614* 2. SetUserData 615* 3. check ret 616 */ 617HWTEST_F(ConsumerSurfaceTest, UserDataChangeListen002, Function | MediumTest | Level2) 618{ 619 sptr<IConsumerSurface> csTestUserData = IConsumerSurface::Create(); 620 621 auto func = [&csTestUserData](const std::string& FuncName) { 622 constexpr int32_t RegisterListenerNum = 1000; 623 std::vector<GSError> ret(RegisterListenerNum, OHOS::GSERROR_INVALID_ARGUMENTS); 624 std::string strs[RegisterListenerNum]; 625 constexpr int32_t stringLengthMax = 32; 626 char str[stringLengthMax] = {}; 627 for (int i = 0; i < RegisterListenerNum; i++) { 628 auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%s%d", FuncName.c_str(), i); 629 ASSERT_GT(secRet, 0); 630 strs[i] = str; 631 ASSERT_EQ(csTestUserData->RegisterUserDataChangeListener(strs[i], [i, &ret] 632 (const std::string& key, const std::string& value) { 633 ret[i] = OHOS::GSERROR_OK; 634 }), OHOS::GSERROR_OK); 635 } 636 637 if (csTestUserData->SetUserData("Regist", FuncName) == OHOS::GSERROR_OK) { 638 for (int i = 0; i < RegisterListenerNum; i++) { 639 ASSERT_EQ(ret[i], OHOS::GSERROR_OK); 640 } 641 } 642 643 for (int i = 0; i < RegisterListenerNum; i++) { 644 csTestUserData->UnRegisterUserDataChangeListener(strs[i]); 645 } 646 }; 647 648 std::thread t1(func, "thread1"); 649 std::thread t2(func, "thread2"); 650 t1.join(); 651 t2.join(); 652} 653 654/* 655* Function: SetUserData 656* Type: Function 657* Rank: Important(2) 658* EnvConditions: N/A 659* CaseDescription: 1. call SetUserData many times 660* 2. check ret 661 */ 662HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener001, Function | MediumTest | Level2) 663{ 664 class TestConsumerListener : public IBufferConsumerListener { 665 public: 666 void OnBufferAvailable() override 667 { 668 sptr<SurfaceBuffer> buffer; 669 int32_t flushFence; 670 671 cs->AcquireBuffer(buffer, flushFence, timestamp, damage); 672 int32_t *p = (int32_t*)buffer->GetVirAddr(); 673 if (p != nullptr) { 674 for (int32_t i = 0; i < 128; i++) { 675 ASSERT_EQ(p[i], i); 676 } 677 } 678 679 cs->ReleaseBuffer(buffer, -1); 680 } 681 }; 682 683 sptr<IBufferConsumerListener> listener = new TestConsumerListener(); 684 GSError ret = cs->RegisterConsumerListener(listener); 685 ASSERT_EQ(ret, OHOS::GSERROR_OK); 686 687 sptr<SurfaceBuffer> buffer; 688 int releaseFence = -1; 689 ret = ps->RequestBuffer(buffer, releaseFence, requestConfig); 690 ASSERT_EQ(ret, OHOS::GSERROR_OK); 691 ASSERT_NE(buffer, nullptr); 692 693 int32_t *p = (int32_t*)buffer->GetVirAddr(); 694 if (p != nullptr) { 695 for (int32_t i = 0; i < 128; i++) { 696 p[i] = i; 697 } 698 } 699 700 GraphicTransformType tranformType = ps->GetTransform(); 701 ret = ps->FlushBuffer(buffer, -1, flushConfig); 702 ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_180), OHOS::GSERROR_OK); 703 GraphicTransformType bufferTranformType = GraphicTransformType::GRAPHIC_ROTATE_NONE; 704 ASSERT_EQ(cs->GetSurfaceBufferTransformType(nullptr, &bufferTranformType), OHOS::SURFACE_ERROR_INVALID_PARAM); 705 ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, nullptr), OHOS::SURFACE_ERROR_INVALID_PARAM); 706 ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, &bufferTranformType), OHOS::GSERROR_OK); 707 ASSERT_EQ(bufferTranformType, tranformType); 708 ASSERT_EQ(ret, OHOS::GSERROR_OK); 709 listener->OnTunnelHandleChange(); 710 listener->OnGoBackground(); 711 listener->OnCleanCache(); 712 listener->OnTransformChange(); 713 TestConsumerListenerClazz* listenerClazz = new TestConsumerListenerClazz(); 714 listenerClazz->OnTunnelHandleChange(); 715 listenerClazz->OnGoBackground(); 716 listenerClazz->OnCleanCache(); 717 listenerClazz->OnTransformChange(); 718 delete listenerClazz; 719} 720 721/* 722* Function: RegisterConsumerListener, RequestBuffer and FlushBuffer 723* Type: Function 724* Rank: Important(2) 725* EnvConditions: N/A 726* CaseDescription: 1. call RegisterConsumerListener 727* 2. call RequestBuffer 728* 3. call FlushBuffer 729* 4. check ret 730 */ 731HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener002, Function | MediumTest | Level2) 732{ 733 sptr<IBufferConsumerListener> listener = new BufferConsumerListener(); 734 GSError ret = cs->RegisterConsumerListener(listener); 735 ASSERT_EQ(ret, OHOS::GSERROR_OK); 736 737 sptr<SurfaceBuffer> buffer; 738 int releaseFence = -1; 739 ret = ps->RequestBuffer(buffer, releaseFence, requestConfig); 740 ASSERT_EQ(ret, OHOS::GSERROR_OK); 741 ASSERT_NE(buffer, nullptr); 742 743 int32_t *p = (int32_t*)buffer->GetVirAddr(); 744 if (p != nullptr) { 745 for (int32_t i = 0; i < requestConfig.width * requestConfig.height; i++) { 746 p[i] = i; 747 } 748 } 749 ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_90), OHOS::GSERROR_OK); 750 ret = ps->FlushBuffer(buffer, -1, flushConfig); 751 GraphicTransformType bufferTranformType = GraphicTransformType::GRAPHIC_ROTATE_NONE; 752 ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, &bufferTranformType), OHOS::GSERROR_OK); 753 ASSERT_EQ(bufferTranformType, GraphicTransformType::GRAPHIC_ROTATE_90); 754 ASSERT_EQ(ret, OHOS::GSERROR_OK); 755 ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_NONE), OHOS::GSERROR_OK); 756 sptr<OHOS::SyncFence> flushFence; 757 ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage); 758 ASSERT_EQ(ret, OHOS::GSERROR_OK); 759 ASSERT_NE(buffer, nullptr); 760 bool isInCache = false; 761 ASSERT_EQ(cs->IsSurfaceBufferInCache(buffer->GetSeqNum(), isInCache), OHOS::GSERROR_OK); 762 ASSERT_EQ(isInCache, true); 763 ASSERT_EQ(cs->IsSurfaceBufferInCache(0xFFFFFFFF, isInCache), OHOS::GSERROR_OK); 764 ASSERT_EQ(isInCache, false); 765} 766 767/* 768* Function: RegisterConsumerListener 769* Type: Function 770* Rank: Important(2) 771* EnvConditions: N/A 772* CaseDescription: 1. call RegisterConsumerListener with nullptr params 773* 2. check ret 774 */ 775HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener003, Function | MediumTest | Level2) 776{ 777 GSError ret = surface_->RegisterConsumerListener(nullptr); 778 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 779 sptr<IBufferConsumerListener> listener = new BufferConsumerListener(); 780 ret = surface_->RegisterConsumerListener(listener); 781 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 782} 783 784/* 785* Function: RegisterConsumerListener 786* Type: Function 787* Rank: Important(2) 788* EnvConditions: N/A 789* CaseDescription: 1. call RegisterConsumerListener with nullptr params 790* 2. check ret 791 */ 792HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener004, Function | MediumTest | Level2) 793{ 794 GSError ret = surface_->RegisterConsumerListener(nullptr); 795 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 796 TestConsumerListenerClazz* listenerClazz = new TestConsumerListenerClazz(); 797 ret = surface_->RegisterConsumerListener(listenerClazz); 798 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 799 delete listenerClazz; 800} 801 802/* 803* Function: RegisterReleaseListener 804* Type: Function 805* Rank: Important(2) 806* EnvConditions: N/A 807* CaseDescription: 1. call RegisterReleaseListener with nullptr param 808* 2. check ret 809 */ 810HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener001, Function | MediumTest | Level2) 811{ 812 OnReleaseFunc onBufferRelease = nullptr; 813 GSError ret = surface_->RegisterReleaseListener(onBufferRelease); 814 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 815} 816 817/* 818* Function: RegisterReleaseListener 819* Type: Function 820* Rank: Important(2) 821* EnvConditions: N/A 822* CaseDescription: 1. call RegisterReleaseListener with consumer_ is normal 823* 2. check ret 824 */ 825HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener002, Function | MediumTest | Level2) 826{ 827 sptr<BufferQueue> queue = new BufferQueue("test", false); 828 surface_->consumer_ = new BufferQueueConsumer(queue); 829 ASSERT_NE(surface_->consumer_, nullptr); 830 OnReleaseFunc onBufferRelease = nullptr; 831 GSError ret = surface_->RegisterReleaseListener(onBufferRelease); 832 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 833} 834 835/* 836* Function: RegisterReleaseListener 837* Type: Function 838* Rank: Important(2) 839* EnvConditions: N/A 840* CaseDescription: 1. call RegisterReleaseListener 841* 2. check ret 842 */ 843HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener003, Function | MediumTest | Level2) 844{ 845 OnReleaseFuncWithFence func = nullptr; 846 GSError ret = surface_->RegisterReleaseListener(func); 847 ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT); 848} 849 850/* 851* Function: UnRegisterReleaseListener 852* Type: Function 853* Rank: Important(2) 854* EnvConditions: N/A 855* CaseDescription: 1. call UnRegisterReleaseListener 856* 2. check ret 857 */ 858HWTEST_F(ConsumerSurfaceTest, UnRegisterReleaseListener001, Function | MediumTest | Level2) 859{ 860 GSError ret = surface_->UnRegisterReleaseListener(); 861 ASSERT_EQ(ret, OHOS::GSERROR_OK); 862} 863 864/* 865* Function: RegisterDeleteBufferListener 866* Type: Function 867* Rank: Important(2) 868* EnvConditions: N/A 869* CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is nullptr 870* 2. check ret 871 */ 872HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener001, Function | MediumTest | Level2) 873{ 874 OnDeleteBufferFunc func = nullptr; 875 GSError ret = surface_->RegisterDeleteBufferListener(func, false); 876 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 877} 878 879/* 880* Function: RegisterDeleteBufferListener 881* Type: Function 882* Rank: Important(2) 883* EnvConditions: N/A 884* CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal 885* 2. check ret 886 */ 887HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener002, Function | MediumTest | Level2) 888{ 889 sptr<BufferQueue> queue = new BufferQueue("test", false); 890 surface_->consumer_ = new BufferQueueConsumer(queue); 891 ASSERT_NE(surface_->consumer_, nullptr); 892 OnDeleteBufferFunc func = nullptr; 893 GSError ret = surface_->RegisterDeleteBufferListener(func, false); 894 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 895 ret = surface_->RegisterDeleteBufferListener(func, true); 896 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 897} 898 899/* 900* Function: UnregisterConsumerListener 901* Type: Function 902* Rank: Important(2) 903* EnvConditions: N/A 904* CaseDescription: 1. call UnregisterConsumerListener with consumer_ is nullptr 905* 2. check ret 906 */ 907HWTEST_F(ConsumerSurfaceTest, UnregisterConsumerListener001, Function | MediumTest | Level2) 908{ 909 GSError ret = surface_->UnregisterConsumerListener(); 910 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 911} 912 913/* 914* Function: UnregisterConsumerListener 915* Type: Function 916* Rank: Important(2) 917* EnvConditions: N/A 918* CaseDescription: 1. call UnregisterConsumerListener with consumer_ is normal 919* 2. check ret 920 */ 921HWTEST_F(ConsumerSurfaceTest, UnregisterConsumerListener002, Function | MediumTest | Level2) 922{ 923 sptr<BufferQueue> queue = new BufferQueue("test", false); 924 surface_->consumer_ = new BufferQueueConsumer(queue); 925 ASSERT_NE(surface_->consumer_, nullptr); 926 GSError ret = surface_->UnregisterConsumerListener(); 927 ASSERT_EQ(ret, OHOS::GSERROR_OK); 928} 929 930/* 931* Function: RegisterUserDataChangeListener 932* Type: Function 933* Rank: Important(2) 934* EnvConditions: N/A 935* CaseDescription: 1. call RegisterUserDataChangeListener with nullptr param 936* 2. check ret 937 */ 938HWTEST_F(ConsumerSurfaceTest, RegisterUserDataChangeListener001, Function | MediumTest | Level2) 939{ 940 GSError ret = surface_->RegisterUserDataChangeListener("test", nullptr); 941 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 942} 943 944/* 945* Function: GoBackground 946* Type: Function 947* Rank: Important(2) 948* EnvConditions: N/A 949* CaseDescription: 1. call GoBackground with consumer_ is nullptr 950* 2. check ret 951 */ 952HWTEST_F(ConsumerSurfaceTest, GoBackground001, Function | MediumTest | Level2) 953{ 954 GSError ret = surface_->GoBackground(); 955 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 956} 957 958/* 959* Function: GoBackground 960* Type: Function 961* Rank: Important(2) 962* EnvConditions: N/A 963* CaseDescription: 1. call GoBackground with consumer_ is normal 964* 2. check ret 965 */ 966HWTEST_F(ConsumerSurfaceTest, GoBackground002, Function | MediumTest | Level2) 967{ 968 sptr<BufferQueue> queue = new BufferQueue("test", false); 969 surface_->consumer_ = new BufferQueueConsumer(queue); 970 ASSERT_NE(surface_->consumer_, nullptr); 971 GSError ret = surface_->GoBackground(); 972 ASSERT_EQ(ret, OHOS::GSERROR_OK); 973 surface_->producer_ = new BufferQueueProducer(queue); 974 ASSERT_NE(surface_->producer_, nullptr); 975 ret = surface_->GoBackground(); 976 ASSERT_EQ(ret, OHOS::GSERROR_OK); 977} 978 979/* 980* Function: GetUniqueId 981* Type: Function 982* Rank: Important(2) 983* EnvConditions: N/A 984* CaseDescription: 1. call GetUniqueId with producer_ is nullptr 985* 2. check ret 986 */ 987HWTEST_F(ConsumerSurfaceTest, GetUniqueId001, Function | MediumTest | Level2) 988{ 989 uint64_t ret = surface_->GetUniqueId(); 990 ASSERT_EQ(ret, 0); 991} 992 993/* 994* Function: Dump 995* Type: Function 996* Rank: Important(2) 997* EnvConditions: N/A 998* CaseDescription: 1. call Dump 999* 2. check ret 1000 */ 1001HWTEST_F(ConsumerSurfaceTest, Dump001, Function | MediumTest | Level2) 1002{ 1003 std::string result; 1004 surface_->Dump(result); 1005 sptr<BufferQueue> queue = new BufferQueue("test", false); 1006 surface_->consumer_ = new BufferQueueConsumer(queue); 1007 ASSERT_NE(surface_->consumer_, nullptr); 1008 surface_->Dump(result); 1009} 1010 1011/* 1012* Function: SetTransform and GetTransform 1013* Type: Function 1014* Rank: Important(2) 1015* EnvConditions: N/A 1016* CaseDescription: 1. call GetTransform by default 1017 */ 1018HWTEST_F(ConsumerSurfaceTest, transform001, Function | MediumTest | Level2) 1019{ 1020 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_NONE); 1021} 1022 1023/* 1024* Function: SetTransform and GetTransform 1025* Type: Function 1026* Rank: Important(1) 1027* EnvConditions: N/A 1028* CaseDescription: 1. call SetTransform with different paramaters and call GetTransform 1029* 2. check ret 1030 */ 1031HWTEST_F(ConsumerSurfaceTest, transform002, Function | MediumTest | Level1) 1032{ 1033 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_90; 1034 GSError ret = ps->SetTransform(transform); 1035 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1036 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_90); 1037} 1038 1039/* 1040* Function: SetTransform and GetTransform 1041* Type: Function 1042* Rank: Important(1) 1043* EnvConditions: N/A 1044* CaseDescription: 1. call SetTransform with different paramaters and call GetTransform 1045* 2. check ret 1046 */ 1047HWTEST_F(ConsumerSurfaceTest, transform003, Function | MediumTest | Level1) 1048{ 1049 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_180; 1050 GSError ret = ps->SetTransform(transform); 1051 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1052 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_180); 1053} 1054 1055/* 1056* Function: SetTransform and GetTransform 1057* Type: Function 1058* Rank: Important(1) 1059* EnvConditions: N/A 1060* CaseDescription: 1. call SetTransform with different paramaters and call GetTransform 1061* 2. check ret 1062 */ 1063HWTEST_F(ConsumerSurfaceTest, transform004, Function | MediumTest | Level1) 1064{ 1065 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_270; 1066 GSError ret = ps->SetTransform(transform); 1067 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1068 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_270); 1069} 1070 1071/* 1072* Function: SetTransform and GetTransform 1073* Type: Function 1074* Rank: Important(1) 1075* EnvConditions: N/A 1076* CaseDescription: 1. call SetTransform with different paramaters and call GetTransform 1077* 2. check ret 1078 */ 1079HWTEST_F(ConsumerSurfaceTest, transform005, Function | MediumTest | Level1) 1080{ 1081 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_NONE; 1082 GSError ret = ps->SetTransform(transform); 1083 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1084 ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_NONE); 1085} 1086 1087/* 1088* Function: SetTransform and GetTransform 1089* Type: Function 1090* Rank: Important(1) 1091* EnvConditions: N/A 1092* CaseDescription: 1. call SetTransform GetTransform with nullptr 1093* 2. check ret 1094 */ 1095HWTEST_F(ConsumerSurfaceTest, transform006, Function | MediumTest | Level1) 1096{ 1097 GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_NONE; 1098 GSError ret = surface_->SetTransform(transform); 1099 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1100 ASSERT_EQ(surface_->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_BUTT); 1101} 1102 1103/* 1104* Function: SetScalingMode and GetScalingMode 1105* Type: Function 1106* Rank: Important(2) 1107* EnvConditions: N/A 1108* CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret 1109 */ 1110HWTEST_F(ConsumerSurfaceTest, scalingMode001, Function | MediumTest | Level2) 1111{ 1112 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW; 1113 GSError ret = cs->SetScalingMode(-1, scalingMode); 1114 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY); 1115 ret = cs->GetScalingMode(-1, scalingMode); 1116 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY); 1117} 1118 1119/* 1120* Function: SetScalingMode and GetScalingMode 1121* Type: Function 1122* Rank: Important(1) 1123* EnvConditions: N/A 1124* CaseDescription: 1. call SetScalingMode with normal parameters and check ret 1125* 2. call GetScalingMode and check ret 1126 */ 1127HWTEST_F(ConsumerSurfaceTest, scalingMode002, Function | MediumTest | Level1) 1128{ 1129 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW; 1130 sptr<SurfaceBuffer> buffer; 1131 int releaseFence = -1; 1132 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig); 1133 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1134 ASSERT_NE(buffer, nullptr); 1135 1136 uint32_t sequence = buffer->GetSeqNum(); 1137 ret = cs->SetScalingMode(sequence, scalingMode); 1138 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1139 1140 ScalingMode scalingModeGet = ScalingMode::SCALING_MODE_FREEZE; 1141 ret = cs->GetScalingMode(sequence, scalingModeGet); 1142 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1143 ASSERT_EQ(scalingMode, scalingModeGet); 1144 1145 ret = ps->CancelBuffer(buffer); 1146 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1147} 1148 1149/* 1150* Function: SetScalingMode003 1151* Type: Function 1152* Rank: Important(2) 1153* EnvConditions: N/A 1154* CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret 1155 */ 1156HWTEST_F(ConsumerSurfaceTest, scalingMode003, Function | MediumTest | Level2) 1157{ 1158 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW; 1159 GSError ret = cs->SetScalingMode(scalingMode); 1160 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1161} 1162 1163/* 1164* Function: SetScalingMode and GetScalingMode 1165* Type: Function 1166* Rank: Important(1) 1167* EnvConditions: N/A 1168* CaseDescription: 1. call SetScalingMode with nullptr and check ret 1169* 2. call GetScalingMode with nullptr and check ret 1170 */ 1171HWTEST_F(ConsumerSurfaceTest, scalingMode004, Function | MediumTest | Level1) 1172{ 1173 ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW; 1174 GSError ret = surface_->SetScalingMode(firstSeqnum, scalingMode); 1175 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1176 ret = surface_->SetScalingMode(scalingMode); 1177 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1178 ret = surface_->GetScalingMode(firstSeqnum, scalingMode); 1179 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1180} 1181 1182/* 1183* Function: QueryMetaDataType 1184* Type: Function 1185* Rank: Important(1) 1186* EnvConditions: N/A 1187* CaseDescription: 1. call QueryMetaDataType and check ret 1188 */ 1189HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType001, Function | MediumTest | Level1) 1190{ 1191 HDRMetaDataType type = HDRMetaDataType::HDR_META_DATA; 1192 GSError ret = cs->QueryMetaDataType(firstSeqnum, type); 1193 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1194 ASSERT_EQ(type, HDRMetaDataType::HDR_NOT_USED); 1195} 1196 1197/* 1198* Function: QueryMetaDataType 1199* Type: Function 1200* Rank: Important(1) 1201* EnvConditions: N/A 1202* CaseDescription: 1. call SetMetaData with normal parameters and check ret 1203* 2. call QueryMetaDataType and check ret 1204 */ 1205HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType002, Function | MediumTest | Level1) 1206{ 1207 std::vector<GraphicHDRMetaData> metaData; 1208 GraphicHDRMetaData data = { 1209 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X, 1210 .value = 1, 1211 }; 1212 metaData.push_back(data); 1213 GSError ret = cs->SetMetaData(firstSeqnum, metaData); 1214 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1215 1216 HDRMetaDataType type = HDRMetaDataType::HDR_NOT_USED; 1217 ret = cs->QueryMetaDataType(firstSeqnum, type); 1218 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1219 ASSERT_EQ(type, HDRMetaDataType::HDR_META_DATA); 1220} 1221 1222/* 1223* Function: QueryMetaDataType 1224* Type: Function 1225* Rank: Important(1) 1226* EnvConditions: N/A 1227* CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret 1228* 2. call QueryMetaDataType and check ret 1229 */ 1230HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType003, Function | MediumTest | Level1) 1231{ 1232 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS; 1233 std::vector<uint8_t> metaData; 1234 uint8_t data = 1; 1235 metaData.push_back(data); 1236 GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData); 1237 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1238 1239 HDRMetaDataType type = HDRMetaDataType::HDR_NOT_USED; 1240 ret = cs->QueryMetaDataType(firstSeqnum, type); 1241 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1242 ASSERT_EQ(type, HDRMetaDataType::HDR_META_DATA_SET); 1243} 1244 1245/* 1246* Function: QueryMetaDataType 1247* Type: Function 1248* Rank: Important(1) 1249* EnvConditions: N/A 1250* CaseDescription: 1. call QueryMetaDataType with nullptr and check ret 1251 */ 1252HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType004, Function | MediumTest | Level1) 1253{ 1254 HDRMetaDataType type = HDRMetaDataType::HDR_META_DATA; 1255 GSError ret = surface_->QueryMetaDataType(firstSeqnum, type); 1256 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1257} 1258 1259/* 1260* Function: SetMetaData and GetMetaData 1261* Type: Function 1262* Rank: Important(2) 1263* EnvConditions: N/A 1264* CaseDescription: 1. call SetMetaData with abnormal parameters and check ret 1265 */ 1266HWTEST_F(ConsumerSurfaceTest, metaData001, Function | MediumTest | Level2) 1267{ 1268 std::vector<GraphicHDRMetaData> metaData; 1269 GSError ret = cs->SetMetaData(firstSeqnum, metaData); 1270 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1271} 1272 1273/* 1274* Function: SetMetaData and GetMetaData 1275* Type: Function 1276* Rank: Important(1) 1277* EnvConditions: N/A 1278* CaseDescription: 1. call SetMetaData with normal parameters and check ret 1279 */ 1280HWTEST_F(ConsumerSurfaceTest, metaData002, Function | MediumTest | Level1) 1281{ 1282 std::vector<GraphicHDRMetaData> metaData; 1283 GraphicHDRMetaData data = { 1284 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X, 1285 .value = 100, // for test 1286 }; 1287 metaData.push_back(data); 1288 GSError ret = cs->SetMetaData(firstSeqnum, metaData); 1289 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1290} 1291 1292/* 1293* Function: SetMetaData and GetMetaData 1294* Type: Function 1295* Rank: Important(1) 1296* EnvConditions: N/A 1297* CaseDescription: 1. call SetMetaData with normal parameters and check ret 1298* 2. call GetMetaData and check ret 1299 */ 1300HWTEST_F(ConsumerSurfaceTest, metaData003, Function | MediumTest | Level1) 1301{ 1302 std::vector<GraphicHDRMetaData> metaData; 1303 GraphicHDRMetaData data = { 1304 .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X, 1305 .value = 100, // for test 1306 }; 1307 metaData.push_back(data); 1308 1309 sptr<SurfaceBuffer> buffer; 1310 int releaseFence = -1; 1311 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig); 1312 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1313 ASSERT_NE(buffer, nullptr); 1314 1315 uint32_t sequence = buffer->GetSeqNum(); 1316 ret = cs->SetMetaData(sequence, metaData); 1317 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1318 1319 std::vector<GraphicHDRMetaData> metaDataGet; 1320 ret = cs->GetMetaData(sequence, metaDataGet); 1321 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1322 ASSERT_EQ(metaData[0].key, metaDataGet[0].key); 1323 ASSERT_EQ(metaData[0].value, metaDataGet[0].value); 1324 1325 ret = cs->GetMetaData(sequence + 1, metaDataGet); 1326 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY); 1327 1328 ret = ps->CancelBuffer(buffer); 1329 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1330} 1331 1332/* 1333* Function: SetMetaData and GetMetaData 1334* Type: Function 1335* Rank: Important(2) 1336* EnvConditions: N/A 1337* CaseDescription: 1. call SetMetaData and GetMetaData with nullptr and check ret 1338 */ 1339HWTEST_F(ConsumerSurfaceTest, metaData004, Function | MediumTest | Level2) 1340{ 1341 std::vector<GraphicHDRMetaData> metaData; 1342 GSError ret = surface_->SetMetaData(firstSeqnum, metaData); 1343 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1344 ret = surface_->GetMetaData(firstSeqnum, metaData); 1345 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1346} 1347 1348/* 1349* Function: SetMetaDataSet and GetMetaDataSet 1350* Type: Function 1351* Rank: Important(2) 1352* EnvConditions: N/A 1353* CaseDescription: 1. call SetMetaDataSet with abnormal parameters and check ret 1354 */ 1355HWTEST_F(ConsumerSurfaceTest, metaDataSet001, Function | MediumTest | Level2) 1356{ 1357 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS; 1358 std::vector<uint8_t> metaData; 1359 GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData); 1360 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1361} 1362 1363/* 1364* Function: SetMetaDataSet and GetMetaDataSet 1365* Type: Function 1366* Rank: Important(1) 1367* EnvConditions: N/A 1368* CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret 1369 */ 1370HWTEST_F(ConsumerSurfaceTest, metaDataSet002, Function | MediumTest | Level1) 1371{ 1372 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS; 1373 std::vector<uint8_t> metaData; 1374 uint8_t data = 10; // for test 1375 metaData.push_back(data); 1376 GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData); 1377 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1378} 1379 1380/* 1381* Function: SetMetaDataSet and GetMetaDataSet 1382* Type: Function 1383* Rank: Important(1) 1384* EnvConditions: N/A 1385* CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret 1386* 2. call GetMetaDataSet and check ret 1387 */ 1388HWTEST_F(ConsumerSurfaceTest, metaDataSet003, Function | MediumTest | Level1) 1389{ 1390 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS; 1391 std::vector<uint8_t> metaData; 1392 uint8_t data = 10; // for test 1393 metaData.push_back(data); 1394 1395 sptr<SurfaceBuffer> buffer; 1396 int releaseFence = -1; 1397 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig); 1398 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1399 ASSERT_NE(buffer, nullptr); 1400 1401 uint32_t sequence = buffer->GetSeqNum(); 1402 ret = cs->SetMetaDataSet(sequence, key, metaData); 1403 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1404 1405 GraphicHDRMetadataKey keyGet = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X; 1406 std::vector<uint8_t> metaDataGet; 1407 ret = cs->GetMetaDataSet(sequence, keyGet, metaDataGet); 1408 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1409 ASSERT_EQ(key, keyGet); 1410 ASSERT_EQ(metaData[0], metaDataGet[0]); 1411 1412 ret = cs->GetMetaDataSet(sequence + 1, keyGet, metaDataGet); 1413 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY); 1414 1415 ret = ps->CancelBuffer(buffer); 1416 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1417} 1418 1419/* 1420* Function: SetMetaDataSet and GetMetaDataSet 1421* Type: Function 1422* Rank: Important(2) 1423* EnvConditions: N/A 1424* CaseDescription: 1. call SetMetaDataSet and GetMetaDataSet with nullptr and check ret 1425 */ 1426HWTEST_F(ConsumerSurfaceTest, metaDataSet004, Function | MediumTest | Level2) 1427{ 1428 GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS; 1429 std::vector<uint8_t> metaData; 1430 GSError ret = surface_->SetMetaDataSet(firstSeqnum, key, metaData); 1431 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1432 ret = surface_->GetMetaDataSet(firstSeqnum, key, metaData); 1433 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1434} 1435 1436/* 1437* Function: SetTunnelHandle and GetTunnelHandle 1438* Type: Function 1439* Rank: Important(2) 1440* EnvConditions: N/A 1441* CaseDescription: 1. call SetTunnelHandle with abnormal parameters and check ret 1442 */ 1443HWTEST_F(ConsumerSurfaceTest, TunnelHandle001, Function | MediumTest | Level2) 1444{ 1445 GraphicExtDataHandle *handle = nullptr; 1446 GSError ret = cs->SetTunnelHandle(handle); 1447 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1448} 1449 1450/* 1451* Function: SetTunnelHandle and GetTunnelHandle 1452* Type: Function 1453* Rank: Important(2) 1454* EnvConditions: N/A 1455* CaseDescription: 1. call SetTunnelHandle with abnormal parameters and check ret 1456 */ 1457HWTEST_F(ConsumerSurfaceTest, TunnelHandle002, Function | MediumTest | Level2) 1458{ 1459 GraphicExtDataHandle *handle = nullptr; 1460 handle = new GraphicExtDataHandle(); 1461 handle->fd = -1; 1462 handle->reserveInts = 0; 1463 GSError ret = cs->SetTunnelHandle(handle); 1464 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1465} 1466 1467/* 1468* Function: SetTunnelHandle and GetTunnelHandle 1469* Type: Function 1470* Rank: Important(1) 1471* EnvConditions: N/A 1472* CaseDescription: 1. call SetTunnelHandle with normal parameters and check ret 1473* 2. call GetTunnelHandle and check ret 1474* @tc.require: issueI5GMZN issueI5IWHW 1475 */ 1476HWTEST_F(ConsumerSurfaceTest, TunnelHandle003, Function | MediumTest | Level1) 1477{ 1478 GraphicExtDataHandle *handle = static_cast<GraphicExtDataHandle *>( 1479 malloc(sizeof(GraphicExtDataHandle) + sizeof(int32_t))); 1480 handle->fd = -1; 1481 handle->reserveInts = 1; 1482 handle->reserve[0] = 0; 1483 GSError ret = cs->SetTunnelHandle(handle); 1484 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1485 1486 ret = cs->SetTunnelHandle(handle); 1487 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY); 1488 1489 sptr<SurfaceTunnelHandle> handleGet = nullptr; 1490 handleGet = cs->GetTunnelHandle(); 1491 ASSERT_NE(handleGet, nullptr); 1492 ASSERT_EQ(handle->fd, handleGet->GetHandle()->fd); 1493 ASSERT_EQ(handle->reserveInts, handleGet->GetHandle()->reserveInts); 1494 ASSERT_EQ(handle->reserve[0], handleGet->GetHandle()->reserve[0]); 1495 free(handle); 1496} 1497 1498/* 1499* Function: SetTunnelHandle and GetTunnelHandle 1500* Type: Function 1501* Rank: Important(2) 1502* EnvConditions: N/A 1503* CaseDescription: 1. call SetTunnelHandle and GetTunnelHandle with nullptr and check ret 1504 */ 1505HWTEST_F(ConsumerSurfaceTest, TunnelHandle004, Function | MediumTest | Level2) 1506{ 1507 GraphicExtDataHandle *handle = nullptr; 1508 GSError ret = surface_->SetTunnelHandle(handle); 1509 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1510 sptr<SurfaceTunnelHandle> tunnelHandle = surface_->GetTunnelHandle(); 1511 ASSERT_EQ(tunnelHandle, nullptr); 1512} 1513 1514/* 1515* Function: SetPresentTimestamp and GetPresentTimestamp 1516* Type: Function 1517* Rank: Important(2) 1518* EnvConditions: N/A 1519* CaseDescription: 1. call SetPresentTimestamp with abnormal parameters and check ret 1520* @tc.require: issueI5I57K 1521 */ 1522HWTEST_F(ConsumerSurfaceTest, presentTimestamp002, Function | MediumTest | Level2) 1523{ 1524 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_UNSUPPORTED, 0}; 1525 GSError ret = cs->SetPresentTimestamp(-1, timestamp); 1526 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1527} 1528 1529/* 1530* Function: SetPresentTimestamp and GetPresentTimestamp 1531* Type: Function 1532* Rank: Important(2) 1533* EnvConditions: N/A 1534* CaseDescription: 1. call SetPresentTimestamp with abnormal parameters and check ret 1535* @tc.require: issueI5I57K 1536 */ 1537HWTEST_F(ConsumerSurfaceTest, presentTimestamp003, Function | MediumTest | Level2) 1538{ 1539 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_DELAY, 0}; 1540 GSError ret = cs->SetPresentTimestamp(-1, timestamp); 1541 ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY); 1542} 1543 1544/* 1545* Function: SetPresentTimestamp and GetPresentTimestamp 1546* Type: Function 1547* Rank: Important(1) 1548* EnvConditions: N/A 1549* CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret 1550* @tc.require: issueI5I57K 1551 */ 1552HWTEST_F(ConsumerSurfaceTest, presentTimestamp004, Function | MediumTest | Level1) 1553{ 1554 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_DELAY, 0}; 1555 GSError ret = cs->SetPresentTimestamp(firstSeqnum, timestamp); 1556 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1557} 1558 1559/* 1560* Function: SetPresentTimestamp and GetPresentTimestamp 1561* Type: Function 1562* Rank: Important(1) 1563* EnvConditions: N/A 1564* CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret 1565* @tc.require: issueI5I57K 1566 */ 1567HWTEST_F(ConsumerSurfaceTest, presentTimestamp005, Function | MediumTest | Level1) 1568{ 1569 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_TIMESTAMP, 0}; 1570 GSError ret = cs->SetPresentTimestamp(firstSeqnum, timestamp); 1571 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1572} 1573 1574/* 1575* Function: SetPresentTimestamp and GetPresentTimestamp 1576* Type: Function 1577* Rank: Important(1) 1578* EnvConditions: N/A 1579* CaseDescription: 1. call SetPresentTimestamp with nullptr and check ret 1580 */ 1581HWTEST_F(ConsumerSurfaceTest, presentTimestamp006, Function | MediumTest | Level1) 1582{ 1583 GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_TIMESTAMP, 0}; 1584 GSError ret = surface_->SetPresentTimestamp(firstSeqnum, timestamp); 1585 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1586 int64_t time = 0; 1587 ret = surface_->GetPresentTimestamp(firstSeqnum, GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_TIMESTAMP, time); 1588 ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT); 1589} 1590 1591/* 1592* Function: AcquireBuffer and ReleaseBuffer 1593* Type: Function 1594* Rank: Important(2) 1595* EnvConditions: N/A 1596* CaseDescription: 1. call RequestBuffer and FlushBuffer 1597* 2. call AcquireBuffer and ReleaseBuffer 1598* 3. check ret 1599 */ 1600HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel005, Function | MediumTest | Level2) 1601{ 1602 sptr<SurfaceBuffer> buffer; 1603 int releaseFence = -1; 1604 1605 GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig); 1606 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1607 ASSERT_NE(buffer, nullptr); 1608 1609 ret = ps->FlushBuffer(buffer, SyncFence::INVALID_FENCE, flushConfigWithDamages); 1610 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1611 1612 sptr<OHOS::SyncFence> flushFence; 1613 ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damages); 1614 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1615 ASSERT_NE(buffer, nullptr); 1616 ASSERT_EQ(damages.size(), flushConfigWithDamages.damages.size()); 1617 for (decltype(damages.size()) i = 0; i < damages.size(); i++) { 1618 ASSERT_EQ(damages[i].x, flushConfigWithDamages.damages[i].x); 1619 ASSERT_EQ(damages[i].y, flushConfigWithDamages.damages[i].y); 1620 ASSERT_EQ(damages[i].w, flushConfigWithDamages.damages[i].w); 1621 ASSERT_EQ(damages[i].h, flushConfigWithDamages.damages[i].h); 1622 } 1623 1624 ASSERT_EQ(timestamp, flushConfigWithDamages.timestamp); 1625 ret = cs->ReleaseBuffer(buffer, -1); 1626 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1627} 1628 1629/* 1630* Function: AttachBuffer001 1631* Type: Function 1632* Rank: Important(2) 1633* EnvConditions: N/A 1634* CaseDescription: 1. call AttachBuffer 1635* 2. check ret 1636 */ 1637HWTEST_F(ConsumerSurfaceTest, AttachBuffer001, Function | MediumTest | Level2) 1638{ 1639 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create(); 1640 ASSERT_NE(buffer, nullptr); 1641 GSError ret = cs->AttachBuffer(buffer); 1642 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1643} 1644 1645/* 1646* Function: AttachBuffer002 1647* Type: Function 1648* Rank: Important(2) 1649* EnvConditions: N/A 1650* CaseDescription: 1. call AttachBuffer 1651* 2. check ret 1652 */ 1653HWTEST_F(ConsumerSurfaceTest, AttachBuffer002, Function | MediumTest | Level2) 1654{ 1655 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create(); 1656 ASSERT_NE(buffer, nullptr); 1657 int32_t timeOut = 1; 1658 GSError ret = cs->AttachBuffer(buffer, timeOut); 1659 ASSERT_NE(ret, OHOS::GSERROR_OK); 1660} 1661 1662/* 1663* Function: AttachBuffer003 1664* Type: Function 1665* Rank: Important(2) 1666* EnvConditions: N/A 1667* CaseDescription: 1. call AttachBuffer 1668* 2. check ret 1669 */ 1670HWTEST_F(ConsumerSurfaceTest, AttachBuffer003, Function | MediumTest | Level2) 1671{ 1672 sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create(); 1673 ASSERT_NE(buffer, nullptr); 1674 int32_t timeOut = 1; 1675 GSError ret = cs->AttachBuffer(buffer, timeOut); 1676 ASSERT_NE(ret, GSERROR_OK); 1677} 1678 1679/* 1680* Function: AttachBuffer 1681* Type: Function 1682* Rank: Important(2) 1683* EnvConditions: N/A 1684* CaseDescription: 1. call AttachBuffer with nullptr params 1685* 2. check ret 1686 */ 1687HWTEST_F(ConsumerSurfaceTest, AttachBuffer004, Function | MediumTest | Level2) 1688{ 1689 sptr<SurfaceBuffer> buffer = nullptr; 1690 GSError ret = surface_->AttachBuffer(buffer); 1691 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS); 1692} 1693 1694/* 1695* Function: AttachBuffer 1696* Type: Function 1697* Rank: Important(2) 1698* EnvConditions: N/A 1699* CaseDescription: 1. call AttachBuffer with nullptr params 1700* 2. check ret 1701 */ 1702HWTEST_F(ConsumerSurfaceTest, AttachBuffer005, Function | MediumTest | Level2) 1703{ 1704 sptr<SurfaceBuffer> buffer = nullptr; 1705 int32_t timeOut = 1; 1706 GSError ret = surface_->AttachBuffer(buffer, timeOut); 1707 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS); 1708} 1709 1710/* 1711* Function: RegisterSurfaceDelegator 1712* Type: Function 1713* Rank: Important(2) 1714* EnvConditions: N/A 1715* CaseDescription: 1. call RegisterSurfaceDelegator 1716* 2. check ret 1717 */ 1718HWTEST_F(ConsumerSurfaceTest, RegisterSurfaceDelegator001, Function | MediumTest | Level2) 1719{ 1720 GSError ret = cs->RegisterSurfaceDelegator(surfaceDelegator->AsObject()); 1721 ASSERT_EQ(ret, GSERROR_OK); 1722} 1723 1724/* 1725* Function: RegisterSurfaceDelegator 1726* Type: Function 1727* Rank: Important(2) 1728* EnvConditions: N/A 1729* CaseDescription: 1. call RegisterSurfaceDelegator with nullptr params 1730* 2. check ret 1731 */ 1732HWTEST_F(ConsumerSurfaceTest, RegisterSurfaceDelegator002, Function | MediumTest | Level2) 1733{ 1734 GSError ret = surface_->RegisterSurfaceDelegator(nullptr); 1735 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS); 1736 ASSERT_NE(surfaceDelegator, nullptr); 1737 sptr<IRemoteObject> client = surfaceDelegator->AsObject(); 1738 ASSERT_NE(client, nullptr); 1739 ret = surface_->RegisterSurfaceDelegator(client); 1740 ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS); 1741} 1742 1743/* 1744* Function: ConsumerRequestCpuAccess 1745* Type: Function 1746* Rank: Important(2) 1747* EnvConditions: N/A 1748* CaseDescription: 1. usage does not contain BUFFER_USAGE_CPU_HW_BOTH 1749* 2. call ConsumerRequestCpuAccess(fasle/true) 1750* 3. check ret 1751 */ 1752HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess001, Function | MediumTest | Level2) 1753{ 1754 using namespace HDI::Display::Graphic::Common; 1755 BufferRequestConfig config = { 1756 .width = 0x100, 1757 .height = 0x100, 1758 .strideAlignment = 0x8, 1759 .format = GRAPHIC_PIXEL_FMT_RGBA_8888, 1760 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA, 1761 .timeout = 0, 1762 }; 1763 auto cSurface = IConsumerSurface::Create(); 1764 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener(); 1765 cSurface->RegisterConsumerListener(cListener); 1766 auto p = cSurface->GetProducer(); 1767 auto pSurface = Surface::CreateSurfaceAsProducer(p); 1768 1769 // test default 1770 sptr<SurfaceBuffer> buffer; 1771 int releaseFence = -1; 1772 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config); 1773 ASSERT_EQ(ret, GSERROR_OK); 1774 ASSERT_NE(buffer, nullptr); 1775 1776 std::vector<uint8_t> values; 1777 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values); 1778 ASSERT_EQ(values.size(), 0); 1779 1780 ret = pSurface->CancelBuffer(buffer); 1781 ASSERT_EQ(ret, GSERROR_OK); 1782 1783 // test true 1784 cSurface->ConsumerRequestCpuAccess(true); 1785 ret = pSurface->RequestBuffer(buffer, releaseFence, config); 1786 ASSERT_EQ(ret, GSERROR_OK); 1787 ASSERT_NE(buffer, nullptr); 1788 1789 values.clear(); 1790 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values); 1791 ASSERT_EQ(values.size(), 0); 1792 1793 ret = pSurface->CancelBuffer(buffer); 1794 ASSERT_EQ(ret, GSERROR_OK); 1795 1796 // test false 1797 cSurface->ConsumerRequestCpuAccess(false); 1798 ret = pSurface->RequestBuffer(buffer, releaseFence, config); 1799 ASSERT_EQ(ret, GSERROR_OK); 1800 ASSERT_NE(buffer, nullptr); 1801 1802 values.clear(); 1803 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values); 1804 ASSERT_EQ(values.size(), 0); 1805 1806 ret = pSurface->CancelBuffer(buffer); 1807 ASSERT_EQ(ret, GSERROR_OK); 1808} 1809 1810/* 1811* Function: ConsumerRequestCpuAccess 1812* Type: Function 1813* Rank: Important(2) 1814* EnvConditions: N/A 1815* CaseDescription: 1. usage contain BUFFER_USAGE_CPU_HW_BOTH 1816* 2. call ConsumerRequestCpuAccess(true) 1817* 3. check ret 1818 */ 1819HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess002, Function | MediumTest | Level2) 1820{ 1821 using namespace HDI::Display::Graphic::Common; 1822 BufferRequestConfig config = { 1823 .width = 0x100, 1824 .height = 0x100, 1825 .strideAlignment = 0x8, 1826 .format = GRAPHIC_PIXEL_FMT_RGBA_8888, 1827 .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH, 1828 .timeout = 0, 1829 }; 1830 auto cSurface = IConsumerSurface::Create(); 1831 sptr<IBufferConsumerListener> cListener = new BufferConsumerListener(); 1832 cSurface->RegisterConsumerListener(cListener); 1833 auto p = cSurface->GetProducer(); 1834 auto pSurface = Surface::CreateSurfaceAsProducer(p); 1835 1836 // test default 1837 sptr<SurfaceBuffer> buffer; 1838 int releaseFence = -1; 1839 GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config); 1840 ASSERT_EQ(ret, GSERROR_OK); 1841 ASSERT_NE(buffer, nullptr); 1842 1843 std::vector<uint8_t> values; 1844 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values); 1845 if (values.size() == 1) { 1846 ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_HW_ONLY); 1847 } 1848 1849 ret = pSurface->CancelBuffer(buffer); 1850 ASSERT_EQ(ret, GSERROR_OK); 1851 1852 // test true 1853 cSurface->ConsumerRequestCpuAccess(true); 1854 ret = pSurface->RequestBuffer(buffer, releaseFence, config); 1855 ASSERT_EQ(ret, GSERROR_OK); 1856 ASSERT_NE(buffer, nullptr); 1857 1858 values.clear(); 1859 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values); 1860 if (values.size() == 1) { 1861 ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_CPU_ACCESS); 1862 } 1863 1864 ret = pSurface->CancelBuffer(buffer); 1865 ASSERT_EQ(ret, GSERROR_OK); 1866 1867 // test false 1868 cSurface->ConsumerRequestCpuAccess(false); 1869 ret = pSurface->RequestBuffer(buffer, releaseFence, config); 1870 ASSERT_EQ(ret, GSERROR_OK); 1871 ASSERT_NE(buffer, nullptr); 1872 1873 values.clear(); 1874 buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values); 1875 if (values.size() == 1) { 1876 ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_HW_ONLY); 1877 } 1878 1879 ret = pSurface->CancelBuffer(buffer); 1880 ASSERT_EQ(ret, GSERROR_OK); 1881} 1882 1883/* 1884* Function: ConsumerRequestCpuAccess 1885* Type: Function 1886* Rank: Important(2) 1887* EnvConditions: N/A 1888* CaseDescription: 1. call ConsumerRequestCpuAccess with nullptr 1889* 2. check ret 1890 */ 1891HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess003, Function | MediumTest | Level2) 1892{ 1893 ASSERT_NE(surface_, nullptr); 1894 surface_->ConsumerRequestCpuAccess(true); 1895} 1896 1897/* 1898* Function: SetTransformHint and GetTransformHint 1899* Type: Function 1900* Rank: Important(1) 1901* EnvConditions: N/A 1902* CaseDescription: 1. call SetTransformHint with nullptr and check ret 1903* 2. call GetTransformHint with nullptr and check ret 1904 */ 1905HWTEST_F(ConsumerSurfaceTest, transformHint001, Function | MediumTest | Level1) 1906{ 1907 GraphicTransformType typeSet = GraphicTransformType::GRAPHIC_ROTATE_BUTT; 1908 GSError ret = surface_->SetTransformHint(typeSet); 1909 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1910 GraphicTransformType typeGet = surface_->GetTransformHint(); 1911 ASSERT_EQ(typeGet, GraphicTransformType::GRAPHIC_ROTATE_BUTT); 1912} 1913 1914/* 1915* Function: SetSurfaceSourceType and GetSurfaceSourceType 1916* Type: Function 1917* Rank: Important(2) 1918* EnvConditions: N/A 1919* CaseDescription: 1. call SetSurfaceSourceType and check ret 1920* 2. call GetSurfaceSourceType and check ret 1921*/ 1922HWTEST_F(ConsumerSurfaceTest, SurfaceSourceType001, Function | MediumTest | Level2) 1923{ 1924 OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO; 1925 GSError ret = cs->SetSurfaceSourceType(sourceType); 1926 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1927 ASSERT_EQ(cs->GetSurfaceSourceType(), OH_SURFACE_SOURCE_VIDEO); 1928} 1929 1930/* 1931* Function: SetSurfaceSourceType and GetSurfaceSourceType 1932* Type: Function 1933* Rank: Important(2) 1934* EnvConditions: N/A 1935* CaseDescription: 1. call SetSurfaceSourceType with nullptr and check ret 1936* 2. call GetSurfaceSourceType with nullptr and check ret 1937*/ 1938HWTEST_F(ConsumerSurfaceTest, SurfaceSourceType002, Function | MediumTest | Level2) 1939{ 1940 OHSurfaceSource sourceTypeSet = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO; 1941 GSError ret = surface_->SetSurfaceSourceType(sourceTypeSet); 1942 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1943 OHSurfaceSource sourceTypeGet = surface_->GetSurfaceSourceType(); 1944 ASSERT_EQ(sourceTypeGet, OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT); 1945} 1946 1947/* 1948* Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType 1949* Type: Function 1950* Rank: Important(2) 1951* EnvConditions: N/A 1952* CaseDescription: 1. call SetSurfaceAppFrameworkType and check ret 1953* 2. call GetSurfaceAppFrameworkType and check ret 1954*/ 1955HWTEST_F(ConsumerSurfaceTest, SurfaceAppFrameworkType001, Function | MediumTest | Level2) 1956{ 1957 std::string type = "test"; 1958 GSError ret = cs->SetSurfaceAppFrameworkType(type); 1959 ASSERT_EQ(ret, OHOS::GSERROR_OK); 1960 ASSERT_EQ(cs->GetSurfaceAppFrameworkType(), "test"); 1961} 1962 1963/* 1964* Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType 1965* Type: Function 1966* Rank: Important(2) 1967* EnvConditions: N/A 1968* CaseDescription: 1. call SetSurfaceAppFrameworkType with nullptr and check ret 1969* 2. call GetSurfaceAppFrameworkType with nullptr and check ret 1970*/ 1971HWTEST_F(ConsumerSurfaceTest, SurfaceAppFrameworkType002, Function | MediumTest | Level2) 1972{ 1973 std::string type = "test"; 1974 GSError ret = surface_->SetSurfaceAppFrameworkType(type); 1975 ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS); 1976 ASSERT_EQ(surface_->GetSurfaceAppFrameworkType(), ""); 1977} 1978 1979/* 1980* Function: GetHdrWhitePointBrightness and GetSdrWhitePointBrightness 1981* Type: Function 1982* Rank: Important(2) 1983* EnvConditions: N/A 1984* CaseDescription: 1. call GetHdrWhitePointBrightness with nullptr and check ret 1985* 2. call GetSdrWhitePointBrightness with nullptr and check ret 1986*/ 1987HWTEST_F(ConsumerSurfaceTest, WhitePointBrightness001, Function | MediumTest | Level2) 1988{ 1989 float ret = surface_->GetHdrWhitePointBrightness(); 1990 ASSERT_EQ(static_cast<int32_t>(ret), 0); 1991 ret = surface_->GetSdrWhitePointBrightness(); 1992 ASSERT_EQ(static_cast<int32_t>(ret), 0); 1993} 1994 1995/* 1996* Function: InvalidParameter 1997* Type: Function 1998* Rank: Important(2) 1999* EnvConditions: N/A 2000* CaseDescription: 1. call interface with invaild input nullptr and check ret 2001*/ 2002HWTEST_F(ConsumerSurfaceTest, InvalidParameter001, Function | MediumTest | Level2) 2003{ 2004 sptr<OHOS::SurfaceBuffer> sBuffer = nullptr; 2005 sptr<OHOS::SyncFence> fence = nullptr; 2006 ASSERT_EQ(surface_->AcquireLastFlushedBuffer(sBuffer, fence, nullptr, 0, false), GSERROR_NOT_SUPPORT); 2007 ASSERT_EQ(surface_->ReleaseLastFlushedBuffer(sBuffer), GSERROR_NOT_SUPPORT); 2008} 2009 2010/* 2011* Function: GetGlobalAlpha 2012* Type: Function 2013* Rank: Important(2) 2014* EnvConditions: N/A 2015* CaseDescription: 1. call GetGlobalAlpha and check ret 2016*/ 2017HWTEST_F(ConsumerSurfaceTest, GetGlobalAlpha001, Function | MediumTest | Level2) 2018{ 2019 int32_t alpha = -1; 2020 ASSERT_EQ(cs->SetGlobalAlpha(alpha), GSERROR_NOT_SUPPORT); 2021 ASSERT_EQ(cs->GetGlobalAlpha(alpha), GSERROR_OK); 2022} 2023} 2024