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 <consumer_surface.h>
19#include "buffer_consumer_listener.h"
20#include <native_window.h>
21#include "sync_fence.h"
22#include "producer_surface_delegator.h"
23
24using namespace testing;
25using namespace testing::ext;
26
27namespace OHOS::Rosen {
28class ProducerSurfaceTest : public testing::Test {
29public:
30    static void SetUpTestCase();
31    static void TearDownTestCase();
32
33    static inline BufferRequestConfig requestConfig = {
34        .width = 0x100,
35        .height = 0x100,
36        .strideAlignment = 0x8,
37        .format = GRAPHIC_PIXEL_FMT_RGBA_8888,
38        .usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA,
39        .timeout = 0,
40    };
41    static inline BufferFlushConfig flushConfig = {
42        .damage = {
43            .w = 0x100,
44            .h = 0x100,
45        },
46    };
47    static inline int64_t timestamp = 0;
48    static inline Rect damage = {};
49    static inline sptr<IConsumerSurface> csurf = nullptr;
50    static inline sptr<IBufferProducer> producer = nullptr;
51    static inline sptr<Surface> pSurface = nullptr;
52    static inline sptr<ProducerSurfaceDelegator> surfaceDelegator = nullptr;
53
54    static inline GSError OnBufferRelease(sptr<SurfaceBuffer> &buffer)
55    {
56        return GSERROR_OK;
57    }
58};
59
60void ProducerSurfaceTest::SetUpTestCase()
61{
62    csurf = IConsumerSurface::Create();
63    sptr<IBufferConsumerListener> listener = new BufferConsumerListener();
64    csurf->RegisterConsumerListener(listener);
65    producer = csurf->GetProducer();
66    pSurface = Surface::CreateSurfaceAsProducer(producer);
67    pSurface->RegisterReleaseListener(OnBufferRelease);
68}
69
70void ProducerSurfaceTest::TearDownTestCase()
71{
72    pSurface->UnRegisterReleaseListener();
73    csurf = nullptr;
74    producer = nullptr;
75    pSurface = nullptr;
76}
77
78/*
79 * @tc.name  : UserDataChangeListen001
80 * @tc.desc  : Register UserData Change Listener
81 * @tc.size  : MediumTest
82 * @tc.type  : Function
83 * @tc.level : Level 2
84 */
85HWTEST_F(ProducerSurfaceTest, UserDataChangeListen001, Function | MediumTest | Level2)
86{
87    sptr<IConsumerSurface> csurfTestUserData = IConsumerSurface::Create();
88    sptr<IBufferConsumerListener> listenerTestUserData = new BufferConsumerListener();
89    csurfTestUserData->RegisterConsumerListener(listenerTestUserData);
90    sptr<IBufferProducer> producerTestUserData = csurf->GetProducer();
91    sptr<Surface> pSurfaceTestUserData = Surface::CreateSurfaceAsProducer(producerTestUserData);
92
93    GSError ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
94    GSError ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
95    auto func1 = [&ret1](const std::string& key, const std::string& value) {
96        ret1 = OHOS::GSERROR_OK;
97    };
98    auto func2 = [&ret2](const std::string& key, const std::string& value) {
99        ret2 = OHOS::GSERROR_OK;
100    };
101    pSurfaceTestUserData->RegisterUserDataChangeListener("func1", func1);
102    pSurfaceTestUserData->RegisterUserDataChangeListener("func2", func2);
103    pSurfaceTestUserData->RegisterUserDataChangeListener("func3", nullptr);
104    ASSERT_EQ(pSurfaceTestUserData->RegisterUserDataChangeListener("func2", func2), OHOS::GSERROR_INVALID_ARGUMENTS);
105
106    if (pSurfaceTestUserData->SetUserData("Regist", "OK") == OHOS::GSERROR_OK) {
107        ASSERT_EQ(ret1, OHOS::GSERROR_OK);
108        ASSERT_EQ(ret2, OHOS::GSERROR_OK);
109    }
110
111    ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
112    ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
113    pSurfaceTestUserData->UnRegisterUserDataChangeListener("func1");
114    ASSERT_EQ(pSurfaceTestUserData->UnRegisterUserDataChangeListener("func1"), OHOS::GSERROR_INVALID_ARGUMENTS);
115
116    if (pSurfaceTestUserData->SetUserData("UnRegist", "INVALID") == OHOS::GSERROR_OK) {
117        ASSERT_EQ(ret1, OHOS::GSERROR_INVALID_ARGUMENTS);
118        ASSERT_EQ(ret2, OHOS::GSERROR_OK);
119    }
120
121    ret1 = OHOS::GSERROR_INVALID_ARGUMENTS;
122    ret2 = OHOS::GSERROR_INVALID_ARGUMENTS;
123    pSurfaceTestUserData->ClearUserDataChangeListener();
124    pSurfaceTestUserData->RegisterUserDataChangeListener("func1", func1);
125    if (pSurfaceTestUserData->SetUserData("Clear", "OK") == OHOS::GSERROR_OK) {
126        ASSERT_EQ(ret1, OHOS::GSERROR_OK);
127        ASSERT_EQ(ret2, OHOS::GSERROR_INVALID_ARGUMENTS);
128    }
129}
130
131/*
132 * @tc.name  : UserDataChangeListen002
133 * @tc.desc  : Register UserData Change Listener
134 * @tc.size  : MediumTest
135 * @tc.type  : Function
136 * @tc.level : Level 2
137 */
138HWTEST_F(ProducerSurfaceTest, UserDataChangeListen002, Function | MediumTest | Level2)
139{
140    sptr<IConsumerSurface> csurfTestUserData = IConsumerSurface::Create();
141    sptr<IBufferConsumerListener> listenerTestUserData = new BufferConsumerListener();
142    csurfTestUserData->RegisterConsumerListener(listenerTestUserData);
143    sptr<IBufferProducer> producerTestUserData = csurf->GetProducer();
144    sptr<Surface> pSurfaceTestUserData = Surface::CreateSurfaceAsProducer(producerTestUserData);
145
146    auto func = [&pSurfaceTestUserData](const std::string& FuncName) {
147        constexpr int32_t RegisterListenerNum = 1000;
148        std::vector<GSError> ret(RegisterListenerNum, OHOS::GSERROR_INVALID_ARGUMENTS);
149        std::string strs[RegisterListenerNum];
150        constexpr int32_t stringLengthMax = 32;
151        char str[stringLengthMax] = {};
152        for (int i = 0; i < RegisterListenerNum; i++) {
153            auto secRet = snprintf_s(str, sizeof(str), sizeof(str) - 1, "%s%d", FuncName.c_str(), i);
154            ASSERT_GT(secRet, 0);
155            strs[i] = str;
156            ASSERT_EQ(pSurfaceTestUserData->RegisterUserDataChangeListener(strs[i], [i, &ret]
157            (const std::string& key, const std::string& value) {
158                ret[i] = OHOS::GSERROR_OK;
159            }), OHOS::GSERROR_OK);
160        }
161
162        if (pSurfaceTestUserData->SetUserData("Regist", FuncName) == OHOS::GSERROR_OK) {
163            for (int i = 0; i < RegisterListenerNum; i++) {
164                ASSERT_EQ(ret[i], OHOS::GSERROR_OK);
165            }
166        }
167
168        for (int i = 0; i < RegisterListenerNum; i++) {
169            pSurfaceTestUserData->UnRegisterUserDataChangeListener(strs[i]);
170        }
171    };
172
173    std::thread t1(func, "thread1");
174    std::thread t2(func, "thread2");
175    t1.join();
176    t2.join();
177}
178
179}
180