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_hwc_buffer(tdm_output *output, tbm_surface_h *buffers, int buffer_count, bool fill)
187 const tdm_output_mode *mode = NULL;
189 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
190 TDM_UT_RETURN_FALSE_IF_FAIL(mode != NULL);
195 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_buffer_create(w, h, TBM_FORMAT_ARGB8888, TBM_BO_SCANOUT, fill, buffer_count, buffers) == true);
201 tc_tdm_output_prepare(tdm_display *dpy, tdm_output *output, bool fill)
203 tbm_surface_h buffer = NULL;
205 int primary_index = -1;
208 tdm_output_conn_status status;
209 tdm_region fb_damage;
210 tdm_hwc *thwc = NULL;
213 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_is_connected(output) == true);
214 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_mode_setting(output) == true);
215 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON) == TDM_ERROR_NONE);
217 if (tc_tdm_output_is_hwc_enable(output)) {
218 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_output_prepare_hwc_buffer(output, &buffer, 1, fill) == true);
219 thwc = tdm_output_get_hwc(output, &ret);
220 TDM_UT_GOTO_IF_FAIL(thwc != NULL, failed);
222 TDM_UT_GOTO_IF_FAIL(tdm_hwc_set_client_target_buffer(thwc, buffer, fb_damage) == TDM_ERROR_NONE, failed);
223 TDM_UT_GOTO_IF_FAIL(tdm_hwc_validate(thwc, NULL, 0, &num) == TDM_ERROR_NONE, failed);
224 TDM_UT_GOTO_IF_FAIL(tdm_hwc_accept_validation(thwc) == TDM_ERROR_NONE, failed);
225 TDM_UT_GOTO_IF_FAIL(tdm_hwc_commit(thwc, 0, NULL, NULL) == TDM_ERROR_NONE, failed);
227 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_primary_index(output, &primary_index) == TDM_ERROR_NONE);
228 TDM_UT_RETURN_FALSE_IF_FAIL(primary_index >= 0);
230 layer = tdm_output_get_layer(output, primary_index, &ret);
231 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
232 TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
234 TDM_UT_RETURN_FALSE_IF_FAIL(tc_tdm_layer_prepare_buffer(layer, &buffer, 1, fill) == true);
235 TDM_UT_RETURN_FALSE_IF_FAIL(buffer != NULL);
237 TDM_UT_GOTO_IF_FAIL(tc_tdm_layer_set_buffer(layer, buffer) == true, failed);
239 if (tdm_helper_output_commit_per_vblank_enabled(output))
240 TDM_UT_GOTO_IF_FAIL(tdm_layer_commit(layer, NULL, NULL) == TDM_ERROR_NONE, failed);
242 TDM_UT_GOTO_IF_FAIL(tdm_output_commit(output, 0, NULL, NULL) == TDM_ERROR_NONE, failed);
245 TDM_UT_GOTO_IF_FAIL(tdm_output_get_conn_status(output, &status) == TDM_ERROR_NONE, failed);
246 TDM_UT_GOTO_IF_FAIL(status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED, failed);
249 TDM_UT_GOTO_IF_FAIL(tdm_output_wait_vblank(output, 1, 0, _tc_tdm_output_done_cb, &done) == TDM_ERROR_NONE, failed);
250 TDM_UT_GOTO_IF_FAIL(tc_tdm_display_handle_events(dpy) == TDM_ERROR_NONE, failed);
253 tbm_surface_internal_unref(buffer);
257 tbm_surface_internal_unref(buffer);
263 tc_tdm_output_prepare_all_output(tdm_display *dpy, tdm_output **outputs, int output_count, bool fill)
265 for (int o = 0; o < output_count; o++) {
266 if (!tc_tdm_output_is_connected(outputs[o]))
268 if (!tc_tdm_output_prepare(dpy, outputs[o], fill))
275 tc_tdm_output_unset(tdm_display *dpy, tdm_output *output)
279 unsigned int pipe = 0;
280 tdm_hwc *thwc = NULL;
281 const tdm_output_mode *mode = NULL;
282 tdm_output_dpms dpms = TDM_OUTPUT_DPMS_OFF;
283 tdm_region fb_damage = {0, };
286 if (tc_tdm_output_is_hwc_enable(output)) {
287 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_mode(output, &mode) == TDM_ERROR_NONE);
290 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_dpms(output, &dpms) == TDM_ERROR_NONE);
291 if (dpms != TDM_OUTPUT_DPMS_ON)
294 thwc = tdm_output_get_hwc(output, &ret);
295 TDM_UT_RETURN_FALSE_IF_FAIL(thwc != NULL);
297 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_hwc_set_client_target_buffer(thwc, NULL, fb_damage) == TDM_ERROR_NONE);
298 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_hwc_validate(thwc, NULL, 0, &num) == TDM_ERROR_NONE);
299 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_hwc_accept_validation(thwc) == TDM_ERROR_NONE);
300 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_hwc_commit(thwc, 0, NULL, NULL) == TDM_ERROR_NONE);
302 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_layer_count(output, &count) == TDM_ERROR_NONE);
303 TDM_UT_RETURN_FALSE_IF_FAIL(count > 0);
305 for (int l = 0; l < count; l++) {
306 tdm_layer *layer = tdm_output_get_layer(output, l, &ret);
307 TDM_UT_RETURN_FALSE_IF_FAIL(ret == TDM_ERROR_NONE);
308 TDM_UT_RETURN_FALSE_IF_FAIL(layer != NULL);
310 if (tc_tdm_layer_is_cursor_layer(layer))
312 if (tc_tdm_layer_is_video_layer(layer))
315 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_layer_unset_buffer(layer) == TDM_ERROR_NONE);
319 TDM_UT_RETURN_FALSE_IF_FAIL(tdm_output_get_pipe(output, &pipe) == TDM_ERROR_NONE);
321 TDM_INFO("unsetting output(%d) done", pipe);
328 tc_tdm_output_get_vblank_interval_time(tdm_output *output)
330 const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
331 tdm_error ret = tdm_output_get_mode(output, &mode);
333 assert(ret == TDM_ERROR_NONE);
334 assert(mode != NULL);
335 assert(mode->vrefresh > 0);
337 return (double)1.0 / (double)mode->vrefresh;
340 TEST_P(TDMOutput, OutputGetBackendModule)
342 TDM_UT_SKIP_FLAG(has_outputs);
344 for (int o = 0; o < output_count; o++) {
345 tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE;
346 ASSERT_NE(tdm_output_get_backend_module(outputs[o], &ret), NULL);
347 ASSERT_EQ(ret, TDM_ERROR_NONE);
351 TEST_P(TDMOutput, OutputGetBackendModuleNullOBject)
353 TDM_UT_SKIP_FLAG(has_outputs);
355 tdm_error ret = (tdm_error)TDM_UT_INVALID_VALUE;
356 ASSERT_EQ(tdm_output_get_backend_module(NULL, &ret), NULL);
357 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
360 TEST_P(TDMOutput, OutputGetBackendModuleNullOther)
362 TDM_UT_SKIP_FLAG(has_outputs);
364 for (int o = 0; o < output_count; o++) {
365 ASSERT_NE(tdm_output_get_backend_module(outputs[o], NULL), NULL);
369 TEST_P(TDMOutput, OutputGetCapabilities)
371 TDM_UT_SKIP_FLAG(has_outputs);
373 for (int o = 0; o < output_count; o++) {
374 tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
375 ASSERT_EQ(tdm_output_get_capabilities(outputs[o], &capabilities), TDM_ERROR_NONE);
376 ASSERT_NE(capabilities, TDM_UT_INVALID_VALUE);
380 TEST_P(TDMOutput, OutputGetCapabilitiesNullObject)
382 TDM_UT_SKIP_FLAG(has_outputs);
384 tdm_output_capability capabilities = (tdm_output_capability)TDM_UT_INVALID_VALUE;
385 ASSERT_EQ(tdm_output_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
386 ASSERT_EQ(capabilities, (tdm_output_capability)TDM_UT_INVALID_VALUE);
389 TEST_P(TDMOutput, OutputGetCapabilitiesNullOther)
391 TDM_UT_SKIP_FLAG(has_outputs);
393 ASSERT_EQ(tdm_output_get_capabilities(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
396 TEST_P(TDMOutput, OutputGetModelInfo)
398 TDM_UT_SKIP_FLAG(has_outputs);
400 for (int o = 0; o < output_count; o++) {
401 const char *maker = NULL, *model = NULL, *name = NULL;
402 ASSERT_EQ(tdm_output_get_model_info(outputs[o], &maker, &model, &name), TDM_ERROR_NONE);
403 ASSERT_NE(maker, NULL);
404 ASSERT_NE(model, NULL);
405 ASSERT_NE(name, NULL);
409 TEST_P(TDMOutput, OutputGetModelInfoNullObject)
411 TDM_UT_SKIP_FLAG(has_outputs);
413 const char *maker = (const char*)TDM_UT_INVALID_VALUE;
414 const char *model = (const char*)TDM_UT_INVALID_VALUE;
415 const char *name = (const char*)TDM_UT_INVALID_VALUE;
417 ASSERT_EQ(tdm_output_get_model_info(NULL, &maker, &model, &name), TDM_ERROR_INVALID_PARAMETER);
418 ASSERT_EQ(maker, (const char*)TDM_UT_INVALID_VALUE);
419 ASSERT_EQ(model, (const char*)TDM_UT_INVALID_VALUE);
420 ASSERT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
423 TEST_P(TDMOutput, OutputGetModelInfoNullOther)
425 TDM_UT_SKIP_FLAG(has_outputs);
427 ASSERT_EQ(tdm_output_get_model_info(outputs[0], NULL, NULL, NULL), TDM_ERROR_NONE);
430 TEST_P(TDMOutput, OutputGetConnStatus)
432 TDM_UT_SKIP_FLAG(has_outputs);
434 for (int o = 0; o < output_count; o++) {
435 tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
436 ASSERT_EQ(tdm_output_get_conn_status(outputs[o], &status), TDM_ERROR_NONE);
437 ASSERT_NE(status, TDM_UT_INVALID_VALUE);
441 TEST_P(TDMOutput, OutputGetConnStatusNullObject)
443 TDM_UT_SKIP_FLAG(has_outputs);
445 tdm_output_conn_status status = (tdm_output_conn_status)TDM_UT_INVALID_VALUE;
447 ASSERT_EQ(tdm_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
448 ASSERT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
451 TEST_P(TDMOutput, OutputGetConnStatusNullOther)
453 TDM_UT_SKIP_FLAG(has_outputs);
455 ASSERT_EQ(tdm_output_get_conn_status(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
458 TEST_P(TDMOutput, OutputGetOutputType)
460 TDM_UT_SKIP_FLAG(has_outputs);
462 for (int o = 0; o < output_count; o++) {
463 tdm_output_type type = (tdm_output_type)TDM_UT_INVALID_VALUE;
464 ASSERT_EQ(tdm_output_get_output_type(outputs[o], &type), TDM_ERROR_NONE);
465 ASSERT_NE(type, TDM_UT_INVALID_VALUE);
469 TEST_P(TDMOutput, OutputGetOutputTypeNullObject)
471 TDM_UT_SKIP_FLAG(has_outputs);
473 tdm_output_type type = (tdm_output_type)TDM_UT_INVALID_VALUE;
474 ASSERT_EQ(tdm_output_get_output_type(NULL, &type), TDM_ERROR_INVALID_PARAMETER);
475 ASSERT_EQ(type, (tdm_output_type)TDM_UT_INVALID_VALUE);
478 TEST_P(TDMOutput, OutputGetOutputTypeNullOther)
480 TDM_UT_SKIP_FLAG(has_outputs);
482 ASSERT_EQ(tdm_output_get_output_type(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
485 TEST_P(TDMOutput, OutputGetLayerCount)
487 TDM_UT_SKIP_FLAG(has_outputs);
489 for (int o = 0; o < output_count; o++) {
490 int count = TDM_UT_INVALID_VALUE;
491 if (tc_tdm_output_is_hwc_enable(outputs[o])) {
492 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST);
495 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_NONE);
501 TEST_P(TDMOutput, OutputGetLayerCountNullObject)
503 TDM_UT_SKIP_FLAG(has_outputs);
505 int count = TDM_UT_INVALID_VALUE;
506 ASSERT_EQ(tdm_output_get_layer_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
507 ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
510 TEST_P(TDMOutput, OutputGetLayerCountNullOther)
512 TDM_UT_SKIP_FLAG(has_outputs);
514 ASSERT_EQ(tdm_output_get_layer_count(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
517 TEST_P(TDMOutput, OutputGetLayer)
519 TDM_UT_SKIP_FLAG(has_outputs);
521 for (int o = 0; o < output_count; o++) {
524 int layer_count = TDM_UT_INVALID_VALUE;
526 if (tc_tdm_output_is_hwc_enable(outputs[o])) {
527 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST);
528 ASSERT_EQ(layer_count, 0);
530 layer = tdm_output_get_layer(outputs[o], 0, &ret);
531 ASSERT_EQ(ret, TDM_ERROR_BAD_REQUEST);
532 ASSERT_EQ(layer, NULL);
534 ASSERT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_NONE);
535 ASSERT_GT(layer_count, 0);
537 for (int l = 0; l < layer_count; l++) {
538 tdm_layer *layer = tdm_output_get_layer(outputs[o], l, &ret);
539 ASSERT_EQ(ret, TDM_ERROR_NONE);
540 ASSERT_NE(layer, NULL);
546 TEST_P(TDMOutput, OutputGetLayerNullObject)
548 TDM_UT_SKIP_FLAG(has_outputs);
551 tdm_layer *layer = tdm_output_get_layer(NULL, 0, &ret);
552 ASSERT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
553 ASSERT_EQ(layer, NULL);
556 TEST_P(TDMOutput, OutputGetLayerNullOther)
558 TDM_UT_SKIP_FLAG(has_outputs);
561 if (tc_tdm_output_is_hwc_enable(outputs[0])) {
562 layer = tdm_output_get_layer(outputs[0], 0, NULL);
563 ASSERT_EQ(layer, NULL);
565 layer = tdm_output_get_layer(outputs[0], 0, NULL);
566 ASSERT_NE(layer, NULL);
570 TEST_P(TDMOutput, OutputGetAvailableProperties)
572 TDM_UT_SKIP_FLAG(has_outputs);
574 for (int o = 0; o < output_count; o++) {
575 int count = TDM_UT_INVALID_VALUE;
576 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
577 ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
580 ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
584 TEST_P(TDMOutput, OutputGetAvailablePropertiesNullObject)
586 TDM_UT_SKIP_FLAG(has_outputs);
588 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
589 int count = TDM_UT_INVALID_VALUE;
590 ASSERT_EQ(tdm_output_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
591 ASSERT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
592 ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
595 TEST_P(TDMOutput, OutputGetAvailablePropertiesNullOther)
597 TDM_UT_SKIP_FLAG(has_outputs);
599 ASSERT_EQ(tdm_output_get_available_properties(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
602 TEST_P(TDMOutput, OutputGetAvailableModes)
604 TDM_UT_SKIP_FLAG(has_outputs);
606 for (int o = 0; o < output_count; o++) {
607 if (!tc_tdm_output_is_connected(outputs[o]))
610 int count = TDM_UT_INVALID_VALUE;
611 const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE;
612 ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes_array, &count), TDM_ERROR_NONE);
614 ASSERT_TRUE(modes_array != NULL && modes_array != (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
618 TEST_P(TDMOutput, OutputGetAvailableModesNullObject)
620 TDM_UT_SKIP_FLAG(has_outputs);
622 int count = TDM_UT_INVALID_VALUE;
623 const tdm_output_mode *modes_array = (const tdm_output_mode *) TDM_UT_INVALID_VALUE;
624 ASSERT_EQ(tdm_output_get_available_modes(NULL, &modes_array, &count), TDM_ERROR_INVALID_PARAMETER);
625 ASSERT_EQ(count, TDM_UT_INVALID_VALUE);
626 ASSERT_EQ(modes_array, (const tdm_output_mode *) TDM_UT_INVALID_VALUE);
629 TEST_P(TDMOutput, OutputGetAvailableModesNullOther)
631 TDM_UT_SKIP_FLAG(has_outputs);
633 ASSERT_EQ(tdm_output_get_available_modes(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
636 TEST_P(TDMOutput, OutputGetAvailableSize)
638 TDM_UT_SKIP_FLAG(has_outputs);
640 for (int o = 0; o < output_count; o++) {
641 if (!tc_tdm_output_is_connected(outputs[o]))
644 int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
645 int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
646 int preferred_align = TDM_UT_INVALID_VALUE;
647 ASSERT_EQ(tdm_output_get_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
648 ASSERT_NE(min_w, TDM_UT_INVALID_VALUE);
649 ASSERT_NE(min_h, TDM_UT_INVALID_VALUE);
650 ASSERT_NE(max_w, TDM_UT_INVALID_VALUE);
651 ASSERT_NE(max_h, TDM_UT_INVALID_VALUE);
652 ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE);
656 TEST_P(TDMOutput, OutputGetAvailableSizeNullObject)
658 TDM_UT_SKIP_FLAG(has_outputs);
660 int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
661 int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
662 int preferred_align = TDM_UT_INVALID_VALUE;
663 ASSERT_EQ(tdm_output_get_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
664 ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
665 ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
666 ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
667 ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
668 ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
671 TEST_P(TDMOutput, OutputGetAvailableSizeNullOther)
673 TDM_UT_SKIP_FLAG(has_outputs);
675 ASSERT_EQ(tdm_output_get_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
678 TEST_P(TDMOutput, OutputGetCursorAvailableSize)
680 TDM_UT_SKIP_FLAG(has_outputs);
682 int major = TDM_UT_INVALID_VALUE;
683 int minor = TDM_UT_INVALID_VALUE;
685 ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
686 if (major > 1 || (major >= 1 && minor >= 5)) {
687 for (int o = 0; o < output_count; o++) {
688 int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
689 int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
690 int preferred_align = TDM_UT_INVALID_VALUE;
691 ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
692 ASSERT_NE(min_w, TDM_UT_INVALID_VALUE);
693 ASSERT_NE(min_h, TDM_UT_INVALID_VALUE);
694 ASSERT_NE(max_w, TDM_UT_INVALID_VALUE);
695 ASSERT_NE(max_h, TDM_UT_INVALID_VALUE);
696 ASSERT_NE(preferred_align, TDM_UT_INVALID_VALUE);
701 TEST_P(TDMOutput, OutputGetCursorAvailableSizeNullObject)
703 TDM_UT_SKIP_FLAG(has_outputs);
705 int major = TDM_UT_INVALID_VALUE;
706 int minor = TDM_UT_INVALID_VALUE;
708 ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
709 if (major > 1 || (major >= 1 && minor >= 5)) {
710 for (int o = 0; o < output_count; o++) {
711 int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
712 int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
713 int preferred_align = TDM_UT_INVALID_VALUE;
714 ASSERT_EQ(tdm_output_get_cursor_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
715 ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
716 ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
717 ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
718 ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
719 ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
724 TEST_P(TDMOutput, OutputGetCursorAvailableSizeNullOther)
726 TDM_UT_SKIP_FLAG(has_outputs);
728 int major = TDM_UT_INVALID_VALUE;
729 int minor = TDM_UT_INVALID_VALUE;
731 ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
732 if (major > 1 || (major >= 1 && minor >= 5))
733 ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[0], NULL, NULL, NULL, NULL, NULL), TDM_ERROR_NONE);
736 TEST_P(TDMOutput, OutputGetCursorAvailableSizeNoMatchVersion)
738 TDM_UT_SKIP_FLAG(has_outputs);
740 int major = TDM_UT_INVALID_VALUE;
741 int minor = TDM_UT_INVALID_VALUE;
743 ASSERT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
744 if (major <= 1 && minor < 5) {
745 for (int o = 0; o < output_count; o++) {
746 int min_w = TDM_UT_INVALID_VALUE, min_h = TDM_UT_INVALID_VALUE;
747 int max_w = TDM_UT_INVALID_VALUE, max_h = TDM_UT_INVALID_VALUE;
748 int preferred_align = TDM_UT_INVALID_VALUE;
749 ASSERT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_BAD_REQUEST);
750 ASSERT_EQ(min_w, TDM_UT_INVALID_VALUE);
751 ASSERT_EQ(min_h, TDM_UT_INVALID_VALUE);
752 ASSERT_EQ(max_w, TDM_UT_INVALID_VALUE);
753 ASSERT_EQ(max_h, TDM_UT_INVALID_VALUE);
754 ASSERT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
759 TEST_P(TDMOutput, OutputGetPhysicalSize)
761 TDM_UT_SKIP_FLAG(has_outputs);
763 for (int o = 0; o < output_count; o++) {
764 unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE;
765 unsigned int mmHeight = (unsigned int)TDM_UT_INVALID_VALUE;
766 ASSERT_EQ(tdm_output_get_physical_size(outputs[o], &mmWidth, &mmHeight), TDM_ERROR_NONE);
767 ASSERT_NE(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
768 ASSERT_NE(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
772 TEST_P(TDMOutput, OutputGetPhysicalSizeNullObject)
774 TDM_UT_SKIP_FLAG(has_outputs);
776 unsigned int mmWidth = (unsigned int)TDM_UT_INVALID_VALUE;
777 unsigned int mmHeight = (unsigned int)TDM_UT_INVALID_VALUE;
778 ASSERT_EQ(tdm_output_get_physical_size(NULL, &mmWidth, &mmHeight), TDM_ERROR_INVALID_PARAMETER);
779 ASSERT_EQ(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
780 ASSERT_EQ(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
783 TEST_P(TDMOutput, OutputGetPhysicalSizeNullOther)
785 TDM_UT_SKIP_FLAG(has_outputs);
787 ASSERT_EQ(tdm_output_get_physical_size(outputs[0], NULL, NULL), TDM_ERROR_NONE);
790 TEST_P(TDMOutput, OutputGetSubpixel)
792 TDM_UT_SKIP_FLAG(has_outputs);
794 for (int o = 0; o < output_count; o++) {
795 unsigned int subpixel = (unsigned int)TDM_UT_INVALID_VALUE;
796 ASSERT_EQ(tdm_output_get_subpixel(outputs[o], &subpixel), TDM_ERROR_NONE);
797 ASSERT_NE(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
801 TEST_P(TDMOutput, OutputGetSubpixelNullObject)
803 TDM_UT_SKIP_FLAG(has_outputs);
805 unsigned int subpixel = (unsigned int)TDM_UT_INVALID_VALUE;
806 ASSERT_EQ(tdm_output_get_subpixel(NULL, &subpixel), TDM_ERROR_INVALID_PARAMETER);
807 ASSERT_EQ(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
810 TEST_P(TDMOutput, OutputGetSubpixelNullOther)
812 TDM_UT_SKIP_FLAG(has_outputs);
814 ASSERT_EQ(tdm_output_get_subpixel(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
817 TEST_P(TDMOutput, OutputGetPipe)
819 TDM_UT_SKIP_FLAG(has_outputs);
821 for (int o = 0; o < output_count; o++) {
822 unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
823 ASSERT_EQ(tdm_output_get_pipe(outputs[o], &pipe), TDM_ERROR_NONE);
824 ASSERT_NE(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
828 TEST_P(TDMOutput, OutputGetPipeNullObject)
830 TDM_UT_SKIP_FLAG(has_outputs);
832 unsigned int pipe = (unsigned int)TDM_UT_INVALID_VALUE;
833 ASSERT_EQ(tdm_output_get_pipe(NULL, &pipe), TDM_ERROR_INVALID_PARAMETER);
834 ASSERT_EQ(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
837 TEST_P(TDMOutput, OutputGetPipeNullOther)
839 TDM_UT_SKIP_FLAG(has_outputs);
841 ASSERT_EQ(tdm_output_get_pipe(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
844 TEST_P(TDMOutput, OutputGetPrimaryIndex)
846 TDM_UT_SKIP_FLAG(has_outputs);
848 for (int o = 0; o < output_count; o++) {
849 int primary_index = TDM_UT_INVALID_VALUE;
851 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
852 ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE);
853 ASSERT_NE(primary_index, TDM_UT_INVALID_VALUE);
859 TEST_P(TDMOutput, OutputGetPrimaryIndexNullObject)
861 TDM_UT_SKIP_FLAG(has_outputs);
863 int primary_index = TDM_UT_INVALID_VALUE;
864 ASSERT_EQ(tdm_output_get_primary_index(NULL, &primary_index), TDM_ERROR_INVALID_PARAMETER);
865 ASSERT_EQ(primary_index, TDM_UT_INVALID_VALUE);
868 TEST_P(TDMOutput, OutputGetPrimaryIndexNullOther)
870 TDM_UT_SKIP_FLAG(has_outputs);
872 ASSERT_EQ(tdm_output_get_primary_index(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
875 TEST_P(TDMOutput, DISABLED_OutputSetProperty)
879 TEST_P(TDMOutput, OutputSetPropertyNullObject)
881 tdm_value value = {.s32 = 0};
883 ASSERT_EQ(tdm_output_set_property(NULL, 0, value), TDM_ERROR_INVALID_PARAMETER);
886 TEST_P(TDMOutput, OutputGetProperty)
888 TDM_UT_SKIP_FLAG(has_outputs);
890 for (int o = 0; o < output_count; o++) {
891 int count = TDM_UT_INVALID_VALUE;
892 const tdm_prop *props = (const tdm_prop *)TDM_UT_INVALID_VALUE;
893 ASSERT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
896 ASSERT_TRUE(props != NULL && props != (const tdm_prop *)TDM_UT_INVALID_VALUE);
898 for (int i = 0; i < count; i++) {
899 tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
900 ASSERT_EQ(tdm_output_get_property(outputs[o], props[i].id, &value), TDM_ERROR_NONE);
901 ASSERT_NE(value.s32, TDM_UT_INVALID_VALUE);
907 TEST_P(TDMOutput, OutputGetPropertyNullObject)
909 TDM_UT_SKIP_FLAG(has_outputs);
911 tdm_value value = {.s32 = TDM_UT_INVALID_VALUE};
912 ASSERT_EQ(tdm_output_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
913 ASSERT_EQ(value.s32, TDM_UT_INVALID_VALUE);
916 TEST_P(TDMOutput, OutputGetPropertyNullOther)
918 TDM_UT_SKIP_FLAG(has_outputs);
920 ASSERT_EQ(tdm_output_get_property(outputs[0], 0, NULL), TDM_ERROR_INVALID_PARAMETER);
924 _tc_tdm_output_change_cb(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data)
926 bool *done = (bool *)user_data;
931 TEST_P(TDMOutput, OutputAddChangeHandler)
933 TDM_UT_SKIP_FLAG(has_outputs);
935 for (int o = 0; o < output_count; o++) {
936 if (!tc_tdm_output_is_connected(outputs[o]))
939 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
941 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
944 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
945 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
946 ASSERT_EQ(done1, true);
950 TEST_P(TDMOutput, OutputAddChangeHandlerTwice)
952 TDM_UT_SKIP_FLAG(has_outputs);
954 ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
955 ASSERT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_BAD_REQUEST);
958 TEST_P(TDMOutput, OutputAddChangeHandlerNullObject)
960 TDM_UT_SKIP_FLAG(has_outputs);
962 ASSERT_EQ(tdm_output_add_change_handler(NULL, _tc_tdm_output_change_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
965 TEST_P(TDMOutput, OutputAddChangeHandlerNullOther)
967 TDM_UT_SKIP_FLAG(has_outputs);
969 ASSERT_EQ(tdm_output_add_change_handler(outputs[0], NULL, NULL), TDM_ERROR_INVALID_PARAMETER);
972 TEST_P(TDMOutput, OutputRemoveChangeHandler)
974 TDM_UT_SKIP_FLAG(has_outputs);
976 for (int o = 0; o < output_count; o++) {
977 for (int t = 0; t < 10; t++) {
978 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
979 tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL);
984 TEST_P(TDMOutput, OutputRemoveChangeHandlerDifferentData)
986 TDM_UT_SKIP_FLAG(has_outputs);
988 for (int o = 0; o < output_count; o++) {
989 if (!tc_tdm_output_is_connected(outputs[o]))
992 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
995 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
996 tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, NULL);
998 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
999 ASSERT_EQ(done1, true);
1004 _tc_tdm_output_change_cb2(tdm_output *output, tdm_output_change_type type, tdm_value value, void *user_data)
1006 bool *done = (bool*)user_data;
1009 tdm_output_remove_change_handler(output, _tc_tdm_output_change_cb2, user_data);
1012 TEST_P(TDMOutput, OutputRemoveChangeHandlerInHandler)
1014 TDM_UT_SKIP_FLAG(has_outputs);
1016 for (int o = 0; o < output_count; o++) {
1017 if (!tc_tdm_output_is_connected(outputs[o]))
1020 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1023 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done1), TDM_ERROR_NONE);
1024 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1025 ASSERT_EQ(done1, true);
1028 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2), TDM_ERROR_NONE);
1029 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1030 ASSERT_EQ(done2, true);
1033 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done3), TDM_ERROR_NONE);
1034 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1035 ASSERT_EQ(done3, true);
1039 TEST_P(TDMOutput, OutputRemoveChangeHandlerNullObject)
1041 TDM_UT_SKIP_FLAG(has_outputs);
1043 tdm_output_remove_change_handler(NULL, _tc_tdm_output_change_cb, NULL);
1046 TEST_P(TDMOutput, OutputRemoveChangeHandlerNullOther)
1048 TDM_UT_SKIP_FLAG(has_outputs);
1050 tdm_output_remove_change_handler(outputs[0], NULL, NULL);
1053 TEST_P(TDMOutput, OutputSetMode)
1055 TDM_UT_SKIP_FLAG(has_outputs);
1057 for (int o = 0; o < output_count; o++) {
1058 const tdm_output_mode *modes;
1060 if (!tc_tdm_output_is_connected(outputs[o]))
1063 ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
1064 ASSERT_NE(modes, NULL);
1065 ASSERT_GT(count, 0);
1067 for (int m = 0; m < count; m++)
1068 ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
1072 TEST_P(TDMOutput, OutputSetModeNullObject)
1074 TDM_UT_SKIP_FLAG(has_outputs);
1076 const tdm_output_mode *mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
1077 ASSERT_EQ(tdm_output_set_mode(NULL, mode), TDM_ERROR_INVALID_PARAMETER);
1080 TEST_P(TDMOutput, OutputSetModeNullOther)
1082 TDM_UT_SKIP_FLAG(has_outputs);
1084 for (int o = 0; o < output_count; o++) {
1085 if (!tc_tdm_output_is_connected(outputs[o]))
1088 ASSERT_EQ(tdm_output_set_mode(outputs[o], NULL), TDM_ERROR_INVALID_PARAMETER);
1092 TEST_P(TDMOutput, OutputGetMode)
1094 TDM_UT_SKIP_FLAG(has_outputs);
1096 for (int o = 0; o < output_count; o++) {
1097 const tdm_output_mode *modes;
1100 if (!tc_tdm_output_is_connected(outputs[o]))
1103 ASSERT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
1104 ASSERT_NE(modes, NULL);
1105 ASSERT_GT(count, 0);
1107 for (int m = 0; m < count; m++) {
1108 const tdm_output_mode *current_mode;
1109 ASSERT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
1110 ASSERT_EQ(tdm_output_get_mode(outputs[o], ¤t_mode), TDM_ERROR_NONE);
1111 ASSERT_EQ(current_mode, modes + m);
1116 TEST_P(TDMOutput, OutputGetModeNullObject)
1118 TDM_UT_SKIP_FLAG(has_outputs);
1120 const tdm_output_mode *current_mode = (const tdm_output_mode *)TDM_UT_INVALID_VALUE;
1121 ASSERT_EQ(tdm_output_get_mode(NULL, ¤t_mode), TDM_ERROR_INVALID_PARAMETER);
1122 ASSERT_EQ(current_mode, (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
1125 TEST_P(TDMOutput, OutputGetModeNullOther)
1127 TDM_UT_SKIP_FLAG(has_outputs);
1129 ASSERT_EQ(tdm_output_get_mode(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1132 TEST_P(TDMOutput, OutputGetModeNoSet)
1134 TDM_UT_SKIP_FLAG(has_outputs);
1136 for (int o = 0; o < output_count; o++) {
1137 const tdm_output_mode *mode;
1138 ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
1139 ASSERT_EQ(mode, NULL);
1143 TEST_P(TDMOutput, OutputSetDpms)
1145 TDM_UT_SKIP_FLAG(has_outputs);
1147 for (int o = 0; o < output_count; o++) {
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_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
1153 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
1154 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1155 if (tc_tdm_output_is_aod_enable(outputs[o])) {
1156 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
1158 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
1163 TEST_P(TDMOutput, OutputSetDpmsNullObject)
1165 TDM_UT_SKIP_FLAG(has_outputs);
1167 ASSERT_EQ(tdm_output_set_dpms(NULL, TDM_OUTPUT_DPMS_OFF), TDM_ERROR_INVALID_PARAMETER);
1170 TEST_P(TDMOutput, OutputSetDpmsNullOther)
1172 TDM_UT_SKIP_FLAG(has_outputs);
1174 ASSERT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)-1), TDM_ERROR_BAD_REQUEST);
1175 ASSERT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)INT_MAX), TDM_ERROR_BAD_REQUEST);
1178 TEST_P(TDMOutput, OutputSetDpmsAsync)
1180 TDM_UT_SKIP_FLAG(has_outputs);
1182 for (int o = 0; o < output_count; o++) {
1183 if (!tc_tdm_output_is_connected(outputs[o]))
1185 if (!tc_tdm_output_is_async_dpms_enable(outputs[o]))
1189 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1190 ASSERT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
1191 ASSERT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1193 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1194 tdm_output_remove_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1);
1198 TEST_P(TDMOutput, OutputGetDpms)
1200 TDM_UT_SKIP_FLAG(has_outputs);
1202 for (int o = 0; o < output_count; o++) {
1203 tdm_output_dpms dpms_value;
1205 if (!tc_tdm_output_is_connected(outputs[o]))
1208 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1209 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1210 ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_OFF);
1212 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
1213 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1214 ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_STANDBY);
1216 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
1217 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1218 ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_SUSPEND);
1220 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1221 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1222 ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON);
1224 if (tc_tdm_output_is_aod_enable(outputs[o])) {
1225 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
1226 ASSERT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1227 ASSERT_EQ(dpms_value, TDM_OUTPUT_DPMS_AOD);
1229 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_BAD_REQUEST);
1234 TEST_P(TDMOutput, OutputGetDpmsNullObject)
1236 TDM_UT_SKIP_FLAG(has_outputs);
1238 tdm_output_dpms dpms_value = (tdm_output_dpms)TDM_UT_INVALID_VALUE;
1239 ASSERT_EQ(tdm_output_get_dpms(NULL, &dpms_value), TDM_ERROR_INVALID_PARAMETER);
1240 ASSERT_EQ(dpms_value, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
1243 TEST_P(TDMOutput, OutputGetDpmsNullOther)
1245 TDM_UT_SKIP_FLAG(has_outputs);
1247 ASSERT_EQ(tdm_output_get_dpms(outputs[0], NULL), TDM_ERROR_INVALID_PARAMETER);
1250 TEST_P(TDMOutput, OutputWaitVblank)
1252 TDM_UT_SKIP_FLAG(has_outputs);
1254 for (int o = 0; o < output_count; o++) {
1255 if (!tc_tdm_output_is_connected(outputs[o]))
1258 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1260 for (int t = 0; t < 10; t++) {
1261 double start, end, interval;
1263 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
1266 start = tdm_helper_get_time();
1267 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1269 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1270 end = tdm_helper_get_time();
1272 /* "+ interval" consider the delay of socket communication between kernel and platform */
1273 ASSERT_LT((end - start), (interval + interval));
1278 TEST_P(TDMOutput, OutputWaitVblankNullObject)
1280 TDM_UT_SKIP_FLAG(has_outputs);
1282 ASSERT_EQ(tdm_output_wait_vblank(NULL, 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1285 TEST_P(TDMOutput, OutputWaitVblankNullOther)
1287 TDM_UT_SKIP_FLAG(has_outputs);
1289 for (int o = 0; o < output_count; o++) {
1290 if (!tc_tdm_output_is_connected(outputs[o]))
1293 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1295 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, NULL, NULL), TDM_ERROR_NONE);
1299 TEST_P(TDMOutput, OutputWaitVblankTimeout)
1301 TDM_UT_SKIP_FLAG(has_outputs);
1303 for (int o = 0; o < output_count; o++) {
1304 if (!tc_tdm_output_is_connected(outputs[o]))
1307 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1309 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE);
1312 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1314 ASSERT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0);
1318 TEST_P(TDMOutput, OutputWaitVblankInterval0)
1320 TDM_UT_SKIP_FLAG(has_outputs);
1322 ASSERT_EQ(tdm_output_wait_vblank(outputs[0], 0, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1325 TEST_P(TDMOutput, OutputWaitVblankInterval)
1327 TDM_UT_SKIP_FLAG(has_outputs);
1329 for (int o = 0; o < output_count; o++) {
1330 if (!tc_tdm_output_is_connected(outputs[o]))
1333 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1336 for (int t = 1; t < 10; t++) {
1337 double start, end, interval;
1339 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
1342 start = tdm_helper_get_time();
1343 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1345 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1346 end = tdm_helper_get_time();
1348 /* "+ interval" consider the delay of socket communication between kernel and platform */
1349 ASSERT_GT((end - start), (interval * (t - 1)));
1350 ASSERT_LT((end - start), (interval * t + interval));
1355 TEST_P(TDMOutput, OutputWaitVblankFewTimesInOneVblank)
1357 TDM_UT_SKIP_FLAG(has_outputs);
1359 for (int o = 0; o < output_count; o++) {
1360 if (!tc_tdm_output_is_connected(outputs[o]))
1363 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1366 for (int t = 1; t < 10; t++) {
1367 double start, end, interval;
1369 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
1371 done1 = done2 = done3 = false;
1372 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1373 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1374 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1376 start = tdm_helper_get_time();
1377 while (!done1 || !done2 || !done3)
1378 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1379 end = tdm_helper_get_time();
1381 /* "+ interval" consider the delay of socket communication between kernel and platform */
1382 ASSERT_GT((end - start), (interval * (t - 1)));
1383 ASSERT_LT((end - start), (interval * t + interval));
1388 TEST_P(TDMOutput, OutputWaitVblankBeforeDpmsOff)
1390 TDM_UT_SKIP_FLAG(has_outputs);
1392 for (int o = 0; o < output_count; o++) {
1393 if (!tc_tdm_output_is_connected(outputs[o]))
1396 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], false), true);
1398 for (int t = 0; t < 10; t++) {
1401 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done), TDM_ERROR_NONE);
1403 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1405 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1410 TEST_P(TDMOutput, OutputRemoveVblankHandler)
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 tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, &done2);
1427 while (!done1 || done2 || !done3)
1428 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1433 TEST_P(TDMOutput, OutputRemoveVblankHandlerDifferentData)
1435 TDM_UT_SKIP_FLAG(has_outputs);
1437 for (int o = 0; o < output_count; o++) {
1438 if (!tc_tdm_output_is_connected(outputs[o]))
1441 tc_tdm_output_prepare(dpy, outputs[o], true);
1444 for (int t = 1; t < 10; t++) {
1445 done1 = done2 = done3 = false;
1446 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1447 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1448 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1449 tdm_output_remove_vblank_handler(outputs[o], _tc_tdm_output_done_cb, NULL);
1450 while (!done1 || !done2 || !done3)
1451 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1457 _tc_tdm_output_done_cb2(tdm_output *output, unsigned int sequence,
1458 unsigned int tv_sec, unsigned int tv_usec,
1461 bool *done = (bool*)user_data;
1464 tdm_output_remove_commit_handler(output, _tc_tdm_output_done_cb2, user_data);
1467 TEST_P(TDMOutput, OutputRemoveVblankHandlerInHandler)
1469 TDM_UT_SKIP_FLAG(has_outputs);
1471 for (int o = 0; o < output_count; o++) {
1472 if (!tc_tdm_output_is_connected(outputs[o]))
1475 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1478 for (int t = 1; t < 10; t++) {
1479 done1 = done2 = done3 = false;
1480 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1481 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1482 ASSERT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1483 while (!done1 || !done2 || !done3)
1484 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1489 TEST_P(TDMOutput, OutputCommit)
1491 TDM_UT_SKIP_FLAG(has_outputs);
1493 for (int o = 0; o < output_count; o++) {
1494 /* if true, have to use tdm_layer_commit. so skip */
1495 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1498 if (!tc_tdm_output_is_connected(outputs[o]))
1501 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1503 for (int t = 0; t < 10; t++) {
1504 double start, end, interval;
1506 interval = tc_tdm_output_get_vblank_interval_time(outputs[o]);
1509 start = tdm_helper_get_time();
1510 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
1511 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1513 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1514 end = tdm_helper_get_time();
1516 /* "+ interval" consider the delay of socket communication between kernel and platform */
1517 ASSERT_LT((end - start), (interval + interval));
1519 TDM_UT_SKIP_FLAG(0);
1524 TEST_P(TDMOutput, OutputCommitNullObject)
1526 TDM_UT_SKIP_FLAG(has_outputs);
1528 ASSERT_EQ(tdm_output_commit(NULL, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_INVALID_PARAMETER);
1531 TEST_P(TDMOutput, OutputCommitNullOther)
1533 TDM_UT_SKIP_FLAG(has_outputs);
1535 for (int o = 0; o < output_count; o++) {
1536 /* if true, have to use tdm_layer_commit. so skip */
1537 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1540 if (!tc_tdm_output_is_connected(outputs[o]))
1543 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1544 if (!tc_tdm_output_is_hwc_enable(outputs[o]))
1545 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
1547 TDM_UT_SKIP_FLAG(0);
1551 TEST_P(TDMOutput, OutputCommitDpmsSuspend)
1553 TDM_UT_SKIP_FLAG(has_outputs);
1555 for (int o = 0; o < output_count; o++) {
1556 /* if true, have to use tdm_layer_commit. so skip */
1557 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1560 if (!tc_tdm_output_is_connected(outputs[o]))
1563 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1565 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
1567 if (!tc_tdm_output_is_hwc_enable(outputs[o]))
1568 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
1570 TDM_UT_SKIP_FLAG(0);
1574 TEST_P(TDMOutput, OutputCommitDpmsOff)
1576 TDM_UT_SKIP_FLAG(has_outputs);
1578 for (int o = 0; o < output_count; o++) {
1579 /* if true, have to use tdm_layer_commit. so skip */
1580 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1583 if (!tc_tdm_output_is_connected(outputs[o]))
1586 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1588 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1590 if (!tc_tdm_output_is_hwc_enable(outputs[o]))
1591 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_DPMS_OFF);
1593 TDM_UT_SKIP_FLAG(0);
1597 TEST_P(TDMOutput, OutputCommitDpmsAOD)
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 if (!tc_tdm_output_is_aod_enable(outputs[o]))
1612 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1614 ASSERT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
1616 for (int t = 0; t < 10; t++) {
1618 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1620 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1625 TEST_P(TDMOutput, OutputCommitAfterLayerCommit)
1627 TDM_UT_SKIP_FLAG(has_outputs);
1629 for (int o = 0; o < output_count; o++) {
1630 int index = TDM_UT_INVALID_VALUE;
1634 if (!tc_tdm_output_is_connected(outputs[o]))
1637 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1639 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
1640 ASSERT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE);
1641 ASSERT_NE(index, TDM_UT_INVALID_VALUE);
1643 TDM_UT_SKIP_FLAG(0);
1645 layer = tdm_output_get_layer(outputs[o], index, &ret);
1646 ASSERT_EQ(ret, TDM_ERROR_NONE);
1647 ASSERT_NE(layer, NULL);
1649 ASSERT_EQ(tdm_layer_commit(layer, NULL, NULL), TDM_ERROR_NONE);
1651 if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1652 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
1654 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
1658 TEST_P(TDMOutput, OutputCommitMismatchCommitType)
1660 TDM_UT_SKIP_FLAG(has_outputs);
1662 for (int o = 0; o < output_count; o++) {
1663 if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1665 ASSERT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_BAD_REQUEST);
1669 TEST_P(TDMOutput, OutputCommitFewTimesInOneVblank)
1671 TDM_UT_SKIP_FLAG(has_outputs);
1673 for (int o = 0; o < output_count; o++) {
1674 /* if true, have to use tdm_layer_commit. so skip */
1675 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1678 if (!tc_tdm_output_is_connected(outputs[o]))
1681 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1683 for (int t = 0; t < 10; t++) {
1684 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
1685 done1 = done2 = done3 = false;
1686 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1687 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1688 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1689 while (!done1 || !done2 || !done3)
1690 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1692 TDM_UT_SKIP_FLAG(0);
1698 TEST_P(TDMOutput, DISABLED_OutputCommitBeforeDpmsOff)
1700 /* output commit -> dpms off -> then? (commit handler is called? or not?) */
1703 TEST_P(TDMOutput, OutputRemoveCommitHandler)
1705 TDM_UT_SKIP_FLAG(has_outputs);
1707 for (int o = 0; o < output_count; o++) {
1708 /* if true, have to use tdm_layer_commit. so skip */
1709 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1712 if (!tc_tdm_output_is_connected(outputs[o]))
1715 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1717 for (int t = 0; t < 10; t++) {
1718 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
1719 done1 = done2 = done3 = false;
1720 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1721 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1722 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1723 tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, &done2);
1724 while (!done1 || done2 || !done3)
1725 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1727 TDM_UT_SKIP_FLAG(0);
1732 TEST_P(TDMOutput, OutputRemoveCommitHandlerDifferentData)
1734 TDM_UT_SKIP_FLAG(has_outputs);
1736 for (int o = 0; o < output_count; o++) {
1737 /* if true, have to use tdm_layer_commit. so skip */
1738 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1741 if (!tc_tdm_output_is_connected(outputs[o]))
1744 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1746 for (int t = 0; t < 10; t++) {
1747 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
1748 done1 = done2 = done3 = false;
1749 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1750 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1751 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1752 tdm_output_remove_commit_handler(outputs[o], _tc_tdm_output_done_cb, NULL);
1753 while (!done1 || !done2 || !done3)
1754 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1756 TDM_UT_SKIP_FLAG(0);
1761 TEST_P(TDMOutput, OutputRemoveCommitHandlerInHandler)
1763 TDM_UT_SKIP_FLAG(has_outputs);
1765 for (int o = 0; o < output_count; o++) {
1766 /* if true, have to use tdm_layer_commit. so skip */
1767 if (tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1770 if (!tc_tdm_output_is_connected(outputs[o]))
1773 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1775 for (int t = 0; t < 10; t++) {
1776 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
1777 done1 = done2 = done3 = false;
1778 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done1), TDM_ERROR_NONE);
1779 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done2), TDM_ERROR_NONE);
1780 ASSERT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done3), TDM_ERROR_NONE);
1781 while (!done1 || !done2 || !done3)
1782 ASSERT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1784 TDM_UT_SKIP_FLAG(0);
1789 #ifdef TDM_UT_TEST_WITH_PARAMS
1790 INSTANTIATE_TEST_CASE_P(TDMOutputParams,
1792 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
1794 INSTANTIATE_TEST_CASE_P(TDMOutputParams,
1796 Values(TDM_DEFAULT_MODULE));