From: Jeongmo Yang Date: Fri, 30 Nov 2018 07:51:22 +0000 (+0900) Subject: Update unit test X-Git-Tag: accepted/tizen/unified/20181207.061536~1 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fmultimedia%2Flibmm-camcorder.git;a=commitdiff_plain;h=0a6610ad1802f60020bb26dfc70465689500dade;hp=f5c70f11c4a90aa9d9ac0b621405e8023d48bbe1 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 --- diff --git a/packaging/libmm-camcorder.spec b/packaging/libmm-camcorder.spec index 9a8abbd..c3dba0a 100644 --- 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 --- 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); }