1 /**************************************************************************
3 * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
5 * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
6 * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
7 * Contact: Roman Marchenko <r.marchenko@samsung.com>
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the
11 * "Software"), to deal in the Software without restriction, including
12 * without limitation the rights to use, copy, modify, merge, publish,
13 * distribute, sub license, and/or sell copies of the Software, and to
14 * permit persons to whom the Software is furnished to do so, subject to
15 * the following conditions:
17 * The above copyright notice and this permission notice (including the
18 * next paragraph) shall be included in all copies or substantial portions
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
24 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
25 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
26 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
27 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 **************************************************************************/
31 #include "gtest/gtest.h"
32 #include "ut_common.h"
35 #include <sys/epoll.h>
36 #include <sys/timerfd.h>
40 #include "tbm_bufmgr.h"
41 #include "tbm_drm_helper.h"
42 #include "tbm_surface.h"
43 #include "tbm_surface_queue.h"
46 class TDMLayer : public ::testing::Test {
48 tdm_display *dpy = NULL;
49 tbm_bufmgr tbm_bufmgr = NULL;
50 int master_fd = -42, tbm_fd = -42, layer_count = 0, output_count = 0;
51 tdm_layer **tdm_layer_array = NULL;
52 tbm_surface_h *tdm_layers_buffer_array = NULL;
53 tbm_surface_queue_h *tdm_layers_buffer_queue_array = NULL;
54 int *tdm_layer_output_idx = NULL;
55 const tdm_output_mode **preferred_mode_array = NULL;
56 bool has_layers = false;
59 setenv("TDM_DEBUG_MODULE", "all", 1);
60 setenv("TDM_DEBUG", "1", 1);
61 setenv("TDM_THREAD", "0", 1);
62 setenv("TDM_COMMIT_PER_VBLANK", "1", 1);
63 setenv("TDM_DLOG", "1", 1);
64 setenv("XDG_RUNTIME_DIR", ".", 1);
65 setenv("TBM_DLOG", "1", 1);
66 setenv("TBM_DISPLAY_SERVER", "1", 1);
70 const tdm_output_mode *preferred_mode = NULL;
71 tdm_error error = TDM_ERROR_NONE;
75 /* FIXME: fix the error. If we initialize TBM before TDM we get fail
76 * in the tdm_output_set_dpms */
78 tbm_bufmgr = tbm_bufmgr_init(-1);
79 ASSERT_FALSE(tbm_bufmgr == NULL);
82 dpy = tdm_display_init(&error);
83 ASSERT_TRUE(error == TDM_ERROR_NONE);
84 ASSERT_FALSE(dpy == NULL);
86 master_fd = tbm_drm_helper_get_master_fd();
87 tbm_fd = tbm_drm_helper_get_fd();
88 ASSERT_TRUE(tdm_display_get_output_count(dpy, &output_count) == TDM_ERROR_NONE);
90 preferred_mode_array = (const tdm_output_mode **)calloc(output_count, sizeof(tdm_output_mode *));
91 ASSERT_FALSE(NULL == preferred_mode_array);
92 if (!preferred_mode_array)
95 for (int i = 0; i < output_count; i++) {
96 tdm_output *output = tdm_display_get_output(dpy, i, &error);
97 int output_modes_cnt = 0;
98 const tdm_output_mode *output_modes;
100 if (TDM_ERROR_NONE != error || NULL == output)
103 tdm_output_conn_status status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
104 if (TDM_ERROR_NONE != tdm_output_get_conn_status(output, &status))
107 if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
110 error = tdm_output_get_available_modes(output, &output_modes, &output_modes_cnt);
111 if (TDM_ERROR_NONE != error)
113 if (output_modes_cnt <= 0) {
117 for(int j = 0; j < output_modes_cnt; j++)
118 if(output_modes[j].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
119 preferred_mode = &output_modes[j];
124 int temp_layer_count = 0;
125 if (TDM_ERROR_NONE != tdm_output_get_layer_count(output, &temp_layer_count))
127 if (0 == temp_layer_count)
129 tdm_layer_array = (tdm_layer **) realloc(tdm_layer_array,
130 (layer_count + temp_layer_count)*sizeof(tdm_layer *));
132 ASSERT_FALSE(NULL == tdm_layer_array);
134 tdm_layer_output_idx = (int *) realloc(tdm_layer_output_idx,
135 (layer_count + temp_layer_count)*sizeof(int));
136 ASSERT_FALSE(NULL == tdm_layer_output_idx);
138 for (int k = layer_count; k < (layer_count + temp_layer_count); k++) {
139 tdm_layer_array[k] = tdm_output_get_layer(output, k, &error);
140 tdm_layer_output_idx[k] = i;
141 ASSERT_TRUE(TDM_ERROR_NONE == error);
142 ASSERT_FALSE(NULL == tdm_layer_array[k]);
144 layer_count += temp_layer_count;
145 preferred_mode_array[i] = preferred_mode;
148 tdm_layers_buffer_array = (tbm_surface_h *) calloc(layer_count, sizeof(tbm_surface_h));
149 ASSERT_FALSE(NULL == tdm_layers_buffer_array);
151 tdm_layers_buffer_queue_array = (tbm_surface_queue_h *) calloc(layer_count, sizeof(tbm_surface_queue_h));
152 ASSERT_FALSE(NULL == tdm_layers_buffer_queue_array);
154 #ifdef FAIL_ON_UNSUPPORTED
155 ASSERT_GT(layer_count, 0);
164 for (int i = 0; i < layer_count; ++i) {
165 error = tdm_layer_unset_buffer(tdm_layer_array[i]);
166 EXPECT_TRUE(error == TDM_ERROR_NONE);
168 if (tdm_layers_buffer_array[i])
169 tbm_surface_destroy(tdm_layers_buffer_array[i]);
171 if (tdm_layers_buffer_queue_array[i])
172 tbm_surface_queue_destroy(tdm_layers_buffer_queue_array[i]);
174 tdm_layers_buffer_array[i] = NULL;
175 tdm_layers_buffer_queue_array[i] = NULL;
178 tdm_display_deinit(dpy);
180 tbm_bufmgr_deinit(tbm_bufmgr);
183 free(tdm_layer_array);
184 if (tdm_layer_output_idx)
185 free(tdm_layer_output_idx);
186 if (preferred_mode_array)
187 free(preferred_mode_array);
188 if (master_fd > -1) {
189 int temp_master_fd = tbm_drm_helper_get_master_fd();
190 EXPECT_EQ(temp_master_fd, -1) << "Fatal Error. Can't deinit tdm/tbm" << std::endl;
191 if (temp_master_fd > -1)
196 int temp_tbm_fd = tbm_drm_helper_get_fd();
197 EXPECT_EQ(temp_tbm_fd, -1) << "Fatal Error. Can't deinit tdm/tbm" << std::endl;
198 if (temp_tbm_fd > -1)
203 unsetenv("TDM_DEBUG_MODULE");
204 unsetenv("TDM_DEBUG");
205 unsetenv("TDM_THREAD");
206 unsetenv("TDM_COMMIT_PER_VBLANK");
207 unsetenv("TDM_DLOG");
208 unsetenv("XDG_RUNTIME_DIR");
209 unsetenv("TBM_DLOG");
210 unsetenv("TBM_DISPLAY_SERVER");
213 tbm_surface_h UtCreateBufferForLayer(int layer_idx, int width, int height,
214 int format, int flags)
216 tbm_surface_h buffer;
218 buffer = tbm_surface_internal_create_with_flags(width, height, format, flags);
220 tdm_layers_buffer_array[layer_idx] = buffer;
225 tbm_surface_queue_h UtCreateBufferQueueForLayer(int layer_idx, int width, int height,
226 int format, int flags)
228 tbm_surface_queue_h buffer_queue;
230 buffer_queue = tbm_surface_queue_create(2, width, height, format, flags);
232 tdm_layers_buffer_queue_array[layer_idx] = buffer_queue;
238 class TDMLayerCommit : public TDMLayer
244 static const int timeLimitSec = 0;
245 static const int timeLimitNsec = 100000000;
248 static int utLayerCommitHandlerCounter;
249 static void UtLayerCommitHandler(tdm_layer *layer, unsigned int sequence,
250 unsigned int tv_sec, unsigned int tv_usec,
253 int *data = (int *)user_data;
257 utLayerCommitHandlerCounter++;
264 struct epoll_event ep;
266 utLayerCommitHandlerCounter = 0;
268 ASSERT_NO_FATAL_FAILURE(TDMLayer::SetUp());
270 for (int i = 0; i < output_count; ++i) {
271 if (!preferred_mode_array[i])
274 output = tdm_display_get_output(dpy, i, &error);
275 ASSERT_FALSE(output == NULL);
276 ASSERT_TRUE(error == TDM_ERROR_NONE);
278 error = tdm_output_set_mode(output, preferred_mode_array[i]);
279 ASSERT_TRUE(error == TDM_ERROR_NONE);
281 error = tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON);
282 ASSERT_TRUE(error == TDM_ERROR_NONE);
285 epFd = epoll_create1(0);
286 ASSERT_TRUE(epFd != -1);
288 timerFd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
289 ASSERT_TRUE(timerFd != -1);
291 memset(&ep, 0, sizeof ep);
292 ep.events |= EPOLLIN;
293 ep.data.fd = timerFd;
294 ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, timerFd, &ep) == 0);
296 ASSERT_TRUE(tdm_display_get_fd(dpy, &tdmFd) == TDM_ERROR_NONE);
298 memset(&ep, 0, sizeof ep);
299 ep.events |= EPOLLIN;
301 ASSERT_TRUE(epoll_ctl(epFd, EPOLL_CTL_ADD, tdmFd, &ep) == 0);
309 for (int i = 0; i < output_count; ++i) {
310 if (!preferred_mode_array[i])
313 output = tdm_display_get_output(dpy, i, &error);
314 EXPECT_FALSE(output == NULL);
315 EXPECT_TRUE(error == TDM_ERROR_NONE);
317 error = tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF);
318 EXPECT_TRUE(error == TDM_ERROR_NONE);
321 TDMLayer::TearDown();
324 void UtHandleCommitEvent(int num_waiting_layers)
326 struct itimerspec its;
328 struct epoll_event ep_event[2];
330 if (utLayerCommitHandlerCounter == num_waiting_layers)
333 its.it_interval.tv_sec = 0;
334 its.it_interval.tv_nsec = 0;
335 its.it_value.tv_sec = timeLimitSec;
336 its.it_value.tv_nsec = timeLimitNsec;
338 ASSERT_TRUE(timerfd_settime(timerFd, 0, &its, NULL) == 0);
341 count = epoll_wait(epFd, ep_event, sizeof(ep_event), -1);
342 ASSERT_TRUE(count >= 0);
344 for (int i = 0; i < count; i++) {
345 if (ep_event[i].data.fd == timerFd) {
348 ASSERT_TRUE(tdm_display_handle_events(dpy) == TDM_ERROR_NONE);
349 if (utLayerCommitHandlerCounter == num_waiting_layers)
357 class TDMLayerCommitThread : public TDMLayerCommit
362 setenv("TDM_DEBUG_MODULE", "all", 1);
363 setenv("TDM_DEBUG", "1", 1);
364 setenv("TDM_THREAD", "1", 1);
365 setenv("TDM_COMMIT_PER_VBLANK", "1", 1);
366 setenv("TDM_DLOG", "1", 1);
367 setenv("XDG_RUNTIME_DIR", ".", 1);
368 setenv("TBM_DLOG", "1", 1);
369 setenv("TBM_DISPLAY_SERVER", "1", 1);
373 class TDMLayerCommitWithDisabledCommitPerVblank : public TDMLayerCommit
378 setenv("TDM_DEBUG_MODULE", "all", 1);
379 setenv("TDM_DEBUG", "1", 1);
380 setenv("TDM_THREAD", "0", 1);
381 setenv("TDM_COMMIT_PER_VBLANK", "0", 1);
382 setenv("TDM_DLOG", "1", 1);
383 setenv("XDG_RUNTIME_DIR", ".", 1);
384 setenv("TBM_DLOG", "1", 1);
385 setenv("TBM_DISPLAY_SERVER", "1", 1);
389 int TDMLayerCommit::utLayerCommitHandlerCounter = 0;
391 TEST_F(TDMLayer, LayerGetCapabilitiesSuccessful)
393 SKIP_FLAG(has_layers);
394 for (int i = 0; i < layer_count; i++) {
395 tdm_layer_capability capabilities = (tdm_layer_capability) -42;
396 ASSERT_TRUE(TDM_ERROR_NONE == tdm_layer_get_capabilities(tdm_layer_array[i], &capabilities));
397 ASSERT_NE(capabilities, -42);
401 TEST_F(TDMLayer, LayerGetCapabilitiesFailNullAll)
403 SKIP_FLAG(has_layers);
404 ASSERT_EXIT({if (tdm_layer_get_capabilities(NULL, NULL) == TDM_ERROR_NONE) exit(1);
405 exit(0);}, ::testing::ExitedWithCode(0), "");
408 TEST_F(TDMLayer, LayerGetCapabilitiesFailOnlyLayer)
410 SKIP_FLAG(has_layers);
411 ASSERT_EXIT({for (int i = 0; i < layer_count; i++) {
412 if (tdm_layer_get_capabilities(tdm_layer_array[i], NULL) == TDM_ERROR_NONE) exit(1);
414 exit(0);}, ::testing::ExitedWithCode(0), "");
417 TEST_F(TDMLayer, OutputGetPrimaryIndexSuccessful)
419 SKIP_FLAG(has_layers);
420 for (int i = 0; i < output_count; i++) {
421 tdm_error error = TDM_ERROR_NONE;
423 tdm_output * output = tdm_display_get_output(dpy, i, &error);
424 ASSERT_FALSE(NULL == output);
425 ASSERT_TRUE(TDM_ERROR_NONE == error);
426 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_primary_index(output, &index));
427 ASSERT_NE(index, -42);
431 TEST_F(TDMLayer, OutputGetPrimaryIndexFailNullAll)
433 SKIP_FLAG(has_layers);
434 ASSERT_EXIT({if (tdm_output_get_primary_index(NULL, NULL) == TDM_ERROR_NONE) exit(1);
435 exit(0);}, ::testing::ExitedWithCode(0), "");
438 TEST_F(TDMLayer, OutputGetPrimaryIndexFailOnlyOutput)
440 SKIP_FLAG(has_layers);
441 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
442 tdm_error error = TDM_ERROR_NONE;
443 tdm_output * output = tdm_display_get_output(dpy, i, &error);
444 if (NULL == output) exit(1);
445 if (TDM_ERROR_NONE != error) exit(1);
446 if (tdm_output_get_primary_index(output, NULL) == TDM_ERROR_NONE) exit(1);
448 exit(0);}, ::testing::ExitedWithCode(0), "");
451 /* tdm_layer_get_available_formats() */
453 TEST_F(TDMLayer, LayerGetAvailableFormatsFailNullAll)
455 SKIP_FLAG(has_layers);
456 ASSERT_EXIT({if (tdm_layer_get_available_formats(NULL, NULL, NULL) == TDM_ERROR_NONE) exit(1);
457 exit(0);}, ::testing::ExitedWithCode(0), "");
460 TEST_F(TDMLayer, LayerGetAvailableFormatsFailNullLayer)
462 SKIP_FLAG(has_layers);
463 ASSERT_EXIT({const tbm_format *formats;
465 if (tdm_layer_get_available_formats(NULL, &formats, &count) == TDM_ERROR_NONE) exit(1);
466 exit(0);}, ::testing::ExitedWithCode(0), "");
469 TEST_F(TDMLayer, LayerGetAvailableFormatsFailNullFormats)
471 SKIP_FLAG(has_layers);
472 ASSERT_EXIT({int count;
473 for (int i = 0; i < layer_count; i++) {
474 if (tdm_layer_get_available_formats(tdm_layer_array[i], NULL, &count) == TDM_ERROR_NONE) exit(1);
476 exit(0);}, ::testing::ExitedWithCode(0), "");
479 TEST_F(TDMLayer, LayerGetAvailableFormatsFailNullCount)
481 SKIP_FLAG(has_layers);
482 ASSERT_EXIT({const tbm_format *formats;
483 for (int i = 0; i < layer_count; i++) {
484 if (tdm_layer_get_available_formats(tdm_layer_array[i], &formats, NULL) == TDM_ERROR_NONE) exit(1);
486 exit(0);}, ::testing::ExitedWithCode(0), "");
489 TEST_F(TDMLayer, LayerGetAvailableFormatsSuccess)
491 SKIP_FLAG(has_layers);
493 const tbm_format *formats;
496 for (int i = 0; i < layer_count; ++i) {
497 error = tdm_layer_get_available_formats(tdm_layer_array[i], &formats, &count);
498 ASSERT_EQ(TDM_ERROR_NONE, error);
499 ASSERT_NE(NULL, formats);
504 /* tdm_layer_get_available_properties() */
506 TEST_F(TDMLayer, LayerGetAvailablePropertiesFailNullAll)
508 SKIP_FLAG(has_layers);
509 ASSERT_EXIT({if (tdm_layer_get_available_properties(NULL, NULL, NULL) == TDM_ERROR_NONE) exit(1);
510 exit(0);}, ::testing::ExitedWithCode(0), "");
513 TEST_F(TDMLayer, LayerGetAvailablePropertiesFailNullLayer)
515 SKIP_FLAG(has_layers);
516 ASSERT_EXIT({const tdm_prop *props;
518 if (tdm_layer_get_available_properties(NULL, &props, &count) == TDM_ERROR_NONE) exit(1);
519 exit(0);}, ::testing::ExitedWithCode(0), "");
522 TEST_F(TDMLayer, LayerGetAvailablePropertiesFailNullFormats)
524 SKIP_FLAG(has_layers);
525 ASSERT_EXIT({int count;
526 for (int i = 0; i < layer_count; i++) {
527 if (tdm_layer_get_available_properties(tdm_layer_array[i], NULL, &count) == TDM_ERROR_NONE) exit(1);
529 exit(0);}, ::testing::ExitedWithCode(0), "");
532 TEST_F(TDMLayer, LayerGetAvailablePropertiesFailNullCount)
534 SKIP_FLAG(has_layers);
535 ASSERT_EXIT({const tdm_prop *props;
536 for (int i = 0; i < layer_count; i++) {
537 if (tdm_layer_get_available_properties(tdm_layer_array[i], &props, NULL) == TDM_ERROR_NONE) exit(1);
539 exit(0);}, ::testing::ExitedWithCode(0), "");
542 TEST_F(TDMLayer, LayerGetAvailablePropertiesSuccess)
544 SKIP_FLAG(has_layers);
546 const tdm_prop *props;
549 for (int i = 0; i < layer_count; ++i) {
550 error = tdm_layer_get_available_properties(tdm_layer_array[i], &props, &count);
551 ASSERT_EQ(TDM_ERROR_NONE, error);
555 /* tdm_layer_get_zpos() */
557 TEST_F(TDMLayer, LayerGetZposFailNullAll)
559 SKIP_FLAG(has_layers);
560 ASSERT_EXIT({if (tdm_layer_get_zpos(NULL, NULL) == TDM_ERROR_NONE) exit(1);
561 exit(0);}, ::testing::ExitedWithCode(0), "");
564 TEST_F(TDMLayer, LayerGetZposFailNullLayer)
566 SKIP_FLAG(has_layers);
567 ASSERT_EXIT({int zpos;
568 if (tdm_layer_get_zpos(NULL, &zpos) == TDM_ERROR_NONE) exit(1);
569 exit(0);}, ::testing::ExitedWithCode(0), "");
572 TEST_F(TDMLayer, LayerGetZposFailNullZpos)
574 SKIP_FLAG(has_layers);
575 ASSERT_EXIT({for (int i = 0; i < layer_count; i++) {
576 if (tdm_layer_get_zpos(tdm_layer_array[i], NULL) == TDM_ERROR_NONE) exit(1);
578 exit(0);}, ::testing::ExitedWithCode(0), "");
581 TEST_F(TDMLayer, LayerGetZposSuccess)
583 SKIP_FLAG(has_layers);
586 for (int i = 0; i < layer_count; ++i) {
588 error = tdm_layer_get_zpos(tdm_layer_array[i], &zpos);
589 ASSERT_EQ(TDM_ERROR_NONE, error);
590 ASSERT_NE(INT_MIN, zpos);
594 /* tdm_layer_set_property() */
596 TEST_F(TDMLayer, LayerSetPropertyFailNullLayer)
598 SKIP_FLAG(has_layers);
599 ASSERT_EXIT({tdm_value value;
601 if (tdm_layer_set_property(NULL, id, value) == TDM_ERROR_NONE) exit(1);
602 exit(0);}, ::testing::ExitedWithCode(0), "");
605 TEST_F(TDMLayer, LayerSetPropertyFailWrongId)
607 SKIP_FLAG(has_layers);
612 for (int i = 0; i < layer_count; ++i) {
613 error = tdm_layer_set_property(tdm_layer_array[i], id, value);
614 ASSERT_NE(TDM_ERROR_NONE, error);
618 /* tdm_layer_get_property() */
620 TEST_F(TDMLayer, LayerGetPropertyFailNullLayer)
622 SKIP_FLAG(has_layers);
623 ASSERT_EXIT({tdm_value value;
625 if (tdm_layer_get_property(NULL, id, &value) == TDM_ERROR_NONE) exit(1);
626 exit(0);}, ::testing::ExitedWithCode(0), "");
629 TEST_F(TDMLayer, LayerGetPropertyFailNullValue)
631 SKIP_FLAG(has_layers);
632 ASSERT_EXIT({int id = INT_MAX;
633 for (int i = 0; i < layer_count; ++i) {
634 if (tdm_layer_get_property(tdm_layer_array[i], id, NULL) == TDM_ERROR_NONE) exit(1);
636 exit(0);}, ::testing::ExitedWithCode(0), "");
639 TEST_F(TDMLayer, LayerGetPropertyFailWrongId)
641 SKIP_FLAG(has_layers);
646 for (int i = 0; i < layer_count; ++i) {
647 error = tdm_layer_get_property(tdm_layer_array[i], id, &value);
648 ASSERT_NE(TDM_ERROR_NONE, error);
652 /* tdm_layer_set_info() */
654 TEST_F(TDMLayer, LayerSetInfoFailNullAll)
656 SKIP_FLAG(has_layers);
657 ASSERT_EXIT({if (tdm_layer_set_info(NULL, NULL) == TDM_ERROR_NONE) exit(1);
658 exit(0);}, ::testing::ExitedWithCode(0), "");
661 TEST_F(TDMLayer, LayerSetInfoFailNullLayer)
663 SKIP_FLAG(has_layers);
665 ASSERT_EXIT({tdm_info_layer info = {0};
666 if (tdm_layer_set_info(NULL, &info) == TDM_ERROR_NONE) exit(1);
667 exit(0);}, ::testing::ExitedWithCode(0), "");
670 TEST_F(TDMLayer, LayerSetInfoFailNullInfo)
672 SKIP_FLAG(has_layers);
674 ASSERT_EXIT({for (int i = 0; i < layer_count; ++i)
675 if (tdm_layer_set_info(tdm_layer_array[i], NULL) == TDM_ERROR_NONE) exit(1);
676 exit(0);}, ::testing::ExitedWithCode(0), "");
680 _ut_tdm_layer_set_info(tdm_layer *layer, int w, int h)
682 tdm_info_layer info = {0};
684 info.src_config.size.h = w;
685 info.src_config.size.v = h;
686 info.src_config.pos.x = 0;
687 info.src_config.pos.y = 0;
688 info.src_config.pos.w = w;
689 info.src_config.pos.h = h;
690 info.src_config.format = TBM_FORMAT_ARGB8888;
695 info.transform = TDM_TRANSFORM_NORMAL;
697 return tdm_layer_set_info(layer, &info);
700 TEST_F(TDMLayer, LayerSetInfoSuccess)
702 SKIP_FLAG(has_layers);
705 for (int i = 0; i < layer_count; ++i) {
706 error = _ut_tdm_layer_set_info(tdm_layer_array[i], 128, 128);
707 ASSERT_EQ(TDM_ERROR_NONE, error);
711 /* tdm_layer_get_info() */
713 TEST_F(TDMLayer, LayerGetInfoFailNullAll)
715 SKIP_FLAG(has_layers);
716 ASSERT_EXIT({if (tdm_layer_get_info(NULL, NULL) == TDM_ERROR_NONE) exit(1);
717 exit(0);}, ::testing::ExitedWithCode(0), "");
720 TEST_F(TDMLayer, LayerGetInfoFailNullLayer)
722 SKIP_FLAG(has_layers);
724 ASSERT_EXIT({tdm_info_layer info = {0};
725 if (tdm_layer_get_info(NULL, &info) == TDM_ERROR_NONE) exit(1);
726 exit(0);}, ::testing::ExitedWithCode(0), "");
729 TEST_F(TDMLayer, LayerGetInfoFailNullInfo)
731 SKIP_FLAG(has_layers);
733 ASSERT_EXIT({for (int i = 0; i < layer_count; ++i)
734 if (tdm_layer_get_info(tdm_layer_array[i], NULL) == TDM_ERROR_NONE) exit(1);
735 exit(0);}, ::testing::ExitedWithCode(0), "");
738 TEST_F(TDMLayer, LayerGetInfoSuccess)
740 SKIP_FLAG(has_layers);
742 tdm_info_layer set_info = {0};
743 tdm_info_layer ret_info = {0};
745 set_info.src_config.size.h = 128;
746 set_info.src_config.size.v = 128;
747 set_info.src_config.pos.x = 0;
748 set_info.src_config.pos.y = 0;
749 set_info.src_config.pos.w = 128;
750 set_info.src_config.pos.h = 128;
751 set_info.src_config.format = TBM_FORMAT_ARGB8888;
752 set_info.dst_pos.x = 0;
753 set_info.dst_pos.y = 0;
754 set_info.dst_pos.w = 128;
755 set_info.dst_pos.h = 128;
756 set_info.transform = TDM_TRANSFORM_NORMAL;
758 for (int i = 0; i < layer_count; ++i) {
759 error = tdm_layer_get_info(tdm_layer_array[i], &set_info);
760 ASSERT_EQ(TDM_ERROR_NONE, error);
762 error = tdm_layer_get_info(tdm_layer_array[i], &ret_info);
763 ASSERT_EQ(TDM_ERROR_NONE, error);
765 ASSERT_TRUE(!memcmp(&ret_info, &set_info, sizeof(tdm_info_layer)));
769 /* tdm_layer_set_buffer() */
771 TEST_F(TDMLayer, LayerSetBufferFailNullAll)
773 SKIP_FLAG(has_layers);
774 ASSERT_EXIT({if (tdm_layer_set_buffer(NULL, NULL) == TDM_ERROR_NONE) exit(1);
775 exit(0);}, ::testing::ExitedWithCode(0), "");
778 TEST_F(TDMLayer, LayerSetBufferFailNullLayer)
780 SKIP_FLAG(has_layers);
782 ASSERT_EXIT({tdm_error error;
783 tbm_surface_h buffer = UtCreateBufferForLayer(0, 128, 128, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
784 if (!buffer) exit(1);
785 error = tdm_layer_set_buffer(NULL, buffer);
786 if (error == TDM_ERROR_NONE) exit(1);
787 exit(0);}, ::testing::ExitedWithCode(0), "");
790 TEST_F(TDMLayer, LayerSetBufferFailNullBuffer)
792 SKIP_FLAG(has_layers);
794 ASSERT_EXIT({for (int i = 0; i < layer_count; ++i)
795 if (tdm_layer_set_buffer(tdm_layer_array[i], NULL) == TDM_ERROR_NONE) exit(1);
796 exit(0);}, ::testing::ExitedWithCode(0), "");
799 TEST_F(TDMLayer, LayerSetBufferSuccess)
801 SKIP_FLAG(has_layers);
802 tbm_surface_h buffer;
805 for (int i = 0; i < layer_count; ++i) {
806 buffer = UtCreateBufferForLayer(i, 128, 128, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
807 ASSERT_NE(NULL, buffer);
809 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
810 ASSERT_EQ(TDM_ERROR_NONE, error);
814 TEST_F(TDMLayer, LayerSetBufferSuccessTwice)
816 SKIP_FLAG(has_layers);
817 tbm_surface_h buffer;
820 for (int i = 0; i < layer_count; ++i) {
821 buffer = UtCreateBufferForLayer(i, 128, 128, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
822 ASSERT_NE(NULL, buffer);
824 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
825 ASSERT_EQ(TDM_ERROR_NONE, error);
827 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
828 ASSERT_EQ(TDM_ERROR_NONE, error);
832 /* tdm_layer_unset_buffer() */
834 TEST_F(TDMLayer, LayerUnsetBufferFailNullLayer)
836 SKIP_FLAG(has_layers);
838 ASSERT_EXIT({tdm_error error;
839 error = tdm_layer_unset_buffer(NULL);
840 if (error == TDM_ERROR_NONE) exit(1);
841 exit(0);}, ::testing::ExitedWithCode(0), "");
844 TEST_F(TDMLayer, LayerUnsetBufferSuccess)
846 SKIP_FLAG(has_layers);
847 tbm_surface_h buffer;
850 for (int i = 0; i < layer_count; ++i) {
851 buffer = UtCreateBufferForLayer(i, 128, 128, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
852 ASSERT_NE(NULL, buffer);
854 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
855 ASSERT_EQ(TDM_ERROR_NONE, error);
857 error = tdm_layer_unset_buffer(tdm_layer_array[i]);
858 ASSERT_EQ(TDM_ERROR_NONE, error);
862 /* tdm_layer_commit() */
864 TEST_F(TDMLayer, LayerCommitFailNullAll)
866 SKIP_FLAG(has_layers);
868 ASSERT_EXIT({tdm_error error;
869 error = tdm_layer_commit(NULL, NULL, NULL);
870 if (error == TDM_ERROR_NONE) exit(1);
871 exit(0);}, ::testing::ExitedWithCode(0), "");
874 TEST_F(TDMLayer, LayerCommitFailDpmsOff)
876 SKIP_FLAG(has_layers);
879 for (int i = 0; i < layer_count; ++i) {
880 error = tdm_layer_commit(tdm_layer_array[i], NULL, NULL);
881 ASSERT_NE(TDM_ERROR_NONE, error);
885 TEST_F(TDMLayerCommit, LayerCommitSuccess)
887 SKIP_FLAG(has_layers);
891 for (int i = 0; i < layer_count; ++i) {
892 tbm_surface_h buffer = NULL;
893 tdm_layer_capability layer_capability;
895 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
896 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
898 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
899 ASSERT_EQ(TDM_ERROR_NONE, error);
901 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
906 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
907 ASSERT_EQ(TDM_ERROR_NONE, error);
909 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
910 ASSERT_NE(NULL, buffer);
912 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
913 ASSERT_EQ(TDM_ERROR_NONE, error);
915 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
916 ASSERT_EQ(TDM_ERROR_NONE, error);
919 UtHandleCommitEvent(layer_count);
921 ASSERT_EQ(layer_count, utLayerCommitHandlerCounter);
922 ASSERT_EQ(layer_count, data);
925 TEST_F(TDMLayerCommitThread, LayerCommitSuccess)
927 SKIP_FLAG(has_layers);
931 for (int i = 0; i < layer_count; ++i) {
932 tbm_surface_h buffer = NULL;
933 tdm_layer_capability layer_capability;
935 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
936 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
938 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
939 ASSERT_EQ(TDM_ERROR_NONE, error);
941 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
946 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
947 ASSERT_EQ(TDM_ERROR_NONE, error);
949 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
950 ASSERT_NE(NULL, buffer);
952 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
953 ASSERT_EQ(TDM_ERROR_NONE, error);
955 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
956 ASSERT_EQ(TDM_ERROR_NONE, error);
959 UtHandleCommitEvent(layer_count);
961 ASSERT_EQ(layer_count, utLayerCommitHandlerCounter);
962 ASSERT_EQ(layer_count, data);
965 TEST_F(TDMLayerCommit, LayerCommitSuccessOnlyPrimaryLayers)
967 SKIP_FLAG(has_layers);
970 int num_waiting_layers = 0;
972 for (int i = 0; i < layer_count; ++i) {
973 tbm_surface_h buffer = NULL;
974 tdm_layer_capability layer_capability;
976 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
977 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
979 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
980 ASSERT_EQ(TDM_ERROR_NONE, error);
982 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY))
985 num_waiting_layers++;
987 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
988 ASSERT_EQ(TDM_ERROR_NONE, error);
990 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
991 ASSERT_NE(NULL, buffer);
993 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
994 ASSERT_EQ(TDM_ERROR_NONE, error);
996 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
997 ASSERT_EQ(TDM_ERROR_NONE, error);
1000 UtHandleCommitEvent(num_waiting_layers);
1002 ASSERT_EQ(num_waiting_layers, utLayerCommitHandlerCounter);
1003 ASSERT_EQ(num_waiting_layers, data);
1006 TEST_F(TDMLayerCommitThread, LayerCommitSuccessOnlyPrimaryLayers)
1008 SKIP_FLAG(has_layers);
1011 int num_waiting_layers = 0;
1013 for (int i = 0; i < layer_count; ++i) {
1014 tbm_surface_h buffer = NULL;
1015 tdm_layer_capability layer_capability;
1017 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1018 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1020 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1021 ASSERT_EQ(TDM_ERROR_NONE, error);
1023 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY))
1026 num_waiting_layers++;
1028 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1029 ASSERT_EQ(TDM_ERROR_NONE, error);
1031 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1032 ASSERT_NE(NULL, buffer);
1034 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1035 ASSERT_EQ(TDM_ERROR_NONE, error);
1037 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1038 ASSERT_EQ(TDM_ERROR_NONE, error);
1041 UtHandleCommitEvent(num_waiting_layers);
1043 ASSERT_EQ(num_waiting_layers, utLayerCommitHandlerCounter);
1044 ASSERT_EQ(num_waiting_layers, data);
1047 TEST_F(TDMLayerCommitWithDisabledCommitPerVblank, LayerCommitSuccess)
1049 SKIP_FLAG(has_layers);
1053 for (int i = 0; i < layer_count; ++i) {
1054 tbm_surface_h buffer = NULL;
1055 tdm_layer_capability layer_capability;
1057 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1058 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1060 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1061 ASSERT_EQ(TDM_ERROR_NONE, error);
1063 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1068 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1069 ASSERT_EQ(TDM_ERROR_NONE, error);
1071 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1072 ASSERT_NE(NULL, buffer);
1074 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1075 ASSERT_EQ(TDM_ERROR_NONE, error);
1077 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1078 ASSERT_EQ(TDM_ERROR_NONE, error);
1081 UtHandleCommitEvent(layer_count);
1083 ASSERT_EQ(layer_count, utLayerCommitHandlerCounter);
1084 ASSERT_EQ(layer_count, data);
1087 TEST_F(TDMLayerCommitWithDisabledCommitPerVblank, LayerCommitSuccessOnlyPrimaryLayers)
1089 SKIP_FLAG(has_layers);
1092 int num_waiting_layers = 0;
1094 for (int i = 0; i < layer_count; ++i) {
1095 tbm_surface_h buffer = NULL;
1096 tdm_layer_capability layer_capability;
1098 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1099 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1101 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1102 ASSERT_EQ(TDM_ERROR_NONE, error);
1104 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY))
1107 num_waiting_layers++;
1109 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1110 ASSERT_EQ(TDM_ERROR_NONE, error);
1112 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1113 ASSERT_NE(NULL, buffer);
1115 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1116 ASSERT_EQ(TDM_ERROR_NONE, error);
1118 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1119 ASSERT_EQ(TDM_ERROR_NONE, error);
1122 UtHandleCommitEvent(num_waiting_layers);
1124 ASSERT_EQ(num_waiting_layers, utLayerCommitHandlerCounter);
1125 ASSERT_EQ(num_waiting_layers, data);
1128 TEST_F(TDMLayerCommit, LayerCommitSuccessUnsetAfterCommit)
1130 SKIP_FLAG(has_layers);
1134 for (int i = 0; i < layer_count; ++i) {
1135 tbm_surface_h buffer = NULL;
1136 tdm_layer_capability layer_capability;
1138 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1139 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1141 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1142 ASSERT_EQ(TDM_ERROR_NONE, error);
1144 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1149 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1150 ASSERT_EQ(TDM_ERROR_NONE, error);
1152 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1153 ASSERT_NE(NULL, buffer);
1155 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1156 ASSERT_EQ(TDM_ERROR_NONE, error);
1158 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1159 ASSERT_EQ(TDM_ERROR_NONE, error);
1162 for (int i = 0; i < layer_count; ++i) {
1163 error = tdm_layer_unset_buffer(tdm_layer_array[i]);
1164 ASSERT_EQ(TDM_ERROR_NONE, error);
1167 UtHandleCommitEvent(layer_count);
1168 ASSERT_EQ(0, utLayerCommitHandlerCounter);
1172 TEST_F(TDMLayerCommit, LayerCommitSuccessUnsetBeforeCommit_2)
1174 SKIP_FLAG(has_layers);
1178 for (int i = 0; i < layer_count; ++i) {
1179 tbm_surface_h buffer = NULL;
1180 tdm_layer_capability layer_capability;
1182 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1183 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1185 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1186 ASSERT_EQ(TDM_ERROR_NONE, error);
1188 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1193 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1194 ASSERT_EQ(TDM_ERROR_NONE, error);
1196 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1197 ASSERT_NE(NULL, buffer);
1199 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1200 ASSERT_EQ(TDM_ERROR_NONE, error);
1202 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1203 ASSERT_EQ(TDM_ERROR_NONE, error);
1206 UtHandleCommitEvent(layer_count);
1207 ASSERT_EQ(layer_count, utLayerCommitHandlerCounter);
1208 ASSERT_EQ(layer_count, data);
1210 for (int i = 0; i < layer_count; ++i) {
1211 error = tdm_layer_unset_buffer(tdm_layer_array[i]);
1212 ASSERT_EQ(TDM_ERROR_NONE, error);
1216 /* tdm_layer_is_committing() */
1218 TEST_F(TDMLayer, LayerIsCommittingFailNullAll)
1220 SKIP_FLAG(has_layers);
1222 ASSERT_EXIT({tdm_error error;
1223 error = tdm_layer_is_committing(NULL, NULL);
1224 if (error == TDM_ERROR_NONE) exit(1);
1225 exit(0);}, ::testing::ExitedWithCode(0), "");
1228 TEST_F(TDMLayer, LayerIsCommittingFailNullLayer)
1230 SKIP_FLAG(has_layers);
1231 unsigned int committing;
1233 ASSERT_EXIT({tdm_error error;
1234 error = tdm_layer_is_committing(NULL, &committing);
1235 if (error == TDM_ERROR_NONE) exit(1);
1236 exit(0);}, ::testing::ExitedWithCode(0), "");
1239 TEST_F(TDMLayer, LayerIsCommittingFailNullCommitting)
1241 SKIP_FLAG(has_layers);
1243 ASSERT_EXIT({tdm_error error;
1244 error = tdm_layer_is_committing(tdm_layer_array[0], NULL);
1245 if (error == TDM_ERROR_NONE) exit(1);
1246 exit(0);}, ::testing::ExitedWithCode(0), "");
1249 TEST_F(TDMLayer, LayerIsCommittingSuccessWithoutCommit)
1251 SKIP_FLAG(has_layers);
1253 unsigned int committing;
1255 for (int i = 0; i < layer_count; ++i) {
1256 error = tdm_layer_is_committing(tdm_layer_array[0], &committing);
1257 ASSERT_EQ(TDM_ERROR_NONE, error);
1259 ASSERT_EQ(0, committing);
1263 TEST_F(TDMLayerCommit, LayerIsCommittingSuccess)
1265 SKIP_FLAG(has_layers);
1267 unsigned int committing;
1269 for (int i = 0; i < layer_count; ++i) {
1270 tbm_surface_h buffer = NULL;
1271 tdm_layer_capability layer_capability;
1273 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1274 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1276 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1277 ASSERT_EQ(TDM_ERROR_NONE, error);
1279 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1284 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1285 ASSERT_EQ(TDM_ERROR_NONE, error);
1287 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1288 ASSERT_NE(NULL, buffer);
1290 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1291 ASSERT_EQ(TDM_ERROR_NONE, error);
1293 error = tdm_layer_commit(tdm_layer_array[i], NULL, NULL);
1294 ASSERT_EQ(TDM_ERROR_NONE, error);
1296 error = tdm_layer_is_committing(tdm_layer_array[0], &committing);
1297 ASSERT_EQ(TDM_ERROR_NONE, error);
1299 ASSERT_EQ(1, committing);
1303 /* tdm_layer_remove_commit_handler() */
1305 TEST_F(TDMLayer, LayerRemoveCommitHandlerFailNullAll)
1307 SKIP_FLAG(has_layers);
1309 ASSERT_EXIT({tdm_error error;
1310 error = tdm_layer_remove_commit_handler(NULL, NULL, NULL);
1311 if (error == TDM_ERROR_NONE) exit(1);
1312 exit(0);}, ::testing::ExitedWithCode(0), "");
1315 TEST_F(TDMLayerCommit, LayerRemoveCommitHandlerSuccess)
1317 SKIP_FLAG(has_layers);
1321 for (int i = 0; i < layer_count; ++i) {
1322 tbm_surface_h buffer = NULL;
1323 tdm_layer_capability layer_capability;
1325 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1326 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1328 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1329 ASSERT_EQ(TDM_ERROR_NONE, error);
1331 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1336 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1337 ASSERT_EQ(TDM_ERROR_NONE, error);
1339 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1340 ASSERT_NE(NULL, buffer);
1342 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1343 ASSERT_EQ(TDM_ERROR_NONE, error);
1345 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1346 ASSERT_EQ(TDM_ERROR_NONE, error);
1348 error = tdm_layer_remove_commit_handler(tdm_layer_array[i], UtLayerCommitHandler, &data);
1349 ASSERT_EQ(TDM_ERROR_NONE, error);
1352 UtHandleCommitEvent(layer_count);
1353 ASSERT_EQ(0, utLayerCommitHandlerCounter);
1357 /* tdm_layer_get_displaying_buffer() */
1359 TEST_F(TDMLayerCommit, LayerGetDisplayingBufferFailNullAll)
1361 SKIP_FLAG(has_layers);
1363 ASSERT_EXIT({if (tdm_layer_get_displaying_buffer(NULL, NULL) != NULL) exit(1);
1364 exit(0);}, ::testing::ExitedWithCode(0), "");
1367 TEST_F(TDMLayerCommit, LayerGetDisplayingBufferFailWithoutCommit)
1369 SKIP_FLAG(has_layers);
1372 for (int i = 0; i < layer_count; ++i) {
1373 ASSERT_EQ(NULL, tdm_layer_get_displaying_buffer(tdm_layer_array[i], &error));
1374 ASSERT_NE(TDM_ERROR_NONE, error);
1378 TEST_F(TDMLayerCommit, LayerGetDisplayingBufferSuccess)
1380 SKIP_FLAG(has_layers);
1384 for (int i = 0; i < layer_count; ++i) {
1385 tbm_surface_h buffer = NULL;
1386 tdm_layer_capability layer_capability;
1388 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1389 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1391 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1392 ASSERT_EQ(TDM_ERROR_NONE, error);
1394 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1399 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1400 ASSERT_EQ(TDM_ERROR_NONE, error);
1402 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1403 ASSERT_NE(NULL, buffer);
1405 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1406 ASSERT_EQ(TDM_ERROR_NONE, error);
1408 error = tdm_layer_commit(tdm_layer_array[i], UtLayerCommitHandler, &data);
1409 ASSERT_EQ(TDM_ERROR_NONE, error);
1412 UtHandleCommitEvent(layer_count);
1413 ASSERT_EQ(layer_count, utLayerCommitHandlerCounter);
1414 ASSERT_EQ(layer_count, data);
1416 for (int i = 0; i < layer_count; ++i) {
1417 ASSERT_EQ(tdm_layers_buffer_array[i], tdm_layer_get_displaying_buffer(tdm_layer_array[i], &error));
1418 ASSERT_EQ(TDM_ERROR_NONE, error);
1422 /* tdm_layer_is_usable() */
1424 TEST_F(TDMLayer, LayerIsUsableFailNullAll)
1426 SKIP_FLAG(has_layers);
1428 ASSERT_EXIT({if (tdm_layer_is_usable(NULL, NULL) == TDM_ERROR_NONE) exit(1);
1429 exit(0);}, ::testing::ExitedWithCode(0), "");
1432 TEST_F(TDMLayer, LayerIsUsableFailNullLayer)
1434 SKIP_FLAG(has_layers);
1435 unsigned int usable;
1437 ASSERT_EXIT({if (tdm_layer_is_usable(NULL, &usable) == TDM_ERROR_NONE) exit(1);
1438 exit(0);}, ::testing::ExitedWithCode(0), "");
1441 TEST_F(TDMLayer, LayerIsUsableFailNullUsable)
1443 SKIP_FLAG(has_layers);
1445 ASSERT_EXIT({if (tdm_layer_is_usable(tdm_layer_array[0], NULL) == TDM_ERROR_NONE) exit(1);
1446 exit(0);}, ::testing::ExitedWithCode(0), "");
1449 TEST_F(TDMLayer, LayerIsUsableSuccessAllUsable)
1451 SKIP_FLAG(has_layers);
1452 unsigned int usable;
1455 for (int i = 0; i < layer_count; ++i) {
1456 error = tdm_layer_is_usable(tdm_layer_array[i], &usable);
1457 ASSERT_EQ(TDM_ERROR_NONE, error);
1458 ASSERT_NE(0, usable);
1462 TEST_F(TDMLayer, LayerIsUsableSuccessAllUsable_2)
1464 SKIP_FLAG(has_layers);
1465 unsigned int usable;
1468 for (int i = 0; i < layer_count; ++i) {
1469 tbm_surface_h buffer;
1471 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1472 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1474 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1475 ASSERT_NE(NULL, buffer);
1477 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1478 ASSERT_EQ(TDM_ERROR_NONE, error);
1480 error = tdm_layer_unset_buffer(tdm_layer_array[i]);
1481 ASSERT_EQ(TDM_ERROR_NONE, error);
1483 error = tdm_layer_is_usable(tdm_layer_array[i], &usable);
1484 ASSERT_EQ(TDM_ERROR_NONE, error);
1485 ASSERT_NE(0, usable);
1489 TEST_F(TDMLayer, LayerIsUsableSuccessAllNoUsable)
1491 SKIP_FLAG(has_layers);
1492 unsigned int usable;
1495 for (int i = 0; i < layer_count; ++i) {
1496 tbm_surface_h buffer;
1498 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1499 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1501 buffer = UtCreateBufferForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1502 ASSERT_NE(NULL, buffer);
1504 error = tdm_layer_set_buffer(tdm_layer_array[i], buffer);
1505 ASSERT_EQ(TDM_ERROR_NONE, error);
1507 error = tdm_layer_is_usable(tdm_layer_array[i], &usable);
1508 ASSERT_EQ(TDM_ERROR_NONE, error);
1509 ASSERT_EQ(0, usable);
1513 /* tdm_layer_set_video_pos() */
1515 TEST_F(TDMLayer, LayerSetVideoPosFailNullAll)
1517 SKIP_FLAG(has_layers);
1519 ASSERT_EXIT({if (tdm_layer_set_video_pos(NULL, -1) == TDM_ERROR_NONE) exit(1);
1520 exit(0);}, ::testing::ExitedWithCode(0), "");
1523 TEST_F(TDMLayer, LayerSetVideoPosFailNoVideoLayers)
1525 SKIP_FLAG(has_layers);
1527 tdm_layer_capability layer_capability;
1529 for (int i = 0; i < layer_count; ++i) {
1530 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1531 ASSERT_EQ(TDM_ERROR_NONE, error);
1533 if (layer_capability & TDM_LAYER_CAPABILITY_VIDEO)
1536 error = tdm_layer_set_video_pos(tdm_layer_array[i], -1);
1537 ASSERT_NE(TDM_ERROR_NONE, error);
1541 TEST_F(TDMLayer, LayerSetVideoPosSuccess)
1543 SKIP_FLAG(has_layers);
1545 tdm_layer_capability layer_capability;
1547 for (int i = 0; i < layer_count; ++i) {
1548 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1549 ASSERT_EQ(TDM_ERROR_NONE, error);
1551 if (!(layer_capability & TDM_LAYER_CAPABILITY_VIDEO))
1554 error = tdm_layer_set_video_pos(tdm_layer_array[i], -1);
1555 ASSERT_EQ(TDM_ERROR_NONE, error);
1559 /* tdm_layer_create_capture() */
1561 TEST_F(TDMLayer, LayerCreateCaptureNullAll)
1563 SKIP_FLAG(has_layers);
1565 ASSERT_EXIT({if (tdm_layer_create_capture(NULL, NULL) != NULL) exit(1);
1566 exit(0);}, ::testing::ExitedWithCode(0), "");
1569 TEST_F(TDMLayer, LayerCreateCaptureSuccess)
1571 SKIP_FLAG(has_layers);
1573 tdm_capture *capture;
1575 for (int i = 0; i < layer_count; ++i) {
1576 capture = tdm_layer_create_capture(tdm_layer_array[i], &error);
1577 if (error == TDM_ERROR_NO_CAPABILITY)
1580 ASSERT_EQ(TDM_ERROR_NONE, error);
1581 ASSERT_NE(NULL, capture);
1585 /* tdm_layer_get_buffer_flags() */
1587 TEST_F(TDMLayer, LayerGetBufferFlagsNullAll)
1589 SKIP_FLAG(has_layers);
1591 ASSERT_EXIT({if (tdm_layer_get_buffer_flags(NULL, NULL) == TDM_ERROR_NONE) exit(1);
1592 exit(0);}, ::testing::ExitedWithCode(0), "");
1595 TEST_F(TDMLayer, LayerGetBufferFlagsNullLayer)
1597 SKIP_FLAG(has_layers);
1600 ASSERT_EXIT({if (tdm_layer_get_buffer_flags(NULL, &flags) == TDM_ERROR_NONE) exit(1);
1601 exit(0);}, ::testing::ExitedWithCode(0), "");
1604 TEST_F(TDMLayer, LayerGetBufferFlagsNullFlags)
1606 SKIP_FLAG(has_layers);
1608 ASSERT_EXIT({if (tdm_layer_get_buffer_flags(tdm_layer_array[0], NULL) == TDM_ERROR_NONE) exit(1);
1609 exit(0);}, ::testing::ExitedWithCode(0), "");
1612 TEST_F(TDMLayer, LayerGetBufferFlagsSuccess)
1614 SKIP_FLAG(has_layers);
1618 for (int i = 0; i < layer_count; ++i) {
1619 error = tdm_layer_get_buffer_flags(tdm_layer_array[i], &flags);
1620 if (error == TDM_ERROR_NOT_IMPLEMENTED)
1623 ASSERT_EQ(TDM_ERROR_NONE, error);
1627 /* tdm_layer_set_buffer_queue() */
1629 TEST_F(TDMLayer, LayerSetBufferQueueFailNullAll)
1631 SKIP_FLAG(has_layers);
1633 ASSERT_EXIT({if (tdm_layer_set_buffer_queue(NULL, NULL) == TDM_ERROR_NONE) exit(1);
1634 exit(0);}, ::testing::ExitedWithCode(0), "");
1637 TEST_F(TDMLayer, LayerSetBufferQueueFailNullLayer)
1639 SKIP_FLAG(has_layers);
1640 tbm_surface_queue_h bufer_queue;
1642 bufer_queue = UtCreateBufferQueueForLayer(0, 128, 128, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1643 ASSERT_NE(NULL, bufer_queue);
1645 ASSERT_EXIT({if (tdm_layer_set_buffer_queue(NULL, bufer_queue) == TDM_ERROR_NONE) exit(1);
1646 exit(0);}, ::testing::ExitedWithCode(0), "");
1649 TEST_F(TDMLayer, LayerSetBufferQueueFailNullBufferQueue)
1651 SKIP_FLAG(has_layers);
1653 ASSERT_EXIT({if (tdm_layer_set_buffer_queue(tdm_layer_array[0], NULL) == TDM_ERROR_NONE) exit(1);
1654 exit(0);}, ::testing::ExitedWithCode(0), "");
1657 TEST_F(TDMLayer, LayerSetBufferQueueSuccess)
1659 SKIP_FLAG(has_layers);
1661 tbm_surface_queue_h buffer_queue;
1662 tdm_layer_capability layer_capability;
1664 for (int i = 0; i < layer_count; ++i) {
1665 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1666 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1668 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1669 ASSERT_EQ(TDM_ERROR_NONE, error);
1671 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1676 buffer_queue = UtCreateBufferQueueForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1677 ASSERT_NE(NULL, buffer_queue);
1679 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1680 ASSERT_EQ(TDM_ERROR_NONE, error);
1684 TEST_F(TDMLayer, LayerSetBufferQueueSuccessTwice)
1686 SKIP_FLAG(has_layers);
1688 tbm_surface_queue_h buffer_queue;
1689 tdm_layer_capability layer_capability;
1691 for (int i = 0; i < layer_count; ++i) {
1692 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1693 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1695 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1696 ASSERT_EQ(TDM_ERROR_NONE, error);
1698 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1703 buffer_queue = UtCreateBufferQueueForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1704 ASSERT_NE(NULL, buffer_queue);
1706 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1707 ASSERT_EQ(TDM_ERROR_NONE, error);
1709 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1710 ASSERT_EQ(TDM_ERROR_NONE, error);
1714 TEST_F(TDMLayerCommitThread, LayerSetBufferQueueSuccessRemoveBufferQueue)
1716 SKIP_FLAG(has_layers);
1718 tbm_surface_queue_error_e tbm_err;
1719 tbm_surface_queue_h buffer_queue;
1720 tdm_layer_capability layer_capability;
1722 for (int i = 0; i < layer_count; ++i) {
1723 tbm_surface_h surface;
1725 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1726 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1728 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1729 ASSERT_EQ(TDM_ERROR_NONE, error);
1731 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1736 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1737 ASSERT_EQ(TDM_ERROR_NONE, error);
1739 buffer_queue = UtCreateBufferQueueForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1740 ASSERT_NE(NULL, buffer_queue);
1742 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1743 ASSERT_EQ(TDM_ERROR_NONE, error);
1745 tbm_err = tbm_surface_queue_dequeue(buffer_queue, &surface);
1746 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, tbm_err);
1748 tdm_layer_commit(tdm_layer_array[i], NULL, NULL);
1750 tbm_err = tbm_surface_queue_enqueue(buffer_queue, surface);
1751 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, tbm_err);
1754 /* FIXME: use another func. */
1755 UtHandleCommitEvent(1);
1757 for (int i = 0; i < layer_count; ++i) {
1758 ASSERT_NE(NULL, tdm_layer_get_displaying_buffer(tdm_layer_array[i], &error));
1759 ASSERT_EQ(TDM_ERROR_NONE, error);
1761 tbm_surface_queue_destroy(tdm_layers_buffer_queue_array[i]);
1762 tdm_layers_buffer_queue_array[i] = NULL;
1764 ASSERT_EQ(NULL, tdm_layer_get_displaying_buffer(tdm_layer_array[i], &error));
1765 ASSERT_NE(TDM_ERROR_NONE, error);
1769 TEST_F(TDMLayerCommitWithDisabledCommitPerVblank, LayerSetBufferQueueSuccessRemoveBufferQueue)
1771 SKIP_FLAG(has_layers);
1773 tbm_surface_queue_error_e tbm_err;
1774 tbm_surface_queue_h buffer_queue;
1775 tdm_layer_capability layer_capability;
1777 for (int i = 0; i < layer_count; ++i) {
1778 tbm_surface_h surface;
1780 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1781 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1783 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1784 ASSERT_EQ(TDM_ERROR_NONE, error);
1786 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1791 error = _ut_tdm_layer_set_info(tdm_layer_array[i], w, h);
1792 ASSERT_EQ(TDM_ERROR_NONE, error);
1794 buffer_queue = UtCreateBufferQueueForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1795 ASSERT_NE(NULL, buffer_queue);
1797 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1798 ASSERT_EQ(TDM_ERROR_NONE, error);
1800 tbm_err = tbm_surface_queue_dequeue(buffer_queue, &surface);
1801 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, tbm_err);
1803 tdm_layer_commit(tdm_layer_array[i], NULL, NULL);
1805 tbm_err = tbm_surface_queue_enqueue(buffer_queue, surface);
1806 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, tbm_err);
1809 /* FIXME: use another func. */
1810 UtHandleCommitEvent(1);
1812 for (int i = 0; i < layer_count; ++i) {
1813 tbm_surface_h surface;
1815 tbm_err = tbm_surface_queue_dequeue(tdm_layers_buffer_queue_array[i], &surface);
1816 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, error);
1818 tbm_err = tbm_surface_queue_enqueue(tdm_layers_buffer_queue_array[i], surface);
1819 ASSERT_EQ(TBM_SURFACE_QUEUE_ERROR_NONE, error);
1821 error = tdm_layer_unset_buffer_queue(tdm_layer_array[i]);
1822 ASSERT_EQ(TDM_ERROR_NONE, error);
1825 /* FIXME: use another func. */
1826 UtHandleCommitEvent(1);
1828 for (int i = 0; i < layer_count; ++i) {
1829 ASSERT_EQ(NULL, tdm_layer_get_displaying_buffer(tdm_layer_array[i], &error));
1830 ASSERT_NE(TDM_ERROR_NONE, error);
1834 /* tdm_layer_unset_buffer_queue() */
1836 TEST_F(TDMLayer, LayerUnsetBufferQueueFailNullAll)
1838 SKIP_FLAG(has_layers);
1840 ASSERT_EXIT({if (tdm_layer_unset_buffer_queue(NULL) == TDM_ERROR_NONE) exit(1);
1841 exit(0);}, ::testing::ExitedWithCode(0), "");
1844 TEST_F(TDMLayer, LayerUnsetBufferQueueSuccess)
1846 SKIP_FLAG(has_layers);
1848 tbm_surface_queue_h buffer_queue;
1849 tdm_layer_capability layer_capability;
1851 for (int i = 0; i < layer_count; ++i) {
1852 int w = preferred_mode_array[tdm_layer_output_idx[i]]->hdisplay;
1853 int h = preferred_mode_array[tdm_layer_output_idx[i]]->vdisplay;
1855 error = tdm_layer_get_capabilities(tdm_layer_array[i], &layer_capability);
1856 ASSERT_EQ(TDM_ERROR_NONE, error);
1858 if (!(layer_capability & TDM_LAYER_CAPABILITY_PRIMARY)) {
1863 buffer_queue = UtCreateBufferQueueForLayer(i, w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT);
1864 ASSERT_NE(NULL, buffer_queue);
1866 error = tdm_layer_set_buffer_queue(tdm_layer_array[i], buffer_queue);
1867 ASSERT_EQ(TDM_ERROR_NONE, error);
1869 error = tdm_layer_unset_buffer_queue(tdm_layer_array[i]);
1870 ASSERT_EQ(TDM_ERROR_NONE, error);