Patch for coverage

Change-Id: I0fbd522e8329acc848ab7dbf0abd482809b01999

diff --git a/src/audio_io.c b/src/audio_io.c
index f855abc..7a5d1d0 100644 (file)
--- a/src/audio_io.c
+++ b/src/audio_io.c
@@ -119,7 +119,6 @@ int audio_in_unset_state_changed_cb(audio_in_h input)
        return cpp_audio_in_unset_state_changed_cb(input);
 }
 
-
 /* Audio Out */
 int audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sample_type_e type, audio_out_h *output)
 {

diff --git a/src/cpp/CAudioError.cpp b/src/cpp/CAudioError.cpp
index b25a63d..655c34f 100644 (file)
--- a/src/cpp/CAudioError.cpp
+++ b/src/cpp/CAudioError.cpp
@@ -30,6 +30,7 @@ using namespace tizen_media_audio;
 CAudioError::EError CAudioError::__mLastError = CAudioError::EError::ERROR_NONE;
 char CAudioError::__mLastErrorMsg[CAudioError::MSG_LENGTH];
 
+//LCOV_EXCL_START
 CAudioError::CAudioError(EError err) :
     __mError(err) {
     __mLastError = __mError;
@@ -51,6 +52,7 @@ CAudioError::CAudioError(EError err, const char* fileName, const char* parentFun
 
     snprintf(__mLastErrorMsg, CAudioError::MSG_LENGTH, "LastError:%s", __mErrorMsg);
 }
+//LCOV_EXCL_STOP
 
 CAudioError::CAudioError(EError err, const char* msg, const char* fileName, const char* parentFunc, int lineNum) :
     __mError(err) {
@@ -71,10 +73,12 @@ CAudioError::CAudioError(EError err, const char* msg, const char* fileName, cons
     snprintf(__mLastErrorMsg, CAudioError::MSG_LENGTH, "LastError:%s", __mErrorMsg);
 }
 
+//LCOV_EXCL_START
 CAudioError::CAudioError(const CAudioError& err) {
     __mError = err.__mError;
     memcpy(__mErrorMsg, err.__mErrorMsg, MSG_LENGTH);
 }
+//LCOV_EXCL_STOP
 
 CAudioError::~CAudioError() {
 }
@@ -84,16 +88,19 @@ const char* CAudioError::__convertErrorToString(EError err) {
     default:
     case EError::ERROR_NONE:                return COLOR_GREEN "ERROR_NONE"               COLOR_END;
     case EError::ERROR_INVALID_ARGUMENT:    return COLOR_RED   "ERROR_INVALID_ARGUMENT"   COLOR_END;
+//LCOV_EXCL_START
     case EError::ERROR_INVALID_HANDLE:      return COLOR_RED   "ERROR_INVALID_HANDLE"     COLOR_END;
     case EError::ERROR_INVALID_SAMPLERATE:  return COLOR_RED   "ERROR_INVALID_SAMPLERATE" COLOR_END;
     case EError::ERROR_INVALID_CHANNEL:     return COLOR_RED   "ERROR_INVALID_CHANNEL"    COLOR_END;
     case EError::ERROR_INVALID_FORMAT:      return COLOR_RED   "ERROR_INVALID_FORMAT"     COLOR_END;
     case EError::ERROR_INVALID_POINTER:     return COLOR_RED   "ERROR_INVALID_POINTER"    COLOR_END;
+//LCOV_EXCL_STOP
     case EError::ERROR_INVALID_OPERATION:   return COLOR_RED   "ERROR_INVALID_OPERATION"  COLOR_END;
     case EError::ERROR_INVALID_STATE:       return COLOR_RED   "ERROR_INVALID_STATE"      COLOR_END;
     case EError::ERROR_NOT_INITIALIZED:     return COLOR_RED   "ERROR_NOT_INITIALIZED"    COLOR_END;
     case EError::ERROR_NOT_SUPPORTED:       return COLOR_RED   "ERROR_NOT_SUPPORTED"      COLOR_END;
     case EError::ERROR_NOT_SUPPORTED_TYPE:  return COLOR_RED   "ERROR_NOT_SUPPORTED_TYPE" COLOR_END;
+//LCOV_EXCL_START
     case EError::ERROR_PERMISSION_DENIED:   return COLOR_RED   "ERROR_PERMISSION_DENIED"  COLOR_END;
     case EError::ERROR_DEVICE_POLICY_RESTRICTION:   return COLOR_RED   "ERROR_DEVICE_POLICY_RESTRICTION"  COLOR_END;
     case EError::ERROR_DEVICE_NOT_OPENED:   return COLOR_RED   "ERROR_DEVICE_NOT_OPENED"  COLOR_END;
@@ -104,9 +111,11 @@ const char* CAudioError::__convertErrorToString(EError err) {
     case EError::ERROR_POLICY_BLOCKED:      return COLOR_RED   "ERROR_POLICY_BLOCKED"     COLOR_END;
     case EError::ERROR_POLICY_INTERRUPTED:  return COLOR_RED   "ERROR_POLICY_INTERRUPTED" COLOR_END;
     case EError::ERROR_POLICY_DUPLICATED:   return COLOR_RED   "ERROR_POLICY_DUPLICATED"  COLOR_END;
+//LCOV_EXCL_STOP
     }
 }
 
+//LCOV_EXCL_START
 CAudioError::EError CAudioError::getLastError() {
     return __mLastError;
 }
@@ -114,6 +123,7 @@ CAudioError::EError CAudioError::getLastError() {
 const char* CAudioError::getLastErrorMsg() {
     return __mLastErrorMsg;
 }
+//LCOV_EXCL_STOP
 
 CAudioError::EError CAudioError::getError() {
     return __mError;
@@ -123,6 +133,7 @@ const char* CAudioError::getErrorMsg() {
     return __mErrorMsg;
 }
 
+//LCOV_EXCL_START
 CAudioError& CAudioError::operator = (const EError err) {
     __mError = err;
     __mLastError = __mError;
@@ -144,6 +155,7 @@ bool CAudioError::operator != (const EError err) {
 bool CAudioError::operator == (const EError err) {
     return (__mError == err);
 }
+//LCOV_EXCL_STOP
 
 //bool operator == (const CAudioError& src, const CAudioError::EError& err) {
 //    //return (src.__mLastError == err);

diff --git a/src/cpp/CAudioInput.cpp b/src/cpp/CAudioInput.cpp
index 6302501..40521fb 100644 (file)
--- a/src/cpp/CAudioInput.cpp
+++ b/src/cpp/CAudioInput.cpp
@@ -257,8 +257,10 @@ void CAudioInput::prepare() {
         internalUnlock();
         throw;
     } catch (const std::bad_alloc&) {
+//LCOV_EXCL_START
         internalUnlock();
         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
+//LCOV_EXCL_STOP
     }
 }
 

diff --git a/src/cpp/CAudioOutput.cpp b/src/cpp/CAudioOutput.cpp
index f330bed..96b7531 100644 (file)
--- a/src/cpp/CAudioOutput.cpp
+++ b/src/cpp/CAudioOutput.cpp
@@ -156,8 +156,10 @@ void CAudioOutput::prepare() {
         internalUnlock();
         throw;
     } catch (const std::bad_alloc&) {
+//LCOV_EXCL_START
         internalUnlock();
         THROW_ERROR_MSG(CAudioError::EError::ERROR_OUT_OF_MEMORY, "Failed to allocate CPulseAudioClient object");
+//LCOV_EXCL_STOP
     }
 }
 

diff --git a/src/cpp/CPulseAudioClient.cpp b/src/cpp/CPulseAudioClient.cpp
index a877c72..2cf9209 100644 (file)
--- a/src/cpp/CPulseAudioClient.cpp
+++ b/src/cpp/CPulseAudioClient.cpp
@@ -85,6 +85,7 @@ void CPulseAudioClient::__contextStateChangeCb(pa_context* c, void* user_data) {
     }
 }
 
+//LCOV_EXCL_START
 void CPulseAudioClient::__successContextCb(pa_context* c, int success, void* user_data) {
     AUDIO_IO_LOGD("pa_context[%p], success[%d], user_data[%p]", c, success, user_data);
     assert(c);
@@ -114,6 +115,7 @@ static bool __is_microphone_restricted(void) {
 #endif
     return (state ? false : true);
 }
+//LCOV_EXCL_STOP
 
 void CPulseAudioClient::__streamStateChangeCb(pa_stream* s, void* user_data) {
     assert(s);
@@ -239,6 +241,7 @@ void CPulseAudioClient::__streamUnderflowCb(pa_stream* s, void* user_data) {
     pClient->__mIsStarted = false;
 }
 
+//LCOV_EXCL_START
 void CPulseAudioClient::__streamEventCb(pa_stream* s, const char *name, pa_proplist *pl, void *user_data) {
     assert(s);
     assert(user_data);
@@ -250,7 +253,7 @@ void CPulseAudioClient::__streamEventCb(pa_stream* s, const char *name, pa_propl
         pa_operation_unref(pa_stream_cork(pClient->__mpStream, 1, NULL, NULL));
     }
 }
-
+//LCOV_EXCL_STOP
 
 void CPulseAudioClient::__successStreamCb(pa_stream* s, int success, void* user_data) {
     AUDIO_IO_LOGD("pa_stream[%p], success[%d], user_data[%p]", s, success, user_data);
@@ -263,6 +266,7 @@ void CPulseAudioClient::__successStreamCb(pa_stream* s, int success, void* user_
     pa_threaded_mainloop_signal(pClient->__mpMainloop, 0);
 }
 
+//LCOV_EXCL_START
 void CPulseAudioClient::__successDrainCbInThread(pa_stream* s, int success, void* user_data) {
     AUDIO_IO_LOGD("pa_stream[%p], success[%d], user_data[%p]", s, success, user_data);
     assert(s);
@@ -272,6 +276,7 @@ void CPulseAudioClient::__successDrainCbInThread(pa_stream* s, int success, void
     pClient->__mIsOperationSuccess = static_cast<bool>(success);
     pClient->__mIsDraining = false;
 }
+//LCOV_EXCL_STOP
 
 void CPulseAudioClient::__successDrainCb(pa_stream* s, int success, void* user_data) {
     AUDIO_IO_LOGD("pa_stream[%p], success[%d], user_data[%p]", s, success, user_data);
@@ -881,6 +886,7 @@ bool CPulseAudioClient::isInThread() {
     return static_cast<bool>(ret);
 }
 
+//LCOV_EXCL_START
 size_t CPulseAudioClient::getReadableSize() {
     if (__mIsInit == false) {
         THROW_ERROR_MSG(CAudioError::EError::ERROR_NOT_INITIALIZED, "Did not initialize CPulseAudioClient");
@@ -1049,3 +1055,4 @@ CPulseAudioClient::EStreamDirection CPulseAudioClient::getStreamDirection() {
 CPulseStreamSpec CPulseAudioClient::getStreamSpec() {
     return __mSpec;
 }
+//LCOV_EXCL_STOP

diff --git a/src/cpp/CPulseStreamSpec.cpp b/src/cpp/CPulseStreamSpec.cpp
index 92dc4c8..93b10ec 100644 (file)
--- a/src/cpp/CPulseStreamSpec.cpp
+++ b/src/cpp/CPulseStreamSpec.cpp
@@ -110,6 +110,7 @@ void CPulseStreamSpec::__adjustSpec() {
 
     // Sets stream name
     switch (__mLatency) {
+//LCOV_EXCL_START
     case EStreamLatency::STREAM_LATENCY_INPUT_LOW:
         __mStreamName = STREAM_NAME_INPUT_LOW_LATENCY;
         break;
@@ -125,11 +126,13 @@ void CPulseStreamSpec::__adjustSpec() {
     case EStreamLatency::STREAM_LATENCY_INPUT_VOIP:
         __mStreamName = STREAM_NAME_INPUT_VOIP;
         break;
+//LCOV_EXCL_STOP
 
     case EStreamLatency::STREAM_LATENCY_INPUT_DEFAULT:
         __mStreamName = STREAM_NAME_INPUT_DEFAULT;
         break;
 
+//LCOV_EXCL_START
     case EStreamLatency::STREAM_LATENCY_OUTPUT_LOW:
         __mStreamName = STREAM_NAME_OUTPUT_LOW_LATENCY;
         break;
@@ -145,6 +148,7 @@ void CPulseStreamSpec::__adjustSpec() {
     case EStreamLatency::STREAM_LATENCY_OUTPUT_VOIP:
         __mStreamName = STREAM_NAME_OUTPUT_VOIP;
         break;
+//LCOV_EXCL_STOP
 
     case EStreamLatency::STREAM_LATENCY_OUTPUT_DEFAULT:
         __mStreamName = STREAM_NAME_OUTPUT_DEFAULT;
@@ -154,10 +158,12 @@ void CPulseStreamSpec::__adjustSpec() {
         __mStreamName = STREAM_NAME_OUTPUT_DEFAULT_ASYNC;
         break;
 
+//LCOV_EXCL_START
     default:
         AUDIO_IO_LOGW("Invalid __mLatency[%d]", static_cast<int>(__mLatency));
         break;
     }
+//LCOV_EXCL_STOP
 }
 
 CPulseStreamSpec::EStreamLatency CPulseStreamSpec::getStreamLatency() {
@@ -168,6 +174,7 @@ const char* CPulseStreamSpec::getStreamLatencyToString() {
     const char* latency;
 
     switch (__mLatency) {
+//LCOV_EXCL_START
     case EStreamLatency::STREAM_LATENCY_INPUT_LOW:
     case EStreamLatency::STREAM_LATENCY_OUTPUT_LOW:
         latency = STREAM_LATENCY_LOW;
@@ -187,6 +194,7 @@ const char* CPulseStreamSpec::getStreamLatencyToString() {
     case EStreamLatency::STREAM_LATENCY_OUTPUT_VOIP:
         latency = STREAM_LATENCY_VOIP;
         break;
+//LCOV_EXCL_STOP
 
     case EStreamLatency::STREAM_LATENCY_INPUT_DEFAULT:
     case EStreamLatency::STREAM_LATENCY_OUTPUT_DEFAULT:
@@ -197,10 +205,12 @@ const char* CPulseStreamSpec::getStreamLatencyToString() {
         latency = STREAM_LATENCY_DEFAULT_ASYNC;
         break;
 
+//LCOV_EXCL_START
     default:
         AUDIO_IO_LOGW("Invalid __mLatency[%d]", static_cast<int>(__mLatency));
         latency = STREAM_LATENCY_DEFAULT;
         break;
+//LCOV_EXCL_STOP
     }
 
     return latency;

diff --git a/src/cpp/cpp_audio_io.cpp b/src/cpp/cpp_audio_io.cpp
index 8df8dde..182d929 100644 (file)
--- a/src/cpp/cpp_audio_io.cpp
+++ b/src/cpp/cpp_audio_io.cpp
@@ -390,10 +390,12 @@ int cpp_audio_in_create(int sample_rate, audio_channel_e channel, audio_sample_t
         __handle_safe_free(handle, (void *)input, false);
         return __convert_CAudioError(e);
     } catch (const std::bad_alloc&) {
+//LCOV_EXCL_START
         CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY;
         AUDIO_IO_LOGE("Failed to allocate handle");
         __handle_safe_free(handle, (void *)input, false);
         return __convert_CAudioError(e);
+//LCOV_EXCL_STOP
     }
 
     return AUDIO_IO_ERROR_NONE;
@@ -530,6 +532,7 @@ int cpp_audio_in_resume(audio_in_h input) {
     return AUDIO_IO_ERROR_NONE;
 }
 
+//LCOV_EXCL_START
 int cpp_audio_in_drain(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
 
@@ -550,6 +553,7 @@ int cpp_audio_in_drain(audio_in_h input) {
 
     return AUDIO_IO_ERROR_NONE;
 }
+//LCOV_EXCL_STOP
 
 int cpp_audio_in_flush(audio_in_h input) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
@@ -692,6 +696,7 @@ static void __stream_cb_internal(size_t nbytes, void *user_data) {
         audioIo->stream_callback.onStream(audioIo, nbytes, audioIo->stream_callback.user_data);
 }
 
+//LCOV_EXCL_START
 static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state,
                                         CAudioInfo::EAudioIOState state_prev,
                                         bool by_policy,
@@ -704,6 +709,7 @@ static void __state_changed_cb_internal(CAudioInfo::EAudioIOState state,
                                                        __convert_state_type(state), by_policy,
                                                        audioIo->state_changed_callback.user_data);
 }
+//LCOV_EXCL_STOP
 
 int cpp_audio_in_set_stream_cb(audio_in_h input, audio_in_stream_cb callback, void* user_data) {
     audio_io_s* handle = static_cast<audio_io_s*>(input);
@@ -889,10 +895,12 @@ int cpp_audio_out_create_new(int sample_rate, audio_channel_e channel, audio_sam
         __handle_safe_free(handle, (void *)output, true);
         return __convert_CAudioError(e);
     } catch (const std::bad_alloc&) {
+//LCOV_EXCL_START
         CAudioError e = CAudioError::EError::ERROR_OUT_OF_MEMORY;
         AUDIO_IO_LOGE("Failed to allocate handle");
         __handle_safe_free(handle, (void *)output, true);
         return __convert_CAudioError(e);
+//LCOV_EXCL_STOP
     }
 
     return AUDIO_IO_ERROR_NONE;