Update unit test

[Version] 0.10.174
[Profile] Common
[Issue Type] Update
[Dependency module] N/A
[Test] [M(T) - Boot=(OK), sdb=(OK), Home=(OK), Touch=(OK), Version=tizen-unified_20181126.2]

Change-Id: Ic4ff7f830aa21ff5d304c8ea537bbe6f80f220f4
Signed-off-by: Jeongmo Yang <jm80.yang@samsung.com>

diff --git a/packaging/libmm-camcorder.spec b/packaging/libmm-camcorder.spec
index 9a8abbd..c3dba0a 100644 (file)
--- a/packaging/libmm-camcorder.spec
+++ b/packaging/libmm-camcorder.spec
@@ -1,6 +1,6 @@
 Name:       libmm-camcorder
 Summary:    Camera and recorder library
-Version:    0.10.173
+Version:    0.10.174
 Release:    0
 Group:      Multimedia/Libraries
 License:    Apache-2.0

diff --git a/unittest/gtests_libmm_camcorder.cpp b/unittest/gtests_libmm_camcorder.cpp
index e98032c..4632b0c 100644 (file)
--- a/unittest/gtests_libmm_camcorder.cpp
+++ b/unittest/gtests_libmm_camcorder.cpp
@@ -28,8 +28,40 @@ int g_frame_count;
 MMHandleType g_cam_handle;
 MMCamPreset g_info;
 GDBusConnection *g_dbus_connection;
-GMutex g_msg_lock;
-GCond g_msg_cond;
+GMutex g_lock;
+GCond g_capture_cond;
+GCond g_focus_cond;
+
+static int _message_callback(int id, void *param, void *user_param)
+{
+       MMMessageParamType *m = (MMMessageParamType *)param;
+
+       cout << "[ENTER]" << endl;
+
+       switch (id) {
+       case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
+               cout << "[STATE CHANGED] " << m->state.previous << " -> " << m->state.current << endl;
+               break;
+       case MM_MESSAGE_CAMCORDER_CAPTURED:
+               cout << "[CAPTURED MESSAGE] SEND SIGNAL" << endl;
+               g_mutex_lock(&g_lock);
+               g_cond_signal(&g_capture_cond);
+               g_mutex_unlock(&g_lock);
+               break;
+       case MM_MESSAGE_CAMCORDER_FOCUS_CHANGED:
+               cout << "[FOCUS CHANGED] SEND SIGNAL" << endl;
+               g_mutex_lock(&g_lock);
+               g_cond_signal(&g_focus_cond);
+               g_mutex_unlock(&g_lock);
+               break;
+       default:
+               break;
+       }
+
+       cout << "[LEAVE]" << endl;
+
+       return 1;
+}
 
 static gboolean _get_video_recording_settings(int *video_encoder, int *audio_encoder, int *file_format)
 {
@@ -117,30 +149,15 @@ static gboolean _get_audio_recording_settings(int *audio_encoder, int *file_form
        return FALSE;
 }
 
-static int _message_callback(int id, void *param, void *user_param)
+static gboolean _video_stream_callback(MMCamcorderVideoStreamDataType *stream, void *user_param)
 {
-       MMMessageParamType *m = (MMMessageParamType *)param;
-
-       switch (id) {
-       case MM_MESSAGE_CAMCORDER_STATE_CHANGED:
-               cout << "[STATE CHANGED] " << m->state.previous << " -> " << m->state.current << endl;
-               break;
-       case MM_MESSAGE_CAMCORDER_CAPTURED:
-               cout << "[CAPTURED MESSAGE] SEND SIGNAL" << endl;
-               g_mutex_lock(&g_msg_lock);
-               g_cond_signal(&g_msg_cond);
-               g_mutex_unlock(&g_msg_lock);
-               break;
-       default:
-               break;
-       }
-
-       return 1;
+       cout << "[VIDEO_STREAM_CALLBACK]" << endl;
+       return TRUE;
 }
 
-static gboolean _video_stream_callback(MMCamcorderVideoStreamDataType *stream, void *user_param)
+static gboolean _audio_stream_callback(MMCamcorderAudioStreamDataType *stream, void *user_param)
 {
-       cout << "[VIDEO_STREAM_CALLBACK]" << endl;
+       cout << "[AUDIO_STREAM_CALLBACK]" << endl;
        return TRUE;
 }
 
@@ -148,17 +165,8 @@ static gboolean _muxed_stream_callback(MMCamcorderMuxedStreamDataType *stream, v
 {
        cout << "[MUXED_STREAM_CALLBACK]" << endl;
 
-       g_mutex_lock(&g_msg_lock);
-
        g_frame_count++;
 
-       if (g_frame_count > 10) {
-               cout << "[MUXED_STREAM_CALLBACK] SEND SIGNAL" << endl;
-               g_cond_signal(&g_msg_cond);
-       }
-
-       g_mutex_unlock(&g_msg_lock);
-
        return TRUE;
 }
 
@@ -168,6 +176,31 @@ static gboolean _video_capture_callback(MMCamcorderCaptureDataType *frame, MMCam
        return TRUE;
 }
 
+static int _start_preview(MMHandleType handle)
+{
+       int ret = MM_ERROR_NONE;
+
+       ret = mm_camcorder_realize(handle);
+       if (ret != MM_ERROR_NONE) {
+               cout << "[REALIZE failed]" << endl;
+               return ret;
+       }
+
+       ret = mm_camcorder_start(handle);
+       if (ret != MM_ERROR_NONE) {
+               cout << "[START failed]" << endl;
+               mm_camcorder_unrealize(handle);
+       }
+
+       return ret;
+}
+
+static void _stop_preview(MMHandleType handle)
+{
+       mm_camcorder_stop(handle);
+       mm_camcorder_unrealize(handle);
+}
+
 
 class MMCamcorderTest : public ::testing::Test {
        protected:
@@ -365,51 +398,41 @@ TEST_F(MMCamcorderTest, CaptureStartP)
        gboolean ret_wait = FALSE;
        gint64 end_time = 0;
 
-       ret = mm_camcorder_realize(g_cam_handle);
-       ret |= mm_camcorder_start(g_cam_handle);
-       EXPECT_EQ(ret, MM_ERROR_NONE);
-
-       if (ret == MM_ERROR_NONE) {
-               g_mutex_lock(&g_msg_lock);
+       ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 
-               if (mm_camcorder_set_video_capture_callback(g_cam_handle, _video_capture_callback, g_cam_handle) != MM_ERROR_NONE)
-                       cout << "[FAILED] set video capture callback" << endl;
+       g_mutex_lock(&g_lock);
 
-               ret = mm_camcorder_capture_start(g_cam_handle);
-               EXPECT_EQ(ret, MM_ERROR_NONE);
+       if (mm_camcorder_set_video_capture_callback(g_cam_handle, _video_capture_callback, g_cam_handle) != MM_ERROR_NONE)
+               cout << "[FAILED] set video capture callback" << endl;
 
-               if (ret == MM_ERROR_NONE) {
-                       end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
+       ret = mm_camcorder_capture_start(g_cam_handle);
+       EXPECT_EQ(ret, MM_ERROR_NONE);
 
-                       ret_wait = g_cond_wait_until(&g_msg_cond, &g_msg_lock, end_time);
+       if (ret == MM_ERROR_NONE) {
+               end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
 
-                       EXPECT_EQ(ret_wait, TRUE);
+               ret_wait = g_cond_wait_until(&g_capture_cond, &g_lock, end_time);
 
-                       mm_camcorder_capture_stop(g_cam_handle);
-               }
+               EXPECT_EQ(ret_wait, TRUE);
 
-               g_mutex_unlock(&g_msg_lock);
+               mm_camcorder_capture_stop(g_cam_handle);
        }
 
-       mm_camcorder_stop(g_cam_handle);
-       mm_camcorder_unrealize(g_cam_handle);
+       g_mutex_unlock(&g_lock);
+
+       _stop_preview(g_cam_handle);
 }
 
 TEST_F(MMCamcorderTest, CaptureStartN1)
 {
        int ret = MM_ERROR_NONE;
 
-       ret = mm_camcorder_realize(g_cam_handle);
-       ret |= mm_camcorder_start(g_cam_handle);
-       EXPECT_EQ(ret, MM_ERROR_NONE);
+       ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 
-       if (ret == MM_ERROR_NONE) {
-               ret = mm_camcorder_capture_start(NULL);
-               EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
-       }
+       ret = mm_camcorder_capture_start(NULL);
+       EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 
-       mm_camcorder_stop(g_cam_handle);
-       mm_camcorder_unrealize(g_cam_handle);
+       _stop_preview(g_cam_handle);
 }
 
 TEST_F(MMCamcorderTest, CaptureStartN2)
@@ -425,6 +448,38 @@ TEST_F(MMCamcorderTest, CaptureStartN2)
        mm_camcorder_unrealize(g_cam_handle);
 }
 
+TEST_F(MMCamcorderTest, CaptureStopP)
+{
+       int ret = MM_ERROR_NONE;
+       gboolean ret_wait = FALSE;
+       gint64 end_time = 0;
+
+       ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+       g_mutex_lock(&g_lock);
+
+       if (mm_camcorder_set_video_capture_callback(g_cam_handle, _video_capture_callback, g_cam_handle) != MM_ERROR_NONE)
+               cout << "[FAILED] set video capture callback" << endl;
+
+       ret = mm_camcorder_capture_start(g_cam_handle);
+       EXPECT_EQ(ret, MM_ERROR_NONE);
+
+       if (ret == MM_ERROR_NONE) {
+               end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
+
+               ret_wait = g_cond_wait_until(&g_capture_cond, &g_lock, end_time);
+
+               EXPECT_EQ(ret_wait, TRUE);
+
+               ret = mm_camcorder_capture_stop(g_cam_handle);
+               EXPECT_EQ(ret, MM_ERROR_NONE);
+       }
+
+       g_mutex_unlock(&g_lock);
+
+       _stop_preview(g_cam_handle);
+}
+
 TEST_F(MMCamcorderTest, SetMessageCallbackP)
 {
        int ret = MM_ERROR_NONE;
@@ -457,6 +512,22 @@ TEST_F(MMCamcorderTest, SetVideoStreamCallbackN)
        EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
 }
 
+TEST_F(MMCamcorderTest, SetAudioStreamCallbackP)
+{
+       int ret = MM_ERROR_NONE;
+
+       ret = mm_camcorder_set_audio_stream_callback(g_cam_handle, _audio_stream_callback, g_cam_handle);
+       EXPECT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, SetAudioStreamCallbackN)
+{
+       int ret = MM_ERROR_NONE;
+
+       ret = mm_camcorder_set_audio_stream_callback(NULL, _audio_stream_callback, g_cam_handle);
+       EXPECT_EQ(ret, MM_ERROR_CAMCORDER_INVALID_ARGUMENT);
+}
+
 TEST_F(MMCamcorderTest, SetVideoCaptureCallbackP)
 {
        int ret = MM_ERROR_NONE;
@@ -496,50 +567,257 @@ TEST_F(MMCamcorderTest, RecordP)
        int audio_encoder = 0;
        int file_format = 0;
        gboolean ret_settings = FALSE;
-       gboolean ret_wait = FALSE;
-       gint64 end_time = 0;
 
-       ret = mm_camcorder_realize(g_cam_handle);
-       ret |= mm_camcorder_start(g_cam_handle);
+       ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+       g_frame_count = 0;
+
+       if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
+               cout << "[FAILED] set muxed stream callback" << endl;
+
+       ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
+       EXPECT_EQ(ret_settings, TRUE);
+
+       ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
+               MMCAM_VIDEO_ENCODER, video_encoder,
+               MMCAM_AUDIO_ENCODER, audio_encoder,
+               MMCAM_FILE_FORMAT, file_format,
+               NULL);
+       EXPECT_EQ(ret, MM_ERROR_NONE);
+
+       ret = mm_camcorder_record(g_cam_handle);
        EXPECT_EQ(ret, MM_ERROR_NONE);
 
        if (ret == MM_ERROR_NONE) {
-               g_mutex_lock(&g_msg_lock);
+               sleep(5);
+
+               EXPECT_EQ(g_frame_count > 30, TRUE);
+
+               mm_camcorder_cancel(g_cam_handle);
+       }
+
+       _stop_preview(g_cam_handle);
+}
+
+TEST_F(MMCamcorderTest, CommitP)
+{
+       int ret = MM_ERROR_NONE;
+       int video_encoder = 0;
+       int audio_encoder = 0;
+       int file_format = 0;
+       gboolean ret_settings = FALSE;
+
+       ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 
-               g_frame_count = 0;
+       if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
+               cout << "[FAILED] set muxed stream callback" << endl;
 
-               if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
-                       cout << "[FAILED] set video capture callback" << endl;
+       ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
+       EXPECT_EQ(ret_settings, TRUE);
 
-               ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
-               EXPECT_EQ(ret_settings, TRUE);
+       ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
+               MMCAM_VIDEO_ENCODER, video_encoder,
+               MMCAM_AUDIO_ENCODER, audio_encoder,
+               MMCAM_FILE_FORMAT, file_format,
+               NULL);
+       EXPECT_EQ(ret, MM_ERROR_NONE);
 
-               ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
-                       MMCAM_VIDEO_ENCODER, video_encoder,
-                       MMCAM_AUDIO_ENCODER, audio_encoder,
-                       MMCAM_FILE_FORMAT, file_format,
-                       NULL);
+       ret = mm_camcorder_record(g_cam_handle);
+       EXPECT_EQ(ret, MM_ERROR_NONE);
 
-               ret = mm_camcorder_record(g_cam_handle);
+       if (ret == MM_ERROR_NONE) {
+               sleep(5);
+               ret = mm_camcorder_commit(g_cam_handle);
                EXPECT_EQ(ret, MM_ERROR_NONE);
+       }
 
-               if (ret == MM_ERROR_NONE) {
-                       end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
+       _stop_preview(g_cam_handle);
+}
 
-                       ret_wait = g_cond_wait_until(&g_msg_cond, &g_msg_lock, end_time);
+TEST_F(MMCamcorderTest, CancelP)
+{
+       int ret = MM_ERROR_NONE;
+       int video_encoder = 0;
+       int audio_encoder = 0;
+       int file_format = 0;
+       gboolean ret_settings = FALSE;
 
-                       cout << "[RECORDING] SIGNAL RECEIVED : " << ret_wait << endl;
+       ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
 
-                       EXPECT_EQ(ret_wait, TRUE);
+       if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
+               cout << "[FAILED] set muxed stream callback" << endl;
 
-                       mm_camcorder_cancel(g_cam_handle);
-               }
+       ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
+       EXPECT_EQ(ret_settings, TRUE);
+
+       ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
+               MMCAM_VIDEO_ENCODER, video_encoder,
+               MMCAM_AUDIO_ENCODER, audio_encoder,
+               MMCAM_FILE_FORMAT, file_format,
+               NULL);
+       EXPECT_EQ(ret, MM_ERROR_NONE);
+
+       ret = mm_camcorder_record(g_cam_handle);
+       EXPECT_EQ(ret, MM_ERROR_NONE);
 
-               g_mutex_unlock(&g_msg_lock);
+       if (ret == MM_ERROR_NONE) {
+               ret = mm_camcorder_cancel(g_cam_handle);
+               EXPECT_EQ(ret, MM_ERROR_NONE);
        }
 
-       mm_camcorder_stop(g_cam_handle);
-       mm_camcorder_unrealize(g_cam_handle);
+       _stop_preview(g_cam_handle);
+}
+
+TEST_F(MMCamcorderTest, PauseP)
+{
+       int ret = MM_ERROR_NONE;
+       int video_encoder = 0;
+       int audio_encoder = 0;
+       int file_format = 0;
+       gboolean ret_settings = FALSE;
+
+       ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+       if (mm_camcorder_set_muxed_stream_callback(g_cam_handle, _muxed_stream_callback, g_cam_handle) != MM_ERROR_NONE)
+               cout << "[FAILED] set muxed stream callback" << endl;
+
+       ret_settings = _get_video_recording_settings(&video_encoder, &audio_encoder, &file_format);
+       EXPECT_EQ(ret_settings, TRUE);
+
+       ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
+               MMCAM_VIDEO_ENCODER, video_encoder,
+               MMCAM_AUDIO_ENCODER, audio_encoder,
+               MMCAM_FILE_FORMAT, file_format,
+               NULL);
+       EXPECT_EQ(ret, MM_ERROR_NONE);
+
+       ret = mm_camcorder_record(g_cam_handle);
+       EXPECT_EQ(ret, MM_ERROR_NONE);
+
+       if (ret == MM_ERROR_NONE) {
+               sleep(5);
+
+               ret = mm_camcorder_pause(g_cam_handle);
+               EXPECT_EQ(ret, MM_ERROR_NONE);
+
+               mm_camcorder_cancel(g_cam_handle);
+       }
+
+       _stop_preview(g_cam_handle);
+}
+
+TEST_F(MMCamcorderTest, GetStateP)
+{
+       int ret = MM_ERROR_NONE;
+       MMCamcorderStateType state = MM_CAMCORDER_STATE_NONE;
+
+       ret = mm_camcorder_get_state(g_cam_handle, &state);
+       ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, GetState2P)
+{
+       int ret = MM_ERROR_NONE;
+       MMCamcorderStateType state = MM_CAMCORDER_STATE_NONE;
+       MMCamcorderStateType old_state = MM_CAMCORDER_STATE_NONE;
+
+       ret = mm_camcorder_get_state2(g_cam_handle, &state, &old_state);
+       ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, GetAttributesP)
+{
+       int ret = MM_ERROR_NONE;
+       int device_count = 0;
+       int audio_device = 0;
+
+       ret = mm_camcorder_get_attributes(g_cam_handle, NULL,
+               MMCAM_CAMERA_DEVICE_COUNT, &device_count,
+               MMCAM_AUDIO_DEVICE, &audio_device,
+               NULL);
+       ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, SetAttributesP)
+{
+       int ret = MM_ERROR_NONE;
+       int audio_encoder = 0;
+       int file_format = 0;
+       gboolean ret_settings = FALSE;
+
+       ret_settings = _get_audio_recording_settings(&audio_encoder, &file_format);
+       ASSERT_EQ(ret_settings, TRUE);
+
+       ret = mm_camcorder_set_attributes(g_cam_handle, NULL,
+               MMCAM_MODE, MM_CAMCORDER_MODE_AUDIO,
+               MMCAM_AUDIO_ENCODER, audio_encoder,
+               MMCAM_FILE_FORMAT, file_format,
+               NULL);
+       ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, GetAttributeInfoP)
+{
+       int ret = MM_ERROR_NONE;
+       MMCamAttrsInfo info;
+
+       ret = mm_camcorder_get_attribute_info(g_cam_handle, MMCAM_MODE, &info);
+       ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, GetFPSListByResolutionP)
+{
+       int ret = MM_ERROR_NONE;
+       int width = 0;
+       int height = 0;
+       MMCamAttrsInfo fps_info;
+
+       ret = mm_camcorder_get_attributes(g_cam_handle, NULL,
+               MMCAM_CAMERA_WIDTH, &width,
+               MMCAM_CAMERA_HEIGHT, &height,
+               NULL);
+       ASSERT_EQ(ret, MM_ERROR_NONE);
+
+       ret = mm_camcorder_get_fps_list_by_resolution(g_cam_handle, width, height, &fps_info);
+       ASSERT_EQ(ret, MM_ERROR_NONE);
+}
+
+TEST_F(MMCamcorderTest, InitFocsingP)
+{
+       ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+       EXPECT_EQ(mm_camcorder_init_focusing(g_cam_handle), MM_ERROR_NONE);
+
+       _stop_preview(g_cam_handle);
+}
+
+TEST_F(MMCamcorderTest, StartFocusingP)
+{
+       gint64 end_time = 0;
+
+       ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+       g_mutex_lock(&g_lock);
+
+       EXPECT_EQ(mm_camcorder_start_focusing(g_cam_handle), MM_ERROR_NONE);
+
+       end_time = g_get_monotonic_time() + 3 * G_TIME_SPAN_SECOND;
+
+       EXPECT_EQ(g_cond_wait_until(&g_focus_cond, &g_lock, end_time), TRUE);
+
+       g_mutex_unlock(&g_lock);
+
+       _stop_preview(g_cam_handle);
+}
+
+TEST_F(MMCamcorderTest, StopFocusingP)
+{
+       ASSERT_EQ(_start_preview(g_cam_handle), MM_ERROR_NONE);
+
+       EXPECT_EQ(mm_camcorder_start_focusing(g_cam_handle), MM_ERROR_NONE);
+       EXPECT_EQ(mm_camcorder_stop_focusing(g_cam_handle), MM_ERROR_NONE);
+
+       _stop_preview(g_cam_handle);
 }