unittest/gtests_libmm_camcorder.cpp

   1 /*
   2  * Copyright (c) 2018 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
  18 #include <gio/gio.h>
  19 #include "gtests_libmm_camcorder.h"
  20
  21 using namespace std;
  22 using ::testing::InitGoogleTest;
  23 using ::testing::Test;
  24 using ::testing::TestCase;
  25
  26 int g_ret;
  27 int g_frame_count;
  28 MMHandleType g_cam_handle;
  29 MMCamPreset g_info;
  30 GDBusConnection *g_dbus_connection;
  31 GMutex g_lock;
  32 GCond g_capture_cond;
  33 GCond g_focus_cond;
  34
  35 static int _message_callback(int id, void *param, void *user_param)
  36 {
  37         MMMessageParamType *m = (MMMessageParamType *)param;
  38
  39         cout << "[ENTER]" << endl;
  40
  41         switch (id) {
  42         case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
  43                 cout << "[STATE CHANGED] " << m->state.previous << " -> " << m->state.current << endl;
  44                 break;
  45         case MM_MESSAGE_CAMCORDER_CAPTURED:
  46                 cout << "[CAPTURED MESSAGE] SEND SIGNAL" << endl;
  47                 g_mutex_lock(&g_lock);
  48                 g_cond_signal(&g_capture_cond);
  49                 g_mutex_unlock(&g_lock);
  50                 break;
  51         case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
  52                 cout << "[FOCUS CHANGED] SEND SIGNAL" << endl;
  53                 g_mutex_lock(&g_lock);
  54                 g_cond_signal(&g_focus_cond);
  55                 g_mutex_unlock(&g_lock);
  56                 break;
  57         default:
  58                 break;
  59         }
  60
  61         cout << "[LEAVE]" << endl;
  62
  63         return 1;
  64 }
  65
  66 static gboolean _get_video_recording_settings(int *video_encoder, int *audio_encoder, int *file_format)
  67 {
  68         int i = 0;
  69         int j = 0;
  70         int tmp_v_enc;
  71         int tmp_a_enc;
  72         int tmp_fmt;
  73         MMCamAttrsInfo info_a_enc;
  74         MMCamAttrsInfo info_fmt;
  75
  76         if (!video_encoder || !audio_encoder || !file_format) {
  77                 cout << "NULL pointer" << endl;
  78                 return FALSE;
  79         }
  80
  81         /* get supported audio encoder list */
  82         mm_camcorder_get_attribute_info(g_cam_handle, MMCAM_AUDIO_ENCODER, &info_a_enc);
  83
  84         /* get supported file format list */
  85         mm_camcorder_get_attribute_info(g_cam_handle, MMCAM_FILE_FORMAT, &info_fmt);
  86
  87         /* compatibility check */
  88         tmp_v_enc = MM_VIDEO_CODEC_MPEG4;
  89
  90         for (i = 0 ; i < info_fmt.int_array.count ; i++) {
  91                 tmp_fmt = info_fmt.int_array.array[i];
  92                 if (mm_camcorder_check_codec_fileformat_compatibility(MMCAM_VIDEO_ENCODER, tmp_v_enc, tmp_fmt) == MM_ERROR_NONE) {
  93                         for (j = 0 ; info_a_enc.int_array.count ; j++) {
  94                                 tmp_a_enc = info_a_enc.int_array.array[j];
  95                                 if (mm_camcorder_check_codec_fileformat_compatibility(MMCAM_AUDIO_ENCODER, tmp_a_enc, tmp_fmt) == MM_ERROR_NONE) {
  96                                         cout << "[VIDEO RECORDING SETTING FOUND]" << endl;
  97
  98                                         *video_encoder = tmp_v_enc;
  99                                         *audio_encoder = tmp_a_enc;
 100                                         *file_format = tmp_fmt;
 101
 102                                         return TRUE;
 103                                 }
 104                         }
 105                 }
 106         }
 107
 108         cout << "[VIDEO RECORDING SETTING FAILED]" << endl;
 109
 110         return FALSE;
 111 }
 112
 113 static gboolean _get_audio_recording_settings(int *audio_encoder, int *file_format)
 114 {
 115         int i = 0;
 116         int tmp_a_enc;
 117         int tmp_fmt;
 118         MMCamAttrsInfo info_a_enc;
 119         MMCamAttrsInfo info_fmt;
 120
 121         if (!audio_encoder || !file_format) {
 122                 cout << "NULL pointer" << endl;
 123                 return FALSE;
 124         }
 125
 126         /* get supported audio encoder list */
 127         mm_camcorder_get_attribute_info(g_cam_handle, MMCAM_AUDIO_ENCODER, &info_a_enc);
 128
 129         /* get supported file format list */
 130         mm_camcorder_get_attribute_info(g_cam_handle, MMCAM_FILE_FORMAT, &info_fmt);
 131
 132         /* compatibility check */
 133         tmp_a_enc = info_a_enc.int_array.array[0];
 134
 135         for (i = 0 ; i < info_fmt.int_array.count ; i++) {
 136                 tmp_fmt = info_fmt.int_array.array[i];
 137                 if (mm_camcorder_check_codec_fileformat_compatibility(MMCAM_AUDIO_ENCODER, tmp_a_enc, tmp_fmt) == MM_ERROR_NONE) {
 138                         cout << "[AUDIO RECORDING SETTING FOUND]" << endl;
 139
 140                         *audio_encoder = tmp_a_enc;
 141                         *file_format = tmp_fmt;
 142
 143                         return TRUE;
 144                 }
 145         }
 146
 147         cout << "[VIDEO RECORDING SETTING FAILED]" << endl;
 148
 149         return FALSE;
 150 }
 151
 152 static gboolean _video_stream_callback(MMCamcorderVideoStreamDataType *stream, void *user_param)
 153 {
 154         cout << "[VIDEO_STREAM_CALLBACK]" << endl;
 155         return TRUE;
 156 }
 157
 158 static gboolean _audio_stream_callback(MMCamcorderAudioStreamDataType *stream, void *user_param)
 159 {
 160         cout << "[AUDIO_STREAM_CALLBACK]" << endl;
 161         return TRUE;
 162 }
 163
 164 static gboolean _muxed_stream_callback(MMCamcorderMuxedStreamDataType *stream, void *user_param)
 165 {
 166         cout << "[MUXED_STREAM_CALLBACK]" << endl;
 167
 168         g_frame_count++;
 169
 170         return TRUE;
 171 }
 172
 173 static gboolean _video_capture_callback(MMCamcorderCaptureDataType *frame, MMCamcorderCaptureDataType *thumbnail, void *user_data)
 174 {
 175         cout << "[CAPTURE_CALLBACK]" << endl;
 176         return TRUE;
 177 }
 178
 179 static int _start_preview(MMHandleType handle)
 180 {
 181         int ret = MM_ERROR_NONE;
 182
 183         ret = mm_camcorder_realize(handle);
 184         if (ret != MM_ERROR_NONE) {
 185                 cout << "[REALIZE failed]" << endl;
 186                 return ret;
 187         }
 188
 189         ret = mm_camcorder_start(handle);
 190         if (ret != MM_ERROR_NONE) {
 191                 cout << "[START failed]" << endl;
 192                 mm_camcorder_unrealize(handle);
 193         }
 194
 195         return ret;
 196 }
 197
 198 static void _stop_preview(MMHandleType handle)
 199 {
 200         mm_camcorder_stop(handle);
 201         mm_camcorder_unrealize(handle);
 202 }
 203
 204
 205 class MMCamcorderTest : public ::testing::Test {
 206         protected:
 207                 void SetUp() {
 208                         cout << "[SetUp]" << endl;
 209
 210                         if (g_dbus_connection) {
 211                                 g_object_unref(g_dbus_connection);
 212                                 g_dbus_connection = NULL;
 213                         }
 214
 215                         g_dbus_connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
 216
 217                         if (g_cam_handle) {
 218                                 mm_camcorder_destroy(g_cam_handle);
 219                                 g_cam_handle = NULL;
 220                         }
 221
 222                         g_info.videodev_type = MM_VIDEO_DEVICE_CAMERA0;
 223
 224                         g_ret = mm_camcorder_create(&g_cam_handle, &g_info);
 225
 226                         cout << "handle " << g_cam_handle << ", dbus connection " << g_dbus_connection << endl;
 227
 228                         /* set gdbus connection */
 229                         if (g_cam_handle && g_dbus_connection) {
 230                                 mm_camcorder_set_attributes(g_cam_handle, NULL,
 231                                         MMCAM_GDBUS_CONNECTION, g_dbus_connection, 4,
 232                                         NULL);
 233                         }
 234
 235                         /* set message callback */
 236                         if (mm_camcorder_set_message_callback(g_cam_handle, _message_callback, g_cam_handle) != MM_ERROR_NONE)
 237                                 cout << "[FAILED] set message callback" << endl;
 238
 239                         return;
 240                 }
 241
 242                 void TearDown() {
 243                         cout << "[TearDown]" << endl << endl;
 244
 245                         if (g_cam_handle) {
 246                                 mm_camcorder_destroy(g_cam_handle);
 247                                 g_cam_handle = NULL;
 248                         }
 249
 250                         if (g_dbus_connection) {
 251                                 g_object_unref(g_dbus_connection);
 252                                 g_dbus_connection = NULL;
 253                         }
 254
 255                         return;
 256                 }
 257 };
 258
 259 TEST_F(MMCamcorderTest, CreateP)
 260 {
 261         EXPECT_EQ(g_ret, MM_ERROR_NONE);
 262 }
 263
 264 TEST_F(MMCamcorderTest, CreateN)
 265 {
 266         int ret = mm_camcorder_create(NULL, NULL);
 267
 268         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 269 }
 270
 271 TEST_F(MMCamcorderTest, DestroyP)
 272 {
 273         int ret = MM_ERROR_NONE;
 274
 275         ret = mm_camcorder_destroy(g_cam_handle);
 276         ASSERT_EQ(ret, MM_ERROR_NONE);
 277
 278         g_cam_handle = NULL;
 279 }
 280
 281 TEST_F(MMCamcorderTest, DestroyN)
 282 {
 283         int ret = MM_ERROR_NONE;
 284
 285         ret = mm_camcorder_destroy(NULL);
 286         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 287 }
 288
 289 TEST_F(MMCamcorderTest, RealizeP)
 290 {
 291         int ret = MM_ERROR_NONE;
 292
 293         ret = mm_camcorder_realize(g_cam_handle);
 294
 295         ASSERT_EQ(ret, MM_ERROR_NONE);
 296
 297         mm_camcorder_unrealize(g_cam_handle);
 298 }
 299
 300 TEST_F(MMCamcorderTest, RealizeN)
 301 {
 302         int ret = MM_ERROR_NONE;
 303
 304         ret = mm_camcorder_realize(NULL);
 305
 306         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 307 }
 308
 309 TEST_F(MMCamcorderTest, UnrealizeP)
 310 {
 311         int ret = MM_ERROR_NONE;
 312
 313         ret = mm_camcorder_realize(g_cam_handle);
 314
 315         ASSERT_EQ(ret, MM_ERROR_NONE);
 316
 317         ret = mm_camcorder_unrealize(g_cam_handle);
 318         EXPECT_EQ(ret, MM_ERROR_NONE);
 319 }
 320
 321 TEST_F(MMCamcorderTest, UnrealizeN)
 322 {
 323         int ret = MM_ERROR_NONE;
 324
 325         ret = mm_camcorder_realize(g_cam_handle);
 326
 327         ASSERT_EQ(ret, MM_ERROR_NONE);
 328
 329         ret = mm_camcorder_unrealize(NULL);
 330         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 331
 332         mm_camcorder_unrealize(g_cam_handle);
 333 }
 334
 335 TEST_F(MMCamcorderTest, StartP)
 336 {
 337         int ret = MM_ERROR_NONE;
 338
 339         ret = mm_camcorder_realize(g_cam_handle);
 340         ASSERT_EQ(ret, MM_ERROR_NONE);
 341
 342         ret = mm_camcorder_start(g_cam_handle);
 343         EXPECT_EQ(ret, MM_ERROR_NONE);
 344
 345         mm_camcorder_stop(g_cam_handle);
 346         mm_camcorder_unrealize(g_cam_handle);
 347 }
 348
 349 TEST_F(MMCamcorderTest, StartN)
 350 {
 351         int ret = MM_ERROR_NONE;
 352
 353         ret = mm_camcorder_realize(g_cam_handle);
 354         ASSERT_EQ(ret, MM_ERROR_NONE);
 355
 356         ret = mm_camcorder_start(NULL);
 357         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 358
 359         mm_camcorder_unrealize(g_cam_handle);
 360 }
 361
 362 TEST_F(MMCamcorderTest, StopP)
 363 {
 364         int ret = MM_ERROR_NONE;
 365
 366         ret = mm_camcorder_realize(g_cam_handle);
 367         ret |= mm_camcorder_start(g_cam_handle);
 368         EXPECT_EQ(ret, MM_ERROR_NONE);
 369
 370         if (ret == MM_ERROR_NONE) {
 371                 ret = mm_camcorder_stop(g_cam_handle);
 372                 EXPECT_EQ(ret, MM_ERROR_NONE);
 373         }
 374
 375         mm_camcorder_unrealize(g_cam_handle);
 376 }
 377
 378 TEST_F(MMCamcorderTest, StopN)
 379 {
 380         int ret = MM_ERROR_NONE;
 381
 382         ret = mm_camcorder_realize(g_cam_handle);
 383         ret |= mm_camcorder_start(g_cam_handle);
 384         EXPECT_EQ(ret, MM_ERROR_NONE);
 385
 386         if (ret == MM_ERROR_NONE) {
 387                 ret = mm_camcorder_stop(NULL);
 388                 EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 389         }
 390
 391         mm_camcorder_stop(g_cam_handle);
 392         mm_camcorder_unrealize(g_cam_handle);
 393 }
 394
 395 TEST_F(MMCamcorderTest, CaptureStartP)
 396 {
 397         int ret = MM_ERROR_NONE;
 398         gboolean ret_wait = FALSE;
 399         gint64 end_time = 0;
 400
 401         ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 402
 403         g_mutex_lock(&g_lock);
 404
 405         if (mm_camcorder_set_video_capture_callback(g_cam_handle, _video_capture_callback, g_cam_handle) != MM_ERROR_NONE)
 406                 cout << "[FAILED] set video capture callback" << endl;
 407
 408         ret = mm_camcorder_capture_start(g_cam_handle);
 409         EXPECT_EQ(ret, MM_ERROR_NONE);
 410
 411         if (ret == MM_ERROR_NONE) {
 412                 end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
 413
 414                 ret_wait = g_cond_wait_until(&g_capture_cond, &g_lock, end_time);
 415
 416                 EXPECT_EQ(ret_wait, TRUE);
 417
 418                 mm_camcorder_capture_stop(g_cam_handle);
 419         }
 420
 421         g_mutex_unlock(&g_lock);
 422
 423         _stop_preview(g_cam_handle);
 424 }
 425
 426 TEST_F(MMCamcorderTest, CaptureStartN1)
 427 {
 428         int ret = MM_ERROR_NONE;
 429
 430         ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 431
 432         ret = mm_camcorder_capture_start(NULL);
 433         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 434
 435         _stop_preview(g_cam_handle);
 436 }
 437
 438 TEST_F(MMCamcorderTest, CaptureStartN2)
 439 {
 440         int ret = MM_ERROR_NONE;
 441
 442         ret = mm_camcorder_realize(g_cam_handle);
 443         ASSERT_EQ(ret, MM_ERROR_NONE);
 444
 445         ret = mm_camcorder_capture_start(g_cam_handle);
 446         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_STATE);
 447
 448         mm_camcorder_unrealize(g_cam_handle);
 449 }
 450
 451 TEST_F(MMCamcorderTest, CaptureStopP)
 452 {
 453         int ret = MM_ERROR_NONE;
 454         gboolean ret_wait = FALSE;
 455         gint64 end_time = 0;
 456
 457         ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 458
 459         g_mutex_lock(&g_lock);
 460
 461         if (mm_camcorder_set_video_capture_callback(g_cam_handle, _video_capture_callback, g_cam_handle) != MM_ERROR_NONE)
 462                 cout << "[FAILED] set video capture callback" << endl;
 463
 464         ret = mm_camcorder_capture_start(g_cam_handle);
 465         EXPECT_EQ(ret, MM_ERROR_NONE);
 466
 467         if (ret == MM_ERROR_NONE) {
 468                 end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
 469
 470                 ret_wait = g_cond_wait_until(&g_capture_cond, &g_lock, end_time);
 471
 472                 EXPECT_EQ(ret_wait, TRUE);
 473
 474                 ret = mm_camcorder_capture_stop(g_cam_handle);
 475                 EXPECT_EQ(ret, MM_ERROR_NONE);
 476         }
 477
 478         g_mutex_unlock(&g_lock);
 479
 480         _stop_preview(g_cam_handle);
 481 }
 482
 483 TEST_F(MMCamcorderTest, SetMessageCallbackP)
 484 {
 485         int ret = MM_ERROR_NONE;
 486
 487         ret = mm_camcorder_set_message_callback(g_cam_handle, _message_callback, g_cam_handle);
 488         EXPECT_EQ(ret, MM_ERROR_NONE);
 489 }
 490
 491 TEST_F(MMCamcorderTest, SetMessageCallbackN)
 492 {
 493         int ret = MM_ERROR_NONE;
 494
 495         ret = mm_camcorder_set_message_callback(NULL, _message_callback, g_cam_handle);
 496         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 497 }
 498
 499 TEST_F(MMCamcorderTest, SetVideoStreamCallbackP)
 500 {
 501         int ret = MM_ERROR_NONE;
 502
 503         ret = mm_camcorder_set_video_stream_callback(g_cam_handle, _video_stream_callback, g_cam_handle);
 504         EXPECT_EQ(ret, MM_ERROR_NONE);
 505 }
 506
 507 TEST_F(MMCamcorderTest, SetVideoStreamCallbackN)
 508 {
 509         int ret = MM_ERROR_NONE;
 510
 511         ret = mm_camcorder_set_video_stream_callback(NULL, _video_stream_callback, g_cam_handle);
 512         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 513 }
 514
 515 TEST_F(MMCamcorderTest, SetAudioStreamCallbackP)
 516 {
 517         int ret = MM_ERROR_NONE;
 518
 519         ret = mm_camcorder_set_audio_stream_callback(g_cam_handle, _audio_stream_callback, g_cam_handle);
 520         EXPECT_EQ(ret, MM_ERROR_NONE);
 521 }
 522
 523 TEST_F(MMCamcorderTest, SetAudioStreamCallbackN)
 524 {
 525         int ret = MM_ERROR_NONE;
 526
 527         ret = mm_camcorder_set_audio_stream_callback(NULL, _audio_stream_callback, g_cam_handle);
 528         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 529 }
 530
 531 TEST_F(MMCamcorderTest, SetVideoCaptureCallbackP)
 532 {
 533         int ret = MM_ERROR_NONE;
 534
 535         ret = mm_camcorder_set_video_capture_callback(g_cam_handle, _video_capture_callback, g_cam_handle);
 536         EXPECT_EQ(ret, MM_ERROR_NONE);
 537 }
 538
 539 TEST_F(MMCamcorderTest, SetVideoCaptureCallbackN)
 540 {
 541         int ret = MM_ERROR_NONE;
 542
 543         ret = mm_camcorder_set_video_capture_callback(NULL, _video_capture_callback, g_cam_handle);
 544         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 545 }
 546
 547 TEST_F(MMCamcorderTest, SetMuxedStreamCallbackP)
 548 {
 549         int ret = MM_ERROR_NONE;
 550
 551         ret = mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle);
 552         EXPECT_EQ(ret, MM_ERROR_NONE);
 553 }
 554
 555 TEST_F(MMCamcorderTest, SetMuxedStreamCallbackN)
 556 {
 557         int ret = MM_ERROR_NONE;
 558
 559         ret = mm_camcorder_set_muxed_stream_callback(NULL, _muxed_stream_callback, g_cam_handle);
 560         EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 561 }
 562
 563 TEST_F(MMCamcorderTest, RecordP)
 564 {
 565         int ret = MM_ERROR_NONE;
 566         int video_encoder = 0;
 567         int audio_encoder = 0;
 568         int file_format = 0;
 569         gboolean ret_settings = FALSE;
 570
 571         ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 572
 573         g_frame_count = 0;
 574
 575         if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
 576                 cout << "[FAILED] set muxed stream callback" << endl;
 577
 578         ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
 579         EXPECT_EQ(ret_settings, TRUE);
 580
 581         ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
 582                 MMCAM_VIDEO_ENCODER, video_encoder,
 583                 MMCAM_AUDIO_ENCODER, audio_encoder,
 584                 MMCAM_FILE_FORMAT, file_format,
 585                 NULL);
 586         EXPECT_EQ(ret, MM_ERROR_NONE);
 587
 588         ret = mm_camcorder_record(g_cam_handle);
 589         EXPECT_EQ(ret, MM_ERROR_NONE);
 590
 591         if (ret == MM_ERROR_NONE) {
 592                 sleep(5);
 593
 594                 EXPECT_EQ(g_frame_count > 30, TRUE);
 595
 596                 mm_camcorder_cancel(g_cam_handle);
 597         }
 598
 599         _stop_preview(g_cam_handle);
 600 }
 601
 602 TEST_F(MMCamcorderTest, CommitP)
 603 {
 604         int ret = MM_ERROR_NONE;
 605         int video_encoder = 0;
 606         int audio_encoder = 0;
 607         int file_format = 0;
 608         gboolean ret_settings = FALSE;
 609
 610         ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 611
 612         if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
 613                 cout << "[FAILED] set muxed stream callback" << endl;
 614
 615         ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
 616         EXPECT_EQ(ret_settings, TRUE);
 617
 618         ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
 619                 MMCAM_VIDEO_ENCODER, video_encoder,
 620                 MMCAM_AUDIO_ENCODER, audio_encoder,
 621                 MMCAM_FILE_FORMAT, file_format,
 622                 NULL);
 623         EXPECT_EQ(ret, MM_ERROR_NONE);
 624
 625         ret = mm_camcorder_record(g_cam_handle);
 626         EXPECT_EQ(ret, MM_ERROR_NONE);
 627
 628         if (ret == MM_ERROR_NONE) {
 629                 sleep(5);
 630                 ret = mm_camcorder_commit(g_cam_handle);
 631                 EXPECT_EQ(ret, MM_ERROR_NONE);
 632         }
 633
 634         _stop_preview(g_cam_handle);
 635 }
 636
 637 TEST_F(MMCamcorderTest, CancelP)
 638 {
 639         int ret = MM_ERROR_NONE;
 640         int video_encoder = 0;
 641         int audio_encoder = 0;
 642         int file_format = 0;
 643         gboolean ret_settings = FALSE;
 644
 645         ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 646
 647         if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
 648                 cout << "[FAILED] set muxed stream callback" << endl;
 649
 650         ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
 651         EXPECT_EQ(ret_settings, TRUE);
 652
 653         ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
 654                 MMCAM_VIDEO_ENCODER, video_encoder,
 655                 MMCAM_AUDIO_ENCODER, audio_encoder,
 656                 MMCAM_FILE_FORMAT, file_format,
 657                 NULL);
 658         EXPECT_EQ(ret, MM_ERROR_NONE);
 659
 660         ret = mm_camcorder_record(g_cam_handle);
 661         EXPECT_EQ(ret, MM_ERROR_NONE);
 662
 663         if (ret == MM_ERROR_NONE) {
 664                 ret = mm_camcorder_cancel(g_cam_handle);
 665                 EXPECT_EQ(ret, MM_ERROR_NONE);
 666         }
 667
 668         _stop_preview(g_cam_handle);
 669 }
 670
 671 TEST_F(MMCamcorderTest, PauseP)
 672 {
 673         int ret = MM_ERROR_NONE;
 674         int video_encoder = 0;
 675         int audio_encoder = 0;
 676         int file_format = 0;
 677         gboolean ret_settings = FALSE;
 678
 679         ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 680
 681         if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
 682                 cout << "[FAILED] set muxed stream callback" << endl;
 683
 684         ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
 685         EXPECT_EQ(ret_settings, TRUE);
 686
 687         ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
 688                 MMCAM_VIDEO_ENCODER, video_encoder,
 689                 MMCAM_AUDIO_ENCODER, audio_encoder,
 690                 MMCAM_FILE_FORMAT, file_format,
 691                 NULL);
 692         EXPECT_EQ(ret, MM_ERROR_NONE);
 693
 694         ret = mm_camcorder_record(g_cam_handle);
 695         EXPECT_EQ(ret, MM_ERROR_NONE);
 696
 697         if (ret == MM_ERROR_NONE) {
 698                 sleep(5);
 699
 700                 ret = mm_camcorder_pause(g_cam_handle);
 701                 EXPECT_EQ(ret, MM_ERROR_NONE);
 702
 703                 mm_camcorder_cancel(g_cam_handle);
 704         }
 705
 706         _stop_preview(g_cam_handle);
 707 }
 708
 709 TEST_F(MMCamcorderTest, GetStateP)
 710 {
 711         int ret = MM_ERROR_NONE;
 712         MMCamcorderStateType state = MM_CAMCORDER_STATE_NONE;
 713
 714         ret = mm_camcorder_get_state(g_cam_handle, &state);
 715         ASSERT_EQ(ret, MM_ERROR_NONE);
 716 }
 717
 718 TEST_F(MMCamcorderTest, GetState2P)
 719 {
 720         int ret = MM_ERROR_NONE;
 721         MMCamcorderStateType state = MM_CAMCORDER_STATE_NONE;
 722         MMCamcorderStateType old_state = MM_CAMCORDER_STATE_NONE;
 723
 724         ret = mm_camcorder_get_state2(g_cam_handle, &state, &old_state);
 725         ASSERT_EQ(ret, MM_ERROR_NONE);
 726 }
 727
 728 TEST_F(MMCamcorderTest, GetAttributesP)
 729 {
 730         int ret = MM_ERROR_NONE;
 731         int device_count = 0;
 732         int audio_device = 0;
 733
 734         ret = mm_camcorder_get_attributes(g_cam_handle, NULL,
 735                 MMCAM_CAMERA_DEVICE_COUNT, &device_count,
 736                 MMCAM_AUDIO_DEVICE, &audio_device,
 737                 NULL);
 738         ASSERT_EQ(ret, MM_ERROR_NONE);
 739 }
 740
 741 TEST_F(MMCamcorderTest, SetAttributesP)
 742 {
 743         int ret = MM_ERROR_NONE;
 744         int audio_encoder = 0;
 745         int file_format = 0;
 746         gboolean ret_settings = FALSE;
 747
 748         ret_settings = _get_audio_recording_settings(&audio_encoder, &file_format);
 749         ASSERT_EQ(ret_settings, TRUE);
 750
 751         ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
 752                 MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
 753                 MMCAM_AUDIO_ENCODER, audio_encoder,
 754                 MMCAM_FILE_FORMAT, file_format,
 755                 NULL);
 756         ASSERT_EQ(ret, MM_ERROR_NONE);
 757 }
 758
 759 TEST_F(MMCamcorderTest, GetAttributeInfoP)
 760 {
 761         int ret = MM_ERROR_NONE;
 762         MMCamAttrsInfo info;
 763
 764         ret = mm_camcorder_get_attribute_info(g_cam_handle, MMCAM_MODE, &info);
 765         ASSERT_EQ(ret, MM_ERROR_NONE);
 766 }
 767
 768 TEST_F(MMCamcorderTest, GetFPSListByResolutionP)
 769 {
 770         int ret = MM_ERROR_NONE;
 771         int width = 0;
 772         int height = 0;
 773         MMCamAttrsInfo fps_info;
 774
 775         ret = mm_camcorder_get_attributes(g_cam_handle, NULL,
 776                 MMCAM_CAMERA_WIDTH, &width,
 777                 MMCAM_CAMERA_HEIGHT, &height,
 778                 NULL);
 779         ASSERT_EQ(ret, MM_ERROR_NONE);
 780
 781         ret = mm_camcorder_get_fps_list_by_resolution(g_cam_handle, width, height, &fps_info);
 782         ASSERT_EQ(ret, MM_ERROR_NONE);
 783 }
 784
 785 TEST_F(MMCamcorderTest, InitFocsingP)
 786 {
 787         ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 788
 789         EXPECT_EQ(mm_camcorder_init_focusing(g_cam_handle), MM_ERROR_NONE);
 790
 791         _stop_preview(g_cam_handle);
 792 }
 793
 794 TEST_F(MMCamcorderTest, StartFocusingP)
 795 {
 796         gint64 end_time = 0;
 797
 798         ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 799
 800         g_mutex_lock(&g_lock);
 801
 802         EXPECT_EQ(mm_camcorder_start_focusing(g_cam_handle), MM_ERROR_NONE);
 803
 804         end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
 805
 806         EXPECT_EQ(g_cond_wait_until(&g_focus_cond, &g_lock, end_time), TRUE);
 807
 808         g_mutex_unlock(&g_lock);
 809
 810         _stop_preview(g_cam_handle);
 811 }
 812
 813 TEST_F(MMCamcorderTest, StopFocusingP)
 814 {
 815         ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 816
 817         EXPECT_EQ(mm_camcorder_start_focusing(g_cam_handle), MM_ERROR_NONE);
 818         EXPECT_EQ(mm_camcorder_stop_focusing(g_cam_handle), MM_ERROR_NONE);
 819
 820         _stop_preview(g_cam_handle);
 821 }
 822
 823
 824 int main(int argc, char **argv)
 825 {
 826         InitGoogleTest(&argc, argv);
 827
 828         return RUN_ALL_TESTS();
 829 }