ut/src/ut_tdm_capture.cpp

   1 /**************************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics co., Ltd. All Rights Reserved.
   4  *
   5  * Contact: Konstantin Drabeniuk <k.drabeniuk@samsung.com>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27 **************************************************************************/
  28
  29 #include "gtest/gtest.h"
  30
  31 #include "tbm_stubs.h"
  32 #include "pthread_stubs.h"
  33 #include "stdlib_stubs.h"
  34 #include "tdm_list_stubs.h"
  35 #include "tdm_capture_stubs.h"
  36
  37 #define pthread_mutex_lock ut_pthread_mutex_lock
  38 #define calloc ut_calloc
  39 #define free ut_free
  40 #define pthread_mutex_init ut_pthread_mutex_init
  41 #define pthread_mutex_unlock ut_pthread_mutex_unlock
  42
  43 #include "tdm_capture.c"
  44
  45 /* UNIT TESTS */
  46
  47 static void _init_test()
  48 {
  49         TBM_BUFMGR_DEINIT_CALLED = 0;
  50         TBM_BO_GET_USER_DATA_NULL = 0;
  51         PTHREAD_MUTEX_INIT_ERROR = 0;
  52         CALLOC_ERROR = 0;
  53         CALLOC_RETURN_BUFFER = 0;
  54         FREE_CALLED = 0;
  55         OUTPUT_CREATE_CAPTURE_ERROR = 0;
  56         CAPTURE_SET_DONE_HANDLER_ERROR = 0;
  57         LAYER_CREATE_CAPTURE_ERROR = 0;
  58         CAPTURE_SET_INFO_ERROR = 0;
  59         CAPTURE_ATTACH_ERROR = 0;
  60         CAPTURE_COMMIT_ERROR = 0;
  61 }
  62
  63 /* tdm_capture_commit */
  64
  65 TEST(tdm_capture_commit, work_flow_success_4)
  66 {
  67         tdm_error error = TDM_ERROR_OPERATION_FAILED;
  68         struct _tdm_private_capture capture;
  69         struct _tdm_private_display private_display;
  70         tdm_private_output private_output;
  71         tdm_error expected_error = TDM_ERROR_NONE;
  72
  73         _init_test();
  74
  75         capture.private_display = &private_display;
  76         private_display.func_capture.capture_commit = capture_commit;
  77         CALLOC_RETURN_BUFFER = 1;
  78         capture.private_output = &private_output;
  79         private_output.current_dpms_value = TDM_OUTPUT_DPMS_ON;
  80
  81         error = tdm_capture_commit(&capture);
  82
  83         ASSERT_EQ(error, expected_error);
  84 }
  85
  86 TEST(tdm_capture_commit, work_flow_success_3)
  87 {
  88         tdm_error error = TDM_ERROR_NONE;
  89         struct _tdm_private_capture capture;
  90         struct _tdm_private_display private_display;
  91         tdm_private_output private_output;
  92         tdm_error not_expected_error = TDM_ERROR_NONE;
  93
  94         _init_test();
  95
  96         capture.private_display = &private_display;
  97         private_display.func_capture.capture_commit = capture_commit;
  98         CAPTURE_COMMIT_ERROR = 1;
  99         capture.private_output = &private_output;
 100         private_output.current_dpms_value = TDM_OUTPUT_DPMS_ON;
 101
 102         error = tdm_capture_commit(&capture);
 103
 104         ASSERT_NE(error, not_expected_error);
 105 }
 106
 107 TEST(tdm_capture_commit, work_flow_success_2)
 108 {
 109         tdm_error error = TDM_ERROR_NONE;
 110         tdm_error expected_error = TDM_ERROR_NOT_IMPLEMENTED;
 111         struct _tdm_private_capture capture;
 112         struct _tdm_private_display private_display;
 113         tdm_private_output private_output;
 114
 115         _init_test();
 116
 117         capture.private_display = &private_display;
 118         private_display.func_capture.capture_commit = NULL;
 119         capture.private_output = &private_output;
 120         private_output.current_dpms_value = TDM_OUTPUT_DPMS_ON;
 121
 122         error = tdm_capture_commit(&capture);
 123
 124         ASSERT_EQ(error, expected_error);
 125 }
 126
 127 TEST(tdm_capture_commit, work_flow_success_1)
 128 {
 129         tdm_error error = TDM_ERROR_NONE;
 130         tdm_error expected_error = TDM_ERROR_BAD_REQUEST;
 131         struct _tdm_private_capture capture;
 132         struct _tdm_private_display private_display;
 133         tdm_private_output private_output;
 134
 135         _init_test();
 136
 137         capture.private_display = &private_display;
 138         private_display.func_capture.capture_commit = NULL;
 139         capture.private_output = &private_output;
 140         private_output.current_dpms_value = TDM_OUTPUT_DPMS_OFF;
 141
 142         error = tdm_capture_commit(&capture);
 143
 144         ASSERT_EQ(error, expected_error);
 145 }
 146
 147 TEST(tdm_capture_commit, null_ptr_fail_1)
 148 {
 149         tdm_error error = TDM_ERROR_NONE;
 150         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 151
 152         _init_test();
 153
 154         error = tdm_capture_commit(NULL);
 155
 156         ASSERT_EQ(error, expected_error);
 157 }
 158
 159 /* tdm_capture_attach */
 160
 161 TEST(tdm_capture_attach, null_ptr_fail_2)
 162 {
 163         tdm_error error = TDM_ERROR_NONE;
 164         struct _tdm_private_capture capture;
 165         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 166
 167         _init_test();
 168
 169         error = tdm_capture_attach(&capture, NULL);
 170
 171         ASSERT_EQ(error, expected_error);
 172 }
 173
 174 TEST(tdm_capture_attach, null_ptr_fail_1)
 175 {
 176         tdm_error error = TDM_ERROR_NONE;
 177         struct _tbm_surface buffer;
 178         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 179
 180         _init_test();
 181
 182         error = tdm_capture_attach(NULL, &buffer);
 183
 184         ASSERT_EQ(error, expected_error);
 185 }
 186
 187 /* tdm_capture_set_info */
 188
 189 TEST(tdm_capture_set_info, work_flow_success_2)
 190 {
 191         tdm_info_capture info;
 192         tdm_error error = TDM_ERROR_OPERATION_FAILED;
 193         struct _tdm_private_capture capture;
 194         struct _tdm_private_display private_display;
 195         tdm_error expected_error = TDM_ERROR_NONE;
 196
 197         _init_test();
 198
 199         capture.private_display = &private_display;
 200         private_display.func_capture.capture_set_info = capture_set_info;
 201
 202         error = tdm_capture_set_info(&capture, &info);
 203
 204         ASSERT_EQ(error, expected_error);
 205 }
 206
 207 TEST(tdm_capture_set_info, work_flow_success_1)
 208 {
 209         tdm_info_capture info;
 210         tdm_error error = TDM_ERROR_NONE;
 211         struct _tdm_private_capture capture;
 212         struct _tdm_private_display private_display;
 213         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
 214
 215         _init_test();
 216
 217         capture.private_display = &private_display;
 218         private_display.func_capture.capture_set_info = capture_set_info;
 219         CAPTURE_SET_INFO_ERROR = 1;
 220
 221         error = tdm_capture_set_info(&capture, &info);
 222
 223         ASSERT_EQ(error, expected_error);
 224 }
 225
 226 TEST(tdm_capture_set_info, null_ptr_fail_2)
 227 {
 228         tdm_error error = TDM_ERROR_NONE;
 229         struct _tdm_private_capture capture;
 230         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 231
 232         _init_test();
 233
 234         error = tdm_capture_set_info(&capture, NULL);
 235
 236         ASSERT_EQ(error, expected_error);
 237 }
 238
 239 TEST(tdm_capture_set_info, null_ptr_fail_1)
 240 {
 241         tdm_error error = TDM_ERROR_NONE;
 242         tdm_info_capture info;
 243         tdm_error expected_error = TDM_ERROR_INVALID_PARAMETER;
 244
 245         _init_test();
 246
 247         error = tdm_capture_set_info(NULL, &info);
 248
 249         ASSERT_EQ(error, expected_error);
 250 }
 251
 252 /* tdm_capture_create_layer_internal */
 253
 254 TEST(tdm_capture_create_layer_internal, work_flow_success_4)
 255 {
 256         tdm_error error = TDM_ERROR_OPERATION_FAILED;
 257         struct _tdm_private_layer private_layer;
 258         struct _tdm_private_output private_output;
 259         struct _tdm_private_display private_display;
 260         tdm_private_capture *actual;
 261         tdm_private_capture *not_expected = NULL;
 262         tdm_error expected_error = TDM_ERROR_NONE;
 263
 264         _init_test();
 265
 266         private_layer.private_output = &private_output;
 267         private_output.private_display = &private_display;
 268         private_display.func_layer.layer_create_capture = layer_create_capture;
 269         private_display.func_capture.capture_destroy = capture_destroy;
 270         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 271
 272         actual = tdm_capture_create_layer_internal(&private_layer, &error);
 273
 274         ASSERT_EQ(error, expected_error);
 275         ASSERT_TRUE(actual != not_expected);
 276         free(actual);
 277 }
 278
 279 TEST(tdm_capture_create_layer_internal, work_flow_success_3)
 280 {
 281         tdm_error error = TDM_ERROR_NONE;
 282         struct _tdm_private_layer private_layer;
 283         struct _tdm_private_output private_output;
 284         struct _tdm_private_display private_display;
 285         tdm_private_capture *actual;
 286         tdm_private_capture *expected = NULL;
 287         tdm_error expected_error = TDM_ERROR_OUT_OF_MEMORY;
 288
 289         _init_test();
 290
 291         private_layer.private_output = &private_output;
 292         private_output.private_display = &private_display;
 293         private_display.func_layer.layer_create_capture = layer_create_capture;
 294         private_display.func_capture.capture_destroy = capture_destroy;
 295         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 296
 297         CALLOC_ERROR = 1;
 298
 299         actual = tdm_capture_create_layer_internal(&private_layer, &error);
 300
 301         ASSERT_EQ(error, expected_error);
 302         ASSERT_TRUE(actual == expected);
 303 }
 304
 305 TEST(tdm_capture_create_layer_internal, work_flow_success_2)
 306 {
 307         tdm_error error = TDM_ERROR_NONE;
 308         struct _tdm_private_layer private_layer;
 309         struct _tdm_private_output private_output;
 310         struct _tdm_private_display private_display;
 311         tdm_private_capture *actual;
 312         tdm_private_capture *expected = NULL;
 313
 314         _init_test();
 315
 316         private_layer.private_output = &private_output;
 317         private_output.private_display = &private_display;
 318         private_display.func_layer.layer_create_capture = layer_create_capture;
 319         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 320
 321         LAYER_CREATE_CAPTURE_ERROR = 1;
 322
 323         actual = tdm_capture_create_layer_internal(&private_layer, &error);
 324
 325         ASSERT_TRUE(actual == expected);
 326 }
 327
 328 TEST(tdm_capture_create_layer_internal, work_flow_success_1)
 329 {
 330         tdm_error error = TDM_ERROR_NONE;
 331         struct _tdm_private_layer private_layer;
 332         struct _tdm_private_output private_output;
 333         struct _tdm_private_display private_display;
 334         tdm_private_capture *actual;
 335         tdm_private_capture *expected = NULL;
 336         tdm_error expected_error = TDM_ERROR_NO_CAPABILITY;
 337
 338         _init_test();
 339
 340         private_layer.private_output = &private_output;
 341         private_output.private_display = &private_display;
 342         private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
 343
 344         actual = tdm_capture_create_layer_internal(&private_layer, &error);
 345
 346         ASSERT_EQ(error, expected_error);
 347         ASSERT_TRUE(actual == expected);
 348 }
 349
 350 /* tc_tdm_capture_create_output_internal */
 351
 352 TEST(tdm_capture_create_output_internal, work_flow_success_5)
 353 {
 354         tdm_error error = TDM_ERROR_OPERATION_FAILED;
 355         struct _tdm_private_output private_output;
 356         struct _tdm_private_display private_display;
 357         tdm_private_capture *actual;
 358         tdm_private_capture *not_expected = NULL;
 359         tdm_error expected_error = TDM_ERROR_NONE;
 360
 361         _init_test();
 362
 363         private_output.private_display = &private_display;
 364         private_display.func_output.output_create_capture = output_create_capture;
 365         private_display.func_capture.capture_destroy = capture_destroy;
 366         private_display.func_capture.capture_set_done_handler =
 367                         capture_set_done_handler;
 368         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 369
 370         actual = tdm_capture_create_output_internal(&private_output, &error);
 371
 372         ASSERT_EQ(error, expected_error);
 373         ASSERT_TRUE(actual != not_expected);
 374         free(actual);
 375 }
 376
 377 TEST(tdm_capture_create_output_internal, work_flow_success_4)
 378 {
 379         tdm_error error = TDM_ERROR_NONE;
 380         struct _tdm_private_output private_output;
 381         struct _tdm_private_display private_display;
 382         tdm_private_capture *actual;
 383         tdm_private_capture *expected = NULL;
 384         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
 385
 386         _init_test();
 387
 388         private_output.private_display = &private_display;
 389         private_display.func_output.output_create_capture = output_create_capture;
 390         private_display.func_capture.capture_destroy = capture_destroy;
 391         private_display.func_capture.capture_set_done_handler = capture_set_done_handler;
 392         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 393         CAPTURE_SET_DONE_HANDLER_ERROR = 1;
 394
 395         actual = tdm_capture_create_output_internal(&private_output, &error);
 396
 397         ASSERT_EQ(error, expected_error);
 398         ASSERT_TRUE(actual == expected);
 399 }
 400
 401 TEST(tdm_capture_create_output_internal, work_flow_success_3)
 402 {
 403         tdm_error error = TDM_ERROR_NONE;
 404         struct _tdm_private_output private_output;
 405         struct _tdm_private_display private_display;
 406         tdm_private_capture *actual;
 407         tdm_private_capture *expected = NULL;
 408         tdm_error expected_error = TDM_ERROR_OUT_OF_MEMORY;
 409
 410         _init_test();
 411
 412         private_output.private_display = &private_display;
 413         private_display.func_output.output_create_capture = output_create_capture;
 414         private_display.func_capture.capture_destroy = capture_destroy;
 415         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 416         CALLOC_ERROR = 1;
 417
 418         actual = tdm_capture_create_output_internal(&private_output, &error);
 419
 420         ASSERT_EQ(error, expected_error);
 421         ASSERT_TRUE(actual == expected);
 422 }
 423
 424 TEST(tdm_capture_create_output_internal, work_flow_success_2)
 425 {
 426         tdm_error error = TDM_ERROR_NONE;
 427         struct _tdm_private_output private_output;
 428         struct _tdm_private_display private_display;
 429         tdm_private_capture *actual;
 430         tdm_private_capture *expected = NULL;
 431         tdm_error expected_error = TDM_ERROR_OPERATION_FAILED;
 432
 433         _init_test();
 434
 435         private_output.private_display = &private_display;
 436         private_display.func_output.output_create_capture = output_create_capture;
 437         private_display.capabilities = TDM_DISPLAY_CAPABILITY_CAPTURE;
 438         OUTPUT_CREATE_CAPTURE_ERROR = 1;
 439
 440         actual = tdm_capture_create_output_internal(&private_output, &error);
 441
 442         ASSERT_EQ(error, expected_error);
 443         ASSERT_TRUE(actual == expected);
 444 }
 445
 446 TEST(tdm_capture_create_output_internal, work_flow_success_1)
 447 {
 448         tdm_error error = TDM_ERROR_NONE;
 449         struct _tdm_private_output private_output;
 450         struct _tdm_private_display private_display;
 451         tdm_private_capture *actual;
 452         tdm_private_capture *expected = NULL;
 453         tdm_error expected_error = TDM_ERROR_NO_CAPABILITY;
 454
 455         _init_test();
 456
 457         private_output.private_display = &private_display;
 458         private_display.capabilities = TDM_DISPLAY_CAPABILITY_PP;
 459         actual = tdm_capture_create_output_internal(&private_output, &error);
 460
 461         ASSERT_EQ(error, expected_error);
 462         ASSERT_TRUE(actual == expected);
 463 }