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 **************************************************************************/
35 static void _tc_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data);
36 static void _tc_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data);
38 TDMOutput::TDMOutput()
41 output_count = TDM_UT_INVALID_VALUE;
44 done1 = done2 = done3 = false;
47 void TDMOutput::SetUp(void)
51 ASSERT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
52 ASSERT_GE(output_count, 0);
54 if (output_count > 0) {
55 outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*));
56 ASSERT_NE(outputs, NULL);
58 for (int o = 0; o < output_count; o++) {
60 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
61 ASSERT_EQ(ret, TDM_ERROR_NONE);
62 ASSERT_NE(output, NULL);
71 void TDMOutput::TearDown(void)
74 for (int o = 0; o < output_count; o++) {
75 ASSERT_EQ(tc_tdm_output_unset(dpy, outputs[o]), true);
76 tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1);
77 tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2);
78 tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done3);
79 tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL);
84 TDMDisplay::TearDown();
88 tc_tdm_output_mode_setting(tdm_output *output)
90 const tdm_output_mode *modes = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
91 const tdm_output_mode *found = NULL;
92 const tdm_output_mode *best = NULL;
93 int count = TDM_UT_INVALID_VALUE;
94 unsigned int pipe = 0;
96 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_available_modes(output, &modes, &count) == TDM_ERROR_NONE);
97 TDM_UT_RETURN_FALSE_IF_FAIL(count > 0);
98 TDM_UT_RETURN_FALSE_IF_FAIL(modes != NULL && modes != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
100 for (int i = 0; i < count; i++) {
103 if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
109 TDM_UT_RETURN_FALSE_IF_FAIL(found != NULL);
111 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_mode(output, found) == TDM_ERROR_NONE);
113 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
115 TDM_INFO("setting output(%d) mode done: %dx%d %d", pipe, found->hdisplay, found->vdisplay, found->vrefresh);
121 tc_tdm_output_is_async_dpms_enable(tdm_output *output)
123 tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
124 if (tdm_output_get_capabilities(output, &capabilities) != TDM_ERROR_NONE)
126 return capabilities & TDM_OUTPUT_CAPABILITY_ASYNC_DPMS;
130 tc_tdm_output_is_hwc_enable(tdm_output *output)
132 tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
133 if (tdm_output_get_capabilities(output, &capabilities) != TDM_ERROR_NONE)
135 return capabilities & TDM_OUTPUT_CAPABILITY_HWC;
139 tc_tdm_output_is_aod_enable(tdm_output *output)
141 tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
142 if (tdm_output_get_capabilities(output, &capabilities) != TDM_ERROR_NONE)
144 return capabilities & TDM_OUTPUT_CAPABILITY_EXTENDED_DPMS;
148 tc_tdm_output_is_connected(tdm_output *output)
150 tdm_output_conn_status status;
151 if (tdm_output_get_conn_status(output, &status) != TDM_ERROR_NONE)
153 return (status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) ? true : false;
157 tc_tdm_output_get_primary_layer(tdm_output *output)
161 int primary_index = -1;
163 TDM_UT_RETURN_VAL_IF_FAIL(tdm_output_get_primary_index(output, &primary_index) == TDM_ERROR_NONE, NULL);
164 TDM_UT_RETURN_VAL_IF_FAIL(primary_index >= 0, NULL);
166 layer = tdm_output_get_layer(output, primary_index, &ret);
167 TDM_UT_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, NULL);
168 TDM_UT_RETURN_VAL_IF_FAIL(layer != NULL, NULL);
174 _tc_tdm_output_done_cb(tdm_output *output, unsigned int sequence,
175 unsigned int tv_sec, unsigned int tv_usec,
178 bool *done = (bool*)user_data;
184 tc_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill)
186 tbm_surface_h buffer = NULL;
188 int primary_index = -1;
191 tdm_output_conn_status status;
193 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_is_connected(output) == true);
194 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_mode_setting(output) == true);
195 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE);
197 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_primary_index(output, &primary_index) == TDM_ERROR_NONE);
198 TDM_UT_RETURN_FALSE_IF_FAIL(primary_index >= 0);
200 layer = tdm_output_get_layer(output, primary_index, &ret);
201 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
202 TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
204 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_prepare_buffer(layer, &buffer, 1, fill) == true);
205 TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
207 TDM_UT_GOTO_IF_FAIL(tc_tdm_layer_set_buffer(layer, buffer) == true, failed);
209 if (tdm_helper_output_commit_per_vblank_enabled(output))
210 TDM_UT_GOTO_IF_FAIL(tdm_layer_commit(layer, NULL, NULL) == TDM_ERROR_NONE, failed);
212 TDM_UT_GOTO_IF_FAIL(tdm_output_commit(output, 0, NULL, NULL) == TDM_ERROR_NONE, failed);
214 TDM_UT_GOTO_IF_FAIL(tdm_output_get_conn_status(output, &status) == TDM_ERROR_NONE, failed);
215 TDM_UT_GOTO_IF_FAIL(status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED, failed);
218 TDM_UT_GOTO_IF_FAIL(tdm_output_wait_vblank(output, 1, 0, _tc_tdm_output_done_cb, &done) == TDM_ERROR_NONE, failed);
219 TDM_UT_GOTO_IF_FAIL(tc_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, failed);
222 tbm_surface_internal_unref(buffer);
226 tbm_surface_internal_unref(buffer);
232 tc_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill)
234 for (int o = 0; o < output_count; o++) {
235 if (!tc_tdm_output_is_connected(outputs[o]))
237 if (!tc_tdm_output_prepare(dpy, outputs[o], fill))
244 tc_tdm_output_unset(tdm_display *dpy, tdm_output *output)
248 unsigned int pipe = 0;
250 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE);
251 TDM_UT_RETURN_FALSE_IF_FAIL(count > 0);
253 for (int l = 0; l < count; l++) {
254 tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
255 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
256 TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
258 if (tc_tdm_layer_is_cursor_layer(layer))
260 if (tc_tdm_layer_is_video_layer(layer))
263 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE);
266 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
268 TDM_INFO("unsetting output(%d) done", pipe);
275 tc_tdm_output_get_vblank_interval_time(tdm_output *output)
277 const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
278 tdm_error ret = tdm_output_get_mode(output, &mode);
280 assert(ret == TDM_ERROR_NONE);
281 assert(mode != NULL);
282 assert(mode->vrefresh > 0);
284 return (double)1.0 / (double)mode->vrefresh;
287 TEST_P(TDMOutput, OutputGetBackendModule)
289 TDM_UT_SKIP_FLAG(has_outputs);
291 for (int o = 0; o < output_count; o++) {
292 tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE;
293 ASSERT_NE(tdm_output_get_backend_module(outputs[o], &ret), NULL);
294 ASSERT_EQ(ret, TDM_ERROR_NONE);
298 TEST_P(TDMOutput, OutputGetBackendModuleNullOBject)
300 TDM_UT_SKIP_FLAG(has_outputs);
302 tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE;
303 ASSERT_EQ(tdm_output_get_backend_module(NULL, &ret), NULL);
304 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
307 TEST_P(TDMOutput, OutputGetBackendModuleNullOther)
309 TDM_UT_SKIP_FLAG(has_outputs);
311 for (int o = 0; o < output_count; o++) {
312 ASSERT_NE(tdm_output_get_backend_module(outputs[o], NULL), NULL);
316 TEST_P(TDMOutput, OutputGetCapabilities)
318 TDM_UT_SKIP_FLAG(has_outputs);
320 for (int o = 0; o < output_count; o++) {
321 tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
322 ASSERT_EQ(tdm_output_get_capabilities(outputs[o], &capabilities), TDM_ERROR_NONE);
323 ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
327 TEST_P(TDMOutput, OutputGetCapabilitiesNullObject)
329 TDM_UT_SKIP_FLAG(has_outputs);
331 tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
332 ASSERT_EQ(tdm_output_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
333 ASSERT_EQ(capabilities, (tdm_output_capability)TDM_UT_INVALID_VALUE);
336 TEST_P(TDMOutput, OutputGetCapabilitiesNullOther)
338 TDM_UT_SKIP_FLAG(has_outputs);
340 ASSERT_EQ(tdm_output_get_capabilities(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
343 TEST_P(TDMOutput, OutputGetModelInfo)
345 TDM_UT_SKIP_FLAG(has_outputs);
347 for (int o = 0; o < output_count; o++) {
348 const char *maker = NULL, *model = NULL, *name = NULL;
349 ASSERT_EQ(tdm_output_get_model_info(outputs[o], &maker, &model, &name), TDM_ERROR_NONE);
350 ASSERT_NE(maker, NULL);
351 ASSERT_NE(model, NULL);
352 ASSERT_NE(name, NULL);
356 TEST_P(TDMOutput, OutputGetModelInfoNullObject)
358 TDM_UT_SKIP_FLAG(has_outputs);
360 const char *maker = (const char*)TDM_UT_INVALID_VALUE;
361 const char *model = (const char*)TDM_UT_INVALID_VALUE;
362 const char *name = (const char*)TDM_UT_INVALID_VALUE;
364 ASSERT_EQ(tdm_output_get_model_info(NULL, &maker, &model, &name), TDM_ERROR_INVALID_PARAMETER);
365 ASSERT_EQ(maker, (const char*)TDM_UT_INVALID_VALUE);
366 ASSERT_EQ(model, (const char*)TDM_UT_INVALID_VALUE);
367 ASSERT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
370 TEST_P(TDMOutput, OutputGetModelInfoNullOther)
372 TDM_UT_SKIP_FLAG(has_outputs);
374 ASSERT_EQ(tdm_output_get_model_info(outputs[0], NULL, NULL, NULL), TDM_ERROR_NONE);
377 TEST_P(TDMOutput, OutputGetConnStatus)
379 TDM_UT_SKIP_FLAG(has_outputs);
381 for (int o = 0; o < output_count; o++) {
382 tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
383 ASSERT_EQ(tdm_output_get_conn_status(outputs[o], &status), TDM_ERROR_NONE);
384 ASSERT_NE(status, TDM_UT_INVALID_VALUE);
388 TEST_P(TDMOutput, OutputGetConnStatusNullObject)
390 TDM_UT_SKIP_FLAG(has_outputs);
392 tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
394 ASSERT_EQ(tdm_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
395 ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
398 TEST_P(TDMOutput, OutputGetConnStatusNullOther)
400 TDM_UT_SKIP_FLAG(has_outputs);
402 ASSERT_EQ(tdm_output_get_conn_status(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
405 TEST_P(TDMOutput, OutputGetOutputType)
407 TDM_UT_SKIP_FLAG(has_outputs);
409 for (int o = 0; o < output_count; o++) {
410 tdm_output_type type = (tdm_output_type)TDM_UT_INVALID_VALUE;
411 ASSERT_EQ(tdm_output_get_output_type(outputs[o], &type), TDM_ERROR_NONE);
412 ASSERT_NE(type, TDM_UT_INVALID_VALUE);
416 TEST_P(TDMOutput, OutputGetOutputTypeNullObject)
418 TDM_UT_SKIP_FLAG(has_outputs);
420 tdm_output_type type = (tdm_output_type)TDM_UT_INVALID_VALUE;
421 ASSERT_EQ(tdm_output_get_output_type(NULL, &type), TDM_ERROR_INVALID_PARAMETER);
422 ASSERT_EQ(type, (tdm_output_type)TDM_UT_INVALID_VALUE);
425 TEST_P(TDMOutput, OutputGetOutputTypeNullOther)
427 TDM_UT_SKIP_FLAG(has_outputs);
429 ASSERT_EQ(tdm_output_get_output_type(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
432 TEST_P(TDMOutput, OutputGetLayerCount)
434 TDM_UT_SKIP_FLAG(has_outputs);
436 for (int o = 0; o < output_count; o++) {
437 int count = TDM_UT_INVALID_VALUE;
438 if (tc_tdm_output_is_hwc_enable(outputs[o])) {
439 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST);
442 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
448 TEST_P(TDMOutput, OutputGetLayerCountNullObject)
450 TDM_UT_SKIP_FLAG(has_outputs);
452 int count = TDM_UT_INVALID_VALUE;
453 ASSERT_EQ(tdm_output_get_layer_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
454 ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
457 TEST_P(TDMOutput, OutputGetLayerCountNullOther)
459 TDM_UT_SKIP_FLAG(has_outputs);
461 ASSERT_EQ(tdm_output_get_layer_count(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
464 TEST_P(TDMOutput, OutputGetLayer)
466 TDM_UT_SKIP_FLAG(has_outputs);
468 for (int o = 0; o < output_count; o++) {
471 int layer_count = TDM_UT_INVALID_VALUE;
473 if (tc_tdm_output_is_hwc_enable(outputs[o])) {
474 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST);
475 ASSERT_EQ(layer_count, 0);
477 layer = tdm_output_get_layer(outputs[o], 0, &ret);
478 ASSERT_EQ(ret, TDM_ERROR_BAD_REQUEST);
479 ASSERT_EQ(layer, NULL);
481 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_NONE);
482 ASSERT_GT(layer_count, 0);
484 for (int l = 0; l < layer_count; l++) {
485 tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
486 ASSERT_EQ(ret, TDM_ERROR_NONE);
487 ASSERT_NE(layer, NULL);
493 TEST_P(TDMOutput, OutputGetLayerNullObject)
495 TDM_UT_SKIP_FLAG(has_outputs);
498 tdm_layer *layer = tdm_output_get_layer(NULL, 0, &ret);
499 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
500 ASSERT_EQ(layer, NULL);
503 TEST_P(TDMOutput, OutputGetLayerNullOther)
505 TDM_UT_SKIP_FLAG(has_outputs);
508 if (tc_tdm_output_is_hwc_enable(outputs[0])) {
509 layer = tdm_output_get_layer(outputs[0], 0, NULL);
510 ASSERT_EQ(layer, NULL);
512 layer = tdm_output_get_layer(outputs[0], 0, NULL);
513 ASSERT_NE(layer, NULL);
517 TEST_P(TDMOutput, OutputGetAvailableProperties)
519 TDM_UT_SKIP_FLAG(has_outputs);
521 for (int o = 0; o < output_count; o++) {
522 int count = TDM_UT_INVALID_VALUE;
523 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
524 ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
527 ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
531 TEST_P(TDMOutput, OutputGetAvailablePropertiesNullObject)
533 TDM_UT_SKIP_FLAG(has_outputs);
535 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
536 int count = TDM_UT_INVALID_VALUE;
537 ASSERT_EQ(tdm_output_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
538 ASSERT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
539 ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
542 TEST_P(TDMOutput, OutputGetAvailablePropertiesNullOther)
544 TDM_UT_SKIP_FLAG(has_outputs);
546 ASSERT_EQ(tdm_output_get_available_properties(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
549 TEST_P(TDMOutput, OutputGetAvailableModes)
551 TDM_UT_SKIP_FLAG(has_outputs);
553 for (int o = 0; o < output_count; o++) {
554 if (!tc_tdm_output_is_connected(outputs[o]))
557 int count = TDM_UT_INVALID_VALUE;
558 const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE;
559 ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes_array, &count), TDM_ERROR_NONE);
561 ASSERT_TRUE(modes_array != NULL && modes_array != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
565 TEST_P(TDMOutput, OutputGetAvailableModesNullObject)
567 TDM_UT_SKIP_FLAG(has_outputs);
569 int count = TDM_UT_INVALID_VALUE;
570 const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE;
571 ASSERT_EQ(tdm_output_get_available_modes(NULL, &modes_array, &count), TDM_ERROR_INVALID_PARAMETER);
572 ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
573 ASSERT_EQ(modes_array, (const tdm_output_mode *) TDM_UT_INVALID_VALUE);
576 TEST_P(TDMOutput, OutputGetAvailableModesNullOther)
578 TDM_UT_SKIP_FLAG(has_outputs);
580 ASSERT_EQ(tdm_output_get_available_modes(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
583 TEST_P(TDMOutput, OutputGetAvailableSize)
585 TDM_UT_SKIP_FLAG(has_outputs);
587 for (int o = 0; o < output_count; o++) {
588 if (!tc_tdm_output_is_connected(outputs[o]))
591 int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
592 int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
593 int preferred_align = TDM_UT_INVALID_VALUE;
594 ASSERT_EQ(tdm_output_get_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
595 ASSERT_NE(min_w, TDM_UT_INVALID_VALUE);
596 ASSERT_NE(min_h, TDM_UT_INVALID_VALUE);
597 ASSERT_NE(max_w, TDM_UT_INVALID_VALUE);
598 ASSERT_NE(max_h, TDM_UT_INVALID_VALUE);
599 ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE);
603 TEST_P(TDMOutput, OutputGetAvailableSizeNullObject)
605 TDM_UT_SKIP_FLAG(has_outputs);
607 int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
608 int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
609 int preferred_align = TDM_UT_INVALID_VALUE;
610 ASSERT_EQ(tdm_output_get_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
611 ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
612 ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
613 ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
614 ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
615 ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
618 TEST_P(TDMOutput, OutputGetAvailableSizeNullOther)
620 TDM_UT_SKIP_FLAG(has_outputs);
622 ASSERT_EQ(tdm_output_get_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
625 TEST_P(TDMOutput, OutputGetCursorAvailableSize)
627 TDM_UT_SKIP_FLAG(has_outputs);
629 int major = TDM_UT_INVALID_VALUE;
630 int minor = TDM_UT_INVALID_VALUE;
632 ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
633 if (major > 1 || (major >= 1 && minor >= 5)) {
634 for (int o = 0; o < output_count; o++) {
635 int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
636 int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
637 int preferred_align = TDM_UT_INVALID_VALUE;
638 ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
639 ASSERT_NE(min_w, TDM_UT_INVALID_VALUE);
640 ASSERT_NE(min_h, TDM_UT_INVALID_VALUE);
641 ASSERT_NE(max_w, TDM_UT_INVALID_VALUE);
642 ASSERT_NE(max_h, TDM_UT_INVALID_VALUE);
643 ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE);
648 TEST_P(TDMOutput, OutputGetCursorAvailableSizeNullObject)
650 TDM_UT_SKIP_FLAG(has_outputs);
652 int major = TDM_UT_INVALID_VALUE;
653 int minor = TDM_UT_INVALID_VALUE;
655 ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
656 if (major > 1 || (major >= 1 && minor >= 5)) {
657 for (int o = 0; o < output_count; o++) {
658 int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
659 int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
660 int preferred_align = TDM_UT_INVALID_VALUE;
661 ASSERT_EQ(tdm_output_get_cursor_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
662 ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
663 ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
664 ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
665 ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
666 ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
671 TEST_P(TDMOutput, OutputGetCursorAvailableSizeNullOther)
673 TDM_UT_SKIP_FLAG(has_outputs);
675 int major = TDM_UT_INVALID_VALUE;
676 int minor = TDM_UT_INVALID_VALUE;
678 ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
679 if (major > 1 || (major >= 1 && minor >= 5))
680 ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
683 TEST_P(TDMOutput, OutputGetCursorAvailableSizeNoMatchVersion)
685 TDM_UT_SKIP_FLAG(has_outputs);
687 int major = TDM_UT_INVALID_VALUE;
688 int minor = TDM_UT_INVALID_VALUE;
690 ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
691 if (major <= 1 && minor < 5) {
692 for (int o = 0; o < output_count; o++) {
693 int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
694 int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
695 int preferred_align = TDM_UT_INVALID_VALUE;
696 ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_BAD_REQUEST);
697 ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
698 ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
699 ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
700 ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
701 ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
706 TEST_P(TDMOutput, OutputGetPhysicalSize)
708 TDM_UT_SKIP_FLAG(has_outputs);
710 for (int o = 0; o < output_count; o++) {
711 unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE;
712 unsigned int mmHeight = (unsigned int)TDM_UT_INVALID_VALUE;
713 ASSERT_EQ(tdm_output_get_physical_size(outputs[o], &mmWidth, &mmHeight), TDM_ERROR_NONE);
714 ASSERT_NE(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
715 ASSERT_NE(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
719 TEST_P(TDMOutput, OutputGetPhysicalSizeNullObject)
721 TDM_UT_SKIP_FLAG(has_outputs);
723 unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE;
724 unsigned int mmHeight = (unsigned int)TDM_UT_INVALID_VALUE;
725 ASSERT_EQ(tdm_output_get_physical_size(NULL, &mmWidth, &mmHeight), TDM_ERROR_INVALID_PARAMETER);
726 ASSERT_EQ(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
727 ASSERT_EQ(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
730 TEST_P(TDMOutput, OutputGetPhysicalSizeNullOther)
732 TDM_UT_SKIP_FLAG(has_outputs);
734 ASSERT_EQ(tdm_output_get_physical_size(outputs[0], NULL, NULL), TDM_ERROR_NONE);
737 TEST_P(TDMOutput, OutputGetSubpixel)
739 TDM_UT_SKIP_FLAG(has_outputs);
741 for (int o = 0; o < output_count; o++) {
742 unsigned int subpixel = (unsigned int)TDM_UT_INVALID_VALUE;
743 ASSERT_EQ(tdm_output_get_subpixel(outputs[o], &subpixel), TDM_ERROR_NONE);
744 ASSERT_NE(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
748 TEST_P(TDMOutput, OutputGetSubpixelNullObject)
750 TDM_UT_SKIP_FLAG(has_outputs);
752 unsigned int subpixel = (unsigned int)TDM_UT_INVALID_VALUE;
753 ASSERT_EQ(tdm_output_get_subpixel(NULL, &subpixel), TDM_ERROR_INVALID_PARAMETER);
754 ASSERT_EQ(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
757 TEST_P(TDMOutput, OutputGetSubpixelNullOther)
759 TDM_UT_SKIP_FLAG(has_outputs);
761 ASSERT_EQ(tdm_output_get_subpixel(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
764 TEST_P(TDMOutput, OutputGetPipe)
766 TDM_UT_SKIP_FLAG(has_outputs);
768 for (int o = 0; o < output_count; o++) {
769 unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
770 ASSERT_EQ(tdm_output_get_pipe(outputs[o], &pipe), TDM_ERROR_NONE);
771 ASSERT_NE(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
775 TEST_P(TDMOutput, OutputGetPipeNullObject)
777 TDM_UT_SKIP_FLAG(has_outputs);
779 unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
780 ASSERT_EQ(tdm_output_get_pipe(NULL, &pipe), TDM_ERROR_INVALID_PARAMETER);
781 ASSERT_EQ(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
784 TEST_P(TDMOutput, OutputGetPipeNullOther)
786 TDM_UT_SKIP_FLAG(has_outputs);
788 ASSERT_EQ(tdm_output_get_pipe(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
791 TEST_P(TDMOutput, OutputGetPrimaryIndex)
793 TDM_UT_SKIP_FLAG(has_outputs);
795 for (int o = 0; o < output_count; o++) {
796 int primary_index = TDM_UT_INVALID_VALUE;
797 ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE);
798 ASSERT_NE(primary_index, TDM_UT_INVALID_VALUE);
802 TEST_P(TDMOutput, OutputGetPrimaryIndexNullObject)
804 TDM_UT_SKIP_FLAG(has_outputs);
806 int primary_index = TDM_UT_INVALID_VALUE;
807 ASSERT_EQ(tdm_output_get_primary_index(NULL, &primary_index), TDM_ERROR_INVALID_PARAMETER);
808 ASSERT_EQ(primary_index, TDM_UT_INVALID_VALUE);
811 TEST_P(TDMOutput, OutputGetPrimaryIndexNullOther)
813 TDM_UT_SKIP_FLAG(has_outputs);
815 ASSERT_EQ(tdm_output_get_primary_index(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
818 TEST_P(TDMOutput, DISABLED_OutputSetProperty)
822 TEST_P(TDMOutput, OutputSetPropertyNullObject)
824 tdm_value value = {.s32 = 0};
826 ASSERT_EQ(tdm_output_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
829 TEST_P(TDMOutput, OutputGetProperty)
831 TDM_UT_SKIP_FLAG(has_outputs);
833 for (int o = 0; o < output_count; o++) {
834 int count = TDM_UT_INVALID_VALUE;
835 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
836 ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
839 ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
841 for (int i = 0; i < count; i++) {
842 tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
843 ASSERT_EQ(tdm_output_get_property(outputs[o], props[i].id, &value), TDM_ERROR_NONE);
844 ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE);
850 TEST_P(TDMOutput, OutputGetPropertyNullObject)
852 TDM_UT_SKIP_FLAG(has_outputs);
854 tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
855 ASSERT_EQ(tdm_output_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
856 ASSERT_EQ(value.s32, TDM_UT_INVALID_VALUE);
859 TEST_P(TDMOutput, OutputGetPropertyNullOther)
861 TDM_UT_SKIP_FLAG(has_outputs);
863 ASSERT_EQ(tdm_output_get_property(outputs[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
867 _tc_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data)
869 bool *done = (bool *)user_data;
874 TEST_P(TDMOutput, OutputAddChangeHandler)
876 TDM_UT_SKIP_FLAG(has_outputs);
878 for (int o = 0; o < output_count; o++) {
879 if (!tc_tdm_output_is_connected(outputs[o]))
882 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
884 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
887 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
888 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
889 ASSERT_EQ(done1, true);
893 TEST_P(TDMOutput, OutputAddChangeHandlerTwice)
895 TDM_UT_SKIP_FLAG(has_outputs);
897 ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
898 ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST);
901 TEST_P(TDMOutput, OutputAddChangeHandlerNullObject)
903 TDM_UT_SKIP_FLAG(has_outputs);
905 ASSERT_EQ(tdm_output_add_change_handler(NULL, _tc_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
908 TEST_P(TDMOutput, OutputAddChangeHandlerNullOther)
910 TDM_UT_SKIP_FLAG(has_outputs);
912 ASSERT_EQ(tdm_output_add_change_handler(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
915 TEST_P(TDMOutput, OutputRemoveChangeHandler)
917 TDM_UT_SKIP_FLAG(has_outputs);
919 for (int o = 0; o < output_count; o++) {
920 for (int t = 0; t < 10; t++) {
921 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
922 tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL);
927 TEST_P(TDMOutput, OutputRemoveChangeHandlerDifferentData)
929 TDM_UT_SKIP_FLAG(has_outputs);
931 for (int o = 0; o < output_count; o++) {
932 if (!tc_tdm_output_is_connected(outputs[o]))
935 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
938 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
939 tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL);
941 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
942 ASSERT_EQ(done1, true);
947 _tc_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data)
949 bool *done = (bool*)user_data;
952 tdm_output_remove_change_handler(output, _tc_tdm_output_change_cb2, user_data);
955 TEST_P(TDMOutput, OutputRemoveChangeHandlerInHandler)
957 TDM_UT_SKIP_FLAG(has_outputs);
959 for (int o = 0; o < output_count; o++) {
960 if (!tc_tdm_output_is_connected(outputs[o]))
963 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
966 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done1), TDM_ERROR_NONE);
967 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
968 ASSERT_EQ(done1, true);
971 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2), TDM_ERROR_NONE);
972 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
973 ASSERT_EQ(done2, true);
976 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done3), TDM_ERROR_NONE);
977 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
978 ASSERT_EQ(done3, true);
982 TEST_P(TDMOutput, OutputRemoveChangeHandlerNullObject)
984 TDM_UT_SKIP_FLAG(has_outputs);
986 tdm_output_remove_change_handler(NULL, _tc_tdm_output_change_cb, NULL);
989 TEST_P(TDMOutput, OutputRemoveChangeHandlerNullOther)
991 TDM_UT_SKIP_FLAG(has_outputs);
993 tdm_output_remove_change_handler(outputs[0], NULL, NULL);
996 TEST_P(TDMOutput, OutputSetMode)
998 TDM_UT_SKIP_FLAG(has_outputs);
1000 for (int o = 0; o < output_count; o++) {
1001 const tdm_output_mode *modes;
1003 if (!tc_tdm_output_is_connected(outputs[o]))
1006 ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
1007 ASSERT_NE(modes, NULL);
1008 ASSERT_GT(count, 0);
1010 for (int m = 0; m < count; m++)
1011 ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
1015 TEST_P(TDMOutput, OutputSetModeNullObject)
1017 TDM_UT_SKIP_FLAG(has_outputs);
1019 const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
1020 ASSERT_EQ(tdm_output_set_mode(NULL, mode), TDM_ERROR_INVALID_PARAMETER);
1023 TEST_P(TDMOutput, OutputSetModeNullOther)
1025 TDM_UT_SKIP_FLAG(has_outputs);
1027 for (int o = 0; o < output_count; o++) {
1028 if (!tc_tdm_output_is_connected(outputs[o]))
1031 ASSERT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER);
1035 TEST_P(TDMOutput, OutputGetMode)
1037 TDM_UT_SKIP_FLAG(has_outputs);
1039 for (int o = 0; o < output_count; o++) {
1040 const tdm_output_mode *modes;
1043 if (!tc_tdm_output_is_connected(outputs[o]))
1046 ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
1047 ASSERT_NE(modes, NULL);
1048 ASSERT_GT(count, 0);
1050 for (int m = 0; m < count; m++) {
1051 const tdm_output_mode *current_mode;
1052 ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
1053 ASSERT_EQ(tdm_output_get_mode(outputs[o], ¤t_mode), TDM_ERROR_NONE);
1054 ASSERT_EQ(current_mode, modes + m);
1059 TEST_P(TDMOutput, OutputGetModeNullObject)
1061 TDM_UT_SKIP_FLAG(has_outputs);
1063 const tdm_output_mode *current_mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
1064 ASSERT_EQ(tdm_output_get_mode(NULL, ¤t_mode), TDM_ERROR_INVALID_PARAMETER);
1065 ASSERT_EQ(current_mode, (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
1068 TEST_P(TDMOutput, OutputGetModeNullOther)
1070 TDM_UT_SKIP_FLAG(has_outputs);
1072 ASSERT_EQ(tdm_output_get_mode(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1075 TEST_P(TDMOutput, OutputGetModeNoSet)
1077 TDM_UT_SKIP_FLAG(has_outputs);
1079 for (int o = 0; o < output_count; o++) {
1080 const tdm_output_mode *mode;
1081 ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
1082 ASSERT_EQ(mode, NULL);
1086 TEST_P(TDMOutput, OutputSetDpms)
1088 TDM_UT_SKIP_FLAG(has_outputs);
1090 for (int o = 0; o < output_count; o++) {
1091 if (!tc_tdm_output_is_connected(outputs[o]))
1094 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1095 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
1096 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
1097 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1098 if (tc_tdm_output_is_aod_enable(outputs[o])) {
1099 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
1101 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
1106 TEST_P(TDMOutput, OutputSetDpmsNullObject)
1108 TDM_UT_SKIP_FLAG(has_outputs);
1110 ASSERT_EQ(tdm_output_set_dpms(NULL, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_INVALID_PARAMETER);
1113 TEST_P(TDMOutput, OutputSetDpmsNullOther)
1115 TDM_UT_SKIP_FLAG(has_outputs);
1117 ASSERT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)-1), TDM_ERROR_BAD_REQUEST);
1118 ASSERT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)INT_MAX), TDM_ERROR_BAD_REQUEST);
1121 TEST_P(TDMOutput, OutputSetDpmsAsync)
1123 TDM_UT_SKIP_FLAG(has_outputs);
1125 for (int o = 0; o < output_count; o++) {
1126 if (!tc_tdm_output_is_connected(outputs[o]))
1128 if (!tc_tdm_output_is_async_dpms_enable(outputs[o]))
1132 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1133 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
1134 ASSERT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1136 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1137 tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1);
1141 TEST_P(TDMOutput, OutputGetDpms)
1143 TDM_UT_SKIP_FLAG(has_outputs);
1145 for (int o = 0; o < output_count; o++) {
1146 tdm_output_dpms dpms_value;
1148 if (!tc_tdm_output_is_connected(outputs[o]))
1151 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1152 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1153 ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_OFF);
1155 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
1156 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1157 ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_STANDBY);
1159 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
1160 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1161 ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_SUSPEND);
1163 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1164 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1165 ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON);
1167 if (tc_tdm_output_is_aod_enable(outputs[o])) {
1168 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
1169 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1170 ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_AOD);
1172 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
1177 TEST_P(TDMOutput, OutputGetDpmsNullObject)
1179 TDM_UT_SKIP_FLAG(has_outputs);
1181 tdm_output_dpms dpms_value = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
1182 ASSERT_EQ(tdm_output_get_dpms(NULL, &dpms_value), TDM_ERROR_INVALID_PARAMETER);
1183 ASSERT_EQ(dpms_value, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
1186 TEST_P(TDMOutput, OutputGetDpmsNullOther)
1188 TDM_UT_SKIP_FLAG(has_outputs);
1190 ASSERT_EQ(tdm_output_get_dpms(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1193 TEST_P(TDMOutput, OutputWaitVblank)
1195 TDM_UT_SKIP_FLAG(has_outputs);
1197 for (int o = 0; o < output_count; o++) {
1198 if (!tc_tdm_output_is_connected(outputs[o]))
1201 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1203 for (int t = 0; t < 10; t++) {
1204 double start, end, interval;
1206 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
1209 start = tdm_helper_get_time();
1210 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1212 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1213 end = tdm_helper_get_time();
1215 /* "+ interval" consider the delay of socket communication between kernel and platform */
1216 ASSERT_LT((end - start), (interval + interval));
1221 TEST_P(TDMOutput, OutputWaitVblankNullObject)
1223 TDM_UT_SKIP_FLAG(has_outputs);
1225 ASSERT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1228 TEST_P(TDMOutput, OutputWaitVblankNullOther)
1230 TDM_UT_SKIP_FLAG(has_outputs);
1232 for (int o = 0; o < output_count; o++) {
1233 if (!tc_tdm_output_is_connected(outputs[o]))
1236 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1238 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL), TDM_ERROR_NONE);
1242 TEST_P(TDMOutput, OutputWaitVblankTimeout)
1244 TDM_UT_SKIP_FLAG(has_outputs);
1246 for (int o = 0; o < output_count; o++) {
1247 if (!tc_tdm_output_is_connected(outputs[o]))
1250 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1252 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE);
1255 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1257 ASSERT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0);
1261 TEST_P(TDMOutput, OutputWaitVblankInterval0)
1263 TDM_UT_SKIP_FLAG(has_outputs);
1265 ASSERT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1268 TEST_P(TDMOutput, OutputWaitVblankInterval)
1270 TDM_UT_SKIP_FLAG(has_outputs);
1272 for (int o = 0; o < output_count; o++) {
1273 if (!tc_tdm_output_is_connected(outputs[o]))
1276 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1279 for (int t = 1; t < 10; t++) {
1280 double start, end, interval;
1282 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
1285 start = tdm_helper_get_time();
1286 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1288 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1289 end = tdm_helper_get_time();
1291 /* "+ interval" consider the delay of socket communication between kernel and platform */
1292 ASSERT_GT((end - start), (interval * (t - 1)));
1293 ASSERT_LT((end - start), (interval * t + interval));
1298 TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank)
1300 TDM_UT_SKIP_FLAG(has_outputs);
1302 for (int o = 0; o < output_count; o++) {
1303 if (!tc_tdm_output_is_connected(outputs[o]))
1306 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1309 for (int t = 1; t < 10; t++) {
1310 double start, end, interval;
1312 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
1314 done1 = done2 = done3 = false;
1315 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1316 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1317 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1319 start = tdm_helper_get_time();
1320 while (!done1 || !done2 || !done3)
1321 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1322 end = tdm_helper_get_time();
1324 /* "+ interval" consider the delay of socket communication between kernel and platform */
1325 ASSERT_GT((end - start), (interval * (t - 1)));
1326 ASSERT_LT((end - start), (interval * t + interval));
1331 TEST_P(TDMOutput, OutputWaitVblankBeforeDpmsOff)
1333 TDM_UT_SKIP_FLAG(has_outputs);
1335 for (int o = 0; o < output_count; o++) {
1336 if (!tc_tdm_output_is_connected(outputs[o]))
1339 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], false), true);
1341 for (int t = 0; t < 10; t++) {
1344 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done), TDM_ERROR_NONE);
1346 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1348 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1353 TEST_P(TDMOutput, OutputRemoveVblankHandler)
1355 TDM_UT_SKIP_FLAG(has_outputs);
1357 for (int o = 0; o < output_count; o++) {
1358 if (!tc_tdm_output_is_connected(outputs[o]))
1361 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1364 for (int t = 1; t < 10; t++) {
1365 done1 = done2 = done3 = false;
1366 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1367 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1368 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1369 tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, &done2);
1370 while (!done1 || done2 || !done3)
1371 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1376 TEST_P(TDMOutput, OutputRemoveVblankHandlerDifferentData)
1378 TDM_UT_SKIP_FLAG(has_outputs);
1380 for (int o = 0; o < output_count; o++) {
1381 if (!tc_tdm_output_is_connected(outputs[o]))
1384 tc_tdm_output_prepare(dpy, outputs[o], true);
1387 for (int t = 1; t < 10; t++) {
1388 done1 = done2 = done3 = false;
1389 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1390 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1391 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1392 tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, NULL);
1393 while (!done1 || !done2 || !done3)
1394 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1400 _tc_tdm_output_done_cb2(tdm_output *output, unsigned int sequence,
1401 unsigned int tv_sec, unsigned int tv_usec,
1404 bool *done = (bool*)user_data;
1407 tdm_output_remove_commit_handler(output, _tc_tdm_output_done_cb2, user_data);
1410 TEST_P(TDMOutput, OutputRemoveVblankHandlerInHandler)
1412 TDM_UT_SKIP_FLAG(has_outputs);
1414 for (int o = 0; o < output_count; o++) {
1415 if (!tc_tdm_output_is_connected(outputs[o]))
1418 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1421 for (int t = 1; t < 10; t++) {
1422 done1 = done2 = done3 = false;
1423 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1424 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1425 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1426 while (!done1 || !done2 || !done3)
1427 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1432 TEST_P(TDMOutput, OutputCommit)
1434 TDM_UT_SKIP_FLAG(has_outputs);
1436 for (int o = 0; o < output_count; o++) {
1437 /* if true, have to use tdm_layer_commit. so skip */
1438 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1441 if (!tc_tdm_output_is_connected(outputs[o]))
1444 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1446 for (int t = 0; t < 10; t++) {
1447 double start, end, interval;
1449 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
1452 start = tdm_helper_get_time();
1453 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1455 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1456 end = tdm_helper_get_time();
1458 /* "+ interval" consider the delay of socket communication between kernel and platform */
1459 ASSERT_LT((end - start), (interval + interval));
1464 TEST_P(TDMOutput, OutputCommitNullObject)
1466 TDM_UT_SKIP_FLAG(has_outputs);
1468 ASSERT_EQ(tdm_output_commit(NULL, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1471 TEST_P(TDMOutput, OutputCommitNullOther)
1473 TDM_UT_SKIP_FLAG(has_outputs);
1475 for (int o = 0; o < output_count; o++) {
1476 /* if true, have to use tdm_layer_commit. so skip */
1477 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1480 if (!tc_tdm_output_is_connected(outputs[o]))
1483 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1484 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
1488 TEST_P(TDMOutput, OutputCommitDpmsSuspend)
1490 TDM_UT_SKIP_FLAG(has_outputs);
1492 for (int o = 0; o < output_count; o++) {
1493 /* if true, have to use tdm_layer_commit. so skip */
1494 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1497 if (!tc_tdm_output_is_connected(outputs[o]))
1500 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1502 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
1504 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
1508 TEST_P(TDMOutput, OutputCommitDpmsOff)
1510 TDM_UT_SKIP_FLAG(has_outputs);
1512 for (int o = 0; o < output_count; o++) {
1513 /* if true, have to use tdm_layer_commit. so skip */
1514 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1517 if (!tc_tdm_output_is_connected(outputs[o]))
1520 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1522 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1524 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
1528 TEST_P(TDMOutput, OutputCommitDpmsAOD)
1530 TDM_UT_SKIP_FLAG(has_outputs);
1532 for (int o = 0; o < output_count; o++) {
1533 /* if true, have to use tdm_layer_commit. so skip */
1534 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1537 if (!tc_tdm_output_is_connected(outputs[o]))
1540 if (!tc_tdm_output_is_aod_enable(outputs[o]))
1543 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1545 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
1547 for (int t = 0; t < 10; t++) {
1549 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1551 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1556 TEST_P(TDMOutput, OutputCommitAfterLayerCommit)
1558 TDM_UT_SKIP_FLAG(has_outputs);
1560 for (int o = 0; o < output_count; o++) {
1561 int index = TDM_UT_INVALID_VALUE;
1565 if (!tc_tdm_output_is_connected(outputs[o]))
1568 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1570 ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE);
1571 ASSERT_NE(index, TDM_UT_INVALID_VALUE);
1573 layer = tdm_output_get_layer(outputs[o], index, &ret);
1574 ASSERT_EQ(ret, TDM_ERROR_NONE);
1575 ASSERT_NE(layer, NULL);
1577 ASSERT_EQ(tdm_layer_commit(layer, NULL, NULL), TDM_ERROR_NONE);
1579 if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1580 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
1582 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
1586 TEST_P(TDMOutput, OutputCommitMismatchCommitType)
1588 TDM_UT_SKIP_FLAG(has_outputs);
1590 for (int o = 0; o < output_count; o++) {
1591 if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1593 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
1597 TEST_P(TDMOutput, OutputCommitFewTimesInOneVblank)
1599 TDM_UT_SKIP_FLAG(has_outputs);
1601 for (int o = 0; o < output_count; o++) {
1602 /* if true, have to use tdm_layer_commit. so skip */
1603 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1606 if (!tc_tdm_output_is_connected(outputs[o]))
1609 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1611 for (int t = 0; t < 10; t++) {
1612 done1 = done2 = done3 = false;
1613 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1614 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1615 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1616 while (!done1 || !done2 || !done3)
1617 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1623 TEST_P(TDMOutput, DISABLED_OutputCommitBeforeDpmsOff)
1625 /* output commit -> dpms off -> then? (commit handler is called? or not?) */
1628 TEST_P(TDMOutput, OutputRemoveCommitHandler)
1630 TDM_UT_SKIP_FLAG(has_outputs);
1632 for (int o = 0; o < output_count; o++) {
1633 /* if true, have to use tdm_layer_commit. so skip */
1634 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1637 if (!tc_tdm_output_is_connected(outputs[o]))
1640 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1642 for (int t = 0; t < 10; t++) {
1643 done1 = done2 = done3 = false;
1644 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1645 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1646 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1647 tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, &done2);
1648 while (!done1 || done2 || !done3)
1649 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1654 TEST_P(TDMOutput, OutputRemoveCommitHandlerDifferentData)
1656 TDM_UT_SKIP_FLAG(has_outputs);
1658 for (int o = 0; o < output_count; o++) {
1659 /* if true, have to use tdm_layer_commit. so skip */
1660 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1663 if (!tc_tdm_output_is_connected(outputs[o]))
1666 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1668 for (int t = 0; t < 10; t++) {
1669 done1 = done2 = done3 = false;
1670 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1671 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1672 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1673 tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, NULL);
1674 while (!done1 || !done2 || !done3)
1675 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1680 TEST_P(TDMOutput, OutputRemoveCommitHandlerInHandler)
1682 TDM_UT_SKIP_FLAG(has_outputs);
1684 for (int o = 0; o < output_count; o++) {
1685 /* if true, have to use tdm_layer_commit. so skip */
1686 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1689 if (!tc_tdm_output_is_connected(outputs[o]))
1692 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1694 for (int t = 0; t < 10; t++) {
1695 done1 = done2 = done3 = false;
1696 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done1), TDM_ERROR_NONE);
1697 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done2), TDM_ERROR_NONE);
1698 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done3), TDM_ERROR_NONE);
1699 while (!done1 || !done2 || !done3)
1700 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1705 #ifdef TDM_UT_TEST_WITH_PARAMS
1706 INSTANTIATE_TEST_CASE_P(TDMOutputParams,
1708 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1710 INSTANTIATE_TEST_CASE_P(TDMOutputParams,
1712 Values(TDM_DEFAULT_MODULE));