1 /**************************************************************************
3 * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
5 * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
6 * Contact: Andrii Sokolenko <a.sokolenko@samsung.com>
7 * Contact: Roman Marchenko <r.marchenko@samsung.com>
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the
11 * "Software"), to deal in the Software without restriction, including
12 * without limitation the rights to use, copy, modify, merge, publish,
13 * distribute, sub license, and/or sell copies of the Software, and to
14 * permit persons to whom the Software is furnished to do so, subject to
15 * the following conditions:
17 * The above copyright notice and this permission notice (including the
18 * next paragraph) shall be included in all copies or substantial portions
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
24 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
25 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
26 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
27 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 **************************************************************************/
31 #include "gtest/gtest.h"
32 #include "ut_common.h"
36 #include "tbm_bufmgr.h"
37 #include "tbm_drm_helper.h"
40 class TDMOutput : public ::testing::Test {
42 tdm_display *dpy = NULL;
43 int output_count = -42, master_fd = -42, tbm_fd = -42;
44 bool has_output = false;
45 tbm_bufmgr tbm_bufmgr = NULL;
46 static unsigned int handle_call;
47 static void tdm_output_change_handler_test_func(tdm_output *output,
48 tdm_output_change_type type,
52 if ( ((int) u_data) < -100) {
53 TDMOutput::handle_call++;
58 setenv("TDM_DLOG", "1", 1);
59 setenv("XDG_RUNTIME_DIR", ".", 1);
60 setenv("TBM_DLOG", "1", 1);
61 setenv("TBM_DISPLAY_SERVER", "1", 1);
62 tbm_bufmgr = tbm_bufmgr_init(-1);
63 ASSERT_FALSE(tbm_bufmgr == NULL);
64 tdm_error error = TDM_ERROR_NONE;
65 dpy = tdm_display_init(&error);
66 ASSERT_TRUE(error == TDM_ERROR_NONE);
67 ASSERT_FALSE(dpy == NULL);
68 master_fd = tbm_drm_helper_get_master_fd();
69 tbm_fd = tbm_drm_helper_get_fd();
70 error = tdm_display_get_output_count(dpy, &output_count);
71 #ifdef FAIL_ON_UNSUPPORTED
72 ASSERT_GT(output_count, 0);
80 tdm_display_deinit(dpy);
82 tbm_bufmgr_deinit(tbm_bufmgr);
85 int temp_master_fd = tbm_drm_helper_get_master_fd();
86 EXPECT_EQ(temp_master_fd, -1) << "Fatal Error. Can't deinit tdm/tbm" << std::endl;
87 if (temp_master_fd > -1)
92 int temp_tbm_fd = tbm_drm_helper_get_fd();
93 EXPECT_EQ(temp_tbm_fd, -1) << "Fatal Error. Can't deinit tdm/tbm" << std::endl;
99 unsetenv("XDG_RUNTIME_DIR");
100 unsetenv("TBM_DLOG");
101 unsetenv("TBM_DISPLAY_SERVER");
105 unsigned int TDMOutput::handle_call = 0;
107 TEST_F(TDMOutput, DisplayGetOutputSuccessful)
109 SKIP_FLAG(has_output);
110 for (int i = 0; i < output_count; i++) {
111 tdm_error error = TDM_ERROR_NONE;
112 ASSERT_FALSE(NULL == tdm_display_get_output(dpy, i, &error));
113 ASSERT_TRUE(TDM_ERROR_NONE == error);
117 TEST_F(TDMOutput, DisplayGetOutputSuccessfulWrongIndex)
119 SKIP_FLAG(has_output);
120 tdm_error error = TDM_ERROR_NONE;
121 ASSERT_TRUE(NULL == tdm_display_get_output(dpy, -1, &error));
122 ASSERT_TRUE(TDM_ERROR_NONE == error);
125 TEST_F(TDMOutput, DisplayGetOutputSuccessfulBigIndex)
127 SKIP_FLAG(has_output);
128 tdm_error error = TDM_ERROR_NONE;
129 ASSERT_TRUE(NULL == tdm_display_get_output(dpy, INT_MAX, &error));
130 ASSERT_TRUE(TDM_ERROR_NONE == error);
133 TEST_F(TDMOutput, DisplayGetOutputSuccessfulSmallIndex)
135 SKIP_FLAG(has_output);
136 tdm_error error = TDM_ERROR_NONE;
137 ASSERT_TRUE(NULL == tdm_display_get_output(dpy, INT_MIN, &error));
138 ASSERT_TRUE(TDM_ERROR_NONE == error);
141 TEST_F(TDMOutput, DisplayGetOutputSuccessfulErrorNull)
143 SKIP_FLAG(has_output);
144 ASSERT_FALSE(NULL == tdm_display_get_output(dpy, 0, NULL));
147 TEST_F(TDMOutput, DisplayOutputGetCapabilitiesSuccessful)
149 SKIP_FLAG(has_output);
150 for (int i = 0; i < output_count; i++) {
151 tdm_error error = TDM_ERROR_NONE;
152 tdm_output_capability capabilities = (tdm_output_capability) -42;
153 tdm_output * output = tdm_display_get_output(dpy, i, &error);
154 ASSERT_FALSE(NULL == output);
155 ASSERT_TRUE(TDM_ERROR_NONE == error);
156 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_capabilities(output, &capabilities));
157 ASSERT_FALSE(-42 == capabilities);
161 TEST_F(TDMOutput, DisplayOutputGetCapabilitiesFailAllNull)
163 SKIP_FLAG(has_output);
164 ASSERT_FALSE(TDM_ERROR_NONE == tdm_output_get_capabilities(NULL, NULL));
167 TEST_F(TDMOutput, DisplayOutputGetCapabilitiesFailOnlyOutput)
169 SKIP_FLAG(has_output);
170 for (int i = 0; i < output_count; i++) {
171 tdm_error error = TDM_ERROR_NONE;
172 tdm_output * output = tdm_display_get_output(dpy, i, &error);
173 ASSERT_FALSE(NULL == output);
174 ASSERT_TRUE(TDM_ERROR_NONE == error);
175 ASSERT_FALSE(TDM_ERROR_NONE == tdm_output_get_capabilities(output, NULL));
179 TEST_F(TDMOutput, OutputGetModelInfoSuccessful)
181 SKIP_FLAG(has_output);
182 for (int i = 0; i < output_count; i++) {
183 tdm_error error = TDM_ERROR_NONE;
184 const char * maker = NULL, * model = NULL, * name = NULL;
185 tdm_output * output = tdm_display_get_output(dpy, i, &error);
186 ASSERT_FALSE(NULL == output);
187 ASSERT_TRUE(TDM_ERROR_NONE == error);
188 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_model_info(output, &maker, &model, &name));
189 ASSERT_FALSE(NULL == maker);
190 ASSERT_FALSE(NULL == model);
191 ASSERT_FALSE(NULL == name);
195 TEST_F(TDMOutput, OutputGetModelInfoFailAllNull)
197 SKIP_FLAG(has_output);
198 ASSERT_FALSE(TDM_ERROR_NONE == tdm_output_get_model_info(NULL, NULL, NULL, NULL));
201 TEST_F(TDMOutput, OutputGetModelInfoSuccessfulOnlyOutput)
203 SKIP_FLAG(has_output);
204 for (int i = 0; i < output_count; i++) {
205 tdm_error error = TDM_ERROR_NONE;
206 tdm_output * output = tdm_display_get_output(dpy, i, &error);
207 ASSERT_FALSE(NULL == output);
208 ASSERT_TRUE(TDM_ERROR_NONE == error);
209 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_model_info(output, NULL, NULL, NULL));
213 TEST_F(TDMOutput, OutputGetConnStatusSuccessful)
215 SKIP_FLAG(has_output);
216 for (int i = 0; i < output_count; i++) {
217 tdm_error error = TDM_ERROR_NONE;
218 tdm_output_conn_status status = (tdm_output_conn_status) -42;
219 tdm_output * output = tdm_display_get_output(dpy, i, &error);
220 ASSERT_FALSE(NULL == output);
221 ASSERT_TRUE(TDM_ERROR_NONE == error);
222 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_conn_status(output, &status));
223 ASSERT_FALSE(-42 == status);
227 TEST_F(TDMOutput, OutputGetConnStatusFailAllNull)
229 SKIP_FLAG(has_output);
230 ASSERT_FALSE(TDM_ERROR_NONE == tdm_output_get_conn_status(NULL, NULL));
233 TEST_F(TDMOutput, OutputGetConnStatusFailOnlyOutput)
235 SKIP_FLAG(has_output);
236 for (int i = 0; i < output_count; i++) {
237 tdm_error error = TDM_ERROR_NONE;
238 tdm_output * output = tdm_display_get_output(dpy, i, &error);
239 ASSERT_FALSE(NULL == output);
240 ASSERT_TRUE(TDM_ERROR_NONE == error);
241 ASSERT_FALSE(TDM_ERROR_NONE == tdm_output_get_conn_status(output, NULL));
245 TEST_F(TDMOutput, OutputSetDPMSSuccessful)
247 SKIP_FLAG(has_output);
248 bool checked = false;
249 for (int i = 0; i < output_count; i++) {
250 tdm_error error = TDM_ERROR_NONE;
251 tdm_output_conn_status status;
252 tdm_output * output = tdm_display_get_output(dpy, i, &error);
253 ASSERT_FALSE(NULL == output);
254 ASSERT_TRUE(TDM_ERROR_NONE == error);
255 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_conn_status(output, &status));
256 if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
259 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON));
260 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_STANDBY));
261 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_SUSPEND));
262 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF));
264 if (false == checked) {
265 FAIL() << "All outputs are disconnected. Testcase skipped" << std::endl;
269 TEST_F(TDMOutput, OutputAddChangeHandlerSuccessful)
271 SKIP_FLAG(has_output);
272 bool checked = false;
273 for (int i = 0; i < output_count; i++) {
274 tdm_error error = TDM_ERROR_NONE;
275 tdm_output * output = tdm_display_get_output(dpy, i, &error);
276 ASSERT_FALSE(NULL == output);
277 ASSERT_TRUE(TDM_ERROR_NONE == error);
278 tdm_output_conn_status status;
279 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_conn_status(output, &status));
280 if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
283 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_add_change_handler(output,
284 tdm_output_change_handler_test_func,
286 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON));
287 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF));
288 ASSERT_GT(handle_call, 0);
290 if (false == checked) {
291 FAIL() << "All outputs are disconnected. Testcase skipped" << std::endl;
295 TEST_F(TDMOutput, OutputAddChangeHandlerSuccessfulFewFuncs)
297 SKIP_FLAG(has_output);
298 bool checked = false;
299 for (int i = 0; i < output_count; i++) {
300 tdm_error error = TDM_ERROR_NONE;
301 tdm_output * output = tdm_display_get_output(dpy, i, &error);
302 ASSERT_FALSE(NULL == output);
303 ASSERT_TRUE(TDM_ERROR_NONE == error);
304 tdm_output_conn_status status;
305 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_conn_status(output, &status));
306 if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
309 for (int k = 0; k < 20; k++) {
310 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_add_change_handler(output,
311 tdm_output_change_handler_test_func,
314 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON));
315 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF));
316 ASSERT_GT(handle_call, 20);
318 if (false == checked) {
319 FAIL() << "All outputs are disconnected. Testcase skipped" << std::endl;
324 TEST_F(TDMOutput, OutputAddChangeHandlerFailAllNull)
326 SKIP_FLAG(has_output);
327 ASSERT_FALSE(TDM_ERROR_NONE == tdm_output_add_change_handler(NULL, NULL, NULL));
330 TEST_F(TDMOutput, OutputAddChangeHandlerFailOnlyOutput)
332 SKIP_FLAG(has_output);
333 for (int i = 0; i < output_count; i++) {
334 tdm_error error = TDM_ERROR_NONE;
335 tdm_output * output = tdm_display_get_output(dpy, i, &error);
336 ASSERT_FALSE(NULL == output);
337 ASSERT_TRUE(TDM_ERROR_NONE == error);
338 ASSERT_FALSE(TDM_ERROR_NONE == tdm_output_add_change_handler(output, NULL, NULL));
342 TEST_F(TDMOutput, OutputAddChangeHandlerFailWrongOutput)
344 SKIP_FLAG(has_output);
345 ASSERT_EXIT({tdm_output *output = (tdm_output *) 0xBEAF;
346 tdm_output_add_change_handler(output,
347 tdm_output_change_handler_test_func,
349 exit(0);}, ::testing::ExitedWithCode(0), "");
352 TEST_F(TDMOutput, OutputRemoveChangeHandlerSuccessful)
354 SKIP_FLAG(has_output);
355 bool checked = false;
356 for (int i = 0; i < output_count; i++) {
357 tdm_error error = TDM_ERROR_NONE;
358 tdm_output * output = tdm_display_get_output(dpy, i, &error);
359 ASSERT_FALSE(NULL == output);
360 ASSERT_TRUE(TDM_ERROR_NONE == error);
361 tdm_output_conn_status status;
362 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_conn_status(output, &status));
363 if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
366 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_add_change_handler(output,
367 tdm_output_change_handler_test_func,
369 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON));
370 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF));
371 ASSERT_GT(handle_call, 0);
373 tdm_output_remove_change_handler(output, tdm_output_change_handler_test_func, (void *) -101);
374 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON));
375 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF));
376 ASSERT_EQ(handle_call, 0);
378 if (false == checked) {
379 FAIL() << "All outputs are disconnected. Testcase skipped" << std::endl;
383 TEST_F(TDMOutput, OutputRemoveChangeHandlerSuccessfulFewFuncs)
385 SKIP_FLAG(has_output);
386 bool checked = false;
387 for (int i = 0; i < output_count; i++) {
388 tdm_error error = TDM_ERROR_NONE;
389 tdm_output * output = tdm_display_get_output(dpy, i, &error);
390 ASSERT_FALSE(NULL == output);
391 ASSERT_TRUE(TDM_ERROR_NONE == error);
392 tdm_output_conn_status status;
393 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_conn_status(output, &status));
394 if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
397 for (int k = 0; k < 20; k++) {
398 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_add_change_handler(output,
399 tdm_output_change_handler_test_func,
402 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON));
403 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF));
404 ASSERT_GT(handle_call, 20);
406 for (int k = 0; k < 20; k++) {
407 tdm_output_remove_change_handler(output, tdm_output_change_handler_test_func, (void *) (-101-k));
409 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_ON));
410 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_set_dpms(output, TDM_OUTPUT_DPMS_OFF));
411 ASSERT_EQ(handle_call, 0);
413 if (false == checked) {
414 FAIL() << "All outputs are disconnected. Testcase skipped" << std::endl;
418 TEST_F(TDMOutput, OutputRemoveChangeHandlerFailAllNull)
420 SKIP_FLAG(has_output);
421 ASSERT_EXIT({tdm_output_remove_change_handler(NULL, NULL, NULL);
422 exit(0);}, ::testing::ExitedWithCode(0), "");
425 TEST_F(TDMOutput, OutputRemoveChangeHandlerFailOnlyOutput)
427 SKIP_FLAG(has_output);
428 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
429 tdm_error error = TDM_ERROR_NONE;
430 tdm_output * output = tdm_display_get_output(dpy, i, &error);
431 if (NULL == output) exit(1);
432 if (TDM_ERROR_NONE != error) exit(1);
433 tdm_output_remove_change_handler(output, NULL, NULL);
434 } exit(0);}, ::testing::ExitedWithCode(0), "");
437 TEST_F(TDMOutput, OutputRemoveChangeHandlerFailWrongOutput)
439 SKIP_FLAG(has_output);
440 ASSERT_EXIT({tdm_output *output = (tdm_output *) 0xBEAF;
441 tdm_output_remove_change_handler(output,
442 tdm_output_change_handler_test_func,
444 exit(0);}, ::testing::ExitedWithCode(0), "");
447 TEST_F(TDMOutput, OutputGetOutputTypeSuccessful)
449 SKIP_FLAG(has_output);
450 for (int i = 0; i < output_count; i++) {
451 tdm_error error = TDM_ERROR_NONE;
452 tdm_output_type type = (tdm_output_type) -42;
453 tdm_output * output = tdm_display_get_output(dpy, i, &error);
454 ASSERT_FALSE(NULL == output);
455 ASSERT_TRUE(TDM_ERROR_NONE == error);
456 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_output_type(output, &type));
457 ASSERT_NE(type, -42);
461 TEST_F(TDMOutput, OutputGetOutputTypeFailNullAll)
463 SKIP_FLAG(has_output);
464 ASSERT_EXIT({if (tdm_output_get_output_type(NULL, NULL) == TDM_ERROR_NONE) exit(1);
465 exit(0);}, ::testing::ExitedWithCode(0), "");
468 TEST_F(TDMOutput, OutputGetOutputTypeFailOnlyOutput)
470 SKIP_FLAG(has_output);
471 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
472 tdm_error error = TDM_ERROR_NONE;
473 tdm_output * output = tdm_display_get_output(dpy, i, &error);
474 if (NULL == output) exit(1);
475 if (TDM_ERROR_NONE != error) exit(1);
476 if (tdm_output_get_output_type(output, NULL) == TDM_ERROR_NONE) exit(1);
478 exit(0);}, ::testing::ExitedWithCode(0), "");
481 TEST_F(TDMOutput, OutputGetLayerCountSuccessful)
483 SKIP_FLAG(has_output);
484 for (int i = 0; i < output_count; i++) {
485 tdm_error error = TDM_ERROR_NONE;
487 tdm_output * output = tdm_display_get_output(dpy, i, &error);
488 ASSERT_FALSE(NULL == output);
489 ASSERT_TRUE(TDM_ERROR_NONE == error);
490 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_layer_count(output, &count));
491 ASSERT_NE(count, -42);
495 TEST_F(TDMOutput, OutputGetLayerCountFailNullAll)
497 SKIP_FLAG(has_output);
498 ASSERT_EXIT({if (tdm_output_get_layer_count(NULL, NULL) == TDM_ERROR_NONE) exit(1);
499 exit(0);}, ::testing::ExitedWithCode(0), "");
502 TEST_F(TDMOutput, OutputGetLayerCountFailOnlyOutput)
504 SKIP_FLAG(has_output);
505 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
506 tdm_error error = TDM_ERROR_NONE;
507 tdm_output * output = tdm_display_get_output(dpy, i, &error);
508 if (NULL == output) exit(1);
509 if (TDM_ERROR_NONE != error) exit(1);
510 if (TDM_ERROR_NONE == tdm_output_get_layer_count(output, NULL)) exit(1);
512 exit(0);}, ::testing::ExitedWithCode(0), "");
515 TEST_F(TDMOutput, OutputGetAvailablePropertiesSuccessful)
517 SKIP_FLAG(has_output);
518 for (int i = 0; i < output_count; i++) {
519 tdm_error error = TDM_ERROR_NONE;
521 const tdm_prop *tdm_prop_array = (const tdm_prop *) 0xBEAF;
522 tdm_output * output = tdm_display_get_output(dpy, i, &error);
523 ASSERT_FALSE(NULL == output);
524 ASSERT_TRUE(TDM_ERROR_NONE == error);
525 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_available_properties(output,
528 ASSERT_NE(count, -42);
529 ASSERT_NE(tdm_prop_array, 0xBEAF);
533 TEST_F(TDMOutput, OutputGetAvailablePropertiesFailNullAll)
535 SKIP_FLAG(has_output);
536 ASSERT_EXIT({if (tdm_output_get_available_properties(NULL, NULL, NULL) == TDM_ERROR_NONE) exit(1);
537 exit(0);}, ::testing::ExitedWithCode(0), "");
540 TEST_F(TDMOutput, OutputGetAvailablePropertiesFailOnlyOutput)
542 SKIP_FLAG(has_output);
543 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
544 tdm_error error = TDM_ERROR_NONE;
545 tdm_output * output = tdm_display_get_output(dpy, i, &error);
546 if (NULL == output) exit(1);
547 if (TDM_ERROR_NONE != error) exit(1);
548 if (TDM_ERROR_NONE == tdm_output_get_available_properties(output, NULL, NULL)) exit(1);
550 exit(0);}, ::testing::ExitedWithCode(0), "");
553 TEST_F(TDMOutput, OutputGetAvailablePropertiesFailNullCount)
555 SKIP_FLAG(has_output);
556 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
557 tdm_error error = TDM_ERROR_NONE;
558 const tdm_prop *tdm_prop_array = NULL;
559 tdm_output * output = tdm_display_get_output(dpy, i, &error);
560 if (NULL == output) exit(1);
561 if (TDM_ERROR_NONE != error) exit(1);
562 if (TDM_ERROR_NONE == tdm_output_get_available_properties(output,
566 exit(0);}, ::testing::ExitedWithCode(0), "");
569 TEST_F(TDMOutput, OutputGetAvailablePropertiesFailNullProperty)
571 SKIP_FLAG(has_output);
572 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
573 tdm_error error = TDM_ERROR_NONE;
575 tdm_output * output = tdm_display_get_output(dpy, i, &error);
576 if (NULL == output) exit(1);
577 if (TDM_ERROR_NONE != error) exit(1);
578 if (TDM_ERROR_NONE == tdm_output_get_available_properties(output,
582 exit(0);}, ::testing::ExitedWithCode(0), "");
585 TEST_F(TDMOutput, OutputGetAvailableModesSuccessful)
587 SKIP_FLAG(has_output);
588 for (int i = 0; i < output_count; i++) {
589 tdm_error error = TDM_ERROR_NONE;
591 const tdm_output_mode *modes_array = (const tdm_output_mode *) 0xBEAF;
592 tdm_output * output = tdm_display_get_output(dpy, i, &error);
593 ASSERT_FALSE(NULL == output);
594 ASSERT_TRUE(TDM_ERROR_NONE == error);
595 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_available_modes(output,
598 ASSERT_NE(count, -42);
599 ASSERT_NE(modes_array, 0xBEAF);
603 TEST_F(TDMOutput, OutputGetAvailableModesFailNullAll)
605 SKIP_FLAG(has_output);
606 ASSERT_EXIT({if (tdm_output_get_available_modes(NULL, NULL, NULL) == TDM_ERROR_NONE) exit(1);
607 exit(0);}, ::testing::ExitedWithCode(0), "");
610 TEST_F(TDMOutput, OutputGetAvailableModesFailOnlyOutput)
612 SKIP_FLAG(has_output);
613 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
614 tdm_error error = TDM_ERROR_NONE;
615 tdm_output * output = tdm_display_get_output(dpy, i, &error);
616 if (NULL == output) exit(1);
617 if (TDM_ERROR_NONE != error) exit(1);
618 if (TDM_ERROR_NONE == tdm_output_get_available_modes(output, NULL, NULL)) exit(1);
620 exit(0);}, ::testing::ExitedWithCode(0), "");
623 TEST_F(TDMOutput, OutputGetAvailableModesFailNullCount)
625 SKIP_FLAG(has_output);
626 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
627 tdm_error error = TDM_ERROR_NONE;
628 const tdm_output_mode *modes_array = NULL;
629 tdm_output * output = tdm_display_get_output(dpy, i, &error);
630 if (NULL == output) exit(1);
631 if (TDM_ERROR_NONE != error) exit(1);
632 if (TDM_ERROR_NONE == tdm_output_get_available_modes(output,
636 exit(0);}, ::testing::ExitedWithCode(0), "");
639 TEST_F(TDMOutput, OutputGetAvailableModesFailNullModes)
641 SKIP_FLAG(has_output);
642 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
643 tdm_error error = TDM_ERROR_NONE;
645 tdm_output * output = tdm_display_get_output(dpy, i, &error);
646 if (NULL == output) exit(1);
647 if (TDM_ERROR_NONE != error) exit(1);
648 if (TDM_ERROR_NONE == tdm_output_get_available_modes(output,
652 exit(0);}, ::testing::ExitedWithCode(0), "");
655 TEST_F(TDMOutput, OutputGetAvailableSizeSuccessful)
657 SKIP_FLAG(has_output);
658 for (int i = 0; i < output_count; i++) {
659 tdm_error error = TDM_ERROR_NONE;
660 int min_w = -42, min_h = -42, max_w = -42, max_h = -42, preferred_align = -42;
661 tdm_output * output = tdm_display_get_output(dpy, i, &error);
662 ASSERT_FALSE(NULL == output);
663 ASSERT_TRUE(TDM_ERROR_NONE == error);
664 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_available_size(output, &min_w, &min_h,
665 &max_w, &max_h, &preferred_align));
666 ASSERT_NE(min_w, -42);
667 ASSERT_NE(min_h, -42);
668 ASSERT_NE(max_w, -42);
669 ASSERT_NE(max_h, -42);
670 ASSERT_NE(preferred_align, -42);
674 TEST_F(TDMOutput, OutputGetAvailableSizeFailNullAll)
676 SKIP_FLAG(has_output);
677 ASSERT_EXIT({if (tdm_output_get_available_size(NULL, NULL, NULL,
678 NULL, NULL, NULL) == TDM_ERROR_NONE) exit(1);
679 exit(0);}, ::testing::ExitedWithCode(0), "");
682 TEST_F(TDMOutput, OutputGetAvailableSizeSuccessfulOnlyOutput)
684 SKIP_FLAG(has_output);
685 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
686 tdm_error error = TDM_ERROR_NONE;
687 tdm_output * output = tdm_display_get_output(dpy, i, &error);
688 if (NULL == output) exit(1);
689 if (TDM_ERROR_NONE != error) exit(1);
690 if (tdm_output_get_available_size(output, NULL, NULL,
691 NULL, NULL, NULL) != TDM_ERROR_NONE) exit(1);
693 exit(0);}, ::testing::ExitedWithCode(0), "");
696 TEST_F(TDMOutput, OutputGetCursorAvailableSizeSuccessful)
698 SKIP_FLAG(has_output);
699 for (int i = 0; i < output_count; i++) {
700 tdm_error error = TDM_ERROR_NONE;
701 int min_w = -42, min_h = -42, max_w = -42, max_h = -42, preferred_align = -42;
702 tdm_output * output = tdm_display_get_output(dpy, i, &error);
703 ASSERT_FALSE(NULL == output);
704 ASSERT_TRUE(TDM_ERROR_NONE == error);
705 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_cursor_available_size(output, &min_w, &min_h,
706 &max_w, &max_h, &preferred_align));
707 ASSERT_NE(min_w, -42);
708 ASSERT_NE(min_h, -42);
709 ASSERT_NE(max_w, -42);
710 ASSERT_NE(max_h, -42);
711 ASSERT_NE(preferred_align, -42);
715 TEST_F(TDMOutput, OutputGetCursorAvailableSizeFailNullAll)
717 SKIP_FLAG(has_output);
718 ASSERT_EXIT({if (tdm_output_get_cursor_available_size(NULL, NULL, NULL,
719 NULL, NULL, NULL) == TDM_ERROR_NONE) exit(1);
720 exit(0);}, ::testing::ExitedWithCode(0), "");
723 TEST_F(TDMOutput, OutputGetCursorAvailableSizeSuccessfulOnlyOutput)
725 SKIP_FLAG(has_output);
726 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
727 tdm_error error = TDM_ERROR_NONE;
728 tdm_output * output = tdm_display_get_output(dpy, i, &error);
729 if (NULL == output) exit(1);
730 if (TDM_ERROR_NONE != error) exit(1);
731 if (tdm_output_get_cursor_available_size(output, NULL, NULL,
732 NULL, NULL, NULL) != TDM_ERROR_NONE) exit(1);
734 exit(0);}, ::testing::ExitedWithCode(0), "");
737 TEST_F(TDMOutput, OutputGetPhysicalSizeSuccessful)
739 SKIP_FLAG(has_output);
740 for (int i = 0; i < output_count; i++) {
741 tdm_error error = TDM_ERROR_NONE;
742 unsigned int mmWidth = UINT_MAX, mmHeight = UINT_MAX;
743 tdm_output * output = tdm_display_get_output(dpy, i, &error);
744 ASSERT_FALSE(NULL == output);
745 ASSERT_TRUE(TDM_ERROR_NONE == error);
746 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_physical_size(output, &mmWidth, &mmHeight));
747 ASSERT_NE(mmWidth, UINT_MAX);
748 ASSERT_NE(mmHeight, UINT_MAX);
752 TEST_F(TDMOutput, OutputGetPhysicalSizeFailNullAll)
754 SKIP_FLAG(has_output);
755 ASSERT_EXIT({if (tdm_output_get_physical_size(NULL, NULL, NULL) == TDM_ERROR_NONE) exit(1);
756 exit(0);}, ::testing::ExitedWithCode(0), "");
759 TEST_F(TDMOutput, OutputGetPhysicalSuccessfulOnlyOutput)
761 SKIP_FLAG(has_output);
762 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
763 tdm_error error = TDM_ERROR_NONE;
764 tdm_output * output = tdm_display_get_output(dpy, i, &error);
765 if (NULL == output) exit(1);
766 if (TDM_ERROR_NONE != error) exit(1);
767 if (tdm_output_get_physical_size(output, NULL, NULL) != TDM_ERROR_NONE) exit(1);
769 exit(0);}, ::testing::ExitedWithCode(0), "");
772 TEST_F(TDMOutput, OutputGetSubpixelSuccessful)
774 SKIP_FLAG(has_output);
775 for (int i = 0; i < output_count; i++) {
776 tdm_error error = TDM_ERROR_NONE;
777 unsigned int subpixel = UINT_MAX;
778 tdm_output * output = tdm_display_get_output(dpy, i, &error);
779 ASSERT_FALSE(NULL == output);
780 ASSERT_TRUE(TDM_ERROR_NONE == error);
781 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_subpixel(output, &subpixel));
782 ASSERT_NE(subpixel, UINT_MAX);
786 TEST_F(TDMOutput, OutputGetSubpixelFailNullAll)
788 SKIP_FLAG(has_output);
789 ASSERT_EXIT({if (tdm_output_get_subpixel(NULL, NULL) == TDM_ERROR_NONE) exit(1);
790 exit(0);}, ::testing::ExitedWithCode(0), "");
793 TEST_F(TDMOutput, OutputGetSubpixelFailOnlyOutput)
795 SKIP_FLAG(has_output);
796 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
797 tdm_error error = TDM_ERROR_NONE;
798 tdm_output * output = tdm_display_get_output(dpy, i, &error);
799 if (NULL == output) exit(1);
800 if (TDM_ERROR_NONE != error) exit(1);
801 if (tdm_output_get_subpixel(output, NULL) == TDM_ERROR_NONE) exit(1);
803 exit(0);}, ::testing::ExitedWithCode(0), "");
806 TEST_F(TDMOutput, OutputGetPipeSuccessful)
808 SKIP_FLAG(has_output);
809 for (int i = 0; i < output_count; i++) {
810 tdm_error error = TDM_ERROR_NONE;
811 unsigned int pipe = UINT_MAX;
812 tdm_output * output = tdm_display_get_output(dpy, i, &error);
813 ASSERT_FALSE(NULL == output);
814 ASSERT_TRUE(TDM_ERROR_NONE == error);
815 ASSERT_TRUE(TDM_ERROR_NONE == tdm_output_get_pipe(output, &pipe));
816 ASSERT_NE(pipe, UINT_MAX);
820 TEST_F(TDMOutput, OutputGetPipeFailNullAll)
822 SKIP_FLAG(has_output);
823 ASSERT_EXIT({if (tdm_output_get_pipe(NULL, NULL) == TDM_ERROR_NONE) exit(1);
824 exit(0);}, ::testing::ExitedWithCode(0), "");
827 TEST_F(TDMOutput, OutputGetPipeFailOnlyOutput)
829 SKIP_FLAG(has_output);
830 ASSERT_EXIT({for (int i = 0; i < output_count; i++) {
831 tdm_error error = TDM_ERROR_NONE;
832 tdm_output * output = tdm_display_get_output(dpy, i, &error);
833 if (NULL == output) exit(1);
834 if (TDM_ERROR_NONE != error) exit(1);
835 if (tdm_output_get_pipe(output, NULL) == TDM_ERROR_NONE) exit(1);
837 exit(0);}, ::testing::ExitedWithCode(0), "");
840 TEST_F(TDMOutput, OutputSetPropertySuccessful)
842 SKIP_FLAG(has_output);
843 for (int i = 0; i < output_count; i++) {
844 tdm_error error = TDM_ERROR_NONE;
845 tdm_value value = {.u32 = 0};
846 tdm_output * output = tdm_display_get_output(dpy, i, &error);
847 ASSERT_FALSE(NULL == output);
848 ASSERT_TRUE(TDM_ERROR_NONE == error);
849 error = tdm_output_set_property(output, UINT_MAX, value);
850 ASSERT_TRUE(error == TDM_ERROR_NOT_IMPLEMENTED || error == TDM_ERROR_OPERATION_FAILED);
854 TEST_F(TDMOutput, OutputSetPropertyFailNullAll)
856 SKIP_FLAG(has_output);
857 ASSERT_EXIT({tdm_error error = TDM_ERROR_NONE;
858 tdm_value value = {.u32 = 0};
859 error = tdm_output_set_property(NULL, 0, value);
860 if (error == TDM_ERROR_NONE || error == TDM_ERROR_NOT_IMPLEMENTED ||
861 error == TDM_ERROR_OPERATION_FAILED) exit(1);
862 exit(0);}, ::testing::ExitedWithCode(0), "");