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 EXPECT_EQ(tdm_display_get_output_count(dpy, &output_count), TDM_ERROR_NONE);
52 EXPECT_GE(output_count, 0);
54 if (output_count > 0) {
55 outputs = (tdm_output**)calloc(output_count, sizeof(tdm_output*));
56 EXPECT_NE(outputs, NULL);
58 for (int o = 0; o < output_count; o++) {
60 tdm_output *output = tdm_display_get_output(dpy, o, &ret);
61 EXPECT_EQ(ret, TDM_ERROR_NONE);
62 EXPECT_NE(output, NULL);
71 void TDMOutput::TearDown(void)
74 for (int o = 0; o < output_count; o++) {
75 EXPECT_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 EXPECT_NE(tdm_output_get_backend_module(outputs[o], &ret), NULL);
347 EXPECT_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 EXPECT_EQ(tdm_output_get_backend_module(NULL, &ret), NULL);
357 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_get_capabilities(outputs[o], &capabilities), TDM_ERROR_NONE);
376 EXPECT_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 EXPECT_EQ(tdm_output_get_capabilities(NULL, &capabilities), TDM_ERROR_INVALID_PARAMETER);
386 EXPECT_EQ(capabilities, (tdm_output_capability)TDM_UT_INVALID_VALUE);
389 TEST_P(TDMOutput, OutputGetCapabilitiesNullOther)
391 TDM_UT_SKIP_FLAG(has_outputs);
393 EXPECT_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 EXPECT_EQ(tdm_output_get_model_info(outputs[o], &maker, &model, &name), TDM_ERROR_NONE);
403 EXPECT_NE(maker, NULL);
404 EXPECT_NE(model, NULL);
405 EXPECT_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 EXPECT_EQ(tdm_output_get_model_info(NULL, &maker, &model, &name), TDM_ERROR_INVALID_PARAMETER);
418 EXPECT_EQ(maker, (const char*)TDM_UT_INVALID_VALUE);
419 EXPECT_EQ(model, (const char*)TDM_UT_INVALID_VALUE);
420 EXPECT_EQ(name, (const char*)TDM_UT_INVALID_VALUE);
423 TEST_P(TDMOutput, OutputGetModelInfoNullOther)
425 TDM_UT_SKIP_FLAG(has_outputs);
427 EXPECT_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 EXPECT_EQ(tdm_output_get_conn_status(outputs[o], &status), TDM_ERROR_NONE);
437 EXPECT_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 EXPECT_EQ(tdm_output_get_conn_status(NULL, &status), TDM_ERROR_INVALID_PARAMETER);
448 EXPECT_EQ(status, (tdm_output_conn_status)TDM_UT_INVALID_VALUE);
451 TEST_P(TDMOutput, OutputGetConnStatusNullOther)
453 TDM_UT_SKIP_FLAG(has_outputs);
455 EXPECT_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 EXPECT_EQ(tdm_output_get_output_type(outputs[o], &type), TDM_ERROR_NONE);
465 EXPECT_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 EXPECT_EQ(tdm_output_get_output_type(NULL, &type), TDM_ERROR_INVALID_PARAMETER);
475 EXPECT_EQ(type, (tdm_output_type)TDM_UT_INVALID_VALUE);
478 TEST_P(TDMOutput, OutputGetOutputTypeNullOther)
480 TDM_UT_SKIP_FLAG(has_outputs);
482 EXPECT_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 EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &count), TDM_ERROR_BAD_REQUEST);
495 EXPECT_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 EXPECT_EQ(tdm_output_get_layer_count(NULL, &count), TDM_ERROR_INVALID_PARAMETER);
507 EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
510 TEST_P(TDMOutput, OutputGetLayerCountNullOther)
512 TDM_UT_SKIP_FLAG(has_outputs);
514 EXPECT_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 EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_BAD_REQUEST);
528 EXPECT_EQ(layer_count, 0);
530 layer = tdm_output_get_layer(outputs[o], 0, &ret);
531 EXPECT_EQ(ret, TDM_ERROR_BAD_REQUEST);
532 EXPECT_EQ(layer, NULL);
534 EXPECT_EQ(tdm_output_get_layer_count(outputs[o], &layer_count), TDM_ERROR_NONE);
535 EXPECT_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 EXPECT_EQ(ret, TDM_ERROR_NONE);
540 EXPECT_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 EXPECT_EQ(ret, TDM_ERROR_INVALID_PARAMETER);
553 EXPECT_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 EXPECT_EQ(layer, NULL);
565 layer = tdm_output_get_layer(outputs[0], 0, NULL);
566 EXPECT_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 EXPECT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
580 EXPECT_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 EXPECT_EQ(tdm_output_get_available_properties(NULL, &props, &count), TDM_ERROR_INVALID_PARAMETER);
591 EXPECT_EQ(props, (const tdm_prop *)TDM_UT_INVALID_VALUE);
592 EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
595 TEST_P(TDMOutput, OutputGetAvailablePropertiesNullOther)
597 TDM_UT_SKIP_FLAG(has_outputs);
599 EXPECT_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 EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes_array, &count), TDM_ERROR_NONE);
614 EXPECT_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 EXPECT_EQ(tdm_output_get_available_modes(NULL, &modes_array, &count), TDM_ERROR_INVALID_PARAMETER);
625 EXPECT_EQ(count, TDM_UT_INVALID_VALUE);
626 EXPECT_EQ(modes_array, (const tdm_output_mode *) TDM_UT_INVALID_VALUE);
629 TEST_P(TDMOutput, OutputGetAvailableModesNullOther)
631 TDM_UT_SKIP_FLAG(has_outputs);
633 EXPECT_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 EXPECT_EQ(tdm_output_get_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
648 EXPECT_NE(min_w, TDM_UT_INVALID_VALUE);
649 EXPECT_NE(min_h, TDM_UT_INVALID_VALUE);
650 EXPECT_NE(max_w, TDM_UT_INVALID_VALUE);
651 EXPECT_NE(max_h, TDM_UT_INVALID_VALUE);
652 EXPECT_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 EXPECT_EQ(tdm_output_get_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
664 EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
665 EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
666 EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
667 EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
668 EXPECT_EQ(preferred_align, TDM_UT_INVALID_VALUE);
671 TEST_P(TDMOutput, OutputGetAvailableSizeNullOther)
673 TDM_UT_SKIP_FLAG(has_outputs);
675 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_NONE);
692 EXPECT_NE(min_w, TDM_UT_INVALID_VALUE);
693 EXPECT_NE(min_h, TDM_UT_INVALID_VALUE);
694 EXPECT_NE(max_w, TDM_UT_INVALID_VALUE);
695 EXPECT_NE(max_h, TDM_UT_INVALID_VALUE);
696 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_get_cursor_available_size(NULL, &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_INVALID_PARAMETER);
715 EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
716 EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
717 EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
718 EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
719 EXPECT_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 EXPECT_EQ(tdm_display_get_backend_info(dpy, NULL, NULL, &major, &minor), TDM_ERROR_NONE);
732 if (major > 1 || (major >= 1 && minor >= 5))
733 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_get_cursor_available_size(outputs[o], &min_w, &min_h, &max_w, &max_h, &preferred_align), TDM_ERROR_BAD_REQUEST);
750 EXPECT_EQ(min_w, TDM_UT_INVALID_VALUE);
751 EXPECT_EQ(min_h, TDM_UT_INVALID_VALUE);
752 EXPECT_EQ(max_w, TDM_UT_INVALID_VALUE);
753 EXPECT_EQ(max_h, TDM_UT_INVALID_VALUE);
754 EXPECT_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 EXPECT_EQ(tdm_output_get_physical_size(outputs[o], &mmWidth, &mmHeight), TDM_ERROR_NONE);
767 EXPECT_NE(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
768 EXPECT_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 EXPECT_EQ(tdm_output_get_physical_size(NULL, &mmWidth, &mmHeight), TDM_ERROR_INVALID_PARAMETER);
779 EXPECT_EQ(mmWidth, (unsigned int)TDM_UT_INVALID_VALUE);
780 EXPECT_EQ(mmHeight, (unsigned int)TDM_UT_INVALID_VALUE);
783 TEST_P(TDMOutput, OutputGetPhysicalSizeNullOther)
785 TDM_UT_SKIP_FLAG(has_outputs);
787 EXPECT_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 EXPECT_EQ(tdm_output_get_subpixel(outputs[o], &subpixel), TDM_ERROR_NONE);
797 EXPECT_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 EXPECT_EQ(tdm_output_get_subpixel(NULL, &subpixel), TDM_ERROR_INVALID_PARAMETER);
807 EXPECT_EQ(subpixel, (unsigned int)TDM_UT_INVALID_VALUE);
810 TEST_P(TDMOutput, OutputGetSubpixelNullOther)
812 TDM_UT_SKIP_FLAG(has_outputs);
814 EXPECT_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 EXPECT_EQ(tdm_output_get_pipe(outputs[o], &pipe), TDM_ERROR_NONE);
824 EXPECT_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 EXPECT_EQ(tdm_output_get_pipe(NULL, &pipe), TDM_ERROR_INVALID_PARAMETER);
834 EXPECT_EQ(pipe, (unsigned int)TDM_UT_INVALID_VALUE);
837 TEST_P(TDMOutput, OutputGetPipeNullOther)
839 TDM_UT_SKIP_FLAG(has_outputs);
841 EXPECT_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 EXPECT_EQ(tdm_output_get_primary_index(outputs[o], &primary_index), TDM_ERROR_NONE);
853 EXPECT_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 EXPECT_EQ(tdm_output_get_primary_index(NULL, &primary_index), TDM_ERROR_INVALID_PARAMETER);
865 EXPECT_EQ(primary_index, TDM_UT_INVALID_VALUE);
868 TEST_P(TDMOutput, OutputGetPrimaryIndexNullOther)
870 TDM_UT_SKIP_FLAG(has_outputs);
872 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_get_available_properties(outputs[o], &props, &count), TDM_ERROR_NONE);
896 EXPECT_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 EXPECT_EQ(tdm_output_get_property(outputs[o], props[i].id, &value), TDM_ERROR_NONE);
901 EXPECT_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 EXPECT_EQ(tdm_output_get_property(NULL, 0, &value), TDM_ERROR_INVALID_PARAMETER);
913 EXPECT_EQ(value.s32, TDM_UT_INVALID_VALUE);
916 TEST_P(TDMOutput, OutputGetPropertyNullOther)
918 TDM_UT_SKIP_FLAG(has_outputs);
920 EXPECT_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 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
941 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
944 EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
945 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
946 EXPECT_EQ(done1, true);
950 TEST_P(TDMOutput, OutputAddChangeHandlerTwice)
952 TDM_UT_SKIP_FLAG(has_outputs);
954 EXPECT_EQ(tdm_output_add_change_handler(outputs[0], _tc_tdm_output_change_cb, NULL), TDM_ERROR_NONE);
955 EXPECT_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 EXPECT_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 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
995 EXPECT_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 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
999 EXPECT_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 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1023 EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done1), TDM_ERROR_NONE);
1024 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1025 EXPECT_EQ(done1, true);
1028 EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done2), TDM_ERROR_NONE);
1029 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1030 EXPECT_EQ(done2, true);
1033 EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb2, &done3), TDM_ERROR_NONE);
1034 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1035 EXPECT_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 EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
1064 EXPECT_NE(modes, NULL);
1065 EXPECT_GT(count, 0);
1067 for (int m = 0; m < count; m++)
1068 EXPECT_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 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_get_available_modes(outputs[o], &modes, &count), TDM_ERROR_NONE);
1104 EXPECT_NE(modes, NULL);
1105 EXPECT_GT(count, 0);
1107 for (int m = 0; m < count; m++) {
1108 const tdm_output_mode *current_mode;
1109 EXPECT_EQ(tdm_output_set_mode(outputs[o], modes + m), TDM_ERROR_NONE);
1110 EXPECT_EQ(tdm_output_get_mode(outputs[o], ¤t_mode), TDM_ERROR_NONE);
1111 EXPECT_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 EXPECT_EQ(tdm_output_get_mode(NULL, ¤t_mode), TDM_ERROR_INVALID_PARAMETER);
1122 EXPECT_EQ(current_mode, (const tdm_output_mode *)TDM_UT_INVALID_VALUE);
1125 TEST_P(TDMOutput, OutputGetModeNullOther)
1127 TDM_UT_SKIP_FLAG(has_outputs);
1129 EXPECT_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 EXPECT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
1139 EXPECT_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 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1152 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
1153 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
1154 EXPECT_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 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
1158 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_set_dpms(outputs[0], (tdm_output_dpms)-1), TDM_ERROR_BAD_REQUEST);
1175 EXPECT_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 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1190 EXPECT_EQ(tdm_output_add_change_handler(outputs[o], _tc_tdm_output_change_cb, &done1), TDM_ERROR_NONE);
1191 EXPECT_EQ(tdm_output_set_dpms_async(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1193 EXPECT_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 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1209 EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1210 EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_OFF);
1212 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_STANDBY), TDM_ERROR_NONE);
1213 EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1214 EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_STANDBY);
1216 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_SUSPEND), TDM_ERROR_NONE);
1217 EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1218 EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_SUSPEND);
1220 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_ON), TDM_ERROR_NONE);
1221 EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1222 EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_ON);
1224 if (tc_tdm_output_is_aod_enable(outputs[o])) {
1225 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
1226 EXPECT_EQ(tdm_output_get_dpms(outputs[o], &dpms_value), TDM_ERROR_NONE);
1227 EXPECT_EQ(dpms_value, TDM_OUTPUT_DPMS_AOD);
1229 EXPECT_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 EXPECT_EQ(tdm_output_get_dpms(NULL, &dpms_value), TDM_ERROR_INVALID_PARAMETER);
1240 EXPECT_EQ(dpms_value, (tdm_output_dpms)TDM_UT_INVALID_VALUE);
1243 TEST_P(TDMOutput, OutputGetDpmsNullOther)
1245 TDM_UT_SKIP_FLAG(has_outputs);
1247 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1269 EXPECT_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 EXPECT_LT((end - start), (interval + interval));
1278 TEST_P(TDMOutput, OutputWaitVblankNullObject)
1280 TDM_UT_SKIP_FLAG(has_outputs);
1282 EXPECT_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 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1295 EXPECT_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 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1309 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, NULL), TDM_ERROR_NONE);
1312 EXPECT_EQ(tc_tdm_display_handle_events(dpy), TDM_ERROR_NONE);
1314 EXPECT_GT(tdm_helper_output_vblank_timer_expired(outputs[o]), 0);
1318 TEST_P(TDMOutput, OutputWaitVblankInterval0)
1320 TDM_UT_SKIP_FLAG(has_outputs);
1322 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1345 EXPECT_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 EXPECT_GT((end - start), (interval * (t - 1)));
1350 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1373 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1374 EXPECT_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 EXPECT_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 EXPECT_GT((end - start), (interval * (t - 1)));
1383 EXPECT_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 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], false), true);
1398 for (int t = 0; t < 10; t++) {
1401 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], 1, 0, _tc_tdm_output_done_cb, &done), TDM_ERROR_NONE);
1403 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_OFF), TDM_ERROR_NONE);
1405 EXPECT_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 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1421 for (int t = 1; t < 10; t++) {
1422 done1 = done2 = done3 = false;
1423 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1424 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1425 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1447 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1448 EXPECT_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 EXPECT_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 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1478 for (int t = 1; t < 10; t++) {
1479 done1 = done2 = done3 = false;
1480 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1481 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1482 EXPECT_EQ(tdm_output_wait_vblank(outputs[o], t, 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1483 while (!done1 || !done2 || !done3)
1484 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1513 EXPECT_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 EXPECT_LT((end - start), (interval + interval));
1519 TDM_UT_SKIP_FLAG(0);
1524 TEST_P(TDMOutput, OutputCommitNullObject)
1526 TDM_UT_SKIP_FLAG(has_outputs);
1528 EXPECT_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 EXPECT_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 EXPECT_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 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1565 EXPECT_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 EXPECT_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 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1588 EXPECT_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 EXPECT_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 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1614 EXPECT_EQ(tdm_output_set_dpms(outputs[o], TDM_OUTPUT_DPMS_AOD), TDM_ERROR_NONE);
1616 for (int t = 0; t < 10; t++) {
1618 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1620 EXPECT_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 EXPECT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
1639 if (!tc_tdm_output_is_hwc_enable(outputs[o])) {
1640 EXPECT_EQ(tdm_output_get_primary_index(outputs[o], &index), TDM_ERROR_NONE);
1641 EXPECT_NE(index, TDM_UT_INVALID_VALUE);
1643 TDM_UT_SKIP_FLAG(0);
1645 layer = tdm_output_get_layer(outputs[o], index, &ret);
1646 EXPECT_EQ(ret, TDM_ERROR_NONE);
1647 EXPECT_NE(layer, NULL);
1649 EXPECT_EQ(tdm_layer_commit(layer, NULL, NULL), TDM_ERROR_NONE);
1651 if (!tdm_helper_output_commit_per_vblank_enabled(outputs[o]))
1652 EXPECT_EQ(tdm_output_commit(outputs[o], 0, NULL, NULL), TDM_ERROR_NONE);
1654 EXPECT_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 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1687 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1688 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done3), TDM_ERROR_NONE);
1689 while (!done1 || !done2 || !done3)
1690 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1721 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1722 EXPECT_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 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done1), TDM_ERROR_NONE);
1750 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb, &done2), TDM_ERROR_NONE);
1751 EXPECT_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 EXPECT_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 EXPECT_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 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done1), TDM_ERROR_NONE);
1779 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done2), TDM_ERROR_NONE);
1780 EXPECT_EQ(tdm_output_commit(outputs[o], 0, _tc_tdm_output_done_cb2, &done3), TDM_ERROR_NONE);
1781 while (!done1 || !done2 || !done3)
1782 EXPECT_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));