1 /*
2 * Copyright (c) 2024 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 <chrono>
16 #include <thread>
17 #include <unistd.h>
18 #include <gtest/gtest.h>
19 #include <securec.h>
20 #include <native_window.h>
21 #include "external_window.h"
22 #include "iconsumer_surface.h"
23 #include "event_handler.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS::Rosen {
29 constexpr uint32_t QUEUE_SIZE = 5;
30 class NativeWindowTest : public testing::Test, public IBufferConsumerListenerClazz {
31 public:
32 static void SetUpTestCase();
33 void OnBufferAvailable() override;
34 void SetData(NativeWindowBuffer *nativeWindowBuffer, NativeWindow *nativeWindow);
35 bool GetData(sptr<SurfaceBuffer> &buffer);
36
37 // OH_NativeWindow_CreateNativeWindow001
38 int32_t ThreadNativeWindowProcess001(int32_t *pipeRead, int32_t *pipeWrite, sptr<IBufferProducer> producer);
39 int32_t CreateNativeWindowAndRequestBuffer001(sptr<IBufferProducer> producer, NativeWindow **nativeWindow);
40
41 // OH_NativeWindow_CreateNativeWindow002
42 int32_t ThreadNativeWindowProcess002(int32_t *pipeRead, int32_t *pipeWrite, sptr<IBufferProducer> producer);
43 int32_t CreateNativeWindowAndRequestBuffer002(sptr<IBufferProducer> producer, NativeWindow **nativeWindow);
44
45 // OH_NativeWindow_CreateNativeWindowFromSurfaceId001
46 int32_t ThreadNativeWindowProcess003(int32_t *pipeRead, int32_t *pipeWrite, uint64_t uniqueId);
47 int32_t CreateNativeWindowAndRequestBuffer003(uint64_t uniqueId, NativeWindow **nativeWindow);
48
49 // OH_NativeWindow_CreateNativeWindowFromSurfaceId002
50 int32_t ThreadNativeWindowProcess004(int32_t *pipeRead, int32_t *pipeWrite, uint64_t uniqueId);
51 int32_t CreateNativeWindowAndRequestBuffer004(uint64_t uniqueId, NativeWindow **nativeWindow);
52 int32_t RequestBuffer001(NativeWindow *nativeWindow);
53
54 // OH_NativeWindow_GetLastFlushedBufferV2001
55 int32_t ThreadNativeWindowProcess005(int32_t *pipeRead, int32_t *pipeWrite, uint64_t uniqueId);
56 int32_t CreateNativeWindowAndRequestBuffer005(uint64_t uniqueId, NativeWindow **nativeWindow);
57
58 // OH_NativeWindow_NativeObjectReference001
59 int32_t ThreadNativeWindowProcess006(int32_t *pipeRead, int32_t *pipeWrite, uint64_t uniqueId);
60
61 // OH_NativeWindow_GetSurfaceId001
62 int32_t ThreadNativeWindowProcess007(int32_t *pipeRead, int32_t *pipeWrite,
63 sptr<IBufferProducer> producer, uint64_t *uniqueId);
64 int32_t CreateNativeWindowAndRequestBuffer007(sptr<IBufferProducer> producer, NativeWindow **nativeWindow);
65
66 // OH_NativeWindow_NativeWindowAttachBuffer001
67 int32_t ThreadNativeWindowProcess008(int32_t *pipeRead, int32_t *pipeWrite, uint64_t uniqueId);
68 int32_t CreateNativeWindowAndRequestBuffer008(uint64_t uniqueId, NativeWindow **nativeWindow);
69 int32_t CreateNativeWindowAndAttachBuffer001(NativeWindow *nativeWindow);
70
71 int32_t g_onBufferAvailable_ = 0;
72 };
73
74 class OnBufferAvailableTest : public IBufferConsumerListenerClazz, public RefBase {
75 public:
76 void OnBufferAvailable() override;
77 };
78
OnBufferAvailable()79 void OnBufferAvailableTest::OnBufferAvailable() {};
80
SetUpTestCase()81 void NativeWindowTest::SetUpTestCase() {}
82
OnBufferAvailable()83 void NativeWindowTest::OnBufferAvailable()
84 {
85 g_onBufferAvailable_++;
86 }
87
CreateNativeWindowAndRequestBuffer001(sptr<IBufferProducer> producer,NativeWindow ** nativeWindow)88 int32_t NativeWindowTest::CreateNativeWindowAndRequestBuffer001(sptr<IBufferProducer> producer,
89 NativeWindow **nativeWindow)
90 {
91 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
92 *nativeWindow = OH_NativeWindow_CreateNativeWindow(&pSurface);
93 struct NativeWindowBuffer *nativeWindowBuffer = nullptr;
94
95 int32_t code = SET_BUFFER_GEOMETRY;
96 int32_t height = 0x100;
97 int32_t width = 0x100;
98 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, height, width);
99
100 int32_t fenceFd = -1;
101 auto ret = OH_NativeWindow_NativeWindowRequestBuffer(*nativeWindow, &nativeWindowBuffer, &fenceFd);
102 if (ret != OHOS::GSERROR_OK) {
103 return ret;
104 }
105
106 struct Region *region = new Region();
107 struct Region::Rect *rect = new Region::Rect();
108 rect->w = 0x100;
109 rect->h = 0x100;
110 region->rects = rect;
111 region->rectNumber = 1;
112 ret = OH_NativeWindow_NativeWindowFlushBuffer(*nativeWindow, nativeWindowBuffer, -1, *region);
113 if (ret != OHOS::GSERROR_OK) {
114 delete rect;
115 delete region;
116 return ret;
117 }
118 delete rect;
119 delete region;
120 return OHOS::GSERROR_OK;
121 }
122
ThreadNativeWindowProcess001(int32_t * pipeRead,int32_t * pipeWrite,sptr<IBufferProducer> producer)123 int32_t NativeWindowTest::ThreadNativeWindowProcess001(int32_t *pipeRead, int32_t *pipeWrite,
124 sptr<IBufferProducer> producer)
125 {
126 int64_t data;
127 NativeWindow *nativeWindow = nullptr;
128 int32_t ret = CreateNativeWindowAndRequestBuffer001(producer, &nativeWindow);
129 if (ret != OHOS::GSERROR_OK) {
130 data = ret;
131 write(pipeWrite[1], &data, sizeof(data));
132 return -1;
133 }
134
135 data = ret;
136 write(pipeWrite[1], &data, sizeof(data));
137 read(pipeRead[0], &data, sizeof(data));
138 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
139 return 0;
140 }
141
142 HWTEST_F(NativeWindowTest, OH_NativeWindow_CreateNativeWindow001, Function | MediumTest | Level2)
143 {
144 int32_t pipeRead[2] = {};
145 int32_t pipeWrite[2] = {};
146 pipe(pipeRead);
147 pipe(pipeWrite);
148
149 sptr<OHOS::IConsumerSurface> cSurface = IConsumerSurface::Create("OH_NativeWindow_CreateNativeWindow001");
150 cSurface->RegisterConsumerListener(this);
151 auto producer = cSurface->GetProducer();
152
__anon31584efa0102() 153 std::thread thread([this, pipeRead, pipeWrite, producer]() {
154 int32_t ret = this->ThreadNativeWindowProcess001((int32_t*)pipeRead, (int32_t*)pipeWrite, producer);
155 EXPECT_EQ(ret, OHOS::GSERROR_OK);
156 });
157
158 int64_t data = 0;
159 read(pipeWrite[0], &data, sizeof(data));
160 EXPECT_EQ(data, OHOS::GSERROR_OK);
161
162 OHOS::sptr<SurfaceBuffer> buffer = nullptr;
163 int32_t fence = -1;
164 int64_t timestamp;
165 Rect damage;
166 auto ret = cSurface->AcquireBuffer(buffer, fence, timestamp, damage);
167 EXPECT_EQ(ret, OHOS::GSERROR_OK);
168 EXPECT_NE(buffer, nullptr);
169
170 ret = cSurface->ReleaseBuffer(buffer, -1);
171 EXPECT_EQ(ret, OHOS::GSERROR_OK);
172
173 write(pipeRead[1], &data, sizeof(data));
174 if (thread.joinable()) {
175 thread.join();
176 }
177 close(pipeRead[0]);
178 close(pipeRead[1]);
179 close(pipeWrite[0]);
180 close(pipeWrite[1]);
181 producer = nullptr;
182 cSurface = nullptr;
183 }
184
SetData(NativeWindowBuffer * nativeWindowBuffer,NativeWindow * nativeWindow)185 void NativeWindowTest::SetData(NativeWindowBuffer *nativeWindowBuffer, NativeWindow *nativeWindow)
186 {
187 nativeWindowBuffer->sfbuffer->GetExtraData()->ExtraSet("123", 0x123);
188 nativeWindowBuffer->sfbuffer->GetExtraData()->ExtraSet("345", (int64_t)0x345);
189 nativeWindowBuffer->sfbuffer->GetExtraData()->ExtraSet("567", "567");
190 }
191
GetData(sptr<SurfaceBuffer> & buffer)192 bool NativeWindowTest::GetData(sptr<SurfaceBuffer> &buffer)
193 {
194 int32_t int32;
195 int64_t int64;
196 std::string str;
197 buffer->GetExtraData()->ExtraGet("123", int32);
198 buffer->GetExtraData()->ExtraGet("345", int64);
199 buffer->GetExtraData()->ExtraGet("567", str);
200 if ((int32 != 0x123) || (int64 != 0x345) || (str != "567")) {
201 return false;
202 }
203
204 return true;
205 }
206
CreateNativeWindowAndRequestBuffer002(sptr<IBufferProducer> producer,NativeWindow ** nativeWindow)207 int32_t NativeWindowTest::CreateNativeWindowAndRequestBuffer002(sptr<IBufferProducer> producer,
208 NativeWindow **nativeWindow)
209 {
210 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
211 *nativeWindow = OH_NativeWindow_CreateNativeWindow(&pSurface);
212 struct NativeWindowBuffer *nativeWindowBuffer = nullptr;
213
214 int32_t code = SET_BUFFER_GEOMETRY;
215 int32_t height = 0x100;
216 int32_t width = 0x100;
217 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, height, width);
218 code = SET_FORMAT;
219 int32_t format = GRAPHIC_PIXEL_FMT_RGBA_8888;
220 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, format);
221
222 int32_t fenceFd = -1;
223 auto ret = OH_NativeWindow_NativeWindowRequestBuffer(*nativeWindow, &nativeWindowBuffer, &fenceFd);
224 if (ret != OHOS::GSERROR_OK) {
225 return ret;
226 }
227 SetData(nativeWindowBuffer, *nativeWindow);
228
229 struct Region *region = new Region();
230 struct Region::Rect *rect = new Region::Rect();
231 rect->w = 0x100;
232 rect->h = 0x100;
233 region->rects = rect;
234 region->rectNumber = 1;
235 ret = OH_NativeWindow_NativeWindowFlushBuffer(*nativeWindow, nativeWindowBuffer, -1, *region);
236 if (ret != OHOS::GSERROR_OK) {
237 delete rect;
238 delete region;
239 return ret;
240 }
241 delete rect;
242 delete region;
243 return OHOS::GSERROR_OK;
244 }
245
ThreadNativeWindowProcess002(int32_t * pipeRead,int32_t * pipeWrite,sptr<IBufferProducer> producer)246 int32_t NativeWindowTest::ThreadNativeWindowProcess002(int32_t *pipeRead, int32_t *pipeWrite,
247 sptr<IBufferProducer> producer)
248 {
249 int64_t data;
250 NativeWindow *nativeWindow = nullptr;
251 int32_t ret = CreateNativeWindowAndRequestBuffer002(producer, &nativeWindow);
252 if (ret != OHOS::GSERROR_OK) {
253 data = ret;
254 write(pipeWrite[1], &data, sizeof(data));
255 return -1;
256 }
257
258 data = ret;
259 write(pipeWrite[1], &data, sizeof(data));
260 read(pipeRead[0], &data, sizeof(data));
261 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
262 return 0;
263 }
264
265 HWTEST_F(NativeWindowTest, OH_NativeWindow_CreateNativeWindow002, Function | MediumTest | Level2)
266 {
267 int32_t pipeRead[2] = {};
268 int32_t pipeWrite[2] = {};
269 pipe(pipeRead);
270 pipe(pipeWrite);
271
272 sptr<OHOS::IConsumerSurface> cSurface = IConsumerSurface::Create("OH_NativeWindow_CreateNativeWindow002");
273 cSurface->RegisterConsumerListener(this);
274 auto producer = cSurface->GetProducer();
275
__anon31584efa0202() 276 std::thread thread([this, pipeRead, pipeWrite, producer]() {
277 int32_t ret = this->ThreadNativeWindowProcess002((int32_t*)pipeRead, (int32_t*)pipeWrite, producer);
278 EXPECT_EQ(ret, OHOS::GSERROR_OK);
279 });
280
281 int64_t data = 0;
282 read(pipeWrite[0], &data, sizeof(data));
283 EXPECT_EQ(data, OHOS::GSERROR_OK);
284
285 OHOS::sptr<SurfaceBuffer> buffer = nullptr;
286 int32_t fence = -1;
287 int64_t timestamp;
288 Rect damage;
289 auto ret = cSurface->AcquireBuffer(buffer, fence, timestamp, damage);
290 EXPECT_EQ(ret, OHOS::GSERROR_OK);
291 EXPECT_NE(buffer, nullptr);
292 EXPECT_EQ(GetData(buffer), true);
293
294 ret = cSurface->ReleaseBuffer(buffer, -1);
295 EXPECT_EQ(ret, OHOS::GSERROR_OK);
296
297 write(pipeRead[1], &data, sizeof(data));
298 if (thread.joinable()) {
299 thread.join();
300 }
301 close(pipeRead[0]);
302 close(pipeRead[1]);
303 close(pipeWrite[0]);
304 close(pipeWrite[1]);
305 producer = nullptr;
306 cSurface = nullptr;
307 }
308
CreateNativeWindowAndRequestBuffer003(uint64_t uniqueId,NativeWindow ** nativeWindow)309 int32_t NativeWindowTest::CreateNativeWindowAndRequestBuffer003(uint64_t uniqueId, NativeWindow **nativeWindow)
310 {
311 int32_t ret = OH_NativeWindow_CreateNativeWindowFromSurfaceId(uniqueId, nativeWindow);
312 if (ret != OHOS::GSERROR_OK) {
313 return ret;
314 }
315 struct NativeWindowBuffer *nativeWindowBuffer = nullptr;
316
317 int32_t code = SET_BUFFER_GEOMETRY;
318 int32_t height = 0x100;
319 int32_t width = 0x100;
320 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, height, width);
321 code = SET_FORMAT;
322 int32_t format = GRAPHIC_PIXEL_FMT_RGBA_8888;
323 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, format);
324
325 int32_t fenceFd = -1;
326 struct Region *region = new Region();
327 struct Region::Rect *rect = new Region::Rect();
328 rect->w = 0x100;
329 rect->h = 0x100;
330 region->rects = rect;
331 region->rectNumber = 1;
332 for (int32_t i = 0; i < QUEUE_SIZE; i++) {
333 ret = OH_NativeWindow_NativeWindowRequestBuffer(*nativeWindow, &nativeWindowBuffer, &fenceFd);
334 if (ret != OHOS::GSERROR_OK) {
335 delete rect;
336 delete region;
337 return ret;
338 }
339 SetData(nativeWindowBuffer, *nativeWindow);
340
341 ret = OH_NativeWindow_NativeWindowFlushBuffer(*nativeWindow, nativeWindowBuffer, -1, *region);
342 if (ret != OHOS::GSERROR_OK) {
343 delete rect;
344 delete region;
345 return ret;
346 }
347 }
348 delete rect;
349 delete region;
350 return OHOS::GSERROR_OK;
351 }
352
ThreadNativeWindowProcess003(int32_t * pipeRead,int32_t * pipeWrite,uint64_t uniqueId)353 int32_t NativeWindowTest::ThreadNativeWindowProcess003(int32_t *pipeRead, int32_t *pipeWrite, uint64_t uniqueId)
354 {
355 int64_t data;
356 NativeWindow *nativeWindow = nullptr;
357 int32_t ret = CreateNativeWindowAndRequestBuffer003(uniqueId, &nativeWindow);
358 if (ret != OHOS::GSERROR_OK) {
359 data = ret;
360 write(pipeWrite[1], &data, sizeof(data));
361 return -1;
362 }
363
364 data = ret;
365 write(pipeWrite[1], &data, sizeof(data));
366 read(pipeRead[0], &data, sizeof(data));
367 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
368 return 0;
369 }
370
371 HWTEST_F(NativeWindowTest, OH_NativeWindow_CreateNativeWindowFromSurfaceId001, Function | MediumTest | Level2)
372 {
373 int32_t pipeRead[2] = {};
374 int32_t pipeWrite[2] = {};
375 pipe(pipeRead);
376 pipe(pipeWrite);
377
378 sptr<OHOS::IConsumerSurface> cSurface =
379 IConsumerSurface::Create("OH_NativeWindow_CreateNativeWindowFromSurfaceId001");
380 cSurface->RegisterConsumerListener(this);
381 auto producer = cSurface->GetProducer();
382 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
383 EXPECT_NE(pSurface, nullptr);
384 EXPECT_EQ(cSurface->SetQueueSize(QUEUE_SIZE), OHOS::GSERROR_OK);
385
386 uint64_t uniqueId = cSurface->GetUniqueId();
__anon31584efa0302() 387 std::thread thread([this, pipeRead, pipeWrite, uniqueId]() {
388 int32_t ret = this->ThreadNativeWindowProcess003((int32_t*)pipeRead, (int32_t*)pipeWrite, uniqueId);
389 EXPECT_EQ(ret, OHOS::GSERROR_OK);
390 });
391
392 int64_t data = 0;
393 read(pipeWrite[0], &data, sizeof(data));
394 EXPECT_EQ(data, OHOS::GSERROR_OK);
395
396 OHOS::sptr<SurfaceBuffer> buffer = nullptr;
397 int32_t fence = -1;
398 int64_t timestamp;
399 Rect damage;
400 EXPECT_EQ(g_onBufferAvailable_, QUEUE_SIZE);
401 while (g_onBufferAvailable_ > 0) {
402 auto ret = cSurface->AcquireBuffer(buffer, fence, timestamp, damage);
403 EXPECT_EQ(ret, OHOS::GSERROR_OK);
404 EXPECT_NE(buffer, nullptr);
405 EXPECT_EQ(GetData(buffer), true);
406
407 ret = cSurface->ReleaseBuffer(buffer, -1);
408 EXPECT_EQ(ret, OHOS::GSERROR_OK);
409 g_onBufferAvailable_--;
410 }
411
412 g_onBufferAvailable_ = 0;
413 write(pipeRead[1], &data, sizeof(data));
414 if (thread.joinable()) {
415 thread.join();
416 }
417 close(pipeRead[0]);
418 close(pipeRead[1]);
419 close(pipeWrite[0]);
420 close(pipeWrite[1]);
421 producer = nullptr;
422 cSurface = nullptr;
423 }
424
RequestBuffer001(NativeWindow * nativeWindow)425 int32_t NativeWindowTest::RequestBuffer001(NativeWindow *nativeWindow)
426 {
427 int32_t fenceFd = -1;
428 struct Region *region = new Region();
429 struct Region::Rect *rect = new Region::Rect();
430 rect->w = 0x100;
431 rect->h = 0x100;
432 region->rects = rect;
433 region->rectNumber = 1;
434 struct NativeWindowBuffer *nativeWindowBuffer = nullptr;
435 int32_t ret;
436 for (int32_t i = 0; i < QUEUE_SIZE; i++) {
437 ret = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd);
438 if (ret != OHOS::GSERROR_OK) {
439 delete rect;
440 delete region;
441 return ret;
442 }
443 SetData(nativeWindowBuffer, nativeWindow);
444
445 ret = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, -1, *region);
446 if (ret != OHOS::GSERROR_OK) {
447 delete rect;
448 delete region;
449 return ret;
450 }
451 }
452 delete rect;
453 delete region;
454 return OHOS::GSERROR_OK;
455 }
456
CreateNativeWindowAndRequestBuffer004(uint64_t uniqueId,NativeWindow ** nativeWindow)457 int32_t NativeWindowTest::CreateNativeWindowAndRequestBuffer004(uint64_t uniqueId, NativeWindow **nativeWindow)
458 {
459 int32_t ret = OH_NativeWindow_CreateNativeWindowFromSurfaceId(uniqueId, nativeWindow);
460 if (ret != OHOS::GSERROR_OK) {
461 return ret;
462 }
463 struct NativeWindowBuffer *nativeWindowBuffer = nullptr;
464
465 int32_t code = SET_BUFFER_GEOMETRY;
466 int32_t height = 0x100;
467 int32_t width = 0x100;
468 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, height, width);
469 code = SET_FORMAT;
470 int32_t format = GRAPHIC_PIXEL_FMT_RGBA_8888;
471 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, format);
472
473 int32_t fenceFd = -1;
474 struct Region *region = new Region();
475 struct Region::Rect *rect = new Region::Rect();
476 rect->w = 0x100;
477 rect->h = 0x100;
478 region->rects = rect;
479 region->rectNumber = 1;
480 for (int32_t i = 0; i < QUEUE_SIZE; i++) {
481 ret = OH_NativeWindow_NativeWindowRequestBuffer(*nativeWindow, &nativeWindowBuffer, &fenceFd);
482 if (ret != OHOS::GSERROR_OK) {
483 delete rect;
484 delete region;
485 return ret;
486 }
487 SetData(nativeWindowBuffer, *nativeWindow);
488
489 ret = OH_NativeWindow_NativeWindowFlushBuffer(*nativeWindow, nativeWindowBuffer, -1, *region);
490 if (ret != OHOS::GSERROR_OK) {
491 delete rect;
492 delete region;
493 return ret;
494 }
495 }
496 delete rect;
497 delete region;
498 return OHOS::GSERROR_OK;
499 }
500
ThreadNativeWindowProcess004(int32_t * pipeRead,int32_t * pipeWrite,uint64_t uniqueId)501 int32_t NativeWindowTest::ThreadNativeWindowProcess004(int32_t *pipeRead, int32_t *pipeWrite, uint64_t uniqueId)
502 {
503 int64_t data;
504 NativeWindow *nativeWindow = nullptr;
505 int32_t ret = CreateNativeWindowAndRequestBuffer004(uniqueId, &nativeWindow);
506 if (ret != OHOS::GSERROR_OK) {
507 data = ret;
508 write(pipeWrite[1], &data, sizeof(data));
509 return -1;
510 }
511
512 data = ret;
513 write(pipeWrite[1], &data, sizeof(data));
514 read(pipeRead[0], &data, sizeof(data));
515 ret = RequestBuffer001(nativeWindow);
516 if (ret != OHOS::GSERROR_OK) {
517 data = ret;
518 write(pipeWrite[1], &data, sizeof(data));
519 return -1;
520 }
521 data = ret;
522 write(pipeWrite[1], &data, sizeof(data));
523 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
524 return 0;
525 }
526
527 HWTEST_F(NativeWindowTest, OH_NativeWindow_CreateNativeWindowFromSurfaceId002, Function | MediumTest | Level2)
528 {
529 int32_t pipeRead[2] = {};
530 int32_t pipeWrite[2] = {};
531 pipe(pipeRead);
532 pipe(pipeWrite);
533
534 sptr<OHOS::IConsumerSurface> cSurface =
535 IConsumerSurface::Create("OH_NativeWindow_CreateNativeWindowFromSurfaceId002");
536 cSurface->RegisterConsumerListener(this);
537 auto producer = cSurface->GetProducer();
538 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
539 EXPECT_NE(pSurface, nullptr);
540 EXPECT_EQ(cSurface->SetQueueSize(QUEUE_SIZE), OHOS::GSERROR_OK);
541
542 uint64_t uniqueId = cSurface->GetUniqueId();
__anon31584efa0402() 543 std::thread thread([this, pipeRead, pipeWrite, uniqueId]() {
544 int32_t ret = this->ThreadNativeWindowProcess004((int32_t*)pipeRead, (int32_t*)pipeWrite, uniqueId);
545 EXPECT_EQ(ret, OHOS::GSERROR_OK);
546 });
547
548 int64_t data = 0;
549 read(pipeWrite[0], &data, sizeof(data));
550 EXPECT_EQ(data, OHOS::GSERROR_OK);
551
552 OHOS::sptr<SurfaceBuffer> buffer = nullptr;
553 int32_t fence = -1;
554 int64_t timestamp;
555 Rect damage;
556 EXPECT_EQ(g_onBufferAvailable_, QUEUE_SIZE);
557 while (g_onBufferAvailable_ > 0) {
558 auto ret = cSurface->AcquireBuffer(buffer, fence, timestamp, damage);
559 EXPECT_EQ(ret, OHOS::GSERROR_OK);
560 EXPECT_NE(buffer, nullptr);
561 EXPECT_EQ(GetData(buffer), true);
562
563 ret = cSurface->ReleaseBuffer(buffer, -1);
564 EXPECT_EQ(ret, OHOS::GSERROR_OK);
565 g_onBufferAvailable_--;
566 }
567
568 write(pipeRead[1], &data, sizeof(data));
569 read(pipeWrite[0], &data, sizeof(data));
570 EXPECT_EQ(data, OHOS::GSERROR_OK);
571 EXPECT_EQ(g_onBufferAvailable_, QUEUE_SIZE);
572 g_onBufferAvailable_ = 0;
573 if (thread.joinable()) {
574 thread.join();
575 }
576 close(pipeRead[0]);
577 close(pipeRead[1]);
578 close(pipeWrite[0]);
579 close(pipeWrite[1]);
580 producer = nullptr;
581 cSurface = nullptr;
582 }
583
CreateNativeWindowAndRequestBuffer005(uint64_t uniqueId,NativeWindow ** nativeWindow)584 int32_t NativeWindowTest::CreateNativeWindowAndRequestBuffer005(uint64_t uniqueId, NativeWindow **nativeWindow)
585 {
586 int32_t ret = OH_NativeWindow_CreateNativeWindowFromSurfaceId(uniqueId, nativeWindow);
587 if (ret != OHOS::GSERROR_OK) {
588 return ret;
589 }
590
591 struct NativeWindowBuffer *nativeWindowBuffer = nullptr;
592 struct NativeWindowBuffer *lastNativeWindowBuffer = nullptr;
593
594 int32_t code = SET_BUFFER_GEOMETRY;
595 int32_t height = 0x100;
596 int32_t width = 0x100;
597 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, height, width);
598 code = SET_FORMAT;
599 int32_t format = GRAPHIC_PIXEL_FMT_RGBA_8888;
600 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, format);
601
602 int32_t fenceFd = -1;
603 struct Region *region = new Region();
604 struct Region::Rect *rect = new Region::Rect();
605 rect->w = 0x100;
606 rect->h = 0x100;
607 region->rects = rect;
608 region->rectNumber = 1;
609 float matrix[16] = {0};
610 for (int32_t i = 0; i < QUEUE_SIZE; i++) {
611 ret = OH_NativeWindow_NativeWindowRequestBuffer(*nativeWindow, &nativeWindowBuffer, &fenceFd);
612 if (ret != OHOS::GSERROR_OK) {
613 delete rect;
614 delete region;
615 return ret;
616 }
617 SetData(nativeWindowBuffer, *nativeWindow);
618
619 ret = OH_NativeWindow_NativeWindowFlushBuffer(*nativeWindow, nativeWindowBuffer, -1, *region);
620 if (ret != OHOS::GSERROR_OK) {
621 delete rect;
622 delete region;
623 return ret;
624 }
625 ret = OH_NativeWindow_GetLastFlushedBufferV2(*nativeWindow, &lastNativeWindowBuffer, &fenceFd, matrix);
626 if (ret != OHOS::GSERROR_OK) {
627 delete rect;
628 delete region;
629 return ret;
630 }
631 if (!GetData(lastNativeWindowBuffer->sfbuffer)) {
632 delete rect;
633 delete region;
634 return -1;
635 }
636 }
637 delete rect;
638 delete region;
639 return OHOS::GSERROR_OK;
640 }
641
ThreadNativeWindowProcess005(int32_t * pipeRead,int32_t * pipeWrite,uint64_t uniqueId)642 int32_t NativeWindowTest::ThreadNativeWindowProcess005(int32_t *pipeRead, int32_t *pipeWrite, uint64_t uniqueId)
643 {
644 int64_t data;
645 NativeWindow *nativeWindow = nullptr;
646 int32_t ret = CreateNativeWindowAndRequestBuffer005(uniqueId, &nativeWindow);
647 if (ret != OHOS::GSERROR_OK) {
648 data = ret;
649 write(pipeWrite[1], &data, sizeof(data));
650 return -1;
651 }
652
653 data = ret;
654 write(pipeWrite[1], &data, sizeof(data));
655 read(pipeRead[0], &data, sizeof(data));
656 ret = RequestBuffer001(nativeWindow);
657 if (ret != OHOS::GSERROR_OK) {
658 data = ret;
659 write(pipeWrite[1], &data, sizeof(data));
660 return -1;
661 }
662 data = ret;
663 write(pipeWrite[1], &data, sizeof(data));
664 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
665 return 0;
666 }
667
668 HWTEST_F(NativeWindowTest, OH_NativeWindow_GetLastFlushedBufferV2001, Function | MediumTest | Level2)
669 {
670 int32_t pipeRead[2] = {};
671 int32_t pipeWrite[2] = {};
672 pipe(pipeRead);
673 pipe(pipeWrite);
674
675 sptr<OHOS::IConsumerSurface> cSurface = IConsumerSurface::Create("OH_NativeWindow_GetLastFlushedBufferV2001");
676 cSurface->RegisterConsumerListener(this);
677 auto producer = cSurface->GetProducer();
678 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
679 EXPECT_NE(pSurface, nullptr);
680 EXPECT_EQ(cSurface->SetQueueSize(QUEUE_SIZE), OHOS::GSERROR_OK);
681
682 uint64_t uniqueId = cSurface->GetUniqueId();
__anon31584efa0502() 683 std::thread thread([this, pipeRead, pipeWrite, uniqueId]() {
684 int32_t ret = this->ThreadNativeWindowProcess005((int32_t*)pipeRead, (int32_t*)pipeWrite, uniqueId);
685 EXPECT_EQ(ret, OHOS::GSERROR_OK);
686 });
687
688 int64_t data = 0;
689 read(pipeWrite[0], &data, sizeof(data));
690 EXPECT_EQ(data, OHOS::GSERROR_OK);
691
692 OHOS::sptr<SurfaceBuffer> buffer = nullptr;
693 int32_t fence = -1;
694 int64_t timestamp;
695 Rect damage;
696 EXPECT_EQ(g_onBufferAvailable_, QUEUE_SIZE);
697 while (g_onBufferAvailable_ > 0) {
698 auto ret = cSurface->AcquireBuffer(buffer, fence, timestamp, damage);
699 EXPECT_EQ(ret, OHOS::GSERROR_OK);
700 EXPECT_NE(buffer, nullptr);
701 EXPECT_EQ(GetData(buffer), true);
702
703 ret = cSurface->ReleaseBuffer(buffer, -1);
704 EXPECT_EQ(ret, OHOS::GSERROR_OK);
705 g_onBufferAvailable_--;
706 }
707
708 write(pipeRead[1], &data, sizeof(data));
709 read(pipeWrite[0], &data, sizeof(data));
710 EXPECT_EQ(data, OHOS::GSERROR_OK);
711 EXPECT_EQ(g_onBufferAvailable_, QUEUE_SIZE);
712 g_onBufferAvailable_ = 0;
713 if (thread.joinable()) {
714 thread.join();
715 }
716 close(pipeRead[0]);
717 close(pipeRead[1]);
718 close(pipeWrite[0]);
719 close(pipeWrite[1]);
720 producer = nullptr;
721 cSurface = nullptr;
722 }
723
ThreadNativeWindowProcess006(int32_t * pipeRead,int32_t * pipeWrite,uint64_t uniqueId)724 int32_t NativeWindowTest::ThreadNativeWindowProcess006(int32_t *pipeRead, int32_t *pipeWrite, uint64_t uniqueId)
725 {
726 int64_t data;
727 NativeWindow *nativeWindow = nullptr;
728 int32_t ret = CreateNativeWindowAndRequestBuffer005(uniqueId, &nativeWindow);
729 if (ret != OHOS::GSERROR_OK) {
730 data = ret;
731 write(pipeWrite[1], &data, sizeof(data));
732 return -1;
733 }
734 ret = OH_NativeWindow_NativeObjectReference(nativeWindow);
735 if (ret != OHOS::GSERROR_OK) {
736 data = ret;
737 write(pipeWrite[1], &data, sizeof(data));
738 return -1;
739 }
740 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
741
742 data = ret;
743 write(pipeWrite[1], &data, sizeof(data));
744 read(pipeRead[0], &data, sizeof(data));
745 ret = RequestBuffer001(nativeWindow);
746 if (ret != OHOS::GSERROR_OK) {
747 data = ret;
748 write(pipeWrite[1], &data, sizeof(data));
749 return -1;
750 }
751 data = ret;
752 write(pipeWrite[1], &data, sizeof(data));
753 ret = OH_NativeWindow_NativeObjectUnreference(nativeWindow);
754 if (ret != OHOS::GSERROR_OK) {
755 return -1;
756 }
757 return 0;
758 }
759
760 HWTEST_F(NativeWindowTest, OH_NativeWindow_NativeObjectReference001, Function | MediumTest | Level2)
761 {
762 int32_t pipeRead[2] = {};
763 int32_t pipeWrite[2] = {};
764 pipe(pipeRead);
765 pipe(pipeWrite);
766
767 sptr<OHOS::IConsumerSurface> cSurface = IConsumerSurface::Create("OH_NativeWindow_NativeObjectReference001");
768 cSurface->RegisterConsumerListener(this);
769 auto producer = cSurface->GetProducer();
770 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
771 EXPECT_NE(pSurface, nullptr);
772 EXPECT_EQ(cSurface->SetQueueSize(QUEUE_SIZE), OHOS::GSERROR_OK);
773
774 uint64_t uniqueId = cSurface->GetUniqueId();
__anon31584efa0602() 775 std::thread thread([this, pipeRead, pipeWrite, uniqueId]() {
776 int32_t ret = this->ThreadNativeWindowProcess006((int32_t*)pipeRead, (int32_t*)pipeWrite, uniqueId);
777 EXPECT_EQ(ret, OHOS::GSERROR_OK);
778 });
779
780 int64_t data = 0;
781 read(pipeWrite[0], &data, sizeof(data));
782 EXPECT_EQ(data, OHOS::GSERROR_OK);
783
784 OHOS::sptr<SurfaceBuffer> buffer = nullptr;
785 int32_t fence = -1;
786 int64_t timestamp;
787 Rect damage;
788 EXPECT_EQ(g_onBufferAvailable_, QUEUE_SIZE);
789 while (g_onBufferAvailable_ > 0) {
790 auto ret = cSurface->AcquireBuffer(buffer, fence, timestamp, damage);
791 EXPECT_EQ(ret, OHOS::GSERROR_OK);
792 EXPECT_NE(buffer, nullptr);
793 EXPECT_EQ(GetData(buffer), true);
794
795 ret = cSurface->ReleaseBuffer(buffer, -1);
796 EXPECT_EQ(ret, OHOS::GSERROR_OK);
797 g_onBufferAvailable_--;
798 }
799
800 write(pipeRead[1], &data, sizeof(data));
801 read(pipeWrite[0], &data, sizeof(data));
802 EXPECT_EQ(data, OHOS::GSERROR_OK);
803 EXPECT_EQ(g_onBufferAvailable_, QUEUE_SIZE);
804 g_onBufferAvailable_ = 0;
805 if (thread.joinable()) {
806 thread.join();
807 }
808 close(pipeRead[0]);
809 close(pipeRead[1]);
810 close(pipeWrite[0]);
811 close(pipeWrite[1]);
812 producer = nullptr;
813 cSurface = nullptr;
814 }
815
CreateNativeWindowAndRequestBuffer007(sptr<IBufferProducer> producer,NativeWindow ** nativeWindow)816 int32_t NativeWindowTest::CreateNativeWindowAndRequestBuffer007(sptr<IBufferProducer> producer,
817 NativeWindow **nativeWindow)
818 {
819 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
820 *nativeWindow = OH_NativeWindow_CreateNativeWindow(&pSurface);
821 struct NativeWindowBuffer *nativeWindowBuffer = nullptr;
822
823 int32_t code = SET_BUFFER_GEOMETRY;
824 int32_t height = 0x100;
825 int32_t width = 0x100;
826 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, height, width);
827 code = SET_FORMAT;
828 int32_t format = GRAPHIC_PIXEL_FMT_RGBA_8888;
829 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, format);
830
831 int32_t fenceFd = -1;
832 auto ret = OH_NativeWindow_NativeWindowRequestBuffer(*nativeWindow, &nativeWindowBuffer, &fenceFd);
833 if (ret != OHOS::GSERROR_OK) {
834 return ret;
835 }
836 SetData(nativeWindowBuffer, *nativeWindow);
837
838 struct Region *region = new Region();
839 struct Region::Rect *rect = new Region::Rect();
840 rect->w = 0x100;
841 rect->h = 0x100;
842 region->rects = rect;
843 region->rectNumber = 1;
844 ret = OH_NativeWindow_NativeWindowFlushBuffer(*nativeWindow, nativeWindowBuffer, -1, *region);
845 if (ret != OHOS::GSERROR_OK) {
846 delete rect;
847 delete region;
848 return ret;
849 }
850 delete rect;
851 delete region;
852 return OHOS::GSERROR_OK;
853 }
854
ThreadNativeWindowProcess007(int32_t * pipeRead,int32_t * pipeWrite,sptr<IBufferProducer> producer,uint64_t * uniqueId)855 int32_t NativeWindowTest::ThreadNativeWindowProcess007(int32_t *pipeRead, int32_t *pipeWrite,
856 sptr<IBufferProducer> producer, uint64_t *uniqueId)
857 {
858 int64_t data;
859 NativeWindow *nativeWindow = nullptr;
860 int32_t ret = CreateNativeWindowAndRequestBuffer007(producer, &nativeWindow);
861 if (ret != OHOS::GSERROR_OK) {
862 data = ret;
863 write(pipeWrite[1], &data, sizeof(data));
864 return -1;
865 }
866 ret = OH_NativeWindow_GetSurfaceId(nativeWindow, uniqueId);
867 if (ret != OHOS::GSERROR_OK) {
868 data = ret;
869 write(pipeWrite[1], &data, sizeof(data));
870 return -1;
871 }
872
873 data = ret;
874 write(pipeWrite[1], &data, sizeof(data));
875 read(pipeRead[0], &data, sizeof(data));
876 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
877 return 0;
878 }
879
880 HWTEST_F(NativeWindowTest, OH_NativeWindow_GetSurfaceId001, Function | MediumTest | Level2)
881 {
882 int32_t pipeRead[2] = {};
883 int32_t pipeWrite[2] = {};
884 pipe(pipeRead);
885 pipe(pipeWrite);
886
887 sptr<OHOS::IConsumerSurface> cSurface = IConsumerSurface::Create("OH_NativeWindow_CreateNativeWindow002");
888 cSurface->RegisterConsumerListener(this);
889 auto producer = cSurface->GetProducer();
890 uint64_t cUniqueId = cSurface->GetUniqueId();
891
__anon31584efa0702() 892 std::thread thread([this, pipeRead, pipeWrite, producer, cUniqueId]() {
893 uint64_t uniqueId = 0;
894 int32_t ret = this->ThreadNativeWindowProcess007((int32_t*)pipeRead, (int32_t*)pipeWrite, producer, &uniqueId);
895 EXPECT_EQ(ret, OHOS::GSERROR_OK);
896 EXPECT_EQ(uniqueId, cUniqueId);
897 });
898
899 int64_t data = 0;
900 read(pipeWrite[0], &data, sizeof(data));
901 EXPECT_EQ(data, OHOS::GSERROR_OK);
902
903 OHOS::sptr<SurfaceBuffer> buffer = nullptr;
904 int32_t fence = -1;
905 int64_t timestamp;
906 Rect damage;
907 auto ret = cSurface->AcquireBuffer(buffer, fence, timestamp, damage);
908 EXPECT_EQ(ret, OHOS::GSERROR_OK);
909 EXPECT_NE(buffer, nullptr);
910 EXPECT_EQ(GetData(buffer), true);
911
912 ret = cSurface->ReleaseBuffer(buffer, -1);
913 EXPECT_EQ(ret, OHOS::GSERROR_OK);
914
915 write(pipeRead[1], &data, sizeof(data));
916 if (thread.joinable()) {
917 thread.join();
918 }
919 close(pipeRead[0]);
920 close(pipeRead[1]);
921 close(pipeWrite[0]);
922 close(pipeWrite[1]);
923 producer = nullptr;
924 cSurface = nullptr;
925 }
926
CreateNativeWindowAndAttachBuffer001(NativeWindow * nativeWindow)927 int32_t NativeWindowTest::CreateNativeWindowAndAttachBuffer001(NativeWindow *nativeWindow)
928 {
929 sptr<OnBufferAvailableTest> onBufferAvailableTest = new OnBufferAvailableTest();
930 sptr<OHOS::IConsumerSurface> cSurface = IConsumerSurface::Create("CreateNativeWindowAndAttachBuffer001");
931 cSurface->RegisterConsumerListener(onBufferAvailableTest);
932 auto producer = cSurface->GetProducer();
933 cSurface->SetQueueSize(QUEUE_SIZE);
934 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
935 if (pSurface == nullptr) {
936 return -1;
937 }
938
939 NativeWindow *nativeWindowNew = OH_NativeWindow_CreateNativeWindow(&pSurface);
940 if (nativeWindowNew == nullptr) {
941 return -1;
942 }
943 int32_t code = SET_BUFFER_GEOMETRY;
944 int32_t height = 0x100;
945 int32_t width = 0x100;
946 OH_NativeWindow_NativeWindowHandleOpt(nativeWindowNew, code, height, width);
947 int32_t fenceFd = -1;
948 struct Region *region = new Region();
949 struct Region::Rect *rect = new Region::Rect();
950 rect->w = 0x100;
951 rect->h = 0x100;
952 region->rects = rect;
953 region->rectNumber = 1;
954 struct NativeWindowBuffer *nativeWindowBuffer = nullptr;
955 int32_t ret;
956 for (int32_t i = 0; i < QUEUE_SIZE; i++) {
957 ret = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindowNew, &nativeWindowBuffer, &fenceFd);
958 if (ret != OHOS::GSERROR_OK) {
959 delete rect;
960 delete region;
961 return ret;
962 }
963 SetData(nativeWindowBuffer, nativeWindowNew);
964 ret = OH_NativeWindow_NativeWindowDetachBuffer(nativeWindowNew, nativeWindowBuffer);
965 if (ret != OHOS::GSERROR_OK) {
966 delete rect;
967 delete region;
968 return ret;
969 }
970 ret = OH_NativeWindow_NativeWindowAttachBuffer(nativeWindow, nativeWindowBuffer);
971 if (ret != OHOS::GSERROR_OK) {
972 delete rect;
973 delete region;
974 return ret;
975 }
976 ret = OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, nativeWindowBuffer, -1, *region);
977 if (ret != OHOS::GSERROR_OK) {
978 delete rect;
979 delete region;
980 return ret;
981 }
982 }
983 delete rect;
984 delete region;
985
986 OH_NativeWindow_DestroyNativeWindow(nativeWindowNew);
987 return OHOS::GSERROR_OK;
988 }
989
CreateNativeWindowAndRequestBuffer008(uint64_t uniqueId,NativeWindow ** nativeWindow)990 int32_t NativeWindowTest::CreateNativeWindowAndRequestBuffer008(uint64_t uniqueId, NativeWindow **nativeWindow)
991 {
992 int32_t ret = OH_NativeWindow_CreateNativeWindowFromSurfaceId(uniqueId, nativeWindow);
993 if (ret != OHOS::GSERROR_OK) {
994 return ret;
995 }
996
997 int32_t code = SET_BUFFER_GEOMETRY;
998 int32_t height = 0x100;
999 int32_t width = 0x100;
1000 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, height, width);
1001 code = SET_FORMAT;
1002 int32_t format = GRAPHIC_PIXEL_FMT_RGBA_8888;
1003 OH_NativeWindow_NativeWindowHandleOpt(*nativeWindow, code, format);
1004
1005 return CreateNativeWindowAndAttachBuffer001(*nativeWindow);
1006 }
1007
ThreadNativeWindowProcess008(int32_t * pipeRead,int32_t * pipeWrite,uint64_t uniqueId)1008 int32_t NativeWindowTest::ThreadNativeWindowProcess008(int32_t *pipeRead, int32_t *pipeWrite, uint64_t uniqueId)
1009 {
1010 int64_t data;
1011 NativeWindow *nativeWindow = nullptr;
1012 int32_t ret = CreateNativeWindowAndRequestBuffer008(uniqueId, &nativeWindow);
1013 if (ret != OHOS::GSERROR_OK) {
1014 data = ret;
1015 write(pipeWrite[1], &data, sizeof(data));
1016 return -1;
1017 }
1018 ret = OH_NativeWindow_NativeObjectReference(nativeWindow);
1019 if (ret != OHOS::GSERROR_OK) {
1020 data = ret;
1021 write(pipeWrite[1], &data, sizeof(data));
1022 return -1;
1023 }
1024 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
1025
1026 data = ret;
1027 write(pipeWrite[1], &data, sizeof(data));
1028 read(pipeRead[0], &data, sizeof(data));
1029 ret = RequestBuffer001(nativeWindow);
1030 if (ret != OHOS::GSERROR_OK) {
1031 data = ret;
1032 write(pipeWrite[1], &data, sizeof(data));
1033 return -1;
1034 }
1035 data = ret;
1036 write(pipeWrite[1], &data, sizeof(data));
1037 ret = OH_NativeWindow_NativeObjectUnreference(nativeWindow);
1038 if (ret != OHOS::GSERROR_OK) {
1039 return -1;
1040 }
1041 return 0;
1042 }
1043
1044 HWTEST_F(NativeWindowTest, OH_NativeWindow_NativeWindowAttachBuffer001, Function | MediumTest | Level2)
1045 {
1046 int32_t pipeRead[2] = {};
1047 int32_t pipeWrite[2] = {};
1048 pipe(pipeRead);
1049 pipe(pipeWrite);
1050
1051 sptr<OHOS::IConsumerSurface> cSurface = IConsumerSurface::Create("OH_NativeWindow_NativeWindowAttachBuffer001");
1052 cSurface->RegisterConsumerListener(this);
1053 auto producer = cSurface->GetProducer();
1054 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
1055 EXPECT_NE(pSurface, nullptr);
1056 EXPECT_EQ(cSurface->SetQueueSize(QUEUE_SIZE), OHOS::GSERROR_OK);
1057
1058 uint64_t uniqueId = cSurface->GetUniqueId();
__anon31584efa0802() 1059 std::thread thread([this, pipeRead, pipeWrite, uniqueId]() {
1060 int32_t ret = this->ThreadNativeWindowProcess008((int32_t*)pipeRead, (int32_t*)pipeWrite, uniqueId);
1061 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1062 });
1063
1064 int64_t data = 0;
1065 read(pipeWrite[0], &data, sizeof(data));
1066 EXPECT_EQ(data, OHOS::GSERROR_OK);
1067
1068 OHOS::sptr<SurfaceBuffer> buffer = nullptr;
1069 int32_t fence = -1;
1070 int64_t timestamp;
1071 Rect damage;
1072 EXPECT_EQ(g_onBufferAvailable_, QUEUE_SIZE);
1073 while (g_onBufferAvailable_ > 0) {
1074 auto ret = cSurface->AcquireBuffer(buffer, fence, timestamp, damage);
1075 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1076 EXPECT_NE(buffer, nullptr);
1077 EXPECT_EQ(GetData(buffer), true);
1078
1079 ret = cSurface->ReleaseBuffer(buffer, -1);
1080 EXPECT_EQ(ret, OHOS::GSERROR_OK);
1081 g_onBufferAvailable_--;
1082 }
1083
1084 write(pipeRead[1], &data, sizeof(data));
1085 read(pipeWrite[0], &data, sizeof(data));
1086 EXPECT_EQ(data, OHOS::GSERROR_OK);
1087 EXPECT_EQ(g_onBufferAvailable_, QUEUE_SIZE);
1088 g_onBufferAvailable_ = 0;
1089 if (thread.joinable()) {
1090 thread.join();
1091 }
1092 close(pipeRead[0]);
1093 close(pipeRead[1]);
1094 close(pipeWrite[0]);
1095 close(pipeWrite[1]);
1096 producer = nullptr;
1097 cSurface = nullptr;
1098 }
1099
1100 /*
1101 * CaseDescription: 1. preSetup: create native window
1102 * 2. operation: set native window format is NATIVEBUFFER_PIXEL_FMT_RGBA16_FLOAT and request buffer
1103 * 3. result: The requested buffer format attribute is NATIVEBUFFER_PIXEL_FMT_RGBA16_FLOAT,
1104 * and NATIVEBUFFER_PIXEL_FMT_RGBA16_FLOAT equal GRAPHIC_PIXEL_FMT_RGBA16_FLOAT
1105 */
1106 HWTEST_F(NativeWindowTest, OH_NativeWindow_NativeWindowSetFormat001, Function | MediumTest | Level2)
1107 {
1108 // preSetup
1109 sptr<IConsumerSurface> cSurface = IConsumerSurface::Create("SurfaceB");
1110 cSurface->RegisterConsumerListener(new OnBufferAvailableTest());
1111 auto producer = cSurface->GetProducer();
1112 sptr<Surface> pSurface = Surface::CreateSurfaceAsProducer(producer);
1113 EXPECT_NE(pSurface, nullptr);
1114 NativeWindow *nativeWindowNew = OH_NativeWindow_CreateNativeWindow(&pSurface);
1115 int32_t code = SET_BUFFER_GEOMETRY;
1116 int32_t height = 0x100;
1117 int32_t width = 0x100;
1118 OH_NativeWindow_NativeWindowHandleOpt(nativeWindowNew, code, height, width);
1119
1120 // operation
1121 code = SET_FORMAT;
1122 int32_t format = 10;
1123 EXPECT_EQ(NATIVEBUFFER_PIXEL_FMT_RGBA16_FLOAT - GRAPHIC_PIXEL_FMT_RGBA16_FLOAT, 0);
1124 OH_NativeWindow_NativeWindowHandleOpt(nativeWindowNew, code, format);
1125
1126 struct NativeWindowBuffer *nativeWindowBuffer = nullptr;
1127 int32_t fenceFd = -1;
1128 auto ret = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindowNew, &nativeWindowBuffer, &fenceFd);
1129
1130 // result
1131 if (ret == GSERROR_OK) {
1132 auto bufferHandle = OH_NativeWindow_GetBufferHandleFromNative(nativeWindowBuffer);
1133 EXPECT_EQ(bufferHandle->format, format);
1134 }
1135 }
1136 }
1137