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