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 **************************************************************************/
37 class TDMHwc : public TDMOutput
49 error = TDM_ERROR_NONE;
52 void TDMHwc::SetUp(void)
57 void TDMHwc::TearDown(void)
59 TDMOutput::TearDown();
63 _tc_tdm_hwc_commit_cb(tdm_hwc *hwc, unsigned int sequence,
64 unsigned int tv_sec, unsigned int tv_usec,
67 bool *done = (bool*)user_data;
72 /* tdm_hwc_window * tdm_hwc_create_window(tdm_output *output, tdm_error *error); */
73 TEST_P(TDMHwc, CreateWindowFailNull)
75 TDM_UT_SKIP_FLAG(has_outputs);
77 ASSERT_EQ(NULL, tdm_hwc_create_window(NULL, &error));
78 ASSERT_NE(TDM_ERROR_NONE, error);
81 TEST_P(TDMHwc, CreateWindowSuccessful)
83 TDM_UT_SKIP_FLAG(has_outputs);
87 tdm_hwc_window * hw = NULL;
89 for (int o = 0; o < output_count; o++) {
90 hwc = tdm_output_get_hwc(outputs[o], &error);
92 hw = tdm_hwc_create_window(hwc, &error);
93 ASSERT_EQ(TDM_ERROR_NONE, error);
94 tdm_hwc_window_destroy(hw);
96 ASSERT_EQ(NULL, tdm_hwc_create_window(hwc, &error));
97 ASSERT_NE(TDM_ERROR_NONE, error);
102 /* tdm_hwc_get_supported_formats() */
103 TEST_P(TDMHwc, GetSupportedFormatsFailNull)
105 TDM_UT_SKIP_FLAG(has_outputs);
109 error = tdm_hwc_get_video_supported_formats(NULL, NULL, NULL);
110 ASSERT_NE(TDM_ERROR_NONE, error);
113 TEST_P(TDMHwc, GetSupportedFormatsSuccessful)
115 TDM_UT_SKIP_FLAG(has_outputs);
118 tdm_error error = TDM_ERROR_NONE;
119 const tbm_format *formats;
122 for (int o = 0; o < output_count; o++) {
123 hwc = tdm_output_get_hwc(outputs[o], &error);
125 error = tdm_hwc_get_video_supported_formats(hwc, &formats, &count);
126 if (error != TDM_ERROR_NOT_IMPLEMENTED) {
127 ASSERT_EQ(TDM_ERROR_NONE, error);
129 ASSERT_NE(NULL, formats);
132 error = tdm_hwc_get_video_supported_formats(hwc, &formats, &count);
133 ASSERT_NE(TDM_ERROR_NONE, error);
139 /* tdm_hwc_get_video_available_properties() */
140 TEST_P(TDMHwc, GetAvailableVideoPropertiesFailNull)
142 TDM_UT_SKIP_FLAG(has_outputs);
145 tdm_error error = TDM_ERROR_NONE;
146 const tdm_prop *props;
149 for (int o = 0; o < output_count; o++) {
150 hwc = tdm_output_get_hwc(outputs[o], &error);
152 error = tdm_hwc_get_video_available_properties(NULL, &props, &count);
153 ASSERT_NE(TDM_ERROR_NONE, error);
155 error = tdm_hwc_get_video_available_properties(hwc, NULL, &count);
156 ASSERT_NE(TDM_ERROR_NONE, error);
158 error = tdm_hwc_get_video_available_properties(hwc, &props, NULL);
159 ASSERT_NE(TDM_ERROR_NONE, error);
161 error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
162 ASSERT_NE(TDM_ERROR_NONE, error);
167 TEST_P(TDMHwc, GetAvailableVideoPropertiesSuccess)
169 TDM_UT_SKIP_FLAG(has_outputs);
172 tdm_error error = TDM_ERROR_NONE;
173 const tdm_prop *props;
176 for (int o = 0; o < output_count; o++) {
177 hwc = tdm_output_get_hwc(outputs[o], &error);
179 error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
180 ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
182 error = tdm_hwc_get_video_available_properties(hwc, &props, &count);
183 ASSERT_NE(TDM_ERROR_NONE, error);
188 /* tdm_hwc_get_capabilities() */
189 TEST_P(TDMHwc, GetAvailableCapabilitiesFailNull)
191 TDM_UT_SKIP_FLAG(has_outputs);
194 tdm_error error = TDM_ERROR_NONE;
195 tdm_hwc_capability hwc_caps;
197 for (int o = 0; o < output_count; o++) {
198 hwc = tdm_output_get_hwc(outputs[o], &error);
200 error = tdm_hwc_get_capabilities(NULL, &hwc_caps);
201 ASSERT_NE(TDM_ERROR_NONE, error);
203 error = tdm_hwc_get_capabilities(hwc, NULL);
204 ASSERT_NE(TDM_ERROR_NONE, error);
206 error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
207 ASSERT_NE(TDM_ERROR_NONE, error);
212 TEST_P(TDMHwc, GetAvailableCapabilitiesSuccess)
214 TDM_UT_SKIP_FLAG(has_outputs);
217 tdm_error error = TDM_ERROR_NONE;
218 tdm_hwc_capability hwc_caps;
220 for (int o = 0; o < output_count; o++) {
221 hwc = tdm_output_get_hwc(outputs[o], &error);
223 error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
224 ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
226 error = tdm_hwc_get_capabilities(hwc, &hwc_caps);
227 ASSERT_NE(TDM_ERROR_NONE, error);
232 /* tdm_hwc_get_available_properties() */
233 TEST_P(TDMHwc, GetAvailablePropertiesFailNullWin)
235 TDM_UT_SKIP_FLAG(has_outputs);
238 tdm_error error = TDM_ERROR_NONE;
239 const tdm_prop *props;
242 for (int o = 0; o < output_count; o++) {
243 hwc = tdm_output_get_hwc(outputs[o], &error);
245 error = tdm_hwc_get_available_properties(NULL, &props, &count);
246 ASSERT_NE(TDM_ERROR_NONE, error);
248 error = tdm_hwc_get_available_properties(hwc, NULL, &count);
249 ASSERT_NE(TDM_ERROR_NONE, error);
251 error = tdm_hwc_get_available_properties(hwc, &props, NULL);
252 ASSERT_NE(TDM_ERROR_NONE, error);
254 error = tdm_hwc_get_available_properties(hwc, &props, &count);
255 ASSERT_NE(TDM_ERROR_NONE, error);
260 TEST_P(TDMHwc, GetAvailablePropertiesSuccess)
262 TDM_UT_SKIP_FLAG(has_outputs);
265 tdm_error error = TDM_ERROR_NONE;
266 const tdm_prop *props;
269 for (int o = 0; o < output_count; o++) {
270 hwc = tdm_output_get_hwc(outputs[o], &error);
272 error = tdm_hwc_get_available_properties(hwc, &props, &count);
273 ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
275 error = tdm_hwc_get_available_properties(hwc, &props, &count);
276 ASSERT_NE(TDM_ERROR_NONE, error);
282 /* tdm_hwc_get_client_target_buffer_queue() */
283 TEST_P(TDMHwc, GetClientTargetBufferQueueFailNullObject)
285 TDM_UT_SKIP_FLAG(has_outputs);
288 tdm_error error = TDM_ERROR_NONE;
289 tbm_surface_queue_h queue = NULL;
291 for (int o = 0; o < output_count; o++) {
292 hwc = tdm_output_get_hwc(outputs[o], &error);
294 queue = tdm_hwc_get_client_target_buffer_queue(NULL, &error);
295 ASSERT_NE(TDM_ERROR_NONE, error);
296 ASSERT_EQ(NULL, queue);
298 queue = tdm_hwc_get_client_target_buffer_queue(NULL, NULL);
299 ASSERT_EQ(NULL, queue);
301 ASSERT_EQ(NULL, queue);
306 TEST_P(TDMHwc, GetClientTargetBufferQueueFailNoHwc)
308 TDM_UT_SKIP_FLAG(has_outputs);
311 tdm_error error = TDM_ERROR_NONE;
312 tbm_surface_queue_h queue = NULL;
314 for (int o = 0; o < output_count; o++) {
315 hwc = tdm_output_get_hwc(outputs[o], &error);
317 queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
318 ASSERT_NE(TDM_ERROR_NONE, error);
319 ASSERT_EQ(NULL, queue);
321 queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
322 ASSERT_NE(TDM_ERROR_NONE, error);
323 ASSERT_EQ(NULL, queue);
328 TEST_P(TDMHwc, GetClientTargetBufferQueueSuccessful)
330 TDM_UT_SKIP_FLAG(has_outputs);
333 tdm_error error = TDM_ERROR_NONE;
334 tbm_surface_queue_h queue = NULL;
336 for (int o = 0; o < output_count; o++) {
337 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
338 hwc = tdm_output_get_hwc(outputs[o], &error);
340 queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
341 tbm_surface_queue_destroy(queue);
342 ASSERT_EQ(TDM_ERROR_NONE, error);
343 ASSERT_NE(NULL, queue);
345 queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL);
346 tbm_surface_queue_destroy(queue);
347 ASSERT_EQ(TDM_ERROR_NONE, error);
348 ASSERT_NE(NULL, queue);
350 queue = tdm_hwc_get_client_target_buffer_queue(hwc, &error);
351 ASSERT_NE(TDM_ERROR_NONE, error);
352 ASSERT_EQ(NULL, queue);
354 queue = tdm_hwc_get_client_target_buffer_queue(hwc, NULL);
355 ASSERT_NE(TDM_ERROR_NONE, error);
356 ASSERT_EQ(NULL, queue);
361 /* tdm_hwc_set_client_target_buffer() */
362 TEST_P(TDMHwc, SetClientTargetBufferFailNullOutput)
364 TDM_UT_SKIP_FLAG(has_outputs);
366 tdm_region damage = {.num_rects = 0, .rects = NULL};
367 tbm_surface_h target_buff = NULL;
369 target_buff = tbm_surface_internal_create_with_flags(720, 1024,
370 TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
371 ASSERT_NE(NULL, target_buff);
373 error = tdm_hwc_set_client_target_buffer(NULL, target_buff, damage);
374 tbm_surface_internal_destroy(target_buff);
375 ASSERT_NE(TDM_ERROR_NONE, error);
378 TEST_P(TDMHwc, SetClientTargetBufferSuccessfulSetBuff)
380 TDM_UT_SKIP_FLAG(has_outputs);
383 tdm_error error = TDM_ERROR_NONE;
384 tdm_region damage = {.num_rects = 0, .rects = NULL};
385 const tdm_output_mode *mode = NULL;
386 tbm_surface_h target_buff = NULL;
388 for (int o = 0; o < output_count; o++) {
389 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
390 hwc = tdm_output_get_hwc(outputs[o], &error);
392 ASSERT_EQ(tdm_output_get_mode(outputs[o], &mode), TDM_ERROR_NONE);
393 ASSERT_NE(mode, NULL);
394 target_buff = tbm_surface_internal_create_with_flags(mode->hdisplay, mode->vdisplay,
395 TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT);
396 ASSERT_NE(NULL, target_buff);
398 error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage);
399 tbm_surface_internal_destroy(target_buff);
400 ASSERT_EQ(TDM_ERROR_NONE, error);
402 error = tdm_hwc_set_client_target_buffer(hwc, target_buff, damage);
403 ASSERT_NE(TDM_ERROR_NONE, error);
408 TEST_P(TDMHwc, SetClientTargetBufferSuccessfulResetBuff)
410 TDM_UT_SKIP_FLAG(has_outputs);
413 tdm_error error = TDM_ERROR_NONE;
414 tdm_region damage = {.num_rects = 0, .rects = NULL};
416 for (int o = 0; o < output_count; o++) {
417 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
418 hwc = tdm_output_get_hwc(outputs[o], &error);
420 error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
421 ASSERT_EQ(TDM_ERROR_NONE, error);
423 error = tdm_hwc_set_client_target_buffer(hwc, NULL, damage);
424 ASSERT_NE(TDM_ERROR_NONE, error);
429 /* tdm_hwc_validate() */
430 TEST_P(TDMHwc, ValidateFailNull)
432 TDM_UT_SKIP_FLAG(has_outputs);
435 tdm_error error = TDM_ERROR_NONE;
438 error = tdm_hwc_validate(NULL, NULL, 0, &num_types);
439 ASSERT_NE(TDM_ERROR_NONE, error);
441 for (int o = 0; o < output_count; o++) {
442 hwc = tdm_output_get_hwc(outputs[o], &error);
444 error = tdm_hwc_validate(hwc, NULL, 0, NULL);
445 ASSERT_NE(TDM_ERROR_NONE, error);
447 error = tdm_hwc_validate(hwc, NULL, 0, NULL);
448 ASSERT_NE(TDM_ERROR_NONE, error);
453 /* tdm_hwc_get_changed_composition_types() */
454 TEST_P(TDMHwc, GetChangedCompositionTypesFailNull)
456 TDM_UT_SKIP_FLAG(has_outputs);
459 tdm_error error = TDM_ERROR_NONE;
460 uint32_t num_elements;
462 error = tdm_hwc_get_changed_composition_types(NULL, &num_elements, NULL, NULL);
463 ASSERT_NE(TDM_ERROR_NONE, error);
465 for (int o = 0; o < output_count; o++) {
466 hwc = tdm_output_get_hwc(outputs[o], &error);
468 error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL);
469 ASSERT_NE(TDM_ERROR_NONE, error);
471 error = tdm_hwc_get_changed_composition_types(hwc, NULL, NULL, NULL);
472 ASSERT_NE(TDM_ERROR_NONE, error);
477 /* tdm_error tdm_hwc_accept_validation() */
478 TEST_P(TDMHwc, AcceptChangesFailNull)
480 TDM_UT_SKIP_FLAG(has_outputs);
482 error = tdm_hwc_accept_validation(NULL);
483 ASSERT_NE(TDM_ERROR_NONE, error);
486 TEST_P(TDMHwc, AcceptChangesFailNoHwc)
489 tdm_error error = TDM_ERROR_NONE;
491 for (int o = 0; o < output_count; o++) {
492 hwc = tdm_output_get_hwc(outputs[o], &error);
494 error = tdm_hwc_accept_validation(hwc);
495 ASSERT_EQ(TDM_ERROR_NONE, error);
497 error = tdm_hwc_accept_validation(hwc);
498 ASSERT_NE(TDM_ERROR_NONE, error);
503 TEST_P(TDMHwc, AcceptChangesSuccessful)
505 TDM_UT_SKIP_FLAG(has_outputs);
508 tdm_error error = TDM_ERROR_NONE;
509 tdm_hwc_window *hwc_wnds[HWC_WIN_NUM];
510 tdm_hwc_window **changed_hwc_window = NULL;
511 tdm_hwc_window_composition *composition_types = NULL;
513 uint32_t get_num = 0;
515 for (int o = 0; o < output_count; o++) {
516 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
517 hwc = tdm_output_get_hwc(outputs[o], &error);
519 for (int w = 0; w < HWC_WIN_NUM; w++) {
520 hwc_wnds[w] = tdm_hwc_create_window(hwc, &error);
521 ASSERT_EQ(TDM_ERROR_NONE, error);
522 error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
523 ASSERT_EQ(TDM_ERROR_NONE, error);
526 error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types);
527 ASSERT_EQ(TDM_ERROR_NONE, error);
530 changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
531 composition_types = (tdm_hwc_window_composition *)calloc(num_types, sizeof(tdm_hwc_window_composition));
534 error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types);
535 ASSERT_EQ(TDM_ERROR_NONE, error);
536 ASSERT_EQ(get_num, num_types);
538 error = tdm_hwc_accept_validation(hwc);
539 ASSERT_EQ(TDM_ERROR_NONE, error);
541 free(composition_types);
542 free(changed_hwc_window);
545 for (int w = 0; w < HWC_WIN_NUM; w++)
546 tdm_hwc_window_destroy(hwc_wnds[w]);
548 ASSERT_EQ(TDM_ERROR_NONE, error);
553 /* tdm_error tdm_hwc_commit() */
554 TEST_P(TDMHwc, CommitFailNull)
556 TDM_UT_SKIP_FLAG(has_outputs);
558 error = tdm_hwc_commit(NULL, 1, NULL, NULL);
559 ASSERT_NE(TDM_ERROR_NONE, error);
562 TEST_P(TDMHwc, CommitSuccessful)
564 TDM_UT_SKIP_FLAG(has_outputs);
567 tdm_error error = TDM_ERROR_NONE;
568 tdm_hwc_window *hwc_wnds[HWC_WIN_NUM];
569 tdm_hwc_window **changed_hwc_window = NULL;
570 tdm_hwc_window_composition *composition_types = NULL;
572 uint32_t get_num = 0;
574 for (int o = 0; o < output_count; o++) {
575 ASSERT_EQ(tc_tdm_output_prepare(dpy, outputs[o], true), true);
576 hwc = tdm_output_get_hwc(outputs[o], &error);
578 for (int w = 0; w < HWC_WIN_NUM; w++) {
579 hwc_wnds[w] = tdm_hwc_create_window(hwc, &error);
580 ASSERT_EQ(TDM_ERROR_NONE, error);
581 error = tdm_hwc_window_set_composition_type(hwc_wnds[w], TDM_HWC_WIN_COMPOSITION_DEVICE);
582 ASSERT_EQ(TDM_ERROR_NONE, error);
585 error = tdm_hwc_validate(hwc, hwc_wnds, HWC_WIN_NUM, &num_types);
586 ASSERT_EQ(TDM_ERROR_NONE, error);
589 changed_hwc_window = (tdm_hwc_window **)calloc(num_types, sizeof(tdm_hwc_window *));
590 composition_types = (tdm_hwc_window_composition *)calloc(num_types, sizeof(tdm_hwc_window_composition));
593 error = tdm_hwc_get_changed_composition_types(hwc, &get_num, changed_hwc_window, composition_types);
594 ASSERT_EQ(TDM_ERROR_NONE, error);
595 ASSERT_EQ(get_num, num_types);
597 error = tdm_hwc_accept_validation(hwc);
598 ASSERT_EQ(TDM_ERROR_NONE, error);
600 free(composition_types);
601 free(changed_hwc_window);
604 error = tdm_hwc_commit(hwc, 0, _tc_tdm_hwc_commit_cb, NULL);
605 ASSERT_EQ(TDM_ERROR_NONE, error);
607 for (int w = 0; w < HWC_WIN_NUM; w++)
608 tdm_hwc_window_destroy(hwc_wnds[w]);
610 ASSERT_EQ(TDM_ERROR_NONE, error);
615 /* tdm_hwc_set_property() */
616 TEST_P(TDMHwc, SetPropertyFailNull)
618 TDM_UT_SKIP_FLAG(has_outputs);
621 tdm_error error = TDM_ERROR_NONE;
626 for (int o = 0; o < output_count; o++) {
627 hwc = tdm_output_get_hwc(outputs[o], &error);
629 error = tdm_hwc_set_property(NULL, 0, value);
630 ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
632 error = tdm_hwc_set_property(hwc, 0, value);
633 ASSERT_NE(TDM_ERROR_NONE, error);
638 TEST_P(TDMHwc, SetPropertySuccess)
640 TDM_UT_SKIP_FLAG(has_outputs);
643 tdm_error error = TDM_ERROR_NONE;
644 const tdm_prop *props;
650 for (int o = 0; o < output_count; o++) {
651 hwc = tdm_output_get_hwc(outputs[o], &error);
653 error = tdm_hwc_get_available_properties(hwc, &props, &count);
654 ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
657 error = tdm_hwc_set_property(hwc, 0, value);
658 ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
660 error = tdm_hwc_set_property(hwc, props[0].id, value);
661 ASSERT_EQ(TDM_ERROR_NONE, error);
664 error = tdm_hwc_set_property(hwc, 0, value);
665 ASSERT_NE(TDM_ERROR_NONE, error);
670 /* tdm_hwc_get_property() */
671 TEST_P(TDMHwc, GetPropertyFailNull)
673 TDM_UT_SKIP_FLAG(has_outputs);
676 tdm_error error = TDM_ERROR_NONE;
679 for (int o = 0; o < output_count; o++) {
680 hwc = tdm_output_get_hwc(outputs[o], &error);
682 error = tdm_hwc_get_property(NULL, 0, &value);
683 ASSERT_EQ(TDM_ERROR_INVALID_PARAMETER, error);
685 error = tdm_hwc_get_property(hwc, 0, &value);
686 ASSERT_NE(TDM_ERROR_NONE, error);
691 TEST_P(TDMHwc, GetPropertySuccess)
693 TDM_UT_SKIP_FLAG(has_outputs);
696 tdm_error error = TDM_ERROR_NONE;
697 const tdm_prop *props;
701 for (int o = 0; o < output_count; o++) {
702 hwc = tdm_output_get_hwc(outputs[o], &error);
705 error = tdm_hwc_get_available_properties(hwc, &props, &count);
706 ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
709 error = tdm_hwc_get_property(hwc, 0, &value);
710 ASSERT_TRUE(TDM_ERROR_NONE == error || TDM_ERROR_NOT_IMPLEMENTED == error);
712 error = tdm_hwc_get_property(hwc, props[0].id, &value);
713 ASSERT_EQ(TDM_ERROR_NONE, error);
716 error = tdm_hwc_get_property(hwc, 0, &value);
717 ASSERT_NE(TDM_ERROR_NONE, error);
722 #ifdef TDM_UT_TEST_WITH_PARAMS
723 INSTANTIATE_TEST_CASE_P(TDMHwcParams,
725 Combine(Bool(), Bool(), Values(TDM_DEFAULT_MODULE)));
727 INSTANTIATE_TEST_CASE_P(TDMHwcParams,
729 Values(TDM_DEFAULT_MODULE));