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
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS::Rosen {
28 class ProducerSurfaceTest : public testing::Test {
29 public:
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
OnBufferRelease(sptr<SurfaceBuffer> & buffer)54 static inline GSError OnBufferRelease(sptr<SurfaceBuffer> &buffer)
55 {
56 return GSERROR_OK;
57 }
58 };
59
SetUpTestCase()60 void 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
TearDownTestCase()70 void 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 */
85 HWTEST_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;
__anon304f46200102(const std::string& key, const std::string& value) 95 auto func1 = [&ret1](const std::string& key, const std::string& value) {
96 ret1 = OHOS::GSERROR_OK;
97 };
__anon304f46200202(const std::string& key, const std::string& value) 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 */
138 HWTEST_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
__anon304f46200302(const std::string& FuncName) 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