tests/unittest.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <iostream>
  20 #include <gmock/gmock.h>
  21 #include <gtest/gtest.h>
  22 #include <unistd.h>
  23
  24 #include <sys/types.h>
  25 #include <sys/syscall.h>
  26 #include <glib.h>
  27 #include <glib-object.h>
  28 #include <malloc.h>
  29 #include <vconf.h>
  30
  31 #include "mtpResponder.h"
  32
  33 using ::testing::InitGoogleTest;
  34 using ::testing::Test;
  35 using ::testing::TestCase;
  36
  37 #ifdef TIZEN_TEST_GCOV
  38 extern "C" void __gcov_flush(void);
  39 #endif
  40
  41 TEST(MtpResponder_t, mtp_init_p0)
  42 {
  43         int ret = 0;
  44         MtpResponder mtp;
  45         add_rem_store_t sel = MTP_ADDREM_AUTO;
  46
  47         ret = mtp.mtp_init(sel);
  48
  49         EXPECT_EQ(ERROR_NONE, ret);
  50 }
  51
  52 TEST(MtpResponder_t, mtp_init_p1)
  53 {
  54         int ret = 0;
  55         MtpResponder mtp;
  56         add_rem_store_t sel = MTP_ADDREM_INTERNAL;
  57
  58         ret = mtp.mtp_init(sel);
  59
  60         EXPECT_EQ(ERROR_NONE, ret);
  61 }
  62
  63 TEST(MtpResponder_t, mtp_init_p2)
  64 {
  65         int ret = 0;
  66         MtpResponder mtp;
  67         add_rem_store_t sel = MTP_ADDREM_EXTERNAL;
  68
  69         ret = mtp.mtp_init(sel);
  70
  71         EXPECT_EQ(ERROR_NONE, ret);
  72 }
  73
  74 TEST(MtpResponder_t, mtp_init_p3)
  75 {
  76         int ret = 0;
  77         MtpResponder mtp;
  78         add_rem_store_t sel = MTP_ADDREM_ALL;
  79
  80         ret = mtp.mtp_init(sel);
  81
  82         EXPECT_EQ(ERROR_NONE, ret);
  83 }
  84
  85 TEST(MtpResponder_t, mtp_deinit_p0)
  86 {
  87         int ret = 0;
  88         MtpResponder mtp;
  89
  90         ret = mtp.mtp_deinit();
  91
  92         EXPECT_EQ(ERROR_NONE, ret);
  93 }
  94
  95 TEST(MtpResponder_t, hutil_get_storage_entry_n)
  96 {
  97         int ret = 0;
  98         MtpResponder mtp;
  99
 100         ret = mtp.hutil_get_storage_entry();
 101
 102         EXPECT_NE(ERROR_NONE, ret);
 103 }
 104
 105 TEST(MtpResponder_t, hutil_get_storage_ids_p)
 106 {
 107         int ret = 0;
 108         MtpResponder mtp;
 109
 110         ret = mtp.hutil_get_storage_ids();
 111
 112         EXPECT_EQ(ERROR_NONE, ret);
 113 }
 114
 115 TEST(MtpResponder_t, hutil_get_device_property_n)
 116 {
 117         int ret = 0;
 118         MtpResponder mtp;
 119
 120         ret = mtp.hutil_get_device_property();
 121
 122         EXPECT_NE(ERROR_NONE, ret);
 123 }
 124
 125 TEST(MtpResponder_t, hutil_set_device_property_n)
 126 {
 127         int ret = 0;
 128         MtpResponder mtp;
 129
 130         ret = mtp.hutil_set_device_property();
 131
 132         EXPECT_NE(ERROR_NONE, ret);
 133 }
 134
 135 TEST(MtpResponder_t, hutil_reset_device_entry_n)
 136 {
 137         int ret = 0;
 138         MtpResponder mtp;
 139
 140         ret = mtp.hutil_reset_device_entry();
 141
 142         EXPECT_NE(ERROR_NONE, ret);
 143 }
 144
 145 TEST(MtpResponder_t, hutil_add_object_entry_n)
 146 {
 147         int ret = 0;
 148         MtpResponder mtp;
 149
 150         ret = mtp.hutil_add_object_entry();
 151
 152         EXPECT_NE(ERROR_NONE, ret);
 153 }
 154
 155 TEST(MtpResponder_t, hutil_remove_object_entry_n)
 156 {
 157         int ret = 0;
 158         MtpResponder mtp;
 159
 160         ret = mtp.hutil_remove_object_entry();
 161
 162         EXPECT_NE(ERROR_NONE, ret);
 163 }
 164
 165 TEST(MtpResponder_t, hutil_get_object_entry_n)
 166 {
 167         int ret = 0;
 168         MtpResponder mtp;
 169
 170         ret = mtp.hutil_get_object_entry();
 171
 172         EXPECT_NE(ERROR_NONE, ret);
 173 }
 174
 175 TEST(MtpResponder_t, hutil_copy_object_entries_n)
 176 {
 177         int ret = 0;
 178         MtpResponder mtp;
 179
 180         ret = mtp.hutil_copy_object_entries();
 181
 182         EXPECT_NE(ERROR_NONE, ret);
 183 }
 184
 185 TEST(MtpResponder_t, hutil_move_object_entry_n)
 186 {
 187         int ret = 0;
 188         MtpResponder mtp;
 189
 190         ret = mtp.hutil_move_object_entry();
 191
 192         EXPECT_NE(ERROR_NONE, ret);
 193 }
 194
 195 TEST(MtpResponder_t, hutil_duplicate_object_entry_n)
 196 {
 197         int ret = 0;
 198         MtpResponder mtp;
 199
 200         ret = mtp.hutil_duplicate_object_entry();
 201
 202         EXPECT_NE(ERROR_NONE, ret);
 203 }
 204
 205 TEST(MtpResponder_t, hutil_read_file_data_from_offset_n)
 206 {
 207         int ret = 0;
 208         MtpResponder mtp;
 209
 210         ret = mtp.hutil_read_file_data_from_offset();
 211
 212         EXPECT_NE(ERROR_NONE, ret);
 213 }
 214
 215 TEST(MtpResponder_t, hutil_write_file_data_n)
 216 {
 217         int ret = 0;
 218         MtpResponder mtp;
 219
 220         ret = mtp.hutil_write_file_data();
 221
 222         EXPECT_NE(ERROR_NONE, ret);
 223 }
 224
 225 TEST(MtpResponder_t, hutil_get_object_entry_size_n)
 226 {
 227         int ret = 0;
 228         MtpResponder mtp;
 229
 230         ret = mtp.hutil_get_object_entry_size();
 231
 232         EXPECT_NE(ERROR_NONE, ret);
 233 }
 234
 235 #ifdef MTP_SUPPORT_SET_PROTECTION
 236 TEST(MtpResponder_t, hutil_set_protection_n)
 237 {
 238         int ret = 0;
 239         MtpResponder mtp;
 240
 241         ret = mtp.hutil_set_protection();
 242
 243         EXPECT_NE(ERROR_NONE, ret);
 244 }
 245 #endif /* MTP_SUPPORT_SET_PROTECTION */
 246
 247 TEST(MtpResponder_t, hutil_get_num_objects_n)
 248 {
 249         int ret = 0;
 250         MtpResponder mtp;
 251
 252         ret = mtp.hutil_get_num_objects();
 253
 254         EXPECT_NE(ERROR_NONE, ret);
 255 }
 256
 257 TEST(MtpResponder_t, hutil_get_object_handles_n)
 258 {
 259         int ret = 0;
 260         MtpResponder mtp;
 261
 262         ret = mtp.hutil_get_object_handles();
 263
 264         EXPECT_NE(ERROR_NONE, ret);
 265 }
 266
 267 TEST(MtpResponder_t, hutil_construct_object_entry_p)
 268 {
 269         int ret = 0;
 270         MtpResponder mtp;
 271
 272         ret = mtp.hutil_construct_object_entry();
 273
 274         EXPECT_EQ(ERROR_NONE, ret);
 275 }
 276
 277 //========================================
 278
 279 TEST(MtpResponder_t, hutil_construct_object_entry_prop_list_n)
 280 {
 281         int ret = 0;
 282         MtpResponder mtp;
 283
 284         ret = mtp.hutil_construct_object_entry_prop_list();
 285
 286         EXPECT_NE(ERROR_NONE, ret);
 287 }
 288
 289 TEST(MtpResponder_t, hutil_get_object_prop_value_n)
 290 {
 291         int ret = 0;
 292         MtpResponder mtp;
 293
 294         ret = mtp.hutil_get_object_prop_value();
 295
 296         EXPECT_NE(ERROR_NONE, ret);
 297 }
 298
 299 TEST(MtpResponder_t, hutil_update_object_property_n)
 300 {
 301         int ret = 0;
 302         MtpResponder mtp;
 303
 304         ret = mtp.hutil_update_object_property();
 305
 306         EXPECT_NE(ERROR_NONE, ret);
 307 }
 308
 309 TEST(MtpResponder_t, hutil_get_prop_desc_n)
 310 {
 311         int ret = 0;
 312         MtpResponder mtp;
 313
 314         ret = mtp.hutil_get_prop_desc();
 315
 316         EXPECT_NE(ERROR_NONE, ret);
 317 }
 318
 319 TEST(MtpResponder_t, hutil_get_object_prop_supported_p)
 320 {
 321         int ret = 0;
 322         MtpResponder mtp;
 323
 324         ret = mtp.hutil_get_object_prop_supported();
 325
 326         EXPECT_EQ(ERROR_NONE, ret);
 327 }
 328
 329 TEST(MtpResponder_t, hutil_get_object_prop_list_n)
 330 {
 331         int ret = 0;
 332         MtpResponder mtp;
 333
 334         ret = mtp.hutil_get_object_prop_list();
 335
 336         EXPECT_NE(ERROR_NONE, ret);
 337 }
 338
 339 TEST(MtpResponder_t, hutil_add_object_references_enhanced_p)
 340 {
 341         int ret = 0;
 342         MtpResponder mtp;
 343
 344         ret = mtp.hutil_add_object_references_enhanced();
 345
 346         EXPECT_EQ(ERROR_NONE, ret);
 347 }
 348
 349 TEST(MtpResponder_t, hutil_remove_object_reference_p)
 350 {
 351         int ret = 0;
 352         MtpResponder mtp;
 353
 354         ret = mtp.hutil_remove_object_reference();
 355
 356         EXPECT_EQ(ERROR_NONE, ret);
 357 }
 358
 359 TEST(MtpResponder_t, hutil_get_object_references_n)
 360 {
 361         int ret = 0;
 362         MtpResponder mtp;
 363
 364         ret = mtp.hutil_get_object_references();
 365
 366         EXPECT_NE(ERROR_NONE, ret);
 367 }
 368
 369 TEST(MtpResponder_t, hutil_get_number_of_objects_p)
 370 {
 371         int ret = 0;
 372         MtpResponder mtp;
 373
 374         ret = mtp.hutil_get_number_of_objects();
 375
 376         EXPECT_EQ(ERROR_NONE, ret);
 377 }
 378
 379 TEST(MtpResponder_t, hutil_get_interdep_prop_config_list_size_p)
 380 {
 381         int ret = 0;
 382         MtpResponder mtp;
 383
 384         ret = mtp.hutil_get_interdep_prop_config_list_size();
 385
 386         EXPECT_EQ(ERROR_NONE, ret);
 387 }
 388
 389 TEST(MtpResponder_t, hutil_get_interdep_prop_config_list_data_p)
 390 {
 391         int ret = 0;
 392         MtpResponder mtp;
 393
 394         ret = mtp.hutil_get_interdep_prop_config_list_data();
 395
 396         EXPECT_EQ(ERROR_NONE, ret);
 397 }
 398
 399 TEST(MtpResponder_t, hutil_get_playback_skip_n)
 400 {
 401         int ret = 0;
 402         MtpResponder mtp;
 403
 404         ret = mtp.hutil_get_playback_skip();
 405
 406         EXPECT_NE(ERROR_NONE, ret);
 407 }
 408
 409 TEST(MtpResponder_t, hutil_format_storage_n)
 410 {
 411         int ret = 0;
 412         MtpResponder mtp;
 413
 414         ret = mtp.hutil_format_storage();
 415
 416         EXPECT_NE(ERROR_NONE, ret);
 417 }
 418
 419 TEST(MtpResponder_t, hutil_get_storage_info_size_p)
 420 {
 421         int ret = 0;
 422         MtpResponder mtp;
 423
 424         ret = mtp.hutil_get_storage_info_size();
 425
 426         EXPECT_EQ(ERROR_NONE, ret);
 427 }
 428
 429 //================== _MTP_CMD_HANDLER_H_ ======================
 430
 431 TEST(MtpResponder_t, cmd_hdlr_send_response_n)
 432 {
 433         int ret = 0;
 434         MtpResponder mtp;
 435
 436         ret = mtp.cmd_hdlr_send_response();
 437
 438         EXPECT_EQ(ERROR_NONE, ret);
 439 }
 440
 441 TEST(MtpResponder_t, cmd_hdlr_send_response_code_n)
 442 {
 443         int ret = 0;
 444         MtpResponder mtp;
 445
 446         ret = mtp.cmd_hdlr_send_response_code();
 447
 448         EXPECT_EQ(ERROR_NONE, ret);
 449 }
 450
 451 //================== _MTP_EVENT_HANDLER_H_ ======================
 452
 453 TEST(MtpResponder_t, hdlr_get_param_cmd_container_p)
 454 {
 455         int ret = 0;
 456         MtpResponder mtp;
 457
 458         ret = mtp.hdlr_get_param_cmd_container();
 459
 460         EXPECT_EQ(ERROR_NONE, ret);
 461 }
 462
 463 TEST(MtpResponder_t, hdlr_add_param_resp_container_p)
 464 {
 465         int ret = 0;
 466         MtpResponder mtp;
 467
 468         ret = mtp.hdlr_add_param_resp_container();
 469
 470         EXPECT_EQ(ERROR_NONE, ret);
 471 }
 472
 473 TEST(MtpResponder_t, hdlr_validate_cmd_container_p)
 474 {
 475         int ret = 0;
 476         MtpResponder mtp;
 477
 478         ret = mtp.hdlr_validate_cmd_container();
 479
 480         EXPECT_NE(ERROR_NONE, ret);
 481 }
 482
 483 TEST(MtpResponder_t, hdlr_alloc_buf_data_container_p)
 484 {
 485         int ret = 0;
 486         MtpResponder mtp;
 487
 488         ret = mtp.hdlr_alloc_buf_data_container();
 489
 490         EXPECT_EQ(ERROR_NONE, ret);
 491 }
 492
 493 /*
 494 TEST(MtpResponder_t, hdlr_send_data_container_n)
 495 {
 496         int ret = 0;
 497         MtpResponder mtp;
 498
 499         ret = mtp.hdlr_send_data_container();
 500
 501         EXPECT_EQ(ERROR_NONE, ret);
 502 }
 503
 504 TEST(MtpResponder_t, hdlr_send_bulk_data_n)
 505 {
 506         int ret = 0;
 507         MtpResponder mtp;
 508
 509         ret = mtp.hdlr_send_bulk_data();
 510
 511         EXPECT_EQ(ERROR_NONE, ret);
 512 }
 513 */
 514 TEST(MtpResponder_t, hdlr_rcv_data_container_p)
 515 {
 516         int ret = 0;
 517         MtpResponder mtp;
 518
 519         ret = mtp.hdlr_rcv_data_container();
 520
 521         EXPECT_EQ(ERROR_NONE, ret);
 522 }
 523
 524 TEST(MtpResponder_t, hdlr_get_payload_size_p)
 525 {
 526         int ret = 0;
 527         MtpResponder mtp;
 528
 529         ret = mtp.hdlr_get_payload_size();
 530
 531         EXPECT_EQ(ERROR_NONE, ret);
 532 }
 533
 534 TEST(MtpResponder_t, hdlr_get_payload_data_p)
 535 {
 536         int ret = 0;
 537         MtpResponder mtp;
 538
 539         ret = mtp.hdlr_get_payload_data();
 540
 541         EXPECT_EQ(ERROR_NONE, ret);
 542 }
 543
 544 TEST(MtpResponder_t, hdlr_resp_container_init_p)
 545 {
 546         int ret = 0;
 547         MtpResponder mtp;
 548
 549         ret = mtp.hdlr_resp_container_init();
 550
 551         EXPECT_EQ(ERROR_NONE, ret);
 552 }
 553
 554 TEST(MtpResponder_t, hdlr_init_event_container_p)
 555 {
 556         int ret = 0;
 557         MtpResponder mtp;
 558
 559         ret = mtp.hdlr_init_event_container();
 560
 561         EXPECT_EQ(ERROR_NONE, ret);
 562 }
 563
 564 TEST(MtpResponder_t, hdlr_init_event_container_with_param_p)
 565 {
 566         int ret = 0;
 567         MtpResponder mtp;
 568
 569         ret = mtp.hdlr_init_event_container_with_param();
 570
 571         EXPECT_EQ(ERROR_NONE, ret);
 572 }
 573
 574 TEST(MtpResponder_t, hdlr_conv_cmd_container_byte_order_p)
 575 {
 576         int ret = 0;
 577         MtpResponder mtp;
 578
 579         ret = mtp.hdlr_conv_cmd_container_byte_order();
 580
 581         EXPECT_EQ(ERROR_NONE, ret);
 582 }
 583
 584 TEST(MtpResponder_t, hdlr_conv_data_container_byte_order_p)
 585 {
 586         int ret = 0;
 587         MtpResponder mtp;
 588
 589         ret = mtp.hdlr_conv_data_container_byte_order();
 590
 591         EXPECT_EQ(ERROR_NONE, ret);
 592 }
 593
 594 //mtp_bool _hdlr_rcv_file_in_data_container(data_container_t *dst, mtp_char *filepath, mtp_uint32 path_len);
 595
 596
 597
 598 //========================================
 599
 600 int main(int argc, char **argv)
 601 {
 602 #ifdef TIZEN_TEST_GCOV
 603         setenv("GCOV_PREFIX", "/tmp", 1);
 604 #endif
 605
 606         InitGoogleTest(&argc, argv);
 607         int ret = RUN_ALL_TESTS();
 608
 609 #ifdef TIZEN_TEST_GCOV
 610         __gcov_flush();
 611 #endif
 612         return ret;
 613 }
 614
 615
 616
 617
 618