xref: /foundation/graphic/graphic_surface/surface/test/unittest/consumer_surface_test.cpp

/*
 * Copyright (c) 2021 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include <securec.h>
#include <gtest/gtest.h>
#include <surface.h>
#include <buffer_queue_producer.h>
#include <consumer_surface.h>
#include "buffer_consumer_listener.h"
#include "sync_fence.h"
#include "producer_surface_delegator.h"
#include "buffer_queue_consumer.h"
#include "buffer_queue.h"
#include "v1_1/buffer_handle_meta_key_type.h"

using namespace testing;
using namespace testing::ext;

namespace OHOS::Rosen {
class ConsumerSurfaceTest : public testing::Test {
public:
    static void SetUpTestCase();
    static void TearDownTestCase();
    void SetUp() override;
    void TearDown() override;

    static inline BufferRequestConfig requestConfig = {
        .width = 0x100,
        .height = 0x100,
        .strideAlignment = 0x8,
        .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
        .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
        .timeout = 0,
    };
    static inline BufferFlushConfig flushConfig = {
        .damage = {
            .w = 0x100,
            .h = 0x100,
        },
    };
    static inline BufferFlushConfigWithDamages flushConfigWithDamages = {
        .damages = {
            { .x = 0x100, .y = 0x100, .w = 0x100, .h = 0x100, },
            { .x = 0x200, .y = 0x200, .w = 0x200, .h = 0x200, },
        },
        .timestamp = 0x300,
    };
    static inline int64_t timestamp = 0;
    static inline Rect damage = {};
    static inline std::vector<Rect> damages = {};
    static inline sptr<IConsumerSurface> cs = nullptr;
    static inline sptr<Surface> ps = nullptr;
    static inline sptr<BufferQueue> bq = nullptr;
    static inline sptr<ProducerSurfaceDelegator> surfaceDelegator = nullptr;
    static inline sptr<BufferQueueConsumer> consumer_ = nullptr;
    static inline uint32_t firstSeqnum = 0;
    sptr<ConsumerSurface> surface_ = nullptr;
};

void ConsumerSurfaceTest::SetUpTestCase()
{
    cs = IConsumerSurface::Create();
    sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
    cs->RegisterConsumerListener(listener);
    auto p = cs->GetProducer();
    bq = new BufferQueue("test");
    ps = Surface::CreateSurfaceAsProducer(p);
    surfaceDelegator = ProducerSurfaceDelegator::Create();
}

void ConsumerSurfaceTest::TearDownTestCase()
{
    cs = nullptr;
}

void ConsumerSurfaceTest::SetUp()
{
    surface_ = new ConsumerSurface("test", false);
    ASSERT_NE(surface_, nullptr);
    ASSERT_EQ(surface_->producer_, nullptr);
    ASSERT_EQ(surface_->consumer_, nullptr);
}

void ConsumerSurfaceTest::TearDown()
{
    surface_ = nullptr;
}

class TestConsumerListenerClazz : public IBufferConsumerListenerClazz {
public:
    void OnBufferAvailable() override
    {
    }
};

/*
* Function: GetProducer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. get ConsumerSurface and GetProducer
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ConsumerSurface001, Function | MediumTest | Level2)
{
    ASSERT_NE(cs, nullptr);

    sptr<ConsumerSurface> qs = static_cast<ConsumerSurface*>(cs.GetRefPtr());
    ASSERT_NE(qs, nullptr);
    ASSERT_NE(qs->GetProducer(), nullptr);
}

/*
* Function: ConsumerSurface dtor
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. new ConsumerSurface, only one nullptr for consumer_ and producer_
*                  2. dtor and check ret
 */
HWTEST_F(ConsumerSurfaceTest, ConsumerSurfaceDtor001, Function | MediumTest | Level2)
{
    sptr<BufferQueue> queue = new BufferQueue("test", false);
    surface_->producer_ = new BufferQueueProducer(queue);
    ASSERT_NE(surface_->producer_, nullptr);
    ASSERT_EQ(surface_->consumer_, nullptr);
}

/*
* Function: ConsumerSurface dtor
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. new ConsumerSurface, only one nullptr for consumer_ and producer_
*                  2. dtor and check ret
 */
HWTEST_F(ConsumerSurfaceTest, ConsumerSurfaceDtor002, Function | MediumTest | Level2)
{
    sptr<BufferQueue> queue = new BufferQueue("test", false);
    surface_->consumer_ = new BufferQueueConsumer(queue);
    ASSERT_NE(surface_->consumer_, nullptr);
}

/*
* Function: SetQueueSize and GetQueueSize
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call GetQueueSize and get default value
*                  2. call SetQueueSize
*                  3. call SetQueueSize again with abnormal value
*                  4. call GetQueueSize for BufferQueueProducer and BufferQueue
*                  5. check ret
 */
HWTEST_F(ConsumerSurfaceTest, QueueSize001, Function | MediumTest | Level2)
{
    ASSERT_EQ(cs->GetQueueSize(), (uint32_t)SURFACE_DEFAULT_QUEUE_SIZE);
    GSError ret = cs->SetQueueSize(2);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    ret = cs->SetQueueSize(SURFACE_MAX_QUEUE_SIZE + 1);
    ASSERT_NE(ret, OHOS::GSERROR_OK);

    ASSERT_EQ(cs->GetQueueSize(), 2u);
}

/*
* Function: SetQueueSize and GetQueueSize
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call GetQueueSize
*                  2. call SetQueueSize 2 times
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, QueueSize002, Function | MediumTest | Level2)
{
    sptr<ConsumerSurface> qs = static_cast<ConsumerSurface*>(cs.GetRefPtr());
    sptr<BufferQueueProducer> bqp = static_cast<BufferQueueProducer*>(qs->GetProducer().GetRefPtr());
    ASSERT_EQ(bqp->GetQueueSize(), 2u);

    GSError ret = cs->SetQueueSize(1);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    ret = cs->SetQueueSize(2);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: SetQueueSize and GetQueueSize
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call GetQueueSize with producer_ is nullptr
*                  2. call SetQueueSize with producer_ is nullptr
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, QueueSize003, Function | MediumTest | Level2)
{
    uint32_t size = surface_->GetQueueSize();
    ASSERT_EQ(size, 0);
    GSError ret = surface_->SetQueueSize(1);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: SetDefaultWidthAndHeight, GetDefaultWidth and GetDefaultHeight
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetDefaultWidthAndHeight with consumer_ is nullptr
*                  2. call GetDefaultWidth with producer_ is nullptr
*                  3. call GetDefaultHeight with producer_ is nullptr
*                  4. check ret
 */
HWTEST_F(ConsumerSurfaceTest, DefaultWidthAndHeight001, Function | MediumTest | Level2)
{
    int32_t width = 0;
    int32_t height = 0;
    GSError ret = surface_->SetDefaultWidthAndHeight(width, height);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    width = surface_->GetDefaultWidth();
    ASSERT_EQ(width, -1);
    height = surface_->GetDefaultHeight();
    ASSERT_EQ(height, -1);
}

/*
* Function: SetDefaultWidthAndHeight, GetDefaultWidth and GetDefaultHeight
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetDefaultWidthAndHeight with noraml value
*                  2. call GetDefaultWidth
*                  3. call GetDefaultHeight
*                  4. check ret
 */
HWTEST_F(ConsumerSurfaceTest, DefaultWidthAndHeight002, Function | MediumTest | Level2)
{
    ASSERT_NE(cs, nullptr);
    int32_t width = 100;  // 100 test value for width
    int32_t height = 100;  // 100 test value for height
    GSError ret = cs->SetDefaultWidthAndHeight(width, height);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    int32_t value = cs->GetDefaultWidth();
    ASSERT_EQ(value, width);
    value = cs->GetDefaultHeight();
    ASSERT_EQ(value, height);
}

/*
* Function: SetDefaultUsage and GetDefaultUsage
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetDefaultUsage with consumer_ is nullptr
*                  2. call GetDefaultUsage with producer_ is nullptr
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, DefaultUsage001, Function | MediumTest | Level2)
{
    GSError ret = surface_->SetDefaultUsage(0);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    uint64_t value = surface_->GetDefaultUsage();
    ASSERT_EQ(value, 0);
}

/*
* Function: SetDefaultUsage and GetDefaultUsage
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call GetDefaultUsage with normal
*                  2. call SetDefaultUsage with normal
*                  3. call GetDefaultUsage agagin
*                  4. check ret
 */
HWTEST_F(ConsumerSurfaceTest, DefaultUsage002, Function | MediumTest | Level2)
{
    ASSERT_NE(cs, nullptr);
    int32_t usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA;
    uint32_t value = cs->GetDefaultUsage();
    ASSERT_EQ(value, 0);
    GSError ret = cs->SetDefaultUsage(usage);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    value = cs->GetDefaultUsage();
    ASSERT_EQ(value, usage);
}

/*
* Function: AcquireBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call AcquireBuffer with consumer_ is nullptr
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, AcquireBuffer001, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
    sptr<OHOS::SyncFence> fence;
    GSError ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: AcquireBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call AcquireBuffer with nullptr params
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, AcquireBuffer002, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer = nullptr;
    sptr<OHOS::SyncFence> fence;
    GSError ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    buffer = SurfaceBuffer::Create();
    fence = nullptr;
    ret = surface_->AcquireBuffer(buffer, fence, timestamp, damage);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: ReleaseBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call ReleaseBuffer with consumer_ is nullptr
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ReleaseBuffer001, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
    sptr<OHOS::SyncFence> fence;
    GSError ret = surface_->ReleaseBuffer(buffer, fence);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: ReleaseBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call ReleaseBuffer with nullptr params
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ReleaseBuffer002, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer = nullptr;
    sptr<OHOS::SyncFence> fence;
    GSError ret = surface_->ReleaseBuffer(buffer, fence);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: DetachBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call DetachBuffer with consumer_ is nullptr
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, DetachBuffer001, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer;
    GSError ret = surface_->DetachBuffer(buffer);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: DetachBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call DetachBuffer with nullptr params
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, DetachBuffer002, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer = nullptr;
    GSError ret = surface_->DetachBuffer(buffer);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: QueryIfBufferAvailable
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call QueryIfBufferAvailable with consumer_ is nullptr
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, QueryIfBufferAvailable001, Function | MediumTest | Level2)
{
    bool ret = surface_->QueryIfBufferAvailable();
    ASSERT_EQ(ret, false);
}

/*
* Function: QueryIfBufferAvailable
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call QueryIfBufferAvailable with normal
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, QueryIfBufferAvailable002, Function | MediumTest | Level2)
{
    ASSERT_NE(cs, nullptr);
    bool ret = cs->QueryIfBufferAvailable();
    ASSERT_EQ(ret, true);
}

/*
* Function: RequestBuffer and FlushBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RequestBuffer by cs and ps
*                  2. call FlushBuffer both
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel001, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer;
    int releaseFence = -1;

    GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);
    firstSeqnum = buffer->GetSeqNum();

    ret = ps->FlushBuffer(buffer, -1, flushConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ret = ps->FlushBuffer(buffer, -1, flushConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: AcquireBuffer and ReleaseBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call AcquireBuffer
*                  2. call ReleaseBuffer
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel002, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer;
    int32_t flushFence;

    GSError ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    ret = cs->ReleaseBuffer(buffer, -1);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: AcquireBuffer and ReleaseBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call AcquireBuffer
*                  2. call ReleaseBuffer 2 times
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel003, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer;
    int32_t flushFence;

    GSError ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    ret = cs->ReleaseBuffer(buffer, -1);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    ret = cs->ReleaseBuffer(buffer, -1);
    ASSERT_NE(ret, OHOS::GSERROR_OK);
}

/*
* Function: RequestBuffer and CancelBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RequestBuffer by cs and ps
*                  2. call CancelBuffer both
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel004, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer;
    int releaseFence = -1;

    GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    ret = ps->CancelBuffer(buffer);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: SetUserData
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetUserData many times
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, UserData001, Function | MediumTest | Level2)
{
    GSError ret;

    std::string strs[SURFACE_MAX_USER_DATA_COUNT];
    constexpr int32_t stringLengthMax = 32;
    char str[stringLengthMax] = {};
    for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) {
        auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%d", i);
        ASSERT_GT(secRet, 0);

        strs[i] = str;
        ret = cs->SetUserData(strs[i], "magic");
        ASSERT_EQ(ret, OHOS::GSERROR_OK);
    }

    ret = cs->SetUserData("-1", "error");
    ASSERT_NE(ret, OHOS::GSERROR_OK);

    std::string retStr;
    for (int i = 0; i < SURFACE_MAX_USER_DATA_COUNT; i++) {
        retStr = cs->GetUserData(strs[i]);
        ASSERT_EQ(retStr, "magic");
    }
}

/*
* Function: UserDataChangeListen
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. RegisterUserDataChangeListen
*                  2. SetUserData
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, UserDataChangeListen001, Function | MediumTest | Level2)
{
    sptr<IConsumerSurface> csTestUserData = IConsumerSurface::Create();
    GSError ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
    GSError ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
    auto func1 = [&ret1](const std::string& key, const std::string& value) {
        ret1 = OHOS::GSERROR_OK;
    };
    auto func2 = [&ret2](const std::string& key, const std::string& value) {
        ret2 = OHOS::GSERROR_OK;
    };
    csTestUserData->RegisterUserDataChangeListener("func1", func1);
    csTestUserData->RegisterUserDataChangeListener("func2", func2);
    csTestUserData->RegisterUserDataChangeListener("func3", nullptr);
    ASSERT_EQ(csTestUserData->RegisterUserDataChangeListener("func2", func2), OHOS::GSERROR_INVALID_ARGUMENTS);

    if (csTestUserData->SetUserData("Regist", "OK") == OHOS::GSERROR_OK) {
        ASSERT_EQ(ret1, OHOS::GSERROR_OK);
        ASSERT_EQ(ret2, OHOS::GSERROR_OK);
    }

    ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
    ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
    csTestUserData->UnRegisterUserDataChangeListener("func1");
    ASSERT_EQ(csTestUserData->UnRegisterUserDataChangeListener("func1"), OHOS::GSERROR_INVALID_ARGUMENTS);

    if (csTestUserData->SetUserData("UnRegist", "INVALID") == OHOS::GSERROR_OK) {
        ASSERT_EQ(ret1, OHOS::GSERROR_INVALID_ARGUMENTS);
        ASSERT_EQ(ret2, OHOS::GSERROR_OK);
    }

    ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
    ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
    csTestUserData->ClearUserDataChangeListener();
    csTestUserData->RegisterUserDataChangeListener("func1", func1);
    if (csTestUserData->SetUserData("Clear", "OK") == OHOS::GSERROR_OK) {
        ASSERT_EQ(ret1, OHOS::GSERROR_OK);
        ASSERT_EQ(ret2, OHOS::GSERROR_INVALID_ARGUMENTS);
    }
}

/*
* Function: UserDataChangeListen
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. RegisterUserDataChangeListen
*                  2. SetUserData
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, UserDataChangeListen002, Function | MediumTest | Level2)
{
    sptr<IConsumerSurface> csTestUserData = IConsumerSurface::Create();

    auto func = [&csTestUserData](const std::string& FuncName) {
        constexpr int32_t RegisterListenerNum = 1000;
        std::vector<GSError> ret(RegisterListenerNum, OHOS::GSERROR_INVALID_ARGUMENTS);
        std::string strs[RegisterListenerNum];
        constexpr int32_t stringLengthMax = 32;
        char str[stringLengthMax] = {};
        for (int i = 0; i < RegisterListenerNum; i++) {
            auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%s%d", FuncName.c_str(), i);
            ASSERT_GT(secRet, 0);
            strs[i] = str;
            ASSERT_EQ(csTestUserData->RegisterUserDataChangeListener(strs[i], [i, &ret]
            (const std::string& key, const std::string& value) {
                ret[i] = OHOS::GSERROR_OK;
            }), OHOS::GSERROR_OK);
        }

        if (csTestUserData->SetUserData("Regist", FuncName) == OHOS::GSERROR_OK) {
            for (int i = 0; i < RegisterListenerNum; i++) {
                ASSERT_EQ(ret[i], OHOS::GSERROR_OK);
            }
        }

        for (int i = 0; i < RegisterListenerNum; i++) {
            csTestUserData->UnRegisterUserDataChangeListener(strs[i]);
        }
    };

    std::thread t1(func, "thread1");
    std::thread t2(func, "thread2");
    t1.join();
    t2.join();
}

/*
* Function: SetUserData
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetUserData many times
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener001, Function | MediumTest | Level2)
{
    class TestConsumerListener : public IBufferConsumerListener {
    public:
        void OnBufferAvailable() override
        {
            sptr<SurfaceBuffer> buffer;
            int32_t flushFence;

            cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
            int32_t *p = (int32_t*)buffer->GetVirAddr();
            if (p != nullptr) {
                for (int32_t i = 0; i < 128; i++) {
                    ASSERT_EQ(p[i], i);
                }
            }

            cs->ReleaseBuffer(buffer, -1);
        }
    };

    sptr<IBufferConsumerListener> listener = new TestConsumerListener();
    GSError ret = cs->RegisterConsumerListener(listener);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    sptr<SurfaceBuffer> buffer;
    int releaseFence = -1;
    ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    int32_t *p = (int32_t*)buffer->GetVirAddr();
    if (p != nullptr) {
        for (int32_t i = 0; i < 128; i++) {
            p[i] = i;
        }
    }

    GraphicTransformType tranformType = ps->GetTransform();
    ret = ps->FlushBuffer(buffer, -1, flushConfig);
    ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_180), OHOS::GSERROR_OK);
    GraphicTransformType bufferTranformType = GraphicTransformType::GRAPHIC_ROTATE_NONE;
    ASSERT_EQ(cs->GetSurfaceBufferTransformType(nullptr, &bufferTranformType), OHOS::SURFACE_ERROR_INVALID_PARAM);
    ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, nullptr), OHOS::SURFACE_ERROR_INVALID_PARAM);
    ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, &bufferTranformType), OHOS::GSERROR_OK);
    ASSERT_EQ(bufferTranformType, tranformType);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    listener->OnTunnelHandleChange();
    listener->OnGoBackground();
    listener->OnCleanCache();
    listener->OnTransformChange();
    TestConsumerListenerClazz* listenerClazz = new TestConsumerListenerClazz();
    listenerClazz->OnTunnelHandleChange();
    listenerClazz->OnGoBackground();
    listenerClazz->OnCleanCache();
    listenerClazz->OnTransformChange();
    delete listenerClazz;
}

/*
* Function: RegisterConsumerListener, RequestBuffer and FlushBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterConsumerListener
*                  2. call RequestBuffer
*                  3. call FlushBuffer
*                  4. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener002, Function | MediumTest | Level2)
{
    sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
    GSError ret = cs->RegisterConsumerListener(listener);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    sptr<SurfaceBuffer> buffer;
    int releaseFence = -1;
    ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    int32_t *p = (int32_t*)buffer->GetVirAddr();
    if (p != nullptr) {
        for (int32_t i = 0; i < requestConfig.width * requestConfig.height; i++) {
            p[i] = i;
        }
    }
    ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_90), OHOS::GSERROR_OK);
    ret = ps->FlushBuffer(buffer, -1, flushConfig);
    GraphicTransformType bufferTranformType = GraphicTransformType::GRAPHIC_ROTATE_NONE;
    ASSERT_EQ(cs->GetSurfaceBufferTransformType(buffer, &bufferTranformType), OHOS::GSERROR_OK);
    ASSERT_EQ(bufferTranformType, GraphicTransformType::GRAPHIC_ROTATE_90);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(ps->SetTransform(GraphicTransformType::GRAPHIC_ROTATE_NONE), OHOS::GSERROR_OK);
    sptr<OHOS::SyncFence> flushFence;
    ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damage);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);
    bool isInCache = false;
    ASSERT_EQ(cs->IsSurfaceBufferInCache(buffer->GetSeqNum(), isInCache), OHOS::GSERROR_OK);
    ASSERT_EQ(isInCache, true);
    ASSERT_EQ(cs->IsSurfaceBufferInCache(0xFFFFFFFF, isInCache), OHOS::GSERROR_OK);
    ASSERT_EQ(isInCache, false);
}

/*
* Function: RegisterConsumerListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterConsumerListener with nullptr params
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener003, Function | MediumTest | Level2)
{
    GSError ret = surface_->RegisterConsumerListener(nullptr);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
    ret = surface_->RegisterConsumerListener(listener);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: RegisterConsumerListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterConsumerListener with nullptr params
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterConsumerListener004, Function | MediumTest | Level2)
{
    GSError ret = surface_->RegisterConsumerListener(nullptr);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    TestConsumerListenerClazz* listenerClazz = new TestConsumerListenerClazz();
    ret = surface_->RegisterConsumerListener(listenerClazz);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    delete listenerClazz;
}

/*
* Function: RegisterReleaseListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterReleaseListener with nullptr param
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener001, Function | MediumTest | Level2)
{
    OnReleaseFunc onBufferRelease = nullptr;
    GSError ret = surface_->RegisterReleaseListener(onBufferRelease);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: RegisterReleaseListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterReleaseListener with consumer_ is normal
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener002, Function | MediumTest | Level2)
{
    sptr<BufferQueue> queue = new BufferQueue("test", false);
    surface_->consumer_ = new BufferQueueConsumer(queue);
    ASSERT_NE(surface_->consumer_, nullptr);
    OnReleaseFunc onBufferRelease = nullptr;
    GSError ret = surface_->RegisterReleaseListener(onBufferRelease);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: RegisterReleaseListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterReleaseListener
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterReleaseListener003, Function | MediumTest | Level2)
{
    OnReleaseFuncWithFence func = nullptr;
    GSError ret = surface_->RegisterReleaseListener(func);
    ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
}

/*
* Function: UnRegisterReleaseListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call UnRegisterReleaseListener
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, UnRegisterReleaseListener001, Function | MediumTest | Level2)
{
    GSError ret = surface_->UnRegisterReleaseListener();
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: RegisterDeleteBufferListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is nullptr
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener001, Function | MediumTest | Level2)
{
    OnDeleteBufferFunc func = nullptr;
    GSError ret = surface_->RegisterDeleteBufferListener(func, false);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: RegisterDeleteBufferListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterDeleteBufferListener with consumer_ is normal
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterDeleteBufferListener002, Function | MediumTest | Level2)
{
    sptr<BufferQueue> queue = new BufferQueue("test", false);
    surface_->consumer_ = new BufferQueueConsumer(queue);
    ASSERT_NE(surface_->consumer_, nullptr);
    OnDeleteBufferFunc func = nullptr;
    GSError ret = surface_->RegisterDeleteBufferListener(func, false);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    ret = surface_->RegisterDeleteBufferListener(func, true);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: UnregisterConsumerListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call UnregisterConsumerListener with consumer_ is nullptr
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, UnregisterConsumerListener001, Function | MediumTest | Level2)
{
    GSError ret = surface_->UnregisterConsumerListener();
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: UnregisterConsumerListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call UnregisterConsumerListener with consumer_ is normal
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, UnregisterConsumerListener002, Function | MediumTest | Level2)
{
    sptr<BufferQueue> queue = new BufferQueue("test", false);
    surface_->consumer_ = new BufferQueueConsumer(queue);
    ASSERT_NE(surface_->consumer_, nullptr);
    GSError ret = surface_->UnregisterConsumerListener();
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: RegisterUserDataChangeListener
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterUserDataChangeListener with nullptr param
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterUserDataChangeListener001, Function | MediumTest | Level2)
{
    GSError ret = surface_->RegisterUserDataChangeListener("test", nullptr);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: GoBackground
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call GoBackground with consumer_ is nullptr
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, GoBackground001, Function | MediumTest | Level2)
{
    GSError ret = surface_->GoBackground();
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: GoBackground
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call GoBackground with consumer_ is normal
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, GoBackground002, Function | MediumTest | Level2)
{
    sptr<BufferQueue> queue = new BufferQueue("test", false);
    surface_->consumer_ = new BufferQueueConsumer(queue);
    ASSERT_NE(surface_->consumer_, nullptr);
    GSError ret = surface_->GoBackground();
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    surface_->producer_ = new BufferQueueProducer(queue);
    ASSERT_NE(surface_->producer_, nullptr);
    ret = surface_->GoBackground();
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: GetUniqueId
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call GetUniqueId with producer_ is nullptr
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, GetUniqueId001, Function | MediumTest | Level2)
{
    uint64_t ret = surface_->GetUniqueId();
    ASSERT_EQ(ret, 0);
}

/*
* Function: Dump
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call Dump
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, Dump001, Function | MediumTest | Level2)
{
    std::string result;
    surface_->Dump(result);
    sptr<BufferQueue> queue = new BufferQueue("test", false);
    surface_->consumer_ = new BufferQueueConsumer(queue);
    ASSERT_NE(surface_->consumer_, nullptr);
    surface_->Dump(result);
}

/*
* Function: SetTransform and GetTransform
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call GetTransform by default
 */
HWTEST_F(ConsumerSurfaceTest, transform001, Function | MediumTest | Level2)
{
    ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_NONE);
}

/*
* Function: SetTransform and GetTransform
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, transform002, Function | MediumTest | Level1)
{
    GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_90;
    GSError ret = ps->SetTransform(transform);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_90);
}

/*
* Function: SetTransform and GetTransform
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, transform003, Function | MediumTest | Level1)
{
    GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_180;
    GSError ret = ps->SetTransform(transform);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_180);
}

/*
* Function: SetTransform and GetTransform
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, transform004, Function | MediumTest | Level1)
{
    GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_270;
    GSError ret = ps->SetTransform(transform);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_270);
}

/*
* Function: SetTransform and GetTransform
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetTransform with different paramaters and call GetTransform
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, transform005, Function | MediumTest | Level1)
{
    GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_NONE;
    GSError ret = ps->SetTransform(transform);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(cs->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_NONE);
}

/*
* Function: SetTransform and GetTransform
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetTransform GetTransform with nullptr
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, transform006, Function | MediumTest | Level1)
{
    GraphicTransformType transform = GraphicTransformType::GRAPHIC_ROTATE_NONE;
    GSError ret = surface_->SetTransform(transform);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    ASSERT_EQ(surface_->GetTransform(), GraphicTransformType::GRAPHIC_ROTATE_BUTT);
}

/*
* Function: SetScalingMode and GetScalingMode
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret
 */
HWTEST_F(ConsumerSurfaceTest, scalingMode001, Function | MediumTest | Level2)
{
    ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
    GSError ret = cs->SetScalingMode(-1, scalingMode);
    ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
    ret = cs->GetScalingMode(-1, scalingMode);
    ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
}

/*
* Function: SetScalingMode and GetScalingMode
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetScalingMode with normal parameters and check ret
*                  2. call GetScalingMode and check ret
 */
HWTEST_F(ConsumerSurfaceTest, scalingMode002, Function | MediumTest | Level1)
{
    ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
    sptr<SurfaceBuffer> buffer;
    int releaseFence = -1;
    GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    uint32_t sequence = buffer->GetSeqNum();
    ret = cs->SetScalingMode(sequence, scalingMode);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    ScalingMode scalingModeGet = ScalingMode::SCALING_MODE_FREEZE;
    ret = cs->GetScalingMode(sequence, scalingModeGet);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(scalingMode, scalingModeGet);

    ret = ps->CancelBuffer(buffer);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: SetScalingMode003
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetScalingMode with abnormal parameters and check ret
 */
HWTEST_F(ConsumerSurfaceTest, scalingMode003, Function | MediumTest | Level2)
{
    ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
    GSError ret = cs->SetScalingMode(scalingMode);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: SetScalingMode and GetScalingMode
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetScalingMode with nullptr and check ret
*                  2. call GetScalingMode with nullptr and check ret
 */
HWTEST_F(ConsumerSurfaceTest, scalingMode004, Function | MediumTest | Level1)
{
    ScalingMode scalingMode = ScalingMode::SCALING_MODE_SCALE_TO_WINDOW;
    GSError ret = surface_->SetScalingMode(firstSeqnum, scalingMode);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    ret = surface_->SetScalingMode(scalingMode);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    ret = surface_->GetScalingMode(firstSeqnum, scalingMode);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: QueryMetaDataType
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call QueryMetaDataType and check ret
 */
HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType001, Function | MediumTest | Level1)
{
    HDRMetaDataType type = HDRMetaDataType::HDR_META_DATA;
    GSError ret = cs->QueryMetaDataType(firstSeqnum, type);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(type, HDRMetaDataType::HDR_NOT_USED);
}

/*
* Function: QueryMetaDataType
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetMetaData with normal parameters and check ret
*                  2. call QueryMetaDataType and check ret
 */
HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType002, Function | MediumTest | Level1)
{
    std::vector<GraphicHDRMetaData> metaData;
    GraphicHDRMetaData data = {
        .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
        .value = 1,
    };
    metaData.push_back(data);
    GSError ret = cs->SetMetaData(firstSeqnum, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    HDRMetaDataType type = HDRMetaDataType::HDR_NOT_USED;
    ret = cs->QueryMetaDataType(firstSeqnum, type);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(type, HDRMetaDataType::HDR_META_DATA);
}

/*
* Function: QueryMetaDataType
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
*                  2. call QueryMetaDataType and check ret
 */
HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType003, Function | MediumTest | Level1)
{
    GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
    std::vector<uint8_t> metaData;
    uint8_t data = 1;
    metaData.push_back(data);
    GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    HDRMetaDataType type = HDRMetaDataType::HDR_NOT_USED;
    ret = cs->QueryMetaDataType(firstSeqnum, type);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(type, HDRMetaDataType::HDR_META_DATA_SET);
}

/*
* Function: QueryMetaDataType
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call QueryMetaDataType with nullptr and check ret
 */
HWTEST_F(ConsumerSurfaceTest, QueryMetaDataType004, Function | MediumTest | Level1)
{
    HDRMetaDataType type = HDRMetaDataType::HDR_META_DATA;
    GSError ret = surface_->QueryMetaDataType(firstSeqnum, type);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: SetMetaData and GetMetaData
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetMetaData with abnormal parameters and check ret
 */
HWTEST_F(ConsumerSurfaceTest, metaData001, Function | MediumTest | Level2)
{
    std::vector<GraphicHDRMetaData> metaData;
    GSError ret = cs->SetMetaData(firstSeqnum, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: SetMetaData and GetMetaData
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetMetaData with normal parameters and check ret
 */
HWTEST_F(ConsumerSurfaceTest, metaData002, Function | MediumTest | Level1)
{
    std::vector<GraphicHDRMetaData> metaData;
    GraphicHDRMetaData data = {
        .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
        .value = 100,  // for test
    };
    metaData.push_back(data);
    GSError ret = cs->SetMetaData(firstSeqnum, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: SetMetaData and GetMetaData
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetMetaData with normal parameters and check ret
*                  2. call GetMetaData and check ret
 */
HWTEST_F(ConsumerSurfaceTest, metaData003, Function | MediumTest | Level1)
{
    std::vector<GraphicHDRMetaData> metaData;
    GraphicHDRMetaData data = {
        .key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X,
        .value = 100,  // for test
    };
    metaData.push_back(data);

    sptr<SurfaceBuffer> buffer;
    int releaseFence = -1;
    GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    uint32_t sequence = buffer->GetSeqNum();
    ret = cs->SetMetaData(sequence, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    std::vector<GraphicHDRMetaData> metaDataGet;
    ret = cs->GetMetaData(sequence, metaDataGet);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(metaData[0].key, metaDataGet[0].key);
    ASSERT_EQ(metaData[0].value, metaDataGet[0].value);

    ret = cs->GetMetaData(sequence + 1, metaDataGet);
    ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);

    ret = ps->CancelBuffer(buffer);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: SetMetaData and GetMetaData
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetMetaData and GetMetaData with nullptr and check ret
 */
HWTEST_F(ConsumerSurfaceTest, metaData004, Function | MediumTest | Level2)
{
    std::vector<GraphicHDRMetaData> metaData;
    GSError ret = surface_->SetMetaData(firstSeqnum, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    ret = surface_->GetMetaData(firstSeqnum, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: SetMetaDataSet and GetMetaDataSet
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetMetaDataSet with abnormal parameters and check ret
 */
HWTEST_F(ConsumerSurfaceTest, metaDataSet001, Function | MediumTest | Level2)
{
    GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
    std::vector<uint8_t> metaData;
    GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: SetMetaDataSet and GetMetaDataSet
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
 */
HWTEST_F(ConsumerSurfaceTest, metaDataSet002, Function | MediumTest | Level1)
{
    GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
    std::vector<uint8_t> metaData;
    uint8_t data = 10;  // for test
    metaData.push_back(data);
    GSError ret = cs->SetMetaDataSet(firstSeqnum, key, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: SetMetaDataSet and GetMetaDataSet
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetMetaDataSet with normal parameters and check ret
*                  2. call GetMetaDataSet and check ret
 */
HWTEST_F(ConsumerSurfaceTest, metaDataSet003, Function | MediumTest | Level1)
{
    GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
    std::vector<uint8_t> metaData;
    uint8_t data = 10;  // for test
    metaData.push_back(data);

    sptr<SurfaceBuffer> buffer;
    int releaseFence = -1;
    GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    uint32_t sequence = buffer->GetSeqNum();
    ret = cs->SetMetaDataSet(sequence, key, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    GraphicHDRMetadataKey keyGet = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_RED_PRIMARY_X;
    std::vector<uint8_t> metaDataGet;
    ret = cs->GetMetaDataSet(sequence, keyGet, metaDataGet);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(key, keyGet);
    ASSERT_EQ(metaData[0], metaDataGet[0]);

    ret = cs->GetMetaDataSet(sequence + 1, keyGet, metaDataGet);
    ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);

    ret = ps->CancelBuffer(buffer);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: SetMetaDataSet and GetMetaDataSet
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetMetaDataSet and GetMetaDataSet with nullptr and check ret
 */
HWTEST_F(ConsumerSurfaceTest, metaDataSet004, Function | MediumTest | Level2)
{
    GraphicHDRMetadataKey key = GraphicHDRMetadataKey::GRAPHIC_MATAKEY_HDR10_PLUS;
    std::vector<uint8_t> metaData;
    GSError ret = surface_->SetMetaDataSet(firstSeqnum, key, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    ret = surface_->GetMetaDataSet(firstSeqnum, key, metaData);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: SetTunnelHandle and GetTunnelHandle
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetTunnelHandle with abnormal parameters and check ret
 */
HWTEST_F(ConsumerSurfaceTest, TunnelHandle001, Function | MediumTest | Level2)
{
    GraphicExtDataHandle *handle = nullptr;
    GSError ret = cs->SetTunnelHandle(handle);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: SetTunnelHandle and GetTunnelHandle
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetTunnelHandle with abnormal parameters and check ret
 */
HWTEST_F(ConsumerSurfaceTest, TunnelHandle002, Function | MediumTest | Level2)
{
    GraphicExtDataHandle *handle = nullptr;
    handle = new GraphicExtDataHandle();
    handle->fd = -1;
    handle->reserveInts = 0;
    GSError ret = cs->SetTunnelHandle(handle);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: SetTunnelHandle and GetTunnelHandle
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetTunnelHandle with normal parameters and check ret
*                  2. call GetTunnelHandle and check ret
* @tc.require: issueI5GMZN issueI5IWHW
 */
HWTEST_F(ConsumerSurfaceTest, TunnelHandle003, Function | MediumTest | Level1)
{
    GraphicExtDataHandle *handle = static_cast<GraphicExtDataHandle *>(
        malloc(sizeof(GraphicExtDataHandle) + sizeof(int32_t)));
    handle->fd = -1;
    handle->reserveInts = 1;
    handle->reserve[0] = 0;
    GSError ret = cs->SetTunnelHandle(handle);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    ret = cs->SetTunnelHandle(handle);
    ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);

    sptr<SurfaceTunnelHandle> handleGet = nullptr;
    handleGet = cs->GetTunnelHandle();
    ASSERT_NE(handleGet, nullptr);
    ASSERT_EQ(handle->fd, handleGet->GetHandle()->fd);
    ASSERT_EQ(handle->reserveInts, handleGet->GetHandle()->reserveInts);
    ASSERT_EQ(handle->reserve[0], handleGet->GetHandle()->reserve[0]);
    free(handle);
}

/*
* Function: SetTunnelHandle and GetTunnelHandle
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetTunnelHandle and GetTunnelHandle with nullptr and check ret
 */
HWTEST_F(ConsumerSurfaceTest, TunnelHandle004, Function | MediumTest | Level2)
{
    GraphicExtDataHandle *handle = nullptr;
    GSError ret = surface_->SetTunnelHandle(handle);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    sptr<SurfaceTunnelHandle> tunnelHandle = surface_->GetTunnelHandle();
    ASSERT_EQ(tunnelHandle, nullptr);
}

/*
* Function: SetPresentTimestamp and GetPresentTimestamp
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetPresentTimestamp with abnormal parameters and check ret
* @tc.require: issueI5I57K
 */
HWTEST_F(ConsumerSurfaceTest, presentTimestamp002, Function | MediumTest | Level2)
{
    GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_UNSUPPORTED, 0};
    GSError ret = cs->SetPresentTimestamp(-1, timestamp);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: SetPresentTimestamp and GetPresentTimestamp
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetPresentTimestamp with abnormal parameters and check ret
* @tc.require: issueI5I57K
 */
HWTEST_F(ConsumerSurfaceTest, presentTimestamp003, Function | MediumTest | Level2)
{
    GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_DELAY, 0};
    GSError ret = cs->SetPresentTimestamp(-1, timestamp);
    ASSERT_EQ(ret, OHOS::GSERROR_NO_ENTRY);
}

/*
* Function: SetPresentTimestamp and GetPresentTimestamp
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret
* @tc.require: issueI5I57K
 */
HWTEST_F(ConsumerSurfaceTest, presentTimestamp004, Function | MediumTest | Level1)
{
    GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_DELAY, 0};
    GSError ret = cs->SetPresentTimestamp(firstSeqnum, timestamp);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: SetPresentTimestamp and GetPresentTimestamp
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetPresentTimestamp with normal parameters and check ret
* @tc.require: issueI5I57K
 */
HWTEST_F(ConsumerSurfaceTest, presentTimestamp005, Function | MediumTest | Level1)
{
    GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_TIMESTAMP, 0};
    GSError ret = cs->SetPresentTimestamp(firstSeqnum, timestamp);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: SetPresentTimestamp and GetPresentTimestamp
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetPresentTimestamp with nullptr and check ret
 */
HWTEST_F(ConsumerSurfaceTest, presentTimestamp006, Function | MediumTest | Level1)
{
    GraphicPresentTimestamp timestamp = {GRAPHIC_DISPLAY_PTS_TIMESTAMP, 0};
    GSError ret = surface_->SetPresentTimestamp(firstSeqnum, timestamp);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    int64_t time = 0;
    ret = surface_->GetPresentTimestamp(firstSeqnum, GraphicPresentTimestampType::GRAPHIC_DISPLAY_PTS_TIMESTAMP, time);
    ASSERT_EQ(ret, OHOS::GSERROR_NOT_SUPPORT);
}

/*
* Function: AcquireBuffer and ReleaseBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RequestBuffer and FlushBuffer
*                  2. call AcquireBuffer and ReleaseBuffer
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ReqCanFluAcqRel005, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer;
    int releaseFence = -1;

    GSError ret = ps->RequestBuffer(buffer, releaseFence, requestConfig);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    ret = ps->FlushBuffer(buffer, SyncFence::INVALID_FENCE, flushConfigWithDamages);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);

    sptr<OHOS::SyncFence> flushFence;
    ret = cs->AcquireBuffer(buffer, flushFence, timestamp, damages);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_NE(buffer, nullptr);
    ASSERT_EQ(damages.size(), flushConfigWithDamages.damages.size());
    for (decltype(damages.size()) i = 0; i < damages.size(); i++) {
        ASSERT_EQ(damages[i].x, flushConfigWithDamages.damages[i].x);
        ASSERT_EQ(damages[i].y, flushConfigWithDamages.damages[i].y);
        ASSERT_EQ(damages[i].w, flushConfigWithDamages.damages[i].w);
        ASSERT_EQ(damages[i].h, flushConfigWithDamages.damages[i].h);
    }

    ASSERT_EQ(timestamp, flushConfigWithDamages.timestamp);
    ret = cs->ReleaseBuffer(buffer, -1);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: AttachBuffer001
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call AttachBuffer
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, AttachBuffer001, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
    ASSERT_NE(buffer, nullptr);
    GSError ret = cs->AttachBuffer(buffer);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
}

/*
* Function: AttachBuffer002
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call AttachBuffer
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, AttachBuffer002, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
    ASSERT_NE(buffer, nullptr);
    int32_t timeOut = 1;
    GSError ret = cs->AttachBuffer(buffer, timeOut);
    ASSERT_NE(ret, OHOS::GSERROR_OK);
}

/*
* Function: AttachBuffer003
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call AttachBuffer
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, AttachBuffer003, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer = SurfaceBuffer::Create();
    ASSERT_NE(buffer, nullptr);
    int32_t timeOut = 1;
    GSError ret = cs->AttachBuffer(buffer, timeOut);
    ASSERT_NE(ret, GSERROR_OK);
}

/*
* Function: AttachBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call AttachBuffer with nullptr params
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, AttachBuffer004, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer = nullptr;
    GSError ret = surface_->AttachBuffer(buffer);
    ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: AttachBuffer
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call AttachBuffer with nullptr params
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, AttachBuffer005, Function | MediumTest | Level2)
{
    sptr<SurfaceBuffer> buffer = nullptr;
    int32_t timeOut = 1;
    GSError ret = surface_->AttachBuffer(buffer, timeOut);
    ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: RegisterSurfaceDelegator
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterSurfaceDelegator
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterSurfaceDelegator001, Function | MediumTest | Level2)
{
    GSError ret = cs->RegisterSurfaceDelegator(surfaceDelegator->AsObject());
    ASSERT_EQ(ret, GSERROR_OK);
}

/*
* Function: RegisterSurfaceDelegator
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call RegisterSurfaceDelegator with nullptr params
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, RegisterSurfaceDelegator002, Function | MediumTest | Level2)
{
    GSError ret = surface_->RegisterSurfaceDelegator(nullptr);
    ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
    ASSERT_NE(surfaceDelegator, nullptr);
    sptr<IRemoteObject> client = surfaceDelegator->AsObject();
    ASSERT_NE(client, nullptr);
    ret = surface_->RegisterSurfaceDelegator(client);
    ASSERT_EQ(ret, GSERROR_INVALID_ARGUMENTS);
}

/*
* Function: ConsumerRequestCpuAccess
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. usage does not contain BUFFER_USAGE_CPU_HW_BOTH
*                  2. call ConsumerRequestCpuAccess(fasle/true)
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess001, Function | MediumTest | Level2)
{
    using namespace HDI::Display::Graphic::Common;
    BufferRequestConfig config = {
        .width = 0x100,
        .height = 0x100,
        .strideAlignment = 0x8,
        .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
        .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
        .timeout = 0,
    };
    auto cSurface = IConsumerSurface::Create();
    sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
    cSurface->RegisterConsumerListener(cListener);
    auto p = cSurface->GetProducer();
    auto pSurface = Surface::CreateSurfaceAsProducer(p);

    // test default
    sptr<SurfaceBuffer> buffer;
    int releaseFence = -1;
    GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config);
    ASSERT_EQ(ret, GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    std::vector<uint8_t> values;
    buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
    ASSERT_EQ(values.size(), 0);

    ret = pSurface->CancelBuffer(buffer);
    ASSERT_EQ(ret, GSERROR_OK);

    // test true
    cSurface->ConsumerRequestCpuAccess(true);
    ret = pSurface->RequestBuffer(buffer, releaseFence, config);
    ASSERT_EQ(ret, GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    values.clear();
    buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
    ASSERT_EQ(values.size(), 0);

    ret = pSurface->CancelBuffer(buffer);
    ASSERT_EQ(ret, GSERROR_OK);

    // test false
    cSurface->ConsumerRequestCpuAccess(false);
    ret = pSurface->RequestBuffer(buffer, releaseFence, config);
    ASSERT_EQ(ret, GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    values.clear();
    buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
    ASSERT_EQ(values.size(), 0);

    ret = pSurface->CancelBuffer(buffer);
    ASSERT_EQ(ret, GSERROR_OK);
}

/*
* Function: ConsumerRequestCpuAccess
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. usage contain BUFFER_USAGE_CPU_HW_BOTH
*                  2. call ConsumerRequestCpuAccess(true)
*                  3. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess002, Function | MediumTest | Level2)
{
    using namespace HDI::Display::Graphic::Common;
    BufferRequestConfig config = {
        .width = 0x100,
        .height = 0x100,
        .strideAlignment = 0x8,
        .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
        .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA | BUFFER_USAGE_CPU_HW_BOTH,
        .timeout = 0,
    };
    auto cSurface = IConsumerSurface::Create();
    sptr<IBufferConsumerListener> cListener = new BufferConsumerListener();
    cSurface->RegisterConsumerListener(cListener);
    auto p = cSurface->GetProducer();
    auto pSurface = Surface::CreateSurfaceAsProducer(p);

    // test default
    sptr<SurfaceBuffer> buffer;
    int releaseFence = -1;
    GSError ret = pSurface->RequestBuffer(buffer, releaseFence, config);
    ASSERT_EQ(ret, GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    std::vector<uint8_t> values;
    buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
    if (values.size() == 1) {
        ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_HW_ONLY);
    }

    ret = pSurface->CancelBuffer(buffer);
    ASSERT_EQ(ret, GSERROR_OK);

    // test true
    cSurface->ConsumerRequestCpuAccess(true);
    ret = pSurface->RequestBuffer(buffer, releaseFence, config);
    ASSERT_EQ(ret, GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    values.clear();
    buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
    if (values.size() == 1) {
        ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_CPU_ACCESS);
    }

    ret = pSurface->CancelBuffer(buffer);
    ASSERT_EQ(ret, GSERROR_OK);

    // test false
    cSurface->ConsumerRequestCpuAccess(false);
    ret = pSurface->RequestBuffer(buffer, releaseFence, config);
    ASSERT_EQ(ret, GSERROR_OK);
    ASSERT_NE(buffer, nullptr);

    values.clear();
    buffer->GetMetadata(V1_1::BufferHandleAttrKey::ATTRKEY_REQUEST_ACCESS_TYPE, values);
    if (values.size() == 1) {
        ASSERT_EQ(values[0], V1_1::HebcAccessType::HEBC_ACCESS_HW_ONLY);
    }

    ret = pSurface->CancelBuffer(buffer);
    ASSERT_EQ(ret, GSERROR_OK);
}

/*
* Function: ConsumerRequestCpuAccess
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call ConsumerRequestCpuAccess with nullptr
*                  2. check ret
 */
HWTEST_F(ConsumerSurfaceTest, ConsumerRequestCpuAccess003, Function | MediumTest | Level2)
{
    ASSERT_NE(surface_, nullptr);
    surface_->ConsumerRequestCpuAccess(true);
}

/*
* Function: SetTransformHint and GetTransformHint
* Type: Function
* Rank: Important(1)
* EnvConditions: N/A
* CaseDescription: 1. call SetTransformHint with nullptr and check ret
*                  2. call GetTransformHint with nullptr and check ret
 */
HWTEST_F(ConsumerSurfaceTest, transformHint001, Function | MediumTest | Level1)
{
    GraphicTransformType typeSet = GraphicTransformType::GRAPHIC_ROTATE_BUTT;
    GSError ret = surface_->SetTransformHint(typeSet);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    GraphicTransformType typeGet = surface_->GetTransformHint();
    ASSERT_EQ(typeGet, GraphicTransformType::GRAPHIC_ROTATE_BUTT);
}

/*
* Function: SetSurfaceSourceType and GetSurfaceSourceType
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetSurfaceSourceType and check ret
*                  2. call GetSurfaceSourceType and check ret
*/
HWTEST_F(ConsumerSurfaceTest, SurfaceSourceType001, Function | MediumTest | Level2)
{
    OHSurfaceSource sourceType = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
    GSError ret = cs->SetSurfaceSourceType(sourceType);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(cs->GetSurfaceSourceType(), OH_SURFACE_SOURCE_VIDEO);
}

/*
* Function: SetSurfaceSourceType and GetSurfaceSourceType
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetSurfaceSourceType with nullptr and check ret
*                  2. call GetSurfaceSourceType with nullptr and check ret
*/
HWTEST_F(ConsumerSurfaceTest, SurfaceSourceType002, Function | MediumTest | Level2)
{
    OHSurfaceSource sourceTypeSet = OHSurfaceSource::OH_SURFACE_SOURCE_VIDEO;
    GSError ret = surface_->SetSurfaceSourceType(sourceTypeSet);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    OHSurfaceSource sourceTypeGet = surface_->GetSurfaceSourceType();
    ASSERT_EQ(sourceTypeGet, OHSurfaceSource::OH_SURFACE_SOURCE_DEFAULT);
}

/*
* Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetSurfaceAppFrameworkType and check ret
*                  2. call GetSurfaceAppFrameworkType and check ret
*/
HWTEST_F(ConsumerSurfaceTest, SurfaceAppFrameworkType001, Function | MediumTest | Level2)
{
    std::string type = "test";
    GSError ret = cs->SetSurfaceAppFrameworkType(type);
    ASSERT_EQ(ret, OHOS::GSERROR_OK);
    ASSERT_EQ(cs->GetSurfaceAppFrameworkType(), "test");
}

/*
* Function: SetSurfaceAppFrameworkType and GetSurfaceAppFrameworkType
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call SetSurfaceAppFrameworkType with nullptr and check ret
*                  2. call GetSurfaceAppFrameworkType with nullptr and check ret
*/
HWTEST_F(ConsumerSurfaceTest, SurfaceAppFrameworkType002, Function | MediumTest | Level2)
{
    std::string type = "test";
    GSError ret = surface_->SetSurfaceAppFrameworkType(type);
    ASSERT_EQ(ret, OHOS::GSERROR_INVALID_ARGUMENTS);
    ASSERT_EQ(surface_->GetSurfaceAppFrameworkType(), "");
}

/*
* Function: GetHdrWhitePointBrightness and GetSdrWhitePointBrightness
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call GetHdrWhitePointBrightness with nullptr and check ret
*                  2. call GetSdrWhitePointBrightness with nullptr and check ret
*/
HWTEST_F(ConsumerSurfaceTest, WhitePointBrightness001, Function | MediumTest | Level2)
{
    float ret = surface_->GetHdrWhitePointBrightness();
    ASSERT_EQ(static_cast<int32_t>(ret), 0);
    ret = surface_->GetSdrWhitePointBrightness();
    ASSERT_EQ(static_cast<int32_t>(ret), 0);
}

/*
* Function: InvalidParameter
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call interface with invaild input nullptr and check ret
*/
HWTEST_F(ConsumerSurfaceTest, InvalidParameter001, Function | MediumTest | Level2)
{
    sptr<OHOS::SurfaceBuffer> sBuffer = nullptr;
    sptr<OHOS::SyncFence> fence = nullptr;
    ASSERT_EQ(surface_->AcquireLastFlushedBuffer(sBuffer, fence, nullptr, 0, false), GSERROR_NOT_SUPPORT);
    ASSERT_EQ(surface_->ReleaseLastFlushedBuffer(sBuffer), GSERROR_NOT_SUPPORT);
}

/*
* Function: GetGlobalAlpha
* Type: Function
* Rank: Important(2)
* EnvConditions: N/A
* CaseDescription: 1. call GetGlobalAlpha and check ret
*/
HWTEST_F(ConsumerSurfaceTest, GetGlobalAlpha001, Function | MediumTest | Level2)
{
    int32_t alpha = -1;
    ASSERT_EQ(cs->SetGlobalAlpha(alpha), GSERROR_NOT_SUPPORT);
    ASSERT_EQ(cs->GetGlobalAlpha(alpha), GSERROR_OK);
}
}