Add more unittests

Sep 11 19:49:25 localhost tts-unittests[12848]: [----------] 120 tests from TTSTest (27223 ms total)
Sep 11 19:49:25 localhost tts-unittests[12848]: [----------] Global test environment tear-down
Sep 11 19:49:25 localhost tts-unittests[12848]: [==========] 120 tests from 1 test case ran. (27223 ms total)
Sep 11 19:49:25 localhost tts-unittests[12848]: [  PASSED  ] 120 tests.

Change-Id: I5ac5bd4a3da4533a39152128feaaeed5863cf8fe
Signed-off-by: Jihoon Kim <jihoon48.kim@samsung.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 115fc79..79fef14 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -89,7 +89,7 @@ ADD_SUBDIRECTORY(test)
 ## Test
 IF(NOT DEFINED MINIMUM_BUILD)
 ENABLE_TESTING()
-SET(UNITTEST_TTS tts_unittests)
+SET(UNITTEST_TTS tts-unittests)
 ADD_TEST(NAME ${UNITTEST_TTS} COMMAND ${UNITTEST_TTS}
                         WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests)
 

diff --git a/packaging/tts.spec b/packaging/tts.spec
index 5a95cc0..3ebdfdc 100644 (file)
--- a/packaging/tts.spec
+++ b/packaging/tts.spec
@@ -107,7 +107,8 @@ export LDFLAGS="$LDFLAGS -lgcov"
 %endif
 
 cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DLIBDIR=%{_libdir} -DBINDIR=%{_bindir} -DINCLUDEDIR=%{_includedir} \
-        -DTZ_SYS_RO_SHARE=%TZ_SYS_RO_SHARE -DTZ_SYS_BIN=%TZ_SYS_BIN
+        -DTZ_SYS_RO_SHARE=%TZ_SYS_RO_SHARE -DTZ_SYS_BIN=%TZ_SYS_BIN \
+        -DTZ_SYS_RO_PACKAGES=%TZ_SYS_RO_PACKAGES -DTZ_SYS_RO_APP=%TZ_SYS_RO_APP
 
 make %{?jobs:-j%jobs}
 
@@ -143,11 +144,13 @@ install -m 0644 gcov-obj/* %{buildroot}%{_datadir}/gcov/obj
 %endif
 
 %check
+%if "%{_ctest_enable}" == "true"
 ctest -V --output-on-failure %{?_smp_mflags}
 %if 0%{?gcov:1}
 lcov -c --ignore-errors graph --no-external -q -d . -o gcov.info
 genhtml gcov.info
 %endif
+%endif
 
 %post
 /sbin/ldconfig
@@ -199,4 +202,7 @@ mkdir -p %{TZ_SYS_RO_SHARE}/voice/test
 %endif
 
 %files unittests
-%{_bindir}/*
+%manifest tests/org.tizen.tts-unittests.manifest
+%defattr(-,root,root,-)
+%{TZ_SYS_RO_PACKAGES}/org.tizen.tts-unittests.xml
+%{TZ_SYS_RO_APP}/org.tizen.tts-unittests/bin/tts-unittests

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 0ded2d8..07c294d 100644 (file)
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,6 +1,9 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 PROJECT(gtest-tts CXX)
 
+SET(PKGNAME "org.tizen.tts-unittests")
+SET(BINDIR "${TZ_SYS_RO_APP}/${PKGNAME}/bin")
+
 FOREACH(flag ${pkgs_CFLAGS})
        SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
 ENDFOREACH(flag)
@@ -34,4 +37,6 @@ SET_TARGET_PROPERTIES(${UNITTEST_TTS} PROPERTIES
        #Never add any space for LINKFLAGS
        LINK_FLAGS "-Wl,\
 --wrap=system_info_get_platform_bool")
-INSTALL(TARGETS ${UNITTEST_TTS} DESTINATION /usr/bin)
+
+INSTALL(FILES ${CMAKE_SOURCE_DIR}/tests/${PKGNAME}.xml DESTINATION ${TZ_SYS_RO_PACKAGES})
+INSTALL(TARGETS ${UNITTEST_TTS} DESTINATION ${BINDIR})

diff --git a/tests/org.tizen.tts-unittests.manifest b/tests/org.tizen.tts-unittests.manifest
new file mode 100644 (file)
index 0000000..97e8c31
--- /dev/null
+++ b/tests/org.tizen.tts-unittests.manifest
@@ -0,0 +1,5 @@
+<manifest>
+       <request>
+               <domain name="_"/>
+       </request>
+</manifest>

diff --git a/tests/org.tizen.tts-unittests.xml b/tests/org.tizen.tts-unittests.xml
new file mode 100644 (file)
index 0000000..e366f42
--- /dev/null
+++ b/tests/org.tizen.tts-unittests.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns="http://tizen.org/ns/packages" api-version="3.0" package="org.tizen.tts-unittests" version="0.6.2" install-location="internal-only">
+        <label>TTS unittests</label>
+        <author email="jihoon48.kim" href="www.samsung.com">Jihoon Kim</author>
+        <description>TTS unittests</description>
+        <service-application appid="org.tizen.tts-unittests" launch_mode="caller" exec="tts-unittests" hw-acceleration="use-GL" nodisplay="true" multiple="false" type="capp" taskmanage="false">
+            <label>TTS unittests</label>
+            <background-category value="media"/>
+        </service-application>
+</manifest>

diff --git a/tests/src/system_info_mock.cpp b/tests/src/system_info_mock.cpp
index e9000f3..0e00a70 100644 (file)
--- a/tests/src/system_info_mock.cpp
+++ b/tests/src/system_info_mock.cpp
@@ -2,7 +2,7 @@
 #include <stdio.h>
 #include <tizen.h>
 
-EXPORT_API int __wrap_system_info_get_platform_bool (const char *key, bool *value)
+EXPORT_API int __wrap_system_info_get_platform_bool(const char *key, bool *value)
 {
     if (value)
         *value = true;

diff --git a/tests/src/system_info_mock.h b/tests/src/system_info_mock.h
index 2ab4518..075c93b 100644 (file)
--- a/tests/src/system_info_mock.h
+++ b/tests/src/system_info_mock.h
@@ -8,7 +8,7 @@
 extern "C" {
 #endif
 
-int __wrap_system_info_get_platform_bool (const char *key, bool *value);
+int __wrap_system_info_get_platform_bool(const char *key, bool *value);
 
 #ifdef __cplusplus
 }

diff --git a/tests/src/tts_unittests.cpp b/tests/src/tts_unittests.cpp
index 5534bd2..293e6a4 100644 (file)
--- a/tests/src/tts_unittests.cpp
+++ b/tests/src/tts_unittests.cpp
@@ -15,30 +15,275 @@
  */
 
 #include <gtest/gtest.h>
+#include <Ecore.h>
+#include <system_info.h>
 
 #include <tts.h>
 #include "system_info_mock.h"
 
+static tts_h g_tts = NULL;
+static char *g_language = NULL;
+static int g_voice_type;
+static int is_created_hndl = -1;
+static void __tts_state_changed_cb(tts_h tts, tts_state_e previous, tts_state_e current, void* user_data);
+static bool g_supported = false;
+static tts_state_e g_current_state;
+static bool g_utterance_started_cb = false;
+static bool g_utterance_completed_cb = false;
+static int g_utt_id = -1;
+static const char *g_text = "Speech Synthesis is the artificial production of human speech. A computer system used for this purpose is called a speech computer or speech synthesizer,\
+       and can be implemented in software or hardware products. A text-to-speech (TTS) system converts normal language text into speech; other systems render symbolic linguistic\
+       representations like phonetic transcriptions into speech.\
+       Synthesized speech can be created by concatenating pieces of recorded speech that are stored in a database. Systems differ in the size of the stored speech units; \
+       a system that stores phones or diphones provides the largest output range, but may lack clarity. For specific usage domains, the storage of entire words or sentences allows \
+       for high-quality output. Alternatively, a synthesizer can incorporate a model of the vocal tract and other human voice characteristics to create a completely synthetic voice output.\
+       The quality of a speech synthesizer is judged by its similarity to the human voice and by its ability to be understood clearly. An intelligible text-to-speech program allows people \
+       with visual impairments or reading disabilities to listen to written works on a home computer. Many computer operating systems have included speech synthesizers since the early 1990s.\
+       A text-to-speech system is composed of two parts:[3] a front-end and a back-end. The front-end has two major tasks. First, it converts raw text containing symbols like numbers and \
+       abbreviations into the equivalent of written-out words. This process is often called text normalization, pre-processing, or tokenization. The front-end then assigns phonetic \
+       transcriptions to each word, and divides and marks the text into prosodic units, like phrases, clauses, and sentences. The process of assigning phonetic transcriptions to words is \
+       called text-to-phoneme or grapheme-to-phoneme conversion. Phonetic transcriptions and prosody information together make up the symbolic linguistic representation that is output by \
+       the front-end. The back-end?often referred to as the synthesizer?then converts the symbolic linguistic representation into sound. In certain systems, this part includes the computation \
+       of the target prosody (pitch contour, phoneme durations),[4] which is then imposed on the output speech. From Wikipedia";
+
+static bool __tts_supported_voice_cb(tts_h tts, const char* language, int voice_type, void* user_data)
+{
+       return true;
+}
+
+static void __tts_state_changed_cb(tts_h tts, tts_state_e previous, tts_state_e current, void* user_data)
+{
+       g_current_state = current;
+}
+
+static void __tts_utterance_started_cb(tts_h tts, int utt_id, void* user_data)
+{
+       g_utterance_started_cb = true;
+}
+
+static void __tts_utterance_completed_cb(tts_h tts, int utt_id, void *user_data)
+{
+       g_utterance_completed_cb = true;
+       g_utt_id = utt_id;
+}
+
+static void __tts_error_cb(tts_h tts, int utt_id, tts_error_e reason, void* user_data)
+{
+}
+
+static void __tts_default_voice_changed_cb(tts_h tts, const char* previous_language, int previous_voice_type, const char* current_language, int current_voice_type, void* user_data)
+{
+}
+
 namespace {
 
 class TTSTest : public testing::Test {
     public:
         virtual void SetUp() {
-        }
-        virtual void TearDown() {
-        }
+                       ecore_init();
+                       system_info_get_platform_bool("http://tizen.org/feature/speech.synthesis", &g_supported);
+                       g_supported = true;
+
+                       g_current_state = TTS_STATE_CREATED;
+                       /* start of TC */
+                       int ret = TTS_ERROR_NONE;
+                       ret = tts_create(&g_tts);
+                       is_created_hndl = ret;
+
+                       if (g_supported == false) {
+                               g_tts = NULL;
+                               return;
+                       }
+
+                       ret = tts_set_state_changed_cb(g_tts, __tts_state_changed_cb, NULL);
+                       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+                       ret = tts_get_default_voice(g_tts, &g_language, &g_voice_type);
+                       EXPECT_EQ(ret, TTS_ERROR_NONE);
+               }
+
+               virtual void TearDown() {
+                       if (g_language)
+                               free (g_language);
+                       g_language = NULL;
+
+                       int ret = TTS_ERROR_NONE;
+                       if (g_tts) {
+                               ret = tts_destroy(g_tts);
+                               EXPECT_EQ(ret, TTS_ERROR_NONE);
+                       }
+
+                       g_tts = NULL;
+                       is_created_hndl = -1;
+
+                       ecore_shutdown();
+               }
 };
 
+TEST_F(TTSTest, utc_tts_create_p)
+{
+       if (g_supported == false) {
+               EXPECT_EQ(is_created_hndl, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+}
+
 TEST_F(TTSTest, utc_tts_create_n)
 {
-    int ret = tts_create(NULL);
-    EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+       int ret = tts_create(NULL);
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
 }
 
+TEST_F(TTSTest, utc_tts_destroy_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_destroy(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+       ret = tts_destroy(g_tts);
+       g_tts = NULL;
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+TEST_F(TTSTest, utc_tts_destroy_p2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+       ret = tts_destroy(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_mode(g_tts, TTS_MODE_DEFAULT);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_destroy(g_tts);
+       g_tts = NULL;
+       EXPECT_EQ(ret, TTS_ERROR_NONE);}
+
+TEST_F(TTSTest, utc_tts_destroy_p3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+       ret = tts_destroy(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_mode(g_tts, TTS_MODE_NOTIFICATION);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_destroy(g_tts);
+       g_tts = NULL;
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_destroy_p4
+ * @since_tizen                2.3
+ * @description                test whether tts handle is destroyed properly when tts is ready state with screen reader mode
+ */
+TEST_F(TTSTest, utc_tts_destroy_p4)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+       ret = tts_destroy(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_mode(g_tts, TTS_MODE_SCREEN_READER);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_destroy(g_tts);
+       g_tts = NULL;
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+
 TEST_F(TTSTest, utc_tts_destroy_n)
 {
-    int ret = tts_destroy(NULL);
-    EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+       int ret = tts_destroy(NULL);
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+}
+
+TEST_F(TTSTest, utc_tts_destroy_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_destroy(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+TEST_F(TTSTest, utc_tts_set_mode_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_mode(g_tts, TTS_MODE_DEFAULT);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_mode(g_tts, TTS_MODE_DEFAULT);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+TEST_F(TTSTest, utc_tts_set_mode_p2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_mode(g_tts, TTS_MODE_SCREEN_READER);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_mode(g_tts, TTS_MODE_SCREEN_READER);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
 }
 
 TEST_F(TTSTest, utc_tts_set_mode_n)
@@ -47,6 +292,62 @@ TEST_F(TTSTest, utc_tts_set_mode_n)
     EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
 }
 
+TEST_F(TTSTest, utc_tts_set_mode_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_mode(NULL, TTS_MODE_DEFAULT);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_set_mode(g_tts, TTS_MODE_DEFAULT);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+TEST_F(TTSTest, utc_tts_set_mode_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_mode(NULL, TTS_MODE_DEFAULT);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_mode(g_tts, (tts_mode_e)100);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+TEST_F(TTSTest, utc_tts_get_mode_p)
+{
+       tts_mode_e mode;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_mode(g_tts, &mode);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_get_mode(g_tts, &mode);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       return;
+}
+
 TEST_F(TTSTest, utc_tts_get_mode_n)
 {
     tts_mode_e mode;
@@ -54,10 +355,123 @@ TEST_F(TTSTest, utc_tts_get_mode_n)
     EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(TTSTest, utc_tts_set_credential_n)
+TEST_F(TTSTest, utc_tts_get_mode_n2)
 {
-    int ret = tts_set_credential(NULL, "credential");
-    EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+       tts_mode_e mode;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_mode(g_tts, &mode);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_get_mode(g_tts, &mode);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+TEST_F(TTSTest, utc_tts_get_speed_range_p)
+{
+       int min;
+       int normal;
+       int max;
+       int ret = TTS_ERROR_NONE;
+
+       if (g_supported == false) {
+               ret = tts_get_speed_range(g_tts, &min, &normal, &max);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+       ret = tts_get_speed_range(g_tts, &min, &normal, &max);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_speed_range_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_get_speed_range_n)
+{
+       int min;
+       int normal;
+       int max;
+       int ret = TTS_ERROR_NONE;
+
+       if (g_supported == false) {
+               ret = tts_get_speed_range(NULL, &min, &normal, &max);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_get_speed_range(NULL, &min, &normal, &max);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_speed_range_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_get_speed_range_n2)
+{
+       int min;
+       int normal;
+       int max;
+       int ret = TTS_ERROR_NONE;
+
+       if (g_supported == false) {
+               ret = tts_get_speed_range(NULL, &min, &normal, &max);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_get_speed_range(g_tts, &min, &normal, &max);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_prepare_p
+ * @since_tizen                2.3
+ * @description                test whether tts daemon is prepared properly.
+ */
+TEST_F(TTSTest, utc_tts_prepare_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_prepare(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       tts_unprepare(g_tts);
 }
 
 TEST_F(TTSTest, utc_tts_prepare_n)
@@ -66,10 +480,2510 @@ TEST_F(TTSTest, utc_tts_prepare_n)
     EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
 }
 
-TEST_F(TTSTest, utc_tts_unprepare_n)
+/**
+ * @testcase           utc_tts_prepare_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is ready state, not create state.
+ */
+TEST_F(TTSTest, utc_tts_prepare_n2)
 {
-    int ret = tts_unprepare(NULL);
-    EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_prepare(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_prepare(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       tts_unprepare(g_tts);
+}
+
+
+/**
+ * @testcase           utc_tts_foreach_supported_voices_p
+ * @since_tizen                2.3
+ * @description                test whether each supported voices are gotten properly.
+ */
+TEST_F(TTSTest, utc_tts_foreach_supported_voices_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_foreach_supported_voices(g_tts, __tts_supported_voice_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+       ret = tts_foreach_supported_voices(g_tts, __tts_supported_voice_cb, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_foreach_supported_voices_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_foreach_supported_voices_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_foreach_supported_voices(NULL, __tts_supported_voice_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_foreach_supported_voices(NULL, __tts_supported_voice_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_foreach_supported_voices_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_foreach_supported_voices_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_foreach_supported_voices(NULL, __tts_supported_voice_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_foreach_supported_voices(g_tts, __tts_supported_voice_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+
+/**
+ * @testcase           utc_tts_get_default_voice_p
+ * @since_tizen                2.3
+ * @description                test whether default voice is gotten properly.
+ */
+TEST_F(TTSTest, utc_tts_get_default_voice_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_default_voice(g_tts, &g_language, &g_voice_type);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       free (g_language);
+       g_language = NULL;
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+       ret = tts_get_default_voice(g_tts, &g_language, &g_voice_type);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_default_voice_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_get_default_voice_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_default_voice(NULL, &g_language, &g_voice_type);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       free (g_language);
+       g_language = NULL;
+       ret = tts_get_default_voice(NULL, &g_language, &g_voice_type);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_default_voice_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_get_default_voice_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_default_voice(NULL, &g_language, &g_voice_type);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       free (g_language);
+       g_language = NULL;
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_get_default_voice(g_tts, &g_language, &g_voice_type);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_default_voice_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter as type.
+ */
+TEST_F(TTSTest, utc_tts_get_default_voice_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_default_voice(NULL, &g_language, &g_voice_type);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       free(g_language);
+       g_language = NULL;
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_get_default_voice(g_tts, &g_language, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+
+/**
+ * @testcase           utc_tts_get_max_text_size_p
+ * @since_tizen                2.3
+ * @description                test whether max text size is gotten properly.
+ */
+TEST_F(TTSTest, utc_tts_get_max_text_size_p)
+{
+       unsigned int size;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_max_text_size(g_tts, &size);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_get_max_text_size(g_tts, &size);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_max_text_size_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_get_max_text_size_n)
+{
+       unsigned int size;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_max_text_size(NULL, &size);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_get_max_text_size(NULL, &size);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_max_text_size_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_get_max_text_size_n2)
+{
+       unsigned int size;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_max_text_size(NULL, &size);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_get_max_text_size(g_tts, &size);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+
+/**
+ * @testcase           utc_tts_get_max_text_size_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is in create state.
+ */
+TEST_F(TTSTest, utc_tts_get_max_text_size_n3)
+{
+       unsigned int size;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_max_text_size(NULL, &size);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_get_max_text_size(g_tts, &size);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+
+/**
+ * @testcase           utc_tts_get_state_p
+ * @since_tizen                2.3
+ * @description                test whether state is gotten properly in create state.
+ */
+TEST_F(TTSTest, utc_tts_get_state_p)
+{
+       tts_state_e state;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_state(g_tts, &state);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_get_state(g_tts, &state);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_state_p2
+ * @since_tizen                2.3
+ * @description                test whether state is gotten properly in ready state.
+ */
+TEST_F(TTSTest, utc_tts_get_state_p2)
+{
+       tts_state_e state;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_state(g_tts, &state);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_get_state(g_tts, &state);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+
+/**
+ * @testcase           utc_tts_get_state_p3
+ * @since_tizen                2.3
+ * @description                test whether state is gotten properly in play state.
+ */
+TEST_F(TTSTest, utc_tts_get_state_p3)
+{
+       tts_state_e state;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_state(g_tts, &state);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_play(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_PLAYING != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_get_state(g_tts, &state);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_stop(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_state_p4
+ * @since_tizen                2.3
+ * @description                test whether state is gotten properly in pause state.
+ */
+TEST_F(TTSTest, utc_tts_get_state_p4)
+{
+       tts_state_e state;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_state(g_tts, &state);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_play(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_PLAYING != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_pause(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_PAUSED!=g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_get_state(g_tts, &state);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_stop(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+
+/**
+ * @testcase           utc_tts_get_state_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_get_state_n)
+{
+       tts_state_e state;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_state(NULL, &state);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_get_state(NULL, &state);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_state_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_get_state_n2)
+{
+       tts_state_e state;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_state(g_tts, &state);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_get_state(g_tts, &state);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+
+/**
+ * @testcase           utc_tts_add_text_p
+ * @since_tizen                2.3
+ * @description                test whether text is added properly.
+ */
+TEST_F(TTSTest, utc_tts_add_text_p)
+{
+       int utt_id;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_add_text_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_add_text_n)
+{
+       int utt_id;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_add_text(NULL, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_add_text(NULL, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_add_text_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_add_text_n2)
+{
+       int utt_id;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_add_text(NULL, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_add_text_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is in create state.
+ */
+TEST_F(TTSTest, utc_tts_add_text_n3)
+{
+       int utt_id;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_add_text(NULL, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_add_text_n4
+ * @since_tizen                2.3
+ * @description                test whether function returns error when text is over max text size.
+ */
+TEST_F(TTSTest, utc_tts_add_text_n4)
+{
+       int utt_id;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_add_text(g_tts, g_text, g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_add_text_n5
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts speed is abnormal.
+ */
+TEST_F(TTSTest, utc_tts_add_text_n5)
+{
+       int utt_id;
+       int speed = -1;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, speed, &utt_id);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_play_p
+ * @since_tizen                2.3
+ * @description                test whether tts is played properly.
+ */
+TEST_F(TTSTest, utc_tts_play_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_play(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_play(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_PLAYING != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_stop(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_play_p2
+ * @since_tizen                2.3
+ * @description                test whether tts is played all text properly.
+ */
+TEST_F(TTSTest, utc_tts_play_p2)
+{
+       int utt_id;
+       int ret = TTS_ERROR_NONE;
+
+       if (g_supported == false) {
+               ret = tts_play(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       g_utterance_completed_cb = false;
+
+       ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_play(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_PLAYING != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       while (true != g_utterance_completed_cb) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_stop(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_play_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_play_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_play(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_play(NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_play_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_play_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_play(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_play(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_play_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is in create state.
+ */
+TEST_F(TTSTest, utc_tts_play_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_play(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_play(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_pause_p
+ * @since_tizen                2.3
+ * @description                test whether tts is paused properly.
+ */
+TEST_F(TTSTest, utc_tts_pause_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_pause(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_play(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_PLAYING != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_pause(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_PAUSED!=g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_stop(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_pause_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_pause_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_pause(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_pause(NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_pause_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_pause_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_pause(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_pause(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_pause_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is in create state.
+ */
+TEST_F(TTSTest, utc_tts_pause_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_pause(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_pause(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_stop_p
+ * @since_tizen                2.3
+ * @description                test whether tts is stopped properly.
+ */
+TEST_F(TTSTest, utc_tts_stop_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_stop(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_play(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_PLAYING != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_stop(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       return;
+}
+
+/**
+ * @testcase           utc_tts_stop_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_stop_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_stop(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_stop(NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_stop_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_stop_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_stop(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_stop(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_stop_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is in create state.
+ */
+TEST_F(TTSTest, utc_tts_stop_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_stop(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_stop(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_repeat_p
+ * @since_tizen                5.0
+ * @description                test whether tts is repeated properly.
+ */
+TEST_F(TTSTest, utc_tts_repeat_p)
+{
+       int ret = TTS_ERROR_NONE;
+       char* text_repeat = NULL;
+       int utt_id = -1;
+
+       if (g_supported == false) {
+               ret = tts_repeat(g_tts, &text_repeat, &utt_id);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       g_utterance_completed_cb = false;
+
+       ret = tts_add_text(g_tts, "repeat success", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_play(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_PLAYING != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       while (true != g_utterance_completed_cb) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_stop(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       g_utterance_completed_cb = false;
+
+       ret = tts_repeat(g_tts, &text_repeat, &utt_id);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = strncmp(text_repeat, "repeat success", strlen(text_repeat));
+       EXPECT_EQ(ret, 0);
+
+       while (TTS_STATE_PLAYING != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       while (true != g_utterance_completed_cb) {
+               ecore_main_loop_iterate();
+       }
+
+       EXPECT_EQ(utt_id, g_utt_id);
+
+       ret = tts_stop(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_repeat_n
+ * @since_tizen                5.0
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_repeat_n)
+{
+       int ret = TTS_ERROR_NONE;
+
+       if (g_supported == false) {
+               ret = tts_repeat(g_tts, NULL, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_repeat(g_tts, NULL, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase           utc_tts_repeat_n2
+ * @since_tizen                5.0
+ * @description                test whether function returns error with invalid state.
+ */
+TEST_F(TTSTest, utc_tts_repeat_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       char* text_repeat = NULL;
+       int utt_id = -1;
+
+       if (g_supported == false) {
+               ret = tts_repeat(g_tts, &text_repeat, &utt_id);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_repeat(g_tts, &text_repeat, &utt_id);
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase           utc_tts_repeat_n3
+ * @since_tizen                5.0
+ * @description                test whether function returns error with operation failed when there is no previous text.
+ */
+TEST_F(TTSTest, utc_tts_repeat_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       char* text_repeat = NULL;
+       int utt_id = -1;
+
+       if (g_supported == false) {
+               ret = tts_repeat(g_tts, &text_repeat, &utt_id);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_repeat(g_tts, &text_repeat, &utt_id);
+       EXPECT_EQ(ret, TTS_ERROR_OPERATION_FAILED);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unprepare_p
+ * @since_tizen                2.3
+ * @description                test whether tts is unprepared properly.
+ */
+TEST_F(TTSTest, utc_tts_unprepare_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unprepare(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unprepare_p2
+ * @since_tizen                2.3
+ * @description                test whether tts is unprepared properly when tts is in notification mode.
+ */
+TEST_F(TTSTest, utc_tts_unprepare_p2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unprepare(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_mode(g_tts, TTS_MODE_NOTIFICATION);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unprepare_p3
+ * @since_tizen                2.3
+ * @description                test whether tts is unprepared properly when tts is in screen reader mode.
+ */
+TEST_F(TTSTest, utc_tts_unprepare_p3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unprepare(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_mode(g_tts, TTS_MODE_SCREEN_READER);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+TEST_F(TTSTest, utc_tts_unprepare_n)
+{
+    int ret = tts_unprepare(NULL);
+    EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase           utc_tts_unprepare_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_unprepare_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unprepare(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unprepare_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is in create state.
+ */
+TEST_F(TTSTest, utc_tts_unprepare_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unprepare(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_state_changed_cb_p
+ * @since_tizen                2.3
+ * @description                test whether state_changed callback function is set properly.
+ */
+TEST_F(TTSTest, utc_tts_set_state_changed_cb_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_state_changed_cb(g_tts, __tts_state_changed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+       ret = tts_set_state_changed_cb(g_tts, __tts_state_changed_cb, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_state_changed_cb_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_set_state_changed_cb_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_state_changed_cb(NULL, __tts_state_changed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_state_changed_cb(NULL, __tts_state_changed_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_state_changed_cb_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_set_state_changed_cb_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_state_changed_cb(NULL, __tts_state_changed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_set_state_changed_cb(g_tts, __tts_state_changed_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_state_changed_cb_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is not in create state.
+ */
+TEST_F(TTSTest, utc_tts_set_state_changed_cb_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_state_changed_cb(NULL, __tts_state_changed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_set_state_changed_cb(g_tts, __tts_state_changed_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_state_changed_cb_p
+ * @since_tizen                2.3
+ * @description                test whether state_changed callback function is unset properly.
+ */
+TEST_F(TTSTest, utc_tts_unset_state_changed_cb_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_state_changed_cb(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+       ret = tts_unset_state_changed_cb(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_state_changed_cb_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_unset_state_changed_cb_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_state_changed_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_unset_state_changed_cb(NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_state_changed_cb_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_unset_state_changed_cb_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_state_changed_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_unset_state_changed_cb(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_state_changed_cb_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is not in create state.
+ */
+TEST_F(TTSTest, utc_tts_unset_state_changed_cb_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_state_changed_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unset_state_changed_cb(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_utterance_started_cb_p
+ * @since_tizen                2.3
+ * @description                test whether utterance_started callback function is set properly.
+ */
+TEST_F(TTSTest, utc_tts_set_utterance_started_cb_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+       ret = tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_utterance_started_cb_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_set_utterance_started_cb_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_utterance_started_cb(NULL, __tts_utterance_started_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_set_utterance_started_cb(NULL, __tts_utterance_started_cb, NULL);
+       EXPECT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_utterance_started_cb_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_set_utterance_started_cb_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_utterance_started_cb(NULL, __tts_utterance_started_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_utterance_started_cb_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is not in create state.
+ */
+TEST_F(TTSTest, utc_tts_set_utterance_started_cb_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_utterance_started_cb(NULL, __tts_utterance_started_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_utterance_started_cb_p
+ * @since_tizen                2.3
+ * @description                test whether utterance_started callback function is unset properly.
+ */
+TEST_F(TTSTest, utc_tts_unset_utterance_started_cb_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_utterance_started_cb(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_unset_utterance_started_cb(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_utterance_started_cb_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_unset_utterance_started_cb_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_utterance_started_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_unset_utterance_started_cb(NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_utterance_started_cb_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_unset_utterance_started_cb_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_utterance_started_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_unset_utterance_started_cb(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_utterance_started_cb_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is not in create state.
+ */
+TEST_F(TTSTest, utc_tts_unset_utterance_started_cb_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_utterance_started_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unset_utterance_started_cb(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_utterance_completed_cb_p
+ * @since_tizen                2.3
+ * @description                test whether utterance_completed callback function is set properly.
+ */
+TEST_F(TTSTest, utc_tts_set_utterance_completed_cb_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_utterance_completed_cb_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_set_utterance_completed_cb_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_utterance_completed_cb(NULL, __tts_utterance_completed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_set_utterance_completed_cb(NULL, __tts_utterance_completed_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_utterance_completed_cb_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_set_utterance_completed_cb_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_utterance_completed_cb(NULL, __tts_utterance_completed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_utterance_completed_cb_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is not in create state.
+ */
+TEST_F(TTSTest, utc_tts_set_utterance_completed_cb_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_utterance_completed_cb(NULL, __tts_utterance_completed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_utterance_completed_cb_p
+ * @since_tizen                2.3
+ * @description                test whether utterance_completed callback function is unset properly.
+ */
+TEST_F(TTSTest, utc_tts_unset_utterance_completed_cb_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_utterance_completed_cb(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_unset_utterance_completed_cb(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_utterance_completed_cb_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_unset_utterance_completed_cb_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_utterance_completed_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_unset_utterance_completed_cb(NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_utterance_completed_cb_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_unset_utterance_completed_cb_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_utterance_completed_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_unset_utterance_completed_cb(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_utterance_completed_cb_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is in create state.
+ */
+TEST_F(TTSTest, utc_tts_unset_utterance_completed_cb_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_utterance_completed_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unset_utterance_completed_cb(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_error_cb_p
+ * @since_tizen                2.3
+ * @description                test whether error callback function is set properly.
+ */
+TEST_F(TTSTest, utc_tts_set_error_cb_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_error_cb(g_tts, __tts_error_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+       ret = tts_set_error_cb(g_tts, __tts_error_cb, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_error_cb_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_set_error_cb_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_error_cb(NULL, __tts_error_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_set_error_cb(NULL, __tts_error_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_error_cb_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_set_error_cb_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_error_cb(NULL, __tts_error_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_set_error_cb(g_tts, __tts_error_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_error_cb_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is not in create state.
+ */
+TEST_F(TTSTest, utc_tts_set_error_cb_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_error_cb(NULL, __tts_error_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_set_error_cb(g_tts, __tts_error_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_error_cb_p
+ * @since_tizen                2.3
+ * @description                test whether error callback function is unset properly.
+ */
+TEST_F(TTSTest, utc_tts_unset_error_cb_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_error_cb(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_unset_error_cb(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_error_cb_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_unset_error_cb_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_error_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_unset_error_cb(NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_error_cb_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_unset_error_cb_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_error_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_unset_error_cb(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_error_cb_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is not in create state.
+ */
+TEST_F(TTSTest, utc_tts_unset_error_cb_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_error_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unset_error_cb(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_default_voice_changed_cb_p
+ * @since_tizen                2.3
+ * @description                test whether default_voice_changed callback function is set properly.
+ */
+TEST_F(TTSTest, utc_tts_set_default_voice_changed_cb_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_default_voice_changed_cb(g_tts, __tts_default_voice_changed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_default_voice_changed_cb(g_tts, __tts_default_voice_changed_cb, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_default_voice_changed_cb_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_set_default_voice_changed_cb_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_default_voice_changed_cb(NULL, __tts_default_voice_changed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_set_default_voice_changed_cb(NULL, __tts_default_voice_changed_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_default_voice_changed_cb_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_set_default_voice_changed_cb_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_default_voice_changed_cb(NULL, __tts_default_voice_changed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_set_default_voice_changed_cb(g_tts, __tts_default_voice_changed_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_default_voice_changed_cb_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is not in create state.
+ */
+TEST_F(TTSTest, utc_tts_set_default_voice_changed_cb_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_default_voice_changed_cb(NULL, __tts_default_voice_changed_cb, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_set_default_voice_changed_cb(g_tts, __tts_default_voice_changed_cb, NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_default_voice_changed_cb_p
+ * @since_tizen                2.3
+ * @description                test whether default_voice_changed callback function is unset properly.
+ */
+TEST_F(TTSTest, utc_tts_unset_default_voice_changed_cb_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_default_voice_changed_cb(g_tts);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_unset_default_voice_changed_cb(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_default_voice_changed_cb_n
+ * @since_tizen                2.3
+ * @description                test whether function returns error with NULL parameter.
+ */
+TEST_F(TTSTest, utc_tts_unset_default_voice_changed_cb_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_default_voice_changed_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       ret = tts_unset_default_voice_changed_cb(NULL);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_default_voice_changed_cb_n2
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts handle is already destroyed.
+ */
+TEST_F(TTSTest, utc_tts_unset_default_voice_changed_cb_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_default_voice_changed_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_destroy(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_unset_default_voice_changed_cb(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_create(&g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_unset_default_voice_changed_cb_n3
+ * @since_tizen                2.3
+ * @description                test whether function returns error when tts is not in create state.
+ */
+TEST_F(TTSTest, utc_tts_unset_default_voice_changed_cb_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_unset_default_voice_changed_cb(NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unset_default_voice_changed_cb(g_tts);
+       ASSERT_NE(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_get_error_message_n
+ * @since_tizen                3.0
+ * @description                Negative UTC for get error message (invalid parameter)
+ */
+ TEST_F(TTSTest, utc_tts_get_error_message_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_error_message(g_tts, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_get_error_message(g_tts, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase           utc_tts_get_private_data_p
+ * @since_tizen                3.0
+ * @description                Positive UTC for get private data
+ */
+TEST_F(TTSTest, utc_tts_get_private_data_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_private_data(g_tts, NULL, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       char *data = NULL;
+       ret = tts_get_private_data(g_tts, "version", &data);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+       free(data);
+
+       tts_unprepare(g_tts);
+}
+
+/**
+ * @testcase           utc_tts_get_private_data_n
+ * @since_tizen                3.0
+ * @description                Negative UTC for get private data (invalid parameter)
+ */
+TEST_F(TTSTest, utc_tts_get_private_data_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_private_data(g_tts, NULL, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_get_private_data(NULL, NULL, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase           utc_tts_get_private_data_n2
+ * @since_tizen                3.0
+ * @description                Negative UTC for get private data (invalid state)
+ */
+TEST_F(TTSTest, utc_tts_get_private_data_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_private_data(g_tts, NULL, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       char* data = NULL;
+       ret = tts_get_private_data(g_tts, "version", &data);
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase           utc_tts_get_private_data_n3
+ * @since_tizen                3.0
+ * @description                Negative UTC for get private data (invalid parameter)
+ */
+TEST_F(TTSTest, utc_tts_get_private_data_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_get_private_data(g_tts, NULL, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       char* data = NULL;
+       ret = tts_get_private_data(g_tts, NULL, &data);
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase           utc_tts_set_private_data_p
+ * @since_tizen                3.0
+ * @description                Positive UTC for set private data
+ */
+TEST_F(TTSTest, utc_tts_set_private_data_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_private_data(g_tts, NULL, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_set_private_data(g_tts, "version", "2.0");
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+/**
+ * @testcase           utc_tts_set_private_data_n
+ * @since_tizen                3.0
+ * @description                Negative UTC for set private data (invalid parameter)
+ */
+TEST_F(TTSTest, utc_tts_set_private_data_n)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_private_data(g_tts, NULL, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_private_data(NULL, NULL, NULL);
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase           utc_tts_set_private_data_n2
+ * @since_tizen                3.0
+ * @description                Negative UTC for set private data (invalid state)
+ */
+TEST_F(TTSTest, utc_tts_set_private_data_n2)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_private_data(g_tts, NULL, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_private_data(g_tts, "version", "2.0");
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_STATE);
+}
+
+/**
+ * @testcase           utc_tts_set_private_data_n3
+ * @since_tizen                3.0
+ * @description                Negative UTC for set private data (invalid parameter)
+ */
+TEST_F(TTSTest, utc_tts_set_private_data_n3)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_private_data(g_tts, NULL, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_private_data(g_tts, NULL, "2.0");
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase           utc_tts_set_credential_p
+ * @since_tizen                3.0
+ * @description                Positive UTC for set credential
+ */
+TEST_F(TTSTest, utc_tts_set_credential_p)
+{
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_credential(g_tts, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_set_credential(g_tts, "test");
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+}
+
+TEST_F(TTSTest, utc_tts_set_credential_n)
+{
+    int ret = tts_set_credential(NULL, "credential");
+    EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
+}
+
+/**
+ * @testcase           utc_tts_set_credential_n2
+ * @since_tizen                3.0
+ * @description                Negative UTC for set credential (invalid state)
+ */
+TEST_F(TTSTest, utc_tts_set_credential_n2)
+{
+       int utt_id;
+       int ret = TTS_ERROR_NONE;
+       if (g_supported == false) {
+               ret = tts_set_credential(g_tts, NULL);
+               EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
+               return;
+       }
+
+       EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
+
+       ret = tts_prepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       ret = tts_play(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_PLAYING != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_set_credential(g_tts, "test");
+       EXPECT_EQ(ret, TTS_ERROR_INVALID_STATE);
+
+       ret = tts_stop(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
+
+       while (TTS_STATE_READY != g_current_state) {
+               ecore_main_loop_iterate();
+       }
+
+       ret = tts_unprepare(g_tts);
+       EXPECT_EQ(ret, TTS_ERROR_NONE);
 }
 
 } // namespace