tests/src/tts_unittests.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18 #include <Ecore.h>
  19 #include <system_info.h>
  20 #include <tzplatform_config.h>
  21 #include <vconf.h>
  22
  23 #include <tts.h>
  24 #include <tts_internal.h>
  25 #include "system_info_mock.h"
  26
  27 static tts_h g_tts = NULL;
  28 static char *g_language = NULL;
  29 static int g_voice_type;
  30 static int is_created_hndl = -1;
  31 static bool g_supported = false;
  32 static tts_state_e g_current_state;
  33 static tts_service_state_e g_current_service_state = TTS_SERVICE_STATE_READY;
  34 static bool g_utterance_started_cb = false;
  35 static bool g_utterance_completed_cb = false;
  36 static bool g_screen_reader_changed_cb = false;
  37 static bool g_error_cb = false;
  38 static const char* g_test_engine = "test";
  39 static int g_utt_id = -1;
  40 static char* g_pcm_data = nullptr;
  41 static long g_pcm_size = 0;
  42 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,\
  43         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\
  44         representations like phonetic transcriptions into speech.\
  45         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; \
  46         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 \
  47         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.\
  48         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 \
  49         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.\
  50         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 \
  51         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 \
  52         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 \
  53         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 \
  54         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 \
  55         of the target prosody (pitch contour, phoneme durations),[4] which is then imposed on the output speech. From Wikipedia";
  56
  57 static const int g_sample_rate = 24000;
  58 static const char* ENGINE_VCONF_KEY = "db/voice/tts/engine/default";
  59 static const int STATE_CHECK_WAITING_TIME = 5;
  60
  61 static bool __tts_supported_voice_cb(tts_h tts, const char* language, int voice_type, void* user_data)
  62 {
  63         return true;
  64 }
  65
  66 static void __tts_state_changed_cb(tts_h tts, tts_state_e previous, tts_state_e current, void* user_data)
  67 {
  68         g_current_state = current;
  69 }
  70
  71 static void __tts_state_changed_cb_destroy_test(tts_h tts, tts_state_e previous, tts_state_e current, void* user_data)
  72 {
  73         g_current_state = current;
  74
  75         ASSERT_NE(tts_destroy(g_tts), TTS_ERROR_NONE);
  76 }
  77
  78 static void __tts_utterance_started_cb(tts_h tts, int utt_id, void* user_data)
  79 {
  80         g_utterance_started_cb = true;
  81 }
  82
  83 static void __tts_utterance_completed_cb(tts_h tts, int utt_id, void *user_data)
  84 {
  85         g_utterance_completed_cb = true;
  86         g_utt_id = utt_id;
  87 }
  88
  89 static void __tts_error_cb(tts_h tts, int utt_id, tts_error_e reason, void* user_data)
  90 {
  91         g_error_cb = true;
  92 }
  93
  94 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)
  95 {
  96 }
  97
  98 static void __tts_screen_reader_changed_cb(tts_h tts, bool is_on, void* user_data)
  99 {
 100         g_screen_reader_changed_cb = true;
 101 }
 102
 103 static void __tts_engine_changed_cb(tts_h tts, const char* engine_id, const char* language, int voice_type, bool need_credential, void* user_data)
 104 {
 105 }
 106
 107 static void __tts_service_state_changed_cb(tts_h tts, tts_service_state_e previous, tts_service_state_e current, void* user_data)
 108 {
 109         g_current_service_state = current;
 110 }
 111
 112 static bool __is_state_changed(tts_state_e state, int wait_delay)
 113 {
 114         int max_count = wait_delay * 10;
 115         int count = 0;
 116         while (max_count > count && state != g_current_state) {
 117                 ecore_main_loop_iterate();
 118                 usleep(100000);
 119                 count++;
 120         }
 121
 122         if (state != g_current_state) {
 123                 return false;
 124         }
 125
 126         return true;
 127 }
 128
 129 static bool __is_service_state_changed(tts_service_state_e service_state, int wait_delay)
 130 {
 131         int max_count = wait_delay * 10;
 132         int count = 0;
 133         while (max_count > count && service_state != g_current_service_state) {
 134                 ecore_main_loop_iterate();
 135                 usleep(100000);
 136                 count++;
 137         }
 138
 139         if (service_state != g_current_service_state) {
 140                 return false;
 141         }
 142
 143         return true;
 144 }
 145
 146 static bool __is_screen_reader_changed(int wait_delay)
 147 {
 148         int max_count = wait_delay * 10;
 149         int count = 0;
 150         while (max_count > count && false == g_screen_reader_changed_cb) {
 151                 ecore_main_loop_iterate();
 152                 usleep(100000);
 153                 count++;
 154         }
 155
 156         return g_screen_reader_changed_cb;
 157 }
 158
 159 static bool __is_error_occur(int wait_delay)
 160 {
 161         int max_count = wait_delay * 10;
 162         int count = 0;
 163         while (max_count > count && false == g_error_cb) {
 164                 ecore_main_loop_iterate();
 165                 usleep(100000);
 166                 count++;
 167         }
 168
 169         return g_error_cb;
 170 }
 171
 172 static void __get_test_PCM_Data()
 173 {
 174         const char* pcm_path = tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_APP"), "/org.tizen.tts-unittests/res/test_pcm.dat");
 175         FILE* fp_in = fopen(pcm_path, "rb");
 176         if (fp_in == nullptr) {
 177                 return;
 178         }
 179
 180         fseek(fp_in, 0, SEEK_END);
 181         long size = ftell(fp_in);
 182         fseek(fp_in, 0, SEEK_SET);
 183         if (size <= 0) {
 184                 fclose(fp_in);
 185                 return;
 186         }
 187
 188         char* data = (char*)calloc(sizeof(char), size);
 189         if (NULL == data) {
 190                 fclose(fp_in);
 191                 return;
 192         }
 193         size_t read_size = fread(data, sizeof(char), size, fp_in);
 194         fclose(fp_in);
 195
 196         if (read_size <= 0) {
 197                 free(data);
 198                 return;
 199         }
 200
 201         g_pcm_size = size;
 202         g_pcm_data = data;
 203
 204         return;
 205 }
 206
 207 static void __createTTSHandle()
 208 {
 209         g_current_state = TTS_STATE_CREATED;
 210         is_created_hndl = tts_create(&g_tts);
 211         if (g_supported == false) {
 212                 g_tts = nullptr;
 213                 return;
 214         }
 215
 216         EXPECT_EQ(tts_set_state_changed_cb(g_tts, __tts_state_changed_cb, nullptr), TTS_ERROR_NONE);
 217         EXPECT_EQ(tts_get_default_voice(g_tts, &g_language, &g_voice_type), TTS_ERROR_NONE);
 218 }
 219
 220 static void __setUttCb()
 221 {
 222         EXPECT_EQ(tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, nullptr), TTS_ERROR_NONE);
 223         EXPECT_EQ(tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, nullptr), TTS_ERROR_NONE);
 224 }
 225
 226 static void __destroyTTSHandle()
 227 {
 228         if (nullptr == g_tts) {
 229                 return;
 230         }
 231
 232         EXPECT_EQ(tts_destroy(g_tts), TTS_ERROR_NONE);
 233
 234         g_tts = nullptr;
 235 }
 236
 237 static void __clearGlobalValue()
 238 {
 239         free(g_language);
 240         g_language = nullptr;
 241
 242         is_created_hndl = -1;
 243
 244         free(g_pcm_data);
 245         g_pcm_data = nullptr;
 246         g_pcm_size = 0;
 247 }
 248
 249 namespace {
 250
 251 class TTSTest : public testing::Test {
 252         public:
 253                 virtual void SetUp() {
 254                         ecore_init();
 255                         system_info_get_platform_bool("http://tizen.org/feature/speech.synthesis", &g_supported);
 256                         g_supported = true;
 257
 258                         /* start of TC */
 259                         __createTTSHandle();
 260                 }
 261
 262                 virtual void TearDown() {
 263                         __destroyTTSHandle();
 264                         __clearGlobalValue();
 265
 266                         sleep(1);
 267                         ecore_shutdown();
 268                 }
 269 };
 270
 271 class TTSPreparedTest : public testing::Test {
 272         public:
 273                 virtual void SetUp() {
 274                         ecore_init();
 275                         system_info_get_platform_bool("http://tizen.org/feature/speech.synthesis", &g_supported);
 276                         g_supported = true;
 277
 278                         /* start of TC */
 279                         __createTTSHandle();
 280
 281                         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
 282                         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
 283                 }
 284
 285                 virtual void TearDown() {
 286                         EXPECT_EQ(tts_unprepare(g_tts), TTS_ERROR_NONE);
 287
 288                         __destroyTTSHandle();
 289                         __clearGlobalValue();
 290
 291                         sleep(1);
 292                         ecore_shutdown();
 293                 }
 294 };
 295
 296 class TTSPreparedWithUttCbTest : public testing::Test {
 297         public:
 298                 virtual void SetUp() {
 299                         ecore_init();
 300                         system_info_get_platform_bool("http://tizen.org/feature/speech.synthesis", &g_supported);
 301                         g_supported = true;
 302
 303                         /* start of TC */
 304                         __createTTSHandle();
 305                         __setUttCb();
 306
 307                         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
 308                         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
 309                 }
 310
 311                 virtual void TearDown() {
 312                         EXPECT_EQ(tts_unprepare(g_tts), TTS_ERROR_NONE);
 313
 314                         __destroyTTSHandle();
 315                         __clearGlobalValue();
 316
 317                         sleep(1);
 318                         ecore_shutdown();
 319                 }
 320 };
 321
 322 TEST_F(TTSTest, utc_tts_create_p)
 323 {
 324         if (g_supported == false) {
 325                 EXPECT_EQ(is_created_hndl, TTS_ERROR_NOT_SUPPORTED);
 326                 return;
 327         }
 328
 329         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 330 }
 331
 332 TEST_F(TTSTest, utc_tts_create_n)
 333 {
 334         int ret = tts_create(NULL);
 335         EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
 336 }
 337
 338 TEST_F(TTSTest, utc_tts_destroy_p)
 339 {
 340         int ret = TTS_ERROR_NONE;
 341         if (g_supported == false) {
 342                 ret = tts_destroy(g_tts);
 343                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 344                 return;
 345         }
 346
 347         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 348         ret = tts_destroy(g_tts);
 349         g_tts = NULL;
 350         EXPECT_EQ(ret, TTS_ERROR_NONE);
 351 }
 352
 353 TEST_F(TTSTest, utc_tts_destroy_p2)
 354 {
 355         int ret = TTS_ERROR_NONE;
 356         if (g_supported == false) {
 357         ret = tts_destroy(g_tts);
 358                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 359                 return;
 360         }
 361         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 362
 363         ret = tts_set_mode(g_tts, TTS_MODE_DEFAULT);
 364         EXPECT_EQ(ret, TTS_ERROR_NONE);
 365
 366         ret = tts_prepare(g_tts);
 367         EXPECT_EQ(ret, TTS_ERROR_NONE);
 368
 369         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
 370
 371         ret = tts_destroy(g_tts);
 372         g_tts = NULL;
 373         EXPECT_EQ(ret, TTS_ERROR_NONE);}
 374
 375 TEST_F(TTSTest, utc_tts_destroy_p3)
 376 {
 377         int ret = TTS_ERROR_NONE;
 378         if (g_supported == false) {
 379         ret = tts_destroy(g_tts);
 380                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 381                 return;
 382         }
 383         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 384
 385         ret = tts_set_mode(g_tts, TTS_MODE_NOTIFICATION);
 386         EXPECT_EQ(ret, TTS_ERROR_NONE);
 387
 388         ret = tts_prepare(g_tts);
 389         EXPECT_EQ(ret, TTS_ERROR_NONE);
 390
 391         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
 392
 393         ret = tts_destroy(g_tts);
 394         g_tts = NULL;
 395         EXPECT_EQ(ret, TTS_ERROR_NONE);
 396 }
 397
 398 /**
 399  * @testcase            utc_tts_destroy_p4
 400  * @since_tizen         2.3
 401  * @description         test whether multiple tts handles are destroyed properly
 402  */
 403 TEST_F(TTSTest, utc_tts_destroy_p4)
 404 {
 405         int ret = TTS_ERROR_NONE;
 406         if(g_supported == false){
 407                 ret = tts_destroy(g_tts);
 408                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 409                 return;
 410         }
 411
 412         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 413
 414         tts_h tts = NULL;
 415         ret = tts_create(&tts);
 416         EXPECT_EQ(ret, TTS_ERROR_NONE);
 417
 418         ret = tts_destroy(tts);
 419         tts = NULL;
 420         EXPECT_EQ(ret, TTS_ERROR_NONE);
 421
 422         ret = tts_destroy(g_tts);
 423         g_tts = NULL;
 424         EXPECT_EQ(ret, TTS_ERROR_NONE);
 425 }
 426
 427 TEST_F(TTSTest, utc_tts_destroy_n)
 428 {
 429         int ret = tts_destroy(NULL);
 430         EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
 431 }
 432
 433 TEST_F(TTSTest, utc_tts_destroy_n2)
 434 {
 435         int ret = TTS_ERROR_NONE;
 436         if (g_supported == false) {
 437                 ret = tts_destroy(NULL);
 438                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 439                 return;
 440         }
 441
 442         ret = tts_destroy(g_tts);
 443         EXPECT_EQ(ret, TTS_ERROR_NONE);
 444
 445         ret = tts_destroy(g_tts);
 446         ASSERT_NE(ret, TTS_ERROR_NONE);
 447
 448         ret = tts_create(&g_tts);
 449         EXPECT_EQ(ret, TTS_ERROR_NONE);
 450 }
 451
 452 TEST_F(TTSTest, utc_tts_destroy_n3)
 453 {
 454         if (g_supported == false) {
 455                 EXPECT_EQ(tts_destroy(g_tts), TTS_ERROR_NOT_SUPPORTED);
 456                 return;
 457         }
 458
 459         EXPECT_EQ(tts_set_state_changed_cb(g_tts, __tts_state_changed_cb_destroy_test, nullptr), TTS_ERROR_NONE);
 460         EXPECT_EQ(tts_prepare_sync(g_tts), TTS_ERROR_NONE);
 461 }
 462
 463 TEST_F(TTSTest, utc_tts_set_mode_p)
 464 {
 465         int ret = TTS_ERROR_NONE;
 466         if (g_supported == false) {
 467                 ret = tts_set_mode(g_tts, TTS_MODE_DEFAULT);
 468                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 469                 return;
 470         }
 471
 472         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 473
 474         ret = tts_set_mode(g_tts, TTS_MODE_DEFAULT);
 475         EXPECT_EQ(ret, TTS_ERROR_NONE);
 476 }
 477
 478 TEST_F(TTSTest, utc_tts_set_mode_p2)
 479 {
 480         int ret = TTS_ERROR_NONE;
 481         if (g_supported == false) {
 482                 ret = tts_set_mode(g_tts, TTS_MODE_SCREEN_READER);
 483                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 484                 return;
 485         }
 486
 487         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 488
 489         ret = tts_set_mode(g_tts, TTS_MODE_SCREEN_READER);
 490         EXPECT_EQ(ret, TTS_ERROR_NONE);
 491 }
 492
 493 TEST_F(TTSTest, utc_tts_set_mode_n)
 494 {
 495     int ret = tts_set_mode(NULL, TTS_MODE_DEFAULT);
 496     EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
 497 }
 498
 499 TEST_F(TTSPreparedTest, utc_tts_set_mode_n2)
 500 {
 501         int ret = TTS_ERROR_NONE;
 502         if (g_supported == false) {
 503                 ret = tts_set_mode(NULL, TTS_MODE_DEFAULT);
 504                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 505                 return;
 506         }
 507         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 508
 509         ret = tts_set_mode(g_tts, TTS_MODE_DEFAULT);
 510         ASSERT_NE(ret, TTS_ERROR_NONE);
 511 }
 512
 513 TEST_F(TTSTest, utc_tts_set_mode_n3)
 514 {
 515         int ret = TTS_ERROR_NONE;
 516         if (g_supported == false) {
 517                 ret = tts_set_mode(NULL, TTS_MODE_DEFAULT);
 518                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 519                 return;
 520         }
 521         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 522
 523         ret = tts_set_mode(g_tts, (tts_mode_e)100);
 524         ASSERT_NE(ret, TTS_ERROR_NONE);
 525 }
 526
 527 TEST_F(TTSTest, utc_tts_get_mode_p)
 528 {
 529         tts_mode_e mode;
 530         int ret = TTS_ERROR_NONE;
 531         if (g_supported == false) {
 532                 ret = tts_get_mode(g_tts, &mode);
 533                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 534                 return;
 535         }
 536
 537         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 538
 539         ret = tts_get_mode(g_tts, &mode);
 540         EXPECT_EQ(ret, TTS_ERROR_NONE);
 541
 542         return;
 543 }
 544
 545 TEST_F(TTSTest, utc_tts_get_mode_n)
 546 {
 547     tts_mode_e mode;
 548     int ret = tts_get_mode(NULL, &mode);
 549     EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
 550 }
 551
 552 TEST_F(TTSPreparedTest, utc_tts_get_mode_n2)
 553 {
 554         tts_mode_e mode;
 555         int ret = TTS_ERROR_NONE;
 556         if (g_supported == false) {
 557                 ret = tts_get_mode(g_tts, &mode);
 558                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 559                 return;
 560         }
 561         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 562
 563         ret = tts_get_mode(g_tts, &mode);
 564         ASSERT_NE(ret, TTS_ERROR_NONE);
 565 }
 566
 567 TEST_F(TTSTest, utc_tts_get_speed_range_p)
 568 {
 569         int min;
 570         int normal;
 571         int max;
 572         int ret = TTS_ERROR_NONE;
 573
 574         if (g_supported == false) {
 575                 ret = tts_get_speed_range(g_tts, &min, &normal, &max);
 576                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 577                 return;
 578         }
 579
 580         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 581         ret = tts_get_speed_range(g_tts, &min, &normal, &max);
 582         EXPECT_EQ(ret, TTS_ERROR_NONE);
 583 }
 584
 585 /**
 586  * @testcase            utc_tts_get_speed_range_n
 587  * @since_tizen         2.3
 588  * @description         test whether function returns error with NULL parameter.
 589  */
 590 TEST_F(TTSTest, utc_tts_get_speed_range_n)
 591 {
 592         int min;
 593         int normal;
 594         int max;
 595         int ret = TTS_ERROR_NONE;
 596
 597         if (g_supported == false) {
 598                 ret = tts_get_speed_range(NULL, &min, &normal, &max);
 599                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 600                 return;
 601         }
 602
 603         ret = tts_get_speed_range(NULL, &min, &normal, &max);
 604         ASSERT_NE(ret, TTS_ERROR_NONE);
 605 }
 606
 607 /**
 608  * @testcase            utc_tts_get_speed_range_n2
 609  * @since_tizen         2.3
 610  * @description         test whether function returns error when tts handle is already destroyed.
 611  */
 612 TEST_F(TTSTest, utc_tts_get_speed_range_n2)
 613 {
 614         int min;
 615         int normal;
 616         int max;
 617         int ret = TTS_ERROR_NONE;
 618
 619         if (g_supported == false) {
 620                 ret = tts_get_speed_range(NULL, &min, &normal, &max);
 621                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 622                 return;
 623         }
 624
 625         ret = tts_destroy(g_tts);
 626         EXPECT_EQ(ret, TTS_ERROR_NONE);
 627
 628         ret = tts_get_speed_range(g_tts, &min, &normal, &max);
 629         ASSERT_NE(ret, TTS_ERROR_NONE);
 630
 631         ret = tts_create(&g_tts);
 632         EXPECT_EQ(ret, TTS_ERROR_NONE);
 633 }
 634
 635 /**
 636  * @testcase            utc_tts_prepare_p
 637  * @since_tizen         2.3
 638  * @description         test whether tts daemon is prepared properly.
 639  */
 640 TEST_F(TTSTest, utc_tts_prepare_p)
 641 {
 642         int ret = TTS_ERROR_NONE;
 643         if (g_supported == false) {
 644                 ret = tts_prepare(g_tts);
 645                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 646                 return;
 647         }
 648
 649         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 650
 651         ret = tts_prepare(g_tts);
 652         EXPECT_EQ(ret, TTS_ERROR_NONE);
 653
 654         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
 655
 656         tts_unprepare(g_tts);
 657 }
 658
 659 TEST_F(TTSTest, utc_tts_prepare_n)
 660 {
 661     int ret = tts_prepare(NULL);
 662     EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
 663 }
 664
 665 /**
 666  * @testcase            utc_tts_prepare_n2
 667  * @since_tizen         2.3
 668  * @description         test whether function returns error when tts is ready state, not create state.
 669  */
 670 TEST_F(TTSTest, utc_tts_prepare_n2)
 671 {
 672         int ret = TTS_ERROR_NONE;
 673         if (g_supported == false) {
 674                 ret = tts_prepare(g_tts);
 675                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 676                 return;
 677         }
 678
 679         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 680
 681         ret = tts_prepare(g_tts);
 682         EXPECT_EQ(ret, TTS_ERROR_NONE);
 683
 684         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
 685
 686         ret = tts_prepare(g_tts);
 687         ASSERT_NE(ret, TTS_ERROR_NONE);
 688
 689         tts_unprepare(g_tts);
 690 }
 691
 692 /**
 693  * @testcase            utc_tts_prepare_n3
 694  * @since_tizen         2.3
 695  * @description         test whether function returns error when tts sets screen reader mode without feature on.
 696  */
 697 TEST_F(TTSTest, utc_tts_prepare_n3)
 698 {
 699         if (g_supported == false) {
 700                 EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NOT_SUPPORTED);
 701                 return;
 702         }
 703
 704         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 705
 706         EXPECT_EQ(tts_set_mode(g_tts, TTS_MODE_SCREEN_READER), TTS_ERROR_NONE);
 707         ASSERT_NE(tts_prepare(g_tts), TTS_ERROR_NONE);
 708 }
 709
 710 /**
 711  * @testcase            utc_tts_prepare_n4
 712  * @since_tizen         2.3
 713  * @description         test whether state does not change to ready. (expired handle)
 714  */
 715 TEST_F(TTSTest, utc_tts_prepare_n4)
 716 {
 717         if (g_supported == false) {
 718                 EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NOT_SUPPORTED);
 719                 return;
 720         }
 721
 722         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 723
 724         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
 725         EXPECT_EQ(tts_destroy(g_tts), TTS_ERROR_NONE);
 726
 727         EXPECT_EQ(false, __is_state_changed(TTS_STATE_READY, 5));
 728
 729         EXPECT_EQ(tts_create(&g_tts), TTS_ERROR_NONE);
 730 }
 731
 732 /**
 733  * @testcase            utc_tts_prepare_n5
 734  * @since_tizen         2.3
 735  * @description         test whether state does not change to ready. (screen reader feature off)
 736  */
 737 TEST_F(TTSTest, utc_tts_prepare_n5)
 738 {
 739         if (g_supported == false) {
 740                 EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NOT_SUPPORTED);
 741                 return;
 742         }
 743
 744         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 745
 746         EXPECT_EQ(tts_set_mode(g_tts, TTS_MODE_SCREEN_READER), TTS_ERROR_NONE);
 747         EXPECT_EQ(vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, true), 0);
 748
 749         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
 750
 751         EXPECT_EQ(vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, false), 0);
 752         EXPECT_EQ(false, __is_state_changed(TTS_STATE_READY, 5));
 753 }
 754
 755 /**
 756  * @testcase            utc_tts_prepare_sync_p
 757  * @since_tizen         2.3
 758  * @description         test whether tts daemon is prepared properly.
 759  */
 760 TEST_F(TTSTest, utc_tts_prepare_sync_p)
 761 {
 762         int ret = TTS_ERROR_NONE;
 763         if (g_supported == false) {
 764                 ret = tts_prepare_sync(g_tts);
 765                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 766                 return;
 767         }
 768
 769         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 770
 771         ret = tts_prepare_sync(g_tts);
 772         EXPECT_EQ(ret, TTS_ERROR_NONE);
 773
 774         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
 775         ret = tts_unprepare(g_tts);
 776         EXPECT_EQ(ret, TTS_ERROR_NONE);
 777 }
 778
 779 /**
 780  * @testcase            utc_tts_prepare_sync_n
 781  * @since_tizen         2.3
 782  * @description         test whether function returns error when tts is not created.
 783  */
 784 TEST_F(TTSTest, utc_tts_prepare_sync_n)
 785 {
 786         int ret = TTS_ERROR_NONE;
 787         if (g_supported == false) {
 788                 ret = tts_prepare_sync(NULL);
 789                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 790                 return;
 791         }
 792
 793         ret = tts_prepare_sync(NULL);
 794         EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
 795 }
 796
 797 /**
 798  * @testcase            utc_tts_prepare_sync_n2
 799  * @since_tizen         2.3
 800  * @description         test whether function returns error when tts is ready state, not create state.
 801  */
 802 TEST_F(TTSTest, utc_tts_prepare_sync_n2)
 803 {
 804         int ret = TTS_ERROR_NONE;
 805         if (g_supported == false) {
 806                 ret = tts_prepare_sync(g_tts);
 807                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 808                 return;
 809         }
 810
 811         ret = tts_prepare_sync(g_tts);
 812         EXPECT_EQ(ret, TTS_ERROR_NONE);
 813
 814         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
 815
 816         ret = tts_prepare_sync(g_tts);
 817         EXPECT_NE(ret, TTS_ERROR_NONE);
 818
 819         ret = tts_unprepare(g_tts);
 820         EXPECT_EQ(ret, TTS_ERROR_NONE);
 821 }
 822
 823 /**
 824  * @testcase            utc_tts_prepare_sync_n3
 825  * @since_tizen         2.3
 826  * @description         test whether function returns error when tts sets screen reader mode without feature on.
 827  */
 828 TEST_F(TTSTest, utc_tts_prepare_sync_n3)
 829 {
 830         if (g_supported == false) {
 831                 EXPECT_EQ(tts_prepare_sync(g_tts), TTS_ERROR_NOT_SUPPORTED);
 832                 return;
 833         }
 834
 835         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 836
 837         EXPECT_EQ(tts_set_mode(g_tts, TTS_MODE_SCREEN_READER), TTS_ERROR_NONE);
 838         ASSERT_NE(tts_prepare_sync(g_tts), TTS_ERROR_NONE);
 839 }
 840
 841 /**
 842  * @testcase            utc_tts_foreach_supported_voices_p
 843  * @since_tizen         2.3
 844  * @description         test whether each supported voices are gotten properly.
 845  */
 846 TEST_F(TTSTest, utc_tts_foreach_supported_voices_p)
 847 {
 848         int ret = TTS_ERROR_NONE;
 849         if (g_supported == false) {
 850                 ret = tts_foreach_supported_voices(g_tts, __tts_supported_voice_cb, NULL);
 851                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 852                 return;
 853         }
 854
 855         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 856         ret = tts_foreach_supported_voices(g_tts, __tts_supported_voice_cb, NULL);
 857         EXPECT_EQ(ret, TTS_ERROR_NONE);
 858 }
 859
 860 /**
 861  * @testcase            utc_tts_foreach_supported_voices_n
 862  * @since_tizen         2.3
 863  * @description         test whether function returns error with NULL parameter.
 864  */
 865 TEST_F(TTSTest, utc_tts_foreach_supported_voices_n)
 866 {
 867         int ret = TTS_ERROR_NONE;
 868         if (g_supported == false) {
 869                 ret = tts_foreach_supported_voices(NULL, __tts_supported_voice_cb, NULL);
 870                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 871                 return;
 872         }
 873
 874         ret = tts_foreach_supported_voices(NULL, __tts_supported_voice_cb, NULL);
 875         ASSERT_NE(ret, TTS_ERROR_NONE);
 876 }
 877
 878 /**
 879  * @testcase            utc_tts_foreach_supported_voices_n2
 880  * @since_tizen         2.3
 881  * @description         test whether function returns error when tts handle is already destroyed.
 882  */
 883 TEST_F(TTSTest, utc_tts_foreach_supported_voices_n2)
 884 {
 885         int ret = TTS_ERROR_NONE;
 886         if (g_supported == false) {
 887                 ret = tts_foreach_supported_voices(NULL, __tts_supported_voice_cb, NULL);
 888                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 889                 return;
 890         }
 891         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 892
 893         ret = tts_destroy(g_tts);
 894         EXPECT_EQ(ret, TTS_ERROR_NONE);
 895
 896         ret = tts_foreach_supported_voices(g_tts, __tts_supported_voice_cb, NULL);
 897         ASSERT_NE(ret, TTS_ERROR_NONE);
 898
 899         ret = tts_create(&g_tts);
 900         EXPECT_EQ(ret, TTS_ERROR_NONE);
 901 }
 902
 903
 904 /**
 905  * @testcase            utc_tts_get_default_voice_p
 906  * @since_tizen         2.3
 907  * @description         test whether default voice is gotten properly.
 908  */
 909 TEST_F(TTSTest, utc_tts_get_default_voice_p)
 910 {
 911         int ret = TTS_ERROR_NONE;
 912         if (g_supported == false) {
 913                 ret = tts_get_default_voice(g_tts, &g_language, &g_voice_type);
 914                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 915                 return;
 916         }
 917
 918         free (g_language);
 919         g_language = NULL;
 920         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 921         ret = tts_get_default_voice(g_tts, &g_language, &g_voice_type);
 922         EXPECT_EQ(ret, TTS_ERROR_NONE);
 923 }
 924
 925 /**
 926  * @testcase            utc_tts_get_default_voice_n
 927  * @since_tizen         2.3
 928  * @description         test whether function returns error with NULL parameter.
 929  */
 930 TEST_F(TTSTest, utc_tts_get_default_voice_n)
 931 {
 932         int ret = TTS_ERROR_NONE;
 933         if (g_supported == false) {
 934                 ret = tts_get_default_voice(NULL, &g_language, &g_voice_type);
 935                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 936                 return;
 937         }
 938
 939         free (g_language);
 940         g_language = NULL;
 941         ret = tts_get_default_voice(NULL, &g_language, &g_voice_type);
 942         ASSERT_NE(ret, TTS_ERROR_NONE);
 943 }
 944
 945 /**
 946  * @testcase            utc_tts_get_default_voice_n2
 947  * @since_tizen         2.3
 948  * @description         test whether function returns error when tts handle is already destroyed.
 949  */
 950 TEST_F(TTSTest, utc_tts_get_default_voice_n2)
 951 {
 952         int ret = TTS_ERROR_NONE;
 953         if (g_supported == false) {
 954                 ret = tts_get_default_voice(NULL, &g_language, &g_voice_type);
 955                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 956                 return;
 957         }
 958
 959         free (g_language);
 960         g_language = NULL;
 961         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 962
 963         ret = tts_destroy(g_tts);
 964         EXPECT_EQ(ret, TTS_ERROR_NONE);
 965
 966         ret = tts_get_default_voice(g_tts, &g_language, &g_voice_type);
 967         ASSERT_NE(ret, TTS_ERROR_NONE);
 968
 969         ret = tts_create(&g_tts);
 970         EXPECT_EQ(ret, TTS_ERROR_NONE);
 971 }
 972
 973 /**
 974  * @testcase            utc_tts_get_default_voice_n3
 975  * @since_tizen         2.3
 976  * @description         test whether function returns error with NULL parameter as type.
 977  */
 978 TEST_F(TTSTest, utc_tts_get_default_voice_n3)
 979 {
 980         int ret = TTS_ERROR_NONE;
 981         if (g_supported == false) {
 982                 ret = tts_get_default_voice(NULL, &g_language, &g_voice_type);
 983                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
 984                 return;
 985         }
 986
 987         free(g_language);
 988         g_language = NULL;
 989         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
 990
 991         ret = tts_get_default_voice(g_tts, &g_language, NULL);
 992         ASSERT_NE(ret, TTS_ERROR_NONE);
 993 }
 994
 995
 996 /**
 997  * @testcase            utc_tts_get_max_text_size_p
 998  * @since_tizen         2.3
 999  * @description         test whether max text size is gotten properly.
1000  */
1001 TEST_F(TTSPreparedTest, utc_tts_get_max_text_size_p)
1002 {
1003         unsigned int size;
1004         int ret = TTS_ERROR_NONE;
1005         if (g_supported == false) {
1006                 ret = tts_get_max_text_size(g_tts, &size);
1007                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1008                 return;
1009         }
1010
1011         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1012
1013         ret = tts_get_max_text_size(g_tts, &size);
1014         EXPECT_EQ(ret, TTS_ERROR_NONE);
1015 }
1016
1017 /**
1018  * @testcase            utc_tts_get_max_text_size_n
1019  * @since_tizen         2.3
1020  * @description         test whether function returns error with NULL parameter.
1021  */
1022 TEST_F(TTSTest, utc_tts_get_max_text_size_n)
1023 {
1024         unsigned int size;
1025         int ret = TTS_ERROR_NONE;
1026         if (g_supported == false) {
1027                 ret = tts_get_max_text_size(NULL, &size);
1028                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1029                 return;
1030         }
1031
1032         ret = tts_get_max_text_size(NULL, &size);
1033         ASSERT_NE(ret, TTS_ERROR_NONE);
1034 }
1035
1036 /**
1037  * @testcase            utc_tts_get_max_text_size_n2
1038  * @since_tizen         2.3
1039  * @description         test whether function returns error when tts handle is already destroyed.
1040  */
1041 TEST_F(TTSTest, utc_tts_get_max_text_size_n2)
1042 {
1043         unsigned int size;
1044         int ret = TTS_ERROR_NONE;
1045         if (g_supported == false) {
1046                 ret = tts_get_max_text_size(NULL, &size);
1047                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1048                 return;
1049         }
1050         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1051
1052         ret = tts_destroy(g_tts);
1053         EXPECT_EQ(ret, TTS_ERROR_NONE);
1054
1055         ret = tts_get_max_text_size(g_tts, &size);
1056         ASSERT_NE(ret, TTS_ERROR_NONE);
1057
1058         ret = tts_create(&g_tts);
1059         EXPECT_EQ(ret, TTS_ERROR_NONE);
1060 }
1061
1062
1063 /**
1064  * @testcase            utc_tts_get_max_text_size_n3
1065  * @since_tizen         2.3
1066  * @description         test whether function returns error when tts is in create state.
1067  */
1068 TEST_F(TTSTest, utc_tts_get_max_text_size_n3)
1069 {
1070         unsigned int size;
1071         int ret = TTS_ERROR_NONE;
1072         if (g_supported == false) {
1073                 ret = tts_get_max_text_size(NULL, &size);
1074                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1075                 return;
1076         }
1077         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1078
1079         ret = tts_get_max_text_size(g_tts, &size);
1080         ASSERT_NE(ret, TTS_ERROR_NONE);
1081 }
1082
1083
1084 /**
1085  * @testcase            utc_tts_get_state_p
1086  * @since_tizen         2.3
1087  * @description         test whether state is gotten properly in create state.
1088  */
1089 TEST_F(TTSTest, utc_tts_get_state_p)
1090 {
1091         tts_state_e state;
1092         int ret = TTS_ERROR_NONE;
1093         if (g_supported == false) {
1094                 ret = tts_get_state(g_tts, &state);
1095                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1096                 return;
1097         }
1098
1099         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1100
1101         ret = tts_get_state(g_tts, &state);
1102         EXPECT_EQ(ret, TTS_ERROR_NONE);
1103 }
1104
1105 /**
1106  * @testcase            utc_tts_get_state_p2
1107  * @since_tizen         2.3
1108  * @description         test whether state is gotten properly in ready state.
1109  */
1110 TEST_F(TTSPreparedTest, utc_tts_get_state_p2)
1111 {
1112         tts_state_e state;
1113         int ret = TTS_ERROR_NONE;
1114         if (g_supported == false) {
1115                 ret = tts_get_state(g_tts, &state);
1116                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1117                 return;
1118         }
1119         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1120
1121         ret = tts_get_state(g_tts, &state);
1122         EXPECT_EQ(ret, TTS_ERROR_NONE);
1123 }
1124
1125
1126 /**
1127  * @testcase            utc_tts_get_state_p3
1128  * @since_tizen         2.3
1129  * @description         test whether state is gotten properly in play state.
1130  */
1131 TEST_F(TTSPreparedTest, utc_tts_get_state_p3)
1132 {
1133         tts_state_e state;
1134         int ret = TTS_ERROR_NONE;
1135         if (g_supported == false) {
1136                 ret = tts_get_state(g_tts, &state);
1137                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1138                 return;
1139         }
1140         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1141
1142         ret = tts_play(g_tts);
1143         EXPECT_EQ(ret, TTS_ERROR_NONE);
1144
1145         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
1146
1147         ret = tts_get_state(g_tts, &state);
1148         EXPECT_EQ(ret, TTS_ERROR_NONE);
1149
1150         ret = tts_stop(g_tts);
1151         EXPECT_EQ(ret, TTS_ERROR_NONE);
1152
1153         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1154 }
1155
1156 /**
1157  * @testcase            utc_tts_get_state_p4
1158  * @since_tizen         2.3
1159  * @description         test whether state is gotten properly in pause state.
1160  */
1161 TEST_F(TTSPreparedTest, utc_tts_get_state_p4)
1162 {
1163         tts_state_e state;
1164         int ret = TTS_ERROR_NONE;
1165         if (g_supported == false) {
1166                 ret = tts_get_state(g_tts, &state);
1167                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1168                 return;
1169         }
1170         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1171
1172         ret = tts_play(g_tts);
1173         EXPECT_EQ(ret, TTS_ERROR_NONE);
1174
1175         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
1176
1177         ret = tts_pause(g_tts);
1178         EXPECT_EQ(ret, TTS_ERROR_NONE);
1179
1180         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PAUSED, 5));
1181
1182         ret = tts_get_state(g_tts, &state);
1183         EXPECT_EQ(ret, TTS_ERROR_NONE);
1184
1185         ret = tts_stop(g_tts);
1186         EXPECT_EQ(ret, TTS_ERROR_NONE);
1187
1188         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1189 }
1190
1191
1192 /**
1193  * @testcase            utc_tts_get_state_n
1194  * @since_tizen         2.3
1195  * @description         test whether function returns error with NULL parameter.
1196  */
1197 TEST_F(TTSTest, utc_tts_get_state_n)
1198 {
1199         tts_state_e state;
1200         int ret = TTS_ERROR_NONE;
1201         if (g_supported == false) {
1202                 ret = tts_get_state(NULL, &state);
1203                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1204                 return;
1205         }
1206         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1207
1208         ret = tts_get_state(NULL, &state);
1209         ASSERT_NE(ret, TTS_ERROR_NONE);
1210 }
1211
1212 /**
1213  * @testcase            utc_tts_get_state_n2
1214  * @since_tizen         2.3
1215  * @description         test whether function returns error when tts handle is already destroyed.
1216  */
1217 TEST_F(TTSTest, utc_tts_get_state_n2)
1218 {
1219         tts_state_e state;
1220         int ret = TTS_ERROR_NONE;
1221         if (g_supported == false) {
1222                 ret = tts_get_state(g_tts, &state);
1223                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1224                 return;
1225         }
1226         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1227
1228         ret = tts_destroy(g_tts);
1229         EXPECT_EQ(ret, TTS_ERROR_NONE);
1230
1231         ret = tts_get_state(g_tts, &state);
1232         ASSERT_NE(ret, TTS_ERROR_NONE);
1233
1234         ret = tts_create(&g_tts);
1235         EXPECT_EQ(ret, TTS_ERROR_NONE);
1236 }
1237
1238
1239 /**
1240  * @testcase            utc_tts_get_service_state_p
1241  * @since_tizen         7.0
1242  * @description         test whether state is gotten properly in service state ready
1243  */
1244 TEST_F(TTSPreparedTest, utc_tts_get_service_state_p)
1245 {
1246         tts_service_state_e state;
1247         if (g_supported == false) {
1248                 EXPECT_EQ(tts_get_service_state(g_tts, &state), TTS_ERROR_NOT_SUPPORTED);
1249                 return;
1250         }
1251
1252         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1253
1254         EXPECT_EQ(tts_get_service_state(g_tts, &state), TTS_ERROR_NONE);
1255         EXPECT_EQ(state, TTS_SERVICE_STATE_READY);
1256 }
1257
1258 /**
1259  * @testcase            utc_tts_get_service_state_p2
1260  * @since_tizen         7.0
1261  * @description         test whether state is gotten properly when client requests to play.
1262  */
1263 TEST_F(TTSTest, utc_tts_get_service_state_p2)
1264 {
1265         tts_service_state_e state;
1266         if (g_supported == false) {
1267                 EXPECT_EQ(tts_get_service_state(g_tts, &state), TTS_ERROR_NOT_SUPPORTED);
1268                 return;
1269         }
1270         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1271
1272         g_current_service_state = TTS_SERVICE_STATE_READY;
1273         EXPECT_EQ(tts_set_service_state_changed_cb(g_tts, __tts_service_state_changed_cb, nullptr), TTS_ERROR_NONE);
1274         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
1275         EXPECT_EQ(__is_state_changed(TTS_STATE_READY, STATE_CHECK_WAITING_TIME), true);
1276
1277         EXPECT_EQ(tts_get_service_state(g_tts, &state), TTS_ERROR_NONE);
1278         EXPECT_EQ(state, TTS_SERVICE_STATE_READY);
1279
1280         int utt_id = 0;
1281         EXPECT_EQ(tts_add_text(g_tts, "1 2 3 4 5", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id), TTS_ERROR_NONE);
1282         EXPECT_EQ(tts_play(g_tts), TTS_ERROR_NONE);
1283
1284         EXPECT_EQ(tts_get_service_state(g_tts, &state), TTS_ERROR_NONE);
1285         EXPECT_EQ(state, TTS_SERVICE_STATE_SYNTHESIZING);
1286
1287         EXPECT_EQ(__is_service_state_changed(TTS_SERVICE_STATE_PLAYING, STATE_CHECK_WAITING_TIME), true);
1288         EXPECT_EQ(tts_get_service_state(g_tts, &state), TTS_ERROR_NONE);
1289         EXPECT_EQ(state, TTS_SERVICE_STATE_PLAYING);
1290
1291         EXPECT_EQ(tts_stop(g_tts), TTS_ERROR_NONE);
1292
1293         EXPECT_EQ(tts_unprepare(g_tts), TTS_ERROR_NONE);
1294 }
1295
1296 /**
1297  * @testcase            utc_tts_get_service_state_n
1298  * @since_tizen         7.0
1299  * @description         test whether function returns error with NULL parameter.
1300  */
1301 TEST_F(TTSPreparedTest, utc_tts_get_service_state_n)
1302 {
1303         tts_service_state_e state;
1304         if (g_supported == false) {
1305                 EXPECT_EQ(tts_get_service_state(nullptr, &state), TTS_ERROR_NOT_SUPPORTED);
1306                 return;
1307         }
1308         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1309
1310         EXPECT_EQ(tts_get_service_state(nullptr, &state), TTS_ERROR_INVALID_PARAMETER);
1311 }
1312
1313 /**
1314  * @testcase            utc_tts_get_service_state_n2
1315  * @since_tizen         7.0
1316  * @description         test whether function returns error when tts handle is already destroyed.
1317  */
1318 TEST_F(TTSTest, utc_tts_get_service_state_n2)
1319 {
1320         tts_service_state_e state;
1321         if (g_supported == false) {
1322                 EXPECT_EQ(tts_get_service_state(g_tts, &state), TTS_ERROR_NOT_SUPPORTED);
1323                 return;
1324         }
1325         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1326
1327         EXPECT_EQ(tts_destroy(g_tts), TTS_ERROR_NONE);
1328         EXPECT_EQ(tts_get_service_state(g_tts, &state), TTS_ERROR_INVALID_PARAMETER);
1329         EXPECT_EQ(tts_create(&g_tts), TTS_ERROR_NONE);
1330 }
1331
1332 /**
1333  * @testcase            utc_tts_get_service_state_n3
1334  * @since_tizen         7.0
1335  * @description         test whether function returns error when tts is in create state.
1336  */
1337 TEST_F(TTSTest, utc_tts_get_service_state_n3)
1338 {
1339         tts_service_state_e state;
1340         if (g_supported == false) {
1341                 EXPECT_EQ(tts_get_service_state(g_tts, &state), TTS_ERROR_NOT_SUPPORTED);
1342                 return;
1343         }
1344         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1345
1346         EXPECT_EQ(tts_get_service_state(g_tts, &state), TTS_ERROR_INVALID_STATE);
1347 }
1348
1349
1350 /**
1351  * @testcase            utc_tts_add_text_p
1352  * @since_tizen         2.3
1353  * @description         test whether text is added properly.
1354  */
1355 TEST_F(TTSPreparedTest, utc_tts_add_text_p)
1356 {
1357         int utt_id;
1358         int ret = TTS_ERROR_NONE;
1359         if (g_supported == false) {
1360                 ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1361                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1362                 return;
1363         }
1364         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1365
1366         ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1367         EXPECT_EQ(ret, TTS_ERROR_NONE);
1368 }
1369
1370 /**
1371  * @testcase            utc_tts_add_text_n
1372  * @since_tizen         2.3
1373  * @description         test whether function returns error with NULL parameter.
1374  */
1375 TEST_F(TTSTest, utc_tts_add_text_n)
1376 {
1377         int utt_id;
1378         int ret = TTS_ERROR_NONE;
1379         if (g_supported == false) {
1380                 ret = tts_add_text(NULL, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1381                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1382                 return;
1383         }
1384         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1385
1386         ret = tts_add_text(NULL, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1387         ASSERT_NE(ret, TTS_ERROR_NONE);
1388 }
1389
1390 /**
1391  * @testcase            utc_tts_add_text_n2
1392  * @since_tizen         2.3
1393  * @description         test whether function returns error when tts handle is already destroyed.
1394  */
1395 TEST_F(TTSTest, utc_tts_add_text_n2)
1396 {
1397         int utt_id;
1398         int ret = TTS_ERROR_NONE;
1399         if (g_supported == false) {
1400                 ret = tts_add_text(NULL, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1401                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1402                 return;
1403         }
1404         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1405
1406         ret = tts_destroy(g_tts);
1407         EXPECT_EQ(ret, TTS_ERROR_NONE);
1408
1409         ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1410         ASSERT_NE(ret, TTS_ERROR_NONE);
1411
1412         ret = tts_create(&g_tts);
1413         EXPECT_EQ(ret, TTS_ERROR_NONE);
1414 }
1415
1416 /**
1417  * @testcase            utc_tts_add_text_n3
1418  * @since_tizen         2.3
1419  * @description         test whether function returns error when tts is in create state.
1420  */
1421 TEST_F(TTSTest, utc_tts_add_text_n3)
1422 {
1423         int utt_id;
1424         int ret = TTS_ERROR_NONE;
1425         if (g_supported == false) {
1426                 ret = tts_add_text(NULL, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1427                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1428                 return;
1429         }
1430         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1431
1432         ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1433         ASSERT_NE(ret, TTS_ERROR_NONE);
1434 }
1435
1436 /**
1437  * @testcase            utc_tts_add_text_n4
1438  * @since_tizen         2.3
1439  * @description         test whether function returns error when text is over max text size.
1440  */
1441 TEST_F(TTSPreparedTest, utc_tts_add_text_n4)
1442 {
1443         int utt_id;
1444         int ret = TTS_ERROR_NONE;
1445         if (g_supported == false) {
1446                 ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1447                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1448                 return;
1449         }
1450         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1451
1452         ret = tts_add_text(g_tts, g_text, g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1453         ASSERT_NE(ret, TTS_ERROR_NONE);
1454 }
1455
1456 /**
1457  * @testcase            utc_tts_add_text_n5
1458  * @since_tizen         2.3
1459  * @description         test whether function returns error when tts speed is abnormal.
1460  */
1461 TEST_F(TTSPreparedTest, utc_tts_add_text_n5)
1462 {
1463         int utt_id;
1464         int speed = -1;
1465         int ret = TTS_ERROR_NONE;
1466         if (g_supported == false) {
1467                 ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1468                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1469                 return;
1470         }
1471         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1472
1473         ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, speed, &utt_id);
1474         ASSERT_NE(ret, TTS_ERROR_NONE);
1475 }
1476
1477 /**
1478  * @testcase            utc_tts_add_text_n6
1479  * @since_tizen         2.3
1480  * @description         test whether function returns error with empty string.
1481  */
1482 TEST_F(TTSPreparedTest, utc_tts_add_text_n6)
1483 {
1484         int utt_id;
1485         if (g_supported == false) {
1486                 EXPECT_EQ(tts_add_text(g_tts, "", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id), TTS_ERROR_NOT_SUPPORTED);
1487                 return;
1488         }
1489         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1490
1491         EXPECT_NE(tts_add_text(g_tts, "", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id), TTS_ERROR_NONE);
1492 }
1493
1494 /**
1495  * @testcase            utc_tts_play_p
1496  * @since_tizen         2.3
1497  * @description         test whether tts is played properly.
1498  */
1499 TEST_F(TTSPreparedTest, utc_tts_play_p)
1500 {
1501         int ret = TTS_ERROR_NONE;
1502         if (g_supported == false) {
1503                 ret = tts_play(g_tts);
1504                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1505                 return;
1506         }
1507
1508         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1509
1510         ret = tts_play(g_tts);
1511         EXPECT_EQ(ret, TTS_ERROR_NONE);
1512
1513         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
1514
1515         ret = tts_stop(g_tts);
1516         EXPECT_EQ(ret, TTS_ERROR_NONE);
1517
1518         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1519 }
1520
1521 /**
1522  * @testcase            utc_tts_play_p2
1523  * @since_tizen         2.3
1524  * @description         test whether tts is played all text properly.
1525  */
1526 TEST_F(TTSPreparedWithUttCbTest, utc_tts_play_p2)
1527 {
1528         int utt_id;
1529         int ret = TTS_ERROR_NONE;
1530
1531         if (g_supported == false) {
1532                 ret = tts_play(g_tts);
1533                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1534                 return;
1535         }
1536         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1537
1538         g_utterance_completed_cb = false;
1539
1540         ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1541         EXPECT_EQ(ret, TTS_ERROR_NONE);
1542
1543         ret = tts_play(g_tts);
1544         EXPECT_EQ(ret, TTS_ERROR_NONE);
1545
1546         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
1547
1548         while (true != g_utterance_completed_cb) {
1549                 ecore_main_loop_iterate();
1550         }
1551
1552         ret = tts_stop(g_tts);
1553         EXPECT_EQ(ret, TTS_ERROR_NONE);
1554
1555         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1556 }
1557
1558 /**
1559  * @testcase            utc_tts_play_p3
1560  * @since_tizen         2.3
1561  * @description         test whether tts is played all text properly.
1562  */
1563 TEST_F(TTSPreparedWithUttCbTest, utc_tts_play_p3)
1564 {
1565         if (g_supported == false) {
1566                 EXPECT_EQ(tts_play(g_tts), TTS_ERROR_NOT_SUPPORTED);
1567                 return;
1568         }
1569
1570         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1571
1572         g_utterance_completed_cb = false;
1573
1574         int utt_id1 = -1;
1575         int utt_id2 = -1;
1576         EXPECT_EQ(tts_add_text(g_tts, "1 2 3 4 5", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id1), TTS_ERROR_NONE);
1577         EXPECT_EQ(tts_add_text(g_tts, "1 2 3 4 5", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id2), TTS_ERROR_NONE);
1578
1579         EXPECT_EQ(tts_play(g_tts), TTS_ERROR_NONE);
1580         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
1581
1582         while (true != g_utterance_completed_cb) {
1583                 ecore_main_loop_iterate();
1584         }
1585         g_utterance_completed_cb = false;
1586         EXPECT_EQ(utt_id1, g_utt_id);
1587
1588         while (true != g_utterance_completed_cb) {
1589                 ecore_main_loop_iterate();
1590         }
1591         EXPECT_EQ(utt_id2, g_utt_id);
1592
1593         EXPECT_EQ(tts_stop(g_tts), TTS_ERROR_NONE);
1594         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1595 }
1596
1597 /**
1598  * @testcase            utc_tts_play_p4
1599  * @since_tizen         2.3
1600  * @description         test whether tts is played properly.
1601  */
1602 TEST_F(TTSPreparedTest, utc_tts_play_p4)
1603 {
1604         if (g_supported == false) {
1605                 EXPECT_EQ(tts_play(g_tts), TTS_ERROR_NOT_SUPPORTED);
1606                 return;
1607         }
1608
1609         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1610
1611         tts_h tts = NULL;
1612         EXPECT_EQ(tts_create(&tts), TTS_ERROR_NONE);
1613         EXPECT_EQ(tts_prepare_sync(tts), TTS_ERROR_NONE);
1614
1615         EXPECT_EQ(tts_play(g_tts), TTS_ERROR_NONE);
1616         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
1617
1618         EXPECT_EQ(tts_play(tts), TTS_ERROR_NONE);
1619         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1620
1621         EXPECT_EQ(tts_stop(g_tts), TTS_ERROR_NONE);
1622         EXPECT_EQ(tts_stop(tts), TTS_ERROR_NONE);
1623         EXPECT_EQ(tts_unprepare(tts), TTS_ERROR_NONE);
1624         EXPECT_EQ(tts_destroy(tts), TTS_ERROR_NONE);
1625         tts = NULL;
1626 }
1627
1628 /**
1629  * @testcase            utc_tts_play_n
1630  * @since_tizen         2.3
1631  * @description         test whether function returns error with NULL parameter.
1632  */
1633 TEST_F(TTSTest, utc_tts_play_n)
1634 {
1635         int ret = TTS_ERROR_NONE;
1636         if (g_supported == false) {
1637                 ret = tts_play(NULL);
1638                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1639                 return;
1640         }
1641         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1642
1643         ret = tts_play(NULL);
1644         ASSERT_NE(ret, TTS_ERROR_NONE);
1645 }
1646
1647 /**
1648  * @testcase            utc_tts_play_n2
1649  * @since_tizen         2.3
1650  * @description         test whether function returns error when tts handle is already destroyed.
1651  */
1652 TEST_F(TTSTest, utc_tts_play_n2)
1653 {
1654         int ret = TTS_ERROR_NONE;
1655         if (g_supported == false) {
1656                 ret = tts_play(g_tts);
1657                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1658                 return;
1659         }
1660         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1661
1662         ret = tts_destroy(g_tts);
1663         EXPECT_EQ(ret, TTS_ERROR_NONE);
1664
1665         ret = tts_play(g_tts);
1666         ASSERT_NE(ret, TTS_ERROR_NONE);
1667
1668         ret = tts_create(&g_tts);
1669         EXPECT_EQ(ret, TTS_ERROR_NONE);
1670 }
1671
1672 /**
1673  * @testcase            utc_tts_play_n3
1674  * @since_tizen         2.3
1675  * @description         test whether function returns error when tts is in create state.
1676  */
1677 TEST_F(TTSTest, utc_tts_play_n3)
1678 {
1679         int ret = TTS_ERROR_NONE;
1680         if (g_supported == false) {
1681                 ret = tts_play(g_tts);
1682                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1683                 return;
1684         }
1685         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1686
1687         ret = tts_play(g_tts);
1688         ASSERT_NE(ret, TTS_ERROR_NONE);
1689 }
1690
1691 /**
1692  * @testcase            utc_tts_play_n4
1693  * @since_tizen         2.3
1694  * @description         test whether function returns error when interrupt mode client plays.
1695  */
1696 TEST_F(TTSPreparedTest, utc_tts_play_n4)
1697 {
1698         if (g_supported == false) {
1699                 EXPECT_EQ(tts_play(g_tts), TTS_ERROR_NOT_SUPPORTED);
1700                 return;
1701         }
1702
1703         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1704
1705         tts_h tts = NULL;
1706         EXPECT_EQ(tts_create(&tts), TTS_ERROR_NONE);
1707         EXPECT_EQ(tts_set_mode(tts, (tts_mode_e)TTS_MODE_INTERRUPT), TTS_ERROR_NONE);
1708         EXPECT_EQ(tts_prepare_sync(tts), TTS_ERROR_NONE);
1709
1710         EXPECT_EQ(tts_play(tts), TTS_ERROR_NONE);
1711         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1712
1713         EXPECT_NE(tts_play(g_tts), TTS_ERROR_NONE);
1714
1715         EXPECT_EQ(tts_stop(tts), TTS_ERROR_NONE);
1716         EXPECT_EQ(tts_unprepare(tts), TTS_ERROR_NONE);
1717         EXPECT_EQ(tts_destroy(tts), TTS_ERROR_NONE);
1718         tts = NULL;
1719 }
1720
1721 /**
1722  * @testcase            utc_tts_pause_p
1723  * @since_tizen         2.3
1724  * @description         test whether tts is paused properly.
1725  */
1726 TEST_F(TTSPreparedTest, utc_tts_pause_p)
1727 {
1728         int ret = TTS_ERROR_NONE;
1729         if (g_supported == false) {
1730                 ret = tts_pause(g_tts);
1731                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1732                 return;
1733         }
1734
1735         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1736
1737         ret = tts_play(g_tts);
1738         EXPECT_EQ(ret, TTS_ERROR_NONE);
1739
1740         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
1741
1742         ret = tts_pause(g_tts);
1743         EXPECT_EQ(ret, TTS_ERROR_NONE);
1744
1745         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PAUSED, 5));
1746
1747         ret = tts_stop(g_tts);
1748         EXPECT_EQ(ret, TTS_ERROR_NONE);
1749
1750         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1751 }
1752
1753 /**
1754  * @testcase            utc_tts_pause_n
1755  * @since_tizen         2.3
1756  * @description         test whether function returns error with NULL parameter.
1757  */
1758 TEST_F(TTSTest, utc_tts_pause_n)
1759 {
1760         int ret = TTS_ERROR_NONE;
1761         if (g_supported == false) {
1762                 ret = tts_pause(NULL);
1763                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1764                 return;
1765         }
1766         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1767
1768         ret = tts_pause(NULL);
1769         ASSERT_NE(ret, TTS_ERROR_NONE);
1770 }
1771
1772 /**
1773  * @testcase            utc_tts_pause_n2
1774  * @since_tizen         2.3
1775  * @description         test whether function returns error when tts handle is already destroyed.
1776  */
1777 TEST_F(TTSTest, utc_tts_pause_n2)
1778 {
1779         int ret = TTS_ERROR_NONE;
1780         if (g_supported == false) {
1781                 ret = tts_pause(NULL);
1782                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1783                 return;
1784         }
1785         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1786
1787         ret = tts_destroy(g_tts);
1788         EXPECT_EQ(ret, TTS_ERROR_NONE);
1789
1790         ret = tts_pause(g_tts);
1791         ASSERT_NE(ret, TTS_ERROR_NONE);
1792
1793         ret = tts_create(&g_tts);
1794         EXPECT_EQ(ret, TTS_ERROR_NONE);
1795 }
1796
1797 /**
1798  * @testcase            utc_tts_pause_n3
1799  * @since_tizen         2.3
1800  * @description         test whether function returns error when tts is in create state.
1801  */
1802 TEST_F(TTSTest, utc_tts_pause_n3)
1803 {
1804         int ret = TTS_ERROR_NONE;
1805         if (g_supported == false) {
1806                 ret = tts_pause(NULL);
1807                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1808                 return;
1809         }
1810         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1811
1812         ret = tts_pause(g_tts);
1813         ASSERT_NE(ret, TTS_ERROR_NONE);
1814 }
1815
1816 /**
1817  * @testcase            utc_tts_stop_p
1818  * @since_tizen         2.3
1819  * @description         test whether tts is stopped properly.
1820  */
1821 TEST_F(TTSPreparedTest, utc_tts_stop_p)
1822 {
1823         int ret = TTS_ERROR_NONE;
1824         if (g_supported == false) {
1825                 ret = tts_stop(g_tts);
1826                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1827                 return;
1828         }
1829
1830         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1831
1832         ret = tts_play(g_tts);
1833         EXPECT_EQ(ret, TTS_ERROR_NONE);
1834
1835         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
1836
1837         ret = tts_stop(g_tts);
1838         EXPECT_EQ(ret, TTS_ERROR_NONE);
1839
1840         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1841 }
1842
1843 /**
1844  * @testcase            utc_tts_stop_n
1845  * @since_tizen         2.3
1846  * @description         test whether function returns error with NULL parameter.
1847  */
1848 TEST_F(TTSTest, utc_tts_stop_n)
1849 {
1850         int ret = TTS_ERROR_NONE;
1851         if (g_supported == false) {
1852                 ret = tts_stop(NULL);
1853                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1854                 return;
1855         }
1856         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1857
1858         ret = tts_stop(NULL);
1859         ASSERT_NE(ret, TTS_ERROR_NONE);
1860 }
1861
1862 /**
1863  * @testcase            utc_tts_stop_n2
1864  * @since_tizen         2.3
1865  * @description         test whether function returns error when tts handle is already destroyed.
1866  */
1867 TEST_F(TTSTest, utc_tts_stop_n2)
1868 {
1869         int ret = TTS_ERROR_NONE;
1870         if (g_supported == false) {
1871                 ret = tts_stop(NULL);
1872                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1873                 return;
1874         }
1875         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1876
1877         ret = tts_destroy(g_tts);
1878         EXPECT_EQ(ret, TTS_ERROR_NONE);
1879
1880         ret = tts_stop(g_tts);
1881         ASSERT_NE(ret, TTS_ERROR_NONE);
1882
1883         ret = tts_create(&g_tts);
1884         EXPECT_EQ(ret, TTS_ERROR_NONE);
1885 }
1886
1887 /**
1888  * @testcase            utc_tts_stop_n3
1889  * @since_tizen         2.3
1890  * @description         test whether function returns error when tts is in create state.
1891  */
1892 TEST_F(TTSTest, utc_tts_stop_n3)
1893 {
1894         int ret = TTS_ERROR_NONE;
1895         if (g_supported == false) {
1896                 ret = tts_stop(NULL);
1897                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1898                 return;
1899         }
1900         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1901
1902         ret = tts_stop(g_tts);
1903         ASSERT_NE(ret, TTS_ERROR_NONE);
1904 }
1905
1906 /**
1907  * @testcase            utc_tts_repeat_p
1908  * @since_tizen         5.0
1909  * @description         test whether tts is repeated properly.
1910  */
1911 TEST_F(TTSPreparedWithUttCbTest, utc_tts_repeat_p)
1912 {
1913         int ret = TTS_ERROR_NONE;
1914         char* text_repeat = NULL;
1915         int utt_id = -1;
1916
1917         if (g_supported == false) {
1918                 ret = tts_repeat(g_tts, &text_repeat, &utt_id);
1919                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1920                 return;
1921         }
1922
1923         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1924
1925         g_utterance_completed_cb = false;
1926
1927         ret = tts_add_text(g_tts, "repeat success", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
1928         EXPECT_EQ(ret, TTS_ERROR_NONE);
1929
1930         ret = tts_play(g_tts);
1931         EXPECT_EQ(ret, TTS_ERROR_NONE);
1932
1933         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
1934
1935         while (true != g_utterance_completed_cb) {
1936                 ecore_main_loop_iterate();
1937         }
1938
1939         ret = tts_stop(g_tts);
1940         EXPECT_EQ(ret, TTS_ERROR_NONE);
1941
1942         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1943
1944         g_utterance_completed_cb = false;
1945
1946         ret = tts_repeat(g_tts, &text_repeat, &utt_id);
1947         EXPECT_EQ(ret, TTS_ERROR_NONE);
1948
1949         ret = strncmp(text_repeat, "repeat success", strlen(text_repeat));
1950         free(text_repeat);
1951         EXPECT_EQ(ret, 0);
1952
1953         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
1954
1955         while (true != g_utterance_completed_cb) {
1956                 ecore_main_loop_iterate();
1957         }
1958
1959         EXPECT_EQ(utt_id, g_utt_id);
1960
1961         ret = tts_stop(g_tts);
1962         EXPECT_EQ(ret, TTS_ERROR_NONE);
1963
1964         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
1965 }
1966
1967 /**
1968  * @testcase            utc_tts_repeat_n
1969  * @since_tizen         5.0
1970  * @description         test whether function returns error with NULL parameter.
1971  */
1972 TEST_F(TTSTest, utc_tts_repeat_n)
1973 {
1974         int ret = TTS_ERROR_NONE;
1975
1976         if (g_supported == false) {
1977                 ret = tts_repeat(g_tts, NULL, NULL);
1978                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
1979                 return;
1980         }
1981
1982         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
1983
1984         ret = tts_repeat(g_tts, NULL, NULL);
1985         EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
1986 }
1987
1988 /**
1989  * @testcase            utc_tts_repeat_n2
1990  * @since_tizen         5.0
1991  * @description         test whether function returns error with invalid state.
1992  */
1993 TEST_F(TTSTest, utc_tts_repeat_n2)
1994 {
1995         int ret = TTS_ERROR_NONE;
1996         char* text_repeat = NULL;
1997         int utt_id = -1;
1998
1999         if (g_supported == false) {
2000                 ret = tts_repeat(g_tts, &text_repeat, &utt_id);
2001                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2002                 return;
2003         }
2004
2005         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2006
2007         ret = tts_repeat(g_tts, &text_repeat, &utt_id);
2008         EXPECT_EQ(ret, TTS_ERROR_INVALID_STATE);
2009 }
2010
2011 /**
2012  * @testcase            utc_tts_repeat_n3
2013  * @since_tizen         5.0
2014  * @description         test whether function returns error with operation failed when there is no previous text.
2015  */
2016 TEST_F(TTSTest, utc_tts_repeat_n3)
2017 {
2018         int ret = TTS_ERROR_NONE;
2019         char* text_repeat = NULL;
2020         int utt_id = -1;
2021
2022         if (g_supported == false) {
2023                 ret = tts_repeat(g_tts, &text_repeat, &utt_id);
2024                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2025                 return;
2026         }
2027
2028         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2029
2030         ret = tts_prepare(g_tts);
2031         EXPECT_EQ(ret, TTS_ERROR_NONE);
2032
2033         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
2034
2035         ret = tts_repeat(g_tts, &text_repeat, &utt_id);
2036         EXPECT_EQ(ret, TTS_ERROR_OPERATION_FAILED);
2037
2038         ret = tts_unprepare(g_tts);
2039         EXPECT_EQ(ret, TTS_ERROR_NONE);
2040 }
2041
2042 /**
2043  * @testcase            utc_tts_unprepare_p
2044  * @since_tizen         2.3
2045  * @description         test whether tts is unprepared properly.
2046  */
2047 TEST_F(TTSTest, utc_tts_unprepare_p)
2048 {
2049         int ret = TTS_ERROR_NONE;
2050         if (g_supported == false) {
2051                 ret = tts_unprepare(g_tts);
2052                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2053                 return;
2054         }
2055
2056         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2057
2058         ret = tts_prepare(g_tts);
2059         EXPECT_EQ(ret, TTS_ERROR_NONE);
2060
2061         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
2062
2063         ret = tts_unprepare(g_tts);
2064         EXPECT_EQ(ret, TTS_ERROR_NONE);
2065 }
2066
2067 /**
2068  * @testcase            utc_tts_unprepare_p2
2069  * @since_tizen         2.3
2070  * @description         test whether tts is unprepared properly when tts is in notification mode.
2071  */
2072 TEST_F(TTSTest, utc_tts_unprepare_p2)
2073 {
2074         int ret = TTS_ERROR_NONE;
2075         if (g_supported == false) {
2076                 ret = tts_unprepare(g_tts);
2077                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2078                 return;
2079         }
2080         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2081
2082         ret = tts_set_mode(g_tts, TTS_MODE_NOTIFICATION);
2083         EXPECT_EQ(ret, TTS_ERROR_NONE);
2084
2085         ret = tts_prepare(g_tts);
2086         EXPECT_EQ(ret, TTS_ERROR_NONE);
2087
2088         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
2089
2090         ret = tts_unprepare(g_tts);
2091         EXPECT_EQ(ret, TTS_ERROR_NONE);
2092 }
2093
2094 /**
2095  * @testcase            utc_tts_unprepare_p3
2096  * @since_tizen         2.3
2097  * @description         test whether tts is unprepared properly when tts is in screen reader mode.
2098  */
2099 TEST_F(TTSTest, utc_tts_unprepare_p3)
2100 {
2101         if (g_supported == false) {
2102                 EXPECT_EQ(tts_unprepare(g_tts), TTS_ERROR_NOT_SUPPORTED);
2103                 return;
2104         }
2105         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2106
2107         EXPECT_EQ(vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, true), 0);
2108         EXPECT_EQ(tts_set_mode(g_tts, TTS_MODE_SCREEN_READER), TTS_ERROR_NONE);
2109         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
2110         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
2111
2112
2113         EXPECT_EQ(vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, false), 0);
2114         EXPECT_EQ(tts_unprepare(g_tts), TTS_ERROR_NONE);
2115 }
2116
2117 TEST_F(TTSTest, utc_tts_unprepare_n)
2118 {
2119     int ret = tts_unprepare(NULL);
2120     EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
2121 }
2122
2123 /**
2124  * @testcase            utc_tts_unprepare_n2
2125  * @since_tizen         2.3
2126  * @description         test whether function returns error when tts handle is already destroyed.
2127  */
2128 TEST_F(TTSTest, utc_tts_unprepare_n2)
2129 {
2130         int ret = TTS_ERROR_NONE;
2131         if (g_supported == false) {
2132                 ret = tts_unprepare(NULL);
2133                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2134                 return;
2135         }
2136         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2137
2138         ret = tts_destroy(g_tts);
2139         EXPECT_EQ(ret, TTS_ERROR_NONE);
2140
2141         ret = tts_unprepare(g_tts);
2142         ASSERT_NE(ret, TTS_ERROR_NONE);
2143
2144         ret = tts_create(&g_tts);
2145         EXPECT_EQ(ret, TTS_ERROR_NONE);
2146 }
2147
2148 /**
2149  * @testcase            utc_tts_unprepare_n3
2150  * @since_tizen         2.3
2151  * @description         test whether function returns error when tts is in create state.
2152  */
2153 TEST_F(TTSTest, utc_tts_unprepare_n3)
2154 {
2155         int ret = TTS_ERROR_NONE;
2156         if (g_supported == false) {
2157                 ret = tts_unprepare(NULL);
2158                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2159                 return;
2160         }
2161         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2162
2163         ret = tts_unprepare(g_tts);
2164         ASSERT_NE(ret, TTS_ERROR_NONE);
2165 }
2166
2167 /**
2168  * @testcase            utc_tts_set_state_changed_cb_p
2169  * @since_tizen         2.3
2170  * @description         test whether state_changed callback function is set properly.
2171  */
2172 TEST_F(TTSTest, utc_tts_set_state_changed_cb_p)
2173 {
2174         int ret = TTS_ERROR_NONE;
2175         if (g_supported == false) {
2176                 ret = tts_set_state_changed_cb(g_tts, __tts_state_changed_cb, NULL);
2177                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2178                 return;
2179         }
2180
2181         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2182         ret = tts_set_state_changed_cb(g_tts, __tts_state_changed_cb, NULL);
2183         EXPECT_EQ(ret, TTS_ERROR_NONE);
2184 }
2185
2186 /**
2187  * @testcase            utc_tts_set_state_changed_cb_n
2188  * @since_tizen         2.3
2189  * @description         test whether function returns error with NULL parameter.
2190  */
2191 TEST_F(TTSTest, utc_tts_set_state_changed_cb_n)
2192 {
2193         int ret = TTS_ERROR_NONE;
2194         if (g_supported == false) {
2195                 ret = tts_set_state_changed_cb(NULL, __tts_state_changed_cb, NULL);
2196                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2197                 return;
2198         }
2199         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2200
2201         ret = tts_set_state_changed_cb(NULL, __tts_state_changed_cb, NULL);
2202         ASSERT_NE(ret, TTS_ERROR_NONE);
2203 }
2204
2205 /**
2206  * @testcase            utc_tts_set_state_changed_cb_n2
2207  * @since_tizen         2.3
2208  * @description         test whether function returns error when tts handle is already destroyed.
2209  */
2210 TEST_F(TTSTest, utc_tts_set_state_changed_cb_n2)
2211 {
2212         int ret = TTS_ERROR_NONE;
2213         if (g_supported == false) {
2214                 ret = tts_set_state_changed_cb(NULL, __tts_state_changed_cb, NULL);
2215                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2216                 return;
2217         }
2218         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2219
2220         ret = tts_destroy(g_tts);
2221         EXPECT_EQ(ret, TTS_ERROR_NONE);
2222
2223         ret = tts_set_state_changed_cb(g_tts, __tts_state_changed_cb, NULL);
2224         ASSERT_NE(ret, TTS_ERROR_NONE);
2225
2226         ret = tts_create(&g_tts);
2227         EXPECT_EQ(ret, TTS_ERROR_NONE);
2228 }
2229
2230 /**
2231  * @testcase            utc_tts_set_state_changed_cb_n3
2232  * @since_tizen         2.3
2233  * @description         test whether function returns error when tts is not in create state.
2234  */
2235 TEST_F(TTSPreparedTest, utc_tts_set_state_changed_cb_n3)
2236 {
2237         int ret = TTS_ERROR_NONE;
2238         if (g_supported == false) {
2239                 ret = tts_set_state_changed_cb(NULL, __tts_state_changed_cb, NULL);
2240                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2241                 return;
2242         }
2243         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2244
2245         ret = tts_set_state_changed_cb(g_tts, __tts_state_changed_cb, NULL);
2246         ASSERT_NE(ret, TTS_ERROR_NONE);
2247 }
2248
2249 /**
2250  * @testcase            utc_tts_unset_state_changed_cb_p
2251  * @since_tizen         2.3
2252  * @description         test whether state_changed callback function is unset properly.
2253  */
2254 TEST_F(TTSTest, utc_tts_unset_state_changed_cb_p)
2255 {
2256         int ret = TTS_ERROR_NONE;
2257         if (g_supported == false) {
2258                 ret = tts_unset_state_changed_cb(g_tts);
2259                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2260                 return;
2261         }
2262
2263         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2264         ret = tts_unset_state_changed_cb(g_tts);
2265         EXPECT_EQ(ret, TTS_ERROR_NONE);
2266 }
2267
2268 /**
2269  * @testcase            utc_tts_unset_state_changed_cb_n
2270  * @since_tizen         2.3
2271  * @description         test whether function returns error with NULL parameter.
2272  */
2273 TEST_F(TTSTest, utc_tts_unset_state_changed_cb_n)
2274 {
2275         int ret = TTS_ERROR_NONE;
2276         if (g_supported == false) {
2277                 ret = tts_unset_state_changed_cb(NULL);
2278                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2279                 return;
2280         }
2281
2282         ret = tts_unset_state_changed_cb(NULL);
2283         ASSERT_NE(ret, TTS_ERROR_NONE);
2284 }
2285
2286 /**
2287  * @testcase            utc_tts_unset_state_changed_cb_n2
2288  * @since_tizen         2.3
2289  * @description         test whether function returns error when tts handle is already destroyed.
2290  */
2291 TEST_F(TTSTest, utc_tts_unset_state_changed_cb_n2)
2292 {
2293         int ret = TTS_ERROR_NONE;
2294         if (g_supported == false) {
2295                 ret = tts_unset_state_changed_cb(NULL);
2296                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2297                 return;
2298         }
2299         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2300
2301         ret = tts_destroy(g_tts);
2302         EXPECT_EQ(ret, TTS_ERROR_NONE);
2303
2304         ret = tts_unset_state_changed_cb(g_tts);
2305         ASSERT_NE(ret, TTS_ERROR_NONE);
2306
2307         ret = tts_create(&g_tts);
2308         EXPECT_EQ(ret, TTS_ERROR_NONE);
2309 }
2310
2311 /**
2312  * @testcase            utc_tts_unset_state_changed_cb_n3
2313  * @since_tizen         2.3
2314  * @description         test whether function returns error when tts is not in create state.
2315  */
2316 TEST_F(TTSPreparedTest, utc_tts_unset_state_changed_cb_n3)
2317 {
2318         int ret = TTS_ERROR_NONE;
2319         if (g_supported == false) {
2320                 ret = tts_unset_state_changed_cb(NULL);
2321                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2322                 return;
2323         }
2324         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2325
2326         ret = tts_unset_state_changed_cb(g_tts);
2327         ASSERT_NE(ret, TTS_ERROR_NONE);
2328 }
2329
2330 /**
2331  * @testcase            utc_tts_set_utterance_started_cb_p
2332  * @since_tizen         2.3
2333  * @description         test whether utterance_started callback function is set properly.
2334  */
2335 TEST_F(TTSTest, utc_tts_set_utterance_started_cb_p)
2336 {
2337         int ret = TTS_ERROR_NONE;
2338         if (g_supported == false) {
2339                 ret = tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, NULL);
2340                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2341                 return;
2342         }
2343
2344         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2345         ret = tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, NULL);
2346         EXPECT_EQ(ret, TTS_ERROR_NONE);
2347 }
2348
2349 /**
2350  * @testcase            utc_tts_set_utterance_started_cb_n
2351  * @since_tizen         2.3
2352  * @description         test whether function returns error with NULL parameter.
2353  */
2354 TEST_F(TTSTest, utc_tts_set_utterance_started_cb_n)
2355 {
2356         int ret = TTS_ERROR_NONE;
2357         if (g_supported == false) {
2358                 ret = tts_set_utterance_started_cb(NULL, __tts_utterance_started_cb, NULL);
2359                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2360                 return;
2361         }
2362
2363         ret = tts_set_utterance_started_cb(NULL, __tts_utterance_started_cb, NULL);
2364         EXPECT_NE(ret, TTS_ERROR_NONE);
2365 }
2366
2367 /**
2368  * @testcase            utc_tts_set_utterance_started_cb_n2
2369  * @since_tizen         2.3
2370  * @description         test whether function returns error when tts handle is already destroyed.
2371  */
2372 TEST_F(TTSTest, utc_tts_set_utterance_started_cb_n2)
2373 {
2374         int ret = TTS_ERROR_NONE;
2375         if (g_supported == false) {
2376                 ret = tts_set_utterance_started_cb(NULL, __tts_utterance_started_cb, NULL);
2377                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2378                 return;
2379         }
2380         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2381
2382         ret = tts_destroy(g_tts);
2383         EXPECT_EQ(ret, TTS_ERROR_NONE);
2384
2385         ret = tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, NULL);
2386         ASSERT_NE(ret, TTS_ERROR_NONE);
2387
2388         ret = tts_create(&g_tts);
2389         EXPECT_EQ(ret, TTS_ERROR_NONE);
2390 }
2391
2392 /**
2393  * @testcase            utc_tts_set_utterance_started_cb_n3
2394  * @since_tizen         2.3
2395  * @description         test whether function returns error when tts is not in create state.
2396  */
2397 TEST_F(TTSPreparedTest, utc_tts_set_utterance_started_cb_n3)
2398 {
2399         int ret = TTS_ERROR_NONE;
2400         if (g_supported == false) {
2401                 ret = tts_set_utterance_started_cb(NULL, __tts_utterance_started_cb, NULL);
2402                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2403                 return;
2404         }
2405         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2406
2407         ret = tts_set_utterance_started_cb(g_tts, __tts_utterance_started_cb, NULL);
2408         ASSERT_NE(ret, TTS_ERROR_NONE);
2409 }
2410
2411 /**
2412  * @testcase            utc_tts_unset_utterance_started_cb_p
2413  * @since_tizen         2.3
2414  * @description         test whether utterance_started callback function is unset properly.
2415  */
2416 TEST_F(TTSTest, utc_tts_unset_utterance_started_cb_p)
2417 {
2418         int ret = TTS_ERROR_NONE;
2419         if (g_supported == false) {
2420                 ret = tts_unset_utterance_started_cb(g_tts);
2421                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2422                 return;
2423         }
2424
2425         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2426
2427         ret = tts_unset_utterance_started_cb(g_tts);
2428         EXPECT_EQ(ret, TTS_ERROR_NONE);
2429 }
2430
2431 /**
2432  * @testcase            utc_tts_unset_utterance_started_cb_n
2433  * @since_tizen         2.3
2434  * @description         test whether function returns error with NULL parameter.
2435  */
2436 TEST_F(TTSTest, utc_tts_unset_utterance_started_cb_n)
2437 {
2438         int ret = TTS_ERROR_NONE;
2439         if (g_supported == false) {
2440                 ret = tts_unset_utterance_started_cb(NULL);
2441                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2442                 return;
2443         }
2444
2445         ret = tts_unset_utterance_started_cb(NULL);
2446         ASSERT_NE(ret, TTS_ERROR_NONE);
2447 }
2448
2449 /**
2450  * @testcase            utc_tts_unset_utterance_started_cb_n2
2451  * @since_tizen         2.3
2452  * @description         test whether function returns error when tts handle is already destroyed.
2453  */
2454 TEST_F(TTSTest, utc_tts_unset_utterance_started_cb_n2)
2455 {
2456         int ret = TTS_ERROR_NONE;
2457         if (g_supported == false) {
2458                 ret = tts_unset_utterance_started_cb(NULL);
2459                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2460                 return;
2461         }
2462         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2463
2464         ret = tts_destroy(g_tts);
2465         EXPECT_EQ(ret, TTS_ERROR_NONE);
2466
2467         ret = tts_unset_utterance_started_cb(g_tts);
2468         ASSERT_NE(ret, TTS_ERROR_NONE);
2469
2470         ret = tts_create(&g_tts);
2471         EXPECT_EQ(ret, TTS_ERROR_NONE);
2472 }
2473
2474 /**
2475  * @testcase            utc_tts_unset_utterance_started_cb_n3
2476  * @since_tizen         2.3
2477  * @description         test whether function returns error when tts is not in create state.
2478  */
2479 TEST_F(TTSPreparedTest, utc_tts_unset_utterance_started_cb_n3)
2480 {
2481         int ret = TTS_ERROR_NONE;
2482         if (g_supported == false) {
2483                 ret = tts_unset_utterance_started_cb(NULL);
2484                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2485                 return;
2486         }
2487         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2488
2489         ret = tts_unset_utterance_started_cb(g_tts);
2490         ASSERT_NE(ret, TTS_ERROR_NONE);
2491 }
2492
2493 /**
2494  * @testcase            utc_tts_set_utterance_completed_cb_p
2495  * @since_tizen         2.3
2496  * @description         test whether utterance_completed callback function is set properly.
2497  */
2498 TEST_F(TTSTest, utc_tts_set_utterance_completed_cb_p)
2499 {
2500         int ret = TTS_ERROR_NONE;
2501         if (g_supported == false) {
2502                 ret = tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, NULL);
2503                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2504                 return;
2505         }
2506
2507         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2508
2509         ret = tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, NULL);
2510         EXPECT_EQ(ret, TTS_ERROR_NONE);
2511 }
2512
2513 /**
2514  * @testcase            utc_tts_set_utterance_completed_cb_n
2515  * @since_tizen         2.3
2516  * @description         test whether function returns error with NULL parameter.
2517  */
2518 TEST_F(TTSTest, utc_tts_set_utterance_completed_cb_n)
2519 {
2520         int ret = TTS_ERROR_NONE;
2521         if (g_supported == false) {
2522                 ret = tts_set_utterance_completed_cb(NULL, __tts_utterance_completed_cb, NULL);
2523                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2524                 return;
2525         }
2526
2527         ret = tts_set_utterance_completed_cb(NULL, __tts_utterance_completed_cb, NULL);
2528         ASSERT_NE(ret, TTS_ERROR_NONE);
2529 }
2530
2531 /**
2532  * @testcase            utc_tts_set_utterance_completed_cb_n2
2533  * @since_tizen         2.3
2534  * @description         test whether function returns error when tts handle is already destroyed.
2535  */
2536 TEST_F(TTSTest, utc_tts_set_utterance_completed_cb_n2)
2537 {
2538         int ret = TTS_ERROR_NONE;
2539         if (g_supported == false) {
2540                 ret = tts_set_utterance_completed_cb(NULL, __tts_utterance_completed_cb, NULL);
2541                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2542                 return;
2543         }
2544         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2545
2546         ret = tts_destroy(g_tts);
2547         EXPECT_EQ(ret, TTS_ERROR_NONE);
2548
2549         ret = tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, NULL);
2550         ASSERT_NE(ret, TTS_ERROR_NONE);
2551
2552         ret = tts_create(&g_tts);
2553         EXPECT_EQ(ret, TTS_ERROR_NONE);
2554 }
2555
2556 /**
2557  * @testcase            utc_tts_set_utterance_completed_cb_n3
2558  * @since_tizen         2.3
2559  * @description         test whether function returns error when tts is not in create state.
2560  */
2561 TEST_F(TTSPreparedTest, utc_tts_set_utterance_completed_cb_n3)
2562 {
2563         int ret = TTS_ERROR_NONE;
2564         if (g_supported == false) {
2565                 ret = tts_set_utterance_completed_cb(NULL, __tts_utterance_completed_cb, NULL);
2566                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2567                 return;
2568         }
2569         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2570
2571         ret = tts_set_utterance_completed_cb(g_tts, __tts_utterance_completed_cb, NULL);
2572         ASSERT_NE(ret, TTS_ERROR_NONE);
2573 }
2574
2575 /**
2576  * @testcase            utc_tts_unset_utterance_completed_cb_p
2577  * @since_tizen         2.3
2578  * @description         test whether utterance_completed callback function is unset properly.
2579  */
2580 TEST_F(TTSTest, utc_tts_unset_utterance_completed_cb_p)
2581 {
2582         int ret = TTS_ERROR_NONE;
2583         if (g_supported == false) {
2584                 ret = tts_unset_utterance_completed_cb(g_tts);
2585                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2586                 return;
2587         }
2588
2589         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2590
2591         ret = tts_unset_utterance_completed_cb(g_tts);
2592         EXPECT_EQ(ret, TTS_ERROR_NONE);
2593 }
2594
2595 /**
2596  * @testcase            utc_tts_unset_utterance_completed_cb_n
2597  * @since_tizen         2.3
2598  * @description         test whether function returns error with NULL parameter.
2599  */
2600 TEST_F(TTSTest, utc_tts_unset_utterance_completed_cb_n)
2601 {
2602         int ret = TTS_ERROR_NONE;
2603         if (g_supported == false) {
2604                 ret = tts_unset_utterance_completed_cb(NULL);
2605                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2606                 return;
2607         }
2608
2609         ret = tts_unset_utterance_completed_cb(NULL);
2610         ASSERT_NE(ret, TTS_ERROR_NONE);
2611 }
2612
2613 /**
2614  * @testcase            utc_tts_unset_utterance_completed_cb_n2
2615  * @since_tizen         2.3
2616  * @description         test whether function returns error when tts handle is already destroyed.
2617  */
2618 TEST_F(TTSTest, utc_tts_unset_utterance_completed_cb_n2)
2619 {
2620         int ret = TTS_ERROR_NONE;
2621         if (g_supported == false) {
2622                 ret = tts_unset_utterance_completed_cb(NULL);
2623                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2624                 return;
2625         }
2626         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2627
2628         ret = tts_destroy(g_tts);
2629         EXPECT_EQ(ret, TTS_ERROR_NONE);
2630
2631         ret = tts_unset_utterance_completed_cb(g_tts);
2632         ASSERT_NE(ret, TTS_ERROR_NONE);
2633
2634         ret = tts_create(&g_tts);
2635         EXPECT_EQ(ret, TTS_ERROR_NONE);
2636 }
2637
2638 /**
2639  * @testcase            utc_tts_unset_utterance_completed_cb_n3
2640  * @since_tizen         2.3
2641  * @description         test whether function returns error when tts is in create state.
2642  */
2643 TEST_F(TTSPreparedTest, utc_tts_unset_utterance_completed_cb_n3)
2644 {
2645         int ret = TTS_ERROR_NONE;
2646         if (g_supported == false) {
2647                 ret = tts_unset_utterance_completed_cb(NULL);
2648                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2649                 return;
2650         }
2651         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2652
2653         ret = tts_unset_utterance_completed_cb(g_tts);
2654         ASSERT_NE(ret, TTS_ERROR_NONE);
2655 }
2656
2657 /**
2658  * @testcase            utc_tts_set_error_cb_p
2659  * @since_tizen         2.3
2660  * @description         test whether error callback function is set properly.
2661  */
2662 TEST_F(TTSTest, utc_tts_set_error_cb_p)
2663 {
2664         int ret = TTS_ERROR_NONE;
2665         if (g_supported == false) {
2666                 ret = tts_set_error_cb(g_tts, __tts_error_cb, NULL);
2667                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2668                 return;
2669         }
2670
2671         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2672         ret = tts_set_error_cb(g_tts, __tts_error_cb, NULL);
2673         EXPECT_EQ(ret, TTS_ERROR_NONE);
2674 }
2675
2676 /**
2677  * @testcase            utc_tts_set_error_cb_p2
2678  * @since_tizen         2.3
2679  * @description         test whether error callback function is invoked when error occurs.
2680  */
2681 TEST_F(TTSTest, utc_tts_set_error_cb_p2)
2682 {
2683         if (g_supported == false) {
2684                 EXPECT_EQ(tts_set_error_cb(g_tts, __tts_error_cb, NULL), TTS_ERROR_NOT_SUPPORTED);
2685                 return;
2686         }
2687
2688         char* engine_id = vconf_get_str(ENGINE_VCONF_KEY);
2689
2690         g_error_cb = false;
2691         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2692         EXPECT_EQ(tts_set_error_cb(g_tts, __tts_error_cb, NULL), TTS_ERROR_NONE);
2693         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
2694         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
2695
2696         EXPECT_EQ(vconf_set_str(ENGINE_VCONF_KEY, g_test_engine), 0);
2697
2698         EXPECT_EQ(__is_error_occur(5), true);
2699         sleep(1);
2700
2701         EXPECT_EQ(vconf_set_str(ENGINE_VCONF_KEY, engine_id), 0);
2702         g_current_state = TTS_STATE_CREATED;
2703         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
2704         EXPECT_EQ(tts_unprepare(g_tts), TTS_ERROR_NONE);
2705 }
2706
2707 /**
2708  * @testcase            utc_tts_set_error_cb_n
2709  * @since_tizen         2.3
2710  * @description         test whether function returns error with NULL parameter.
2711  */
2712 TEST_F(TTSTest, utc_tts_set_error_cb_n)
2713 {
2714         int ret = TTS_ERROR_NONE;
2715         if (g_supported == false) {
2716                 ret = tts_set_error_cb(NULL, __tts_error_cb, NULL);
2717                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2718                 return;
2719         }
2720
2721         ret = tts_set_error_cb(NULL, __tts_error_cb, NULL);
2722         ASSERT_NE(ret, TTS_ERROR_NONE);
2723 }
2724
2725 /**
2726  * @testcase            utc_tts_set_error_cb_n2
2727  * @since_tizen         2.3
2728  * @description         test whether function returns error when tts handle is already destroyed.
2729  */
2730 TEST_F(TTSTest, utc_tts_set_error_cb_n2)
2731 {
2732         int ret = TTS_ERROR_NONE;
2733         if (g_supported == false) {
2734                 ret = tts_set_error_cb(NULL, __tts_error_cb, NULL);
2735                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2736                 return;
2737         }
2738         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2739
2740         ret = tts_destroy(g_tts);
2741         EXPECT_EQ(ret, TTS_ERROR_NONE);
2742
2743         ret = tts_set_error_cb(g_tts, __tts_error_cb, NULL);
2744         ASSERT_NE(ret, TTS_ERROR_NONE);
2745
2746         ret = tts_create(&g_tts);
2747         EXPECT_EQ(ret, TTS_ERROR_NONE);
2748 }
2749
2750 /**
2751  * @testcase            utc_tts_set_error_cb_n3
2752  * @since_tizen         2.3
2753  * @description         test whether function returns error when tts is not in create state.
2754  */
2755 TEST_F(TTSPreparedTest, utc_tts_set_error_cb_n3)
2756 {
2757         int ret = TTS_ERROR_NONE;
2758         if (g_supported == false) {
2759                 ret = tts_set_error_cb(NULL, __tts_error_cb, NULL);
2760                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2761                 return;
2762         }
2763         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2764
2765         ret = tts_set_error_cb(g_tts, __tts_error_cb, NULL);
2766         ASSERT_NE(ret, TTS_ERROR_NONE);
2767 }
2768
2769 /**
2770  * @testcase            utc_tts_unset_error_cb_p
2771  * @since_tizen         2.3
2772  * @description         test whether error callback function is unset properly.
2773  */
2774 TEST_F(TTSTest, utc_tts_unset_error_cb_p)
2775 {
2776         int ret = TTS_ERROR_NONE;
2777         if (g_supported == false) {
2778                 ret = tts_unset_error_cb(g_tts);
2779                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2780                 return;
2781         }
2782
2783         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2784
2785         ret = tts_unset_error_cb(g_tts);
2786         EXPECT_EQ(ret, TTS_ERROR_NONE);
2787 }
2788
2789 /**
2790  * @testcase            utc_tts_unset_error_cb_n
2791  * @since_tizen         2.3
2792  * @description         test whether function returns error with NULL parameter.
2793  */
2794 TEST_F(TTSTest, utc_tts_unset_error_cb_n)
2795 {
2796         int ret = TTS_ERROR_NONE;
2797         if (g_supported == false) {
2798                 ret = tts_unset_error_cb(NULL);
2799                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2800                 return;
2801         }
2802
2803         ret = tts_unset_error_cb(NULL);
2804         ASSERT_NE(ret, TTS_ERROR_NONE);
2805 }
2806
2807 /**
2808  * @testcase            utc_tts_unset_error_cb_n2
2809  * @since_tizen         2.3
2810  * @description         test whether function returns error when tts handle is already destroyed.
2811  */
2812 TEST_F(TTSTest, utc_tts_unset_error_cb_n2)
2813 {
2814         int ret = TTS_ERROR_NONE;
2815         if (g_supported == false) {
2816                 ret = tts_unset_error_cb(NULL);
2817                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2818                 return;
2819         }
2820
2821         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2822
2823         ret = tts_destroy(g_tts);
2824         EXPECT_EQ(ret, TTS_ERROR_NONE);
2825
2826         ret = tts_unset_error_cb(g_tts);
2827         ASSERT_NE(ret, TTS_ERROR_NONE);
2828
2829         ret = tts_create(&g_tts);
2830         EXPECT_EQ(ret, TTS_ERROR_NONE);
2831 }
2832
2833 /**
2834  * @testcase            utc_tts_unset_error_cb_n3
2835  * @since_tizen         2.3
2836  * @description         test whether function returns error when tts is not in create state.
2837  */
2838 TEST_F(TTSPreparedTest, utc_tts_unset_error_cb_n3)
2839 {
2840         int ret = TTS_ERROR_NONE;
2841         if (g_supported == false) {
2842                 ret = tts_unset_error_cb(NULL);
2843                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2844                 return;
2845         }
2846         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2847
2848         ret = tts_unset_error_cb(g_tts);
2849         ASSERT_NE(ret, TTS_ERROR_NONE);
2850 }
2851
2852 /**
2853  * @testcase            utc_tts_set_default_voice_changed_cb_p
2854  * @since_tizen         2.3
2855  * @description         test whether default_voice_changed callback function is set properly.
2856  */
2857 TEST_F(TTSTest, utc_tts_set_default_voice_changed_cb_p)
2858 {
2859         int ret = TTS_ERROR_NONE;
2860         if (g_supported == false) {
2861                 ret = tts_set_default_voice_changed_cb(g_tts, __tts_default_voice_changed_cb, NULL);
2862                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2863                 return;
2864         }
2865
2866         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2867
2868         ret = tts_set_default_voice_changed_cb(g_tts, __tts_default_voice_changed_cb, NULL);
2869         EXPECT_EQ(ret, TTS_ERROR_NONE);
2870 }
2871
2872 /**
2873  * @testcase            utc_tts_set_default_voice_changed_cb_n
2874  * @since_tizen         2.3
2875  * @description         test whether function returns error with NULL parameter.
2876  */
2877 TEST_F(TTSTest, utc_tts_set_default_voice_changed_cb_n)
2878 {
2879         int ret = TTS_ERROR_NONE;
2880         if (g_supported == false) {
2881                 ret = tts_set_default_voice_changed_cb(NULL, __tts_default_voice_changed_cb, NULL);
2882                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2883                 return;
2884         }
2885
2886         ret = tts_set_default_voice_changed_cb(NULL, __tts_default_voice_changed_cb, NULL);
2887         ASSERT_NE(ret, TTS_ERROR_NONE);
2888 }
2889
2890 /**
2891  * @testcase            utc_tts_set_default_voice_changed_cb_n2
2892  * @since_tizen         2.3
2893  * @description         test whether function returns error when tts handle is already destroyed.
2894  */
2895 TEST_F(TTSTest, utc_tts_set_default_voice_changed_cb_n2)
2896 {
2897         int ret = TTS_ERROR_NONE;
2898         if (g_supported == false) {
2899                 ret = tts_set_default_voice_changed_cb(NULL, __tts_default_voice_changed_cb, NULL);
2900                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2901                 return;
2902         }
2903         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2904
2905         ret = tts_destroy(g_tts);
2906         EXPECT_EQ(ret, TTS_ERROR_NONE);
2907
2908         ret = tts_set_default_voice_changed_cb(g_tts, __tts_default_voice_changed_cb, NULL);
2909         ASSERT_NE(ret, TTS_ERROR_NONE);
2910
2911         ret = tts_create(&g_tts);
2912         EXPECT_EQ(ret, TTS_ERROR_NONE);
2913 }
2914
2915 /**
2916  * @testcase            utc_tts_set_default_voice_changed_cb_n3
2917  * @since_tizen         2.3
2918  * @description         test whether function returns error when tts is not in create state.
2919  */
2920 TEST_F(TTSPreparedTest, utc_tts_set_default_voice_changed_cb_n3)
2921 {
2922         int ret = TTS_ERROR_NONE;
2923         if (g_supported == false) {
2924                 ret = tts_set_default_voice_changed_cb(NULL, __tts_default_voice_changed_cb, NULL);
2925                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2926                 return;
2927         }
2928         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2929
2930         ret = tts_set_default_voice_changed_cb(g_tts, __tts_default_voice_changed_cb, NULL);
2931         ASSERT_NE(ret, TTS_ERROR_NONE);
2932 }
2933
2934 /**
2935  * @testcase            utc_tts_unset_default_voice_changed_cb_p
2936  * @since_tizen         2.3
2937  * @description         test whether default_voice_changed callback function is unset properly.
2938  */
2939 TEST_F(TTSTest, utc_tts_unset_default_voice_changed_cb_p)
2940 {
2941         int ret = TTS_ERROR_NONE;
2942         if (g_supported == false) {
2943                 ret = tts_unset_default_voice_changed_cb(g_tts);
2944                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2945                 return;
2946         }
2947
2948         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2949
2950         ret = tts_unset_default_voice_changed_cb(g_tts);
2951         EXPECT_EQ(ret, TTS_ERROR_NONE);
2952 }
2953
2954 /**
2955  * @testcase            utc_tts_unset_default_voice_changed_cb_n
2956  * @since_tizen         2.3
2957  * @description         test whether function returns error with NULL parameter.
2958  */
2959 TEST_F(TTSTest, utc_tts_unset_default_voice_changed_cb_n)
2960 {
2961         int ret = TTS_ERROR_NONE;
2962         if (g_supported == false) {
2963                 ret = tts_unset_default_voice_changed_cb(NULL);
2964                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2965                 return;
2966         }
2967
2968         ret = tts_unset_default_voice_changed_cb(NULL);
2969         ASSERT_NE(ret, TTS_ERROR_NONE);
2970 }
2971
2972 /**
2973  * @testcase            utc_tts_unset_default_voice_changed_cb_n2
2974  * @since_tizen         2.3
2975  * @description         test whether function returns error when tts handle is already destroyed.
2976  */
2977 TEST_F(TTSTest, utc_tts_unset_default_voice_changed_cb_n2)
2978 {
2979         int ret = TTS_ERROR_NONE;
2980         if (g_supported == false) {
2981                 ret = tts_unset_default_voice_changed_cb(NULL);
2982                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
2983                 return;
2984         }
2985         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
2986
2987         ret = tts_destroy(g_tts);
2988         EXPECT_EQ(ret, TTS_ERROR_NONE);
2989
2990         ret = tts_unset_default_voice_changed_cb(g_tts);
2991         ASSERT_NE(ret, TTS_ERROR_NONE);
2992
2993         ret = tts_create(&g_tts);
2994         EXPECT_EQ(ret, TTS_ERROR_NONE);
2995 }
2996
2997 /**
2998  * @testcase            utc_tts_unset_default_voice_changed_cb_n3
2999  * @since_tizen         2.3
3000  * @description         test whether function returns error when tts is not in create state.
3001  */
3002 TEST_F(TTSPreparedTest, utc_tts_unset_default_voice_changed_cb_n3)
3003 {
3004         int ret = TTS_ERROR_NONE;
3005         if (g_supported == false) {
3006                 ret = tts_unset_default_voice_changed_cb(NULL);
3007                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3008                 return;
3009         }
3010         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3011
3012         ret = tts_unset_default_voice_changed_cb(g_tts);
3013         ASSERT_NE(ret, TTS_ERROR_NONE);
3014 }
3015
3016 /**
3017  * @testcase            utc_tts_set_service_state_changed_cb_p
3018  * @since_tizen         7.0
3019  * @description         test whether service_state_changed callback function is set properly.
3020  */
3021 TEST_F(TTSTest, utc_tts_set_service_state_changed_cb_p)
3022 {
3023         if (g_supported == false) {
3024                 EXPECT_EQ(tts_set_service_state_changed_cb(g_tts, __tts_service_state_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3025                 return;
3026         }
3027
3028         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3029
3030         EXPECT_EQ(tts_set_service_state_changed_cb(g_tts, __tts_service_state_changed_cb, nullptr), TTS_ERROR_NONE);
3031 }
3032
3033 /**
3034  * @testcase            utc_tts_set_service_state_changed_cb_p2
3035  * @since_tizen         7.0
3036  * @description         test whether service_state_changed callback function is invoked when server state is changed.
3037  */
3038 TEST_F(TTSTest, utc_tts_set_service_state_changed_cb_p2)
3039 {
3040         if (g_supported == false) {
3041                 EXPECT_EQ(tts_set_service_state_changed_cb(g_tts, __tts_service_state_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3042                 return;
3043         }
3044
3045         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3046
3047         g_current_service_state = TTS_SERVICE_STATE_READY;
3048         EXPECT_EQ(tts_set_service_state_changed_cb(g_tts, __tts_service_state_changed_cb, nullptr), TTS_ERROR_NONE);
3049         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
3050         EXPECT_EQ(__is_state_changed(TTS_STATE_READY, STATE_CHECK_WAITING_TIME), true);
3051
3052         int utt_id = 0;
3053         EXPECT_EQ(tts_add_text(g_tts, "1 2 3 4 5", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id), TTS_ERROR_NONE);
3054         EXPECT_EQ(tts_play(g_tts), TTS_ERROR_NONE);
3055
3056         EXPECT_EQ(__is_service_state_changed(TTS_SERVICE_STATE_SYNTHESIZING, STATE_CHECK_WAITING_TIME), true);
3057         EXPECT_EQ(tts_stop(g_tts), TTS_ERROR_NONE);
3058
3059         EXPECT_EQ(tts_unprepare(g_tts), TTS_ERROR_NONE);
3060 }
3061
3062 /**
3063  * @testcase            utc_tts_set_service_state_changed_cb_n
3064  * @since_tizen         7.0
3065  * @description         test whether function returns error with NULL parameter.
3066  */
3067 TEST_F(TTSTest, utc_tts_set_service_state_changed_cb_n)
3068 {
3069         if (g_supported == false) {
3070                 EXPECT_EQ(tts_set_service_state_changed_cb(nullptr, __tts_service_state_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3071                 return;
3072         }
3073         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3074
3075         EXPECT_EQ(tts_set_service_state_changed_cb(nullptr, __tts_service_state_changed_cb, nullptr), TTS_ERROR_INVALID_PARAMETER);
3076 }
3077
3078 /**
3079  * @testcase            utc_tts_set_service_state_changed_cb_n2
3080  * @since_tizen         7.0
3081  * @description         test whether function returns error when tts handle is already destroyed.
3082  */
3083 TEST_F(TTSTest, utc_tts_set_service_state_changed_cb_n2)
3084 {
3085         if (g_supported == false) {
3086                 EXPECT_EQ(tts_set_service_state_changed_cb(g_tts, __tts_service_state_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3087                 return;
3088         }
3089         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3090
3091         EXPECT_EQ(tts_destroy(g_tts), TTS_ERROR_NONE);
3092         EXPECT_EQ(tts_set_service_state_changed_cb(g_tts, __tts_service_state_changed_cb, nullptr), TTS_ERROR_INVALID_PARAMETER);
3093         EXPECT_EQ(tts_create(&g_tts), TTS_ERROR_NONE);
3094 }
3095
3096 /**
3097  * @testcase            utc_tts_set_service_state_changed_cb_n3
3098  * @since_tizen         7.0
3099  * @description         test whether function returns error when tts is not in ready state.
3100  */
3101 TEST_F(TTSPreparedTest, utc_tts_set_service_state_changed_cb_n3)
3102 {
3103         if (g_supported == false) {
3104                 EXPECT_EQ(tts_set_service_state_changed_cb(g_tts, __tts_service_state_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3105                 return;
3106         }
3107         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3108
3109         EXPECT_EQ(tts_set_service_state_changed_cb(g_tts, __tts_service_state_changed_cb, nullptr), TTS_ERROR_INVALID_STATE);
3110 }
3111
3112 /**
3113  * @testcase            utc_tts_unset_service_state_changed_cb_p
3114  * @since_tizen         7.0
3115  * @description         test whether service_state_changed callback function is unset properly.
3116  */
3117 TEST_F(TTSTest, utc_tts_unset_service_state_changed_cb_p)
3118 {
3119         if (g_supported == false) {
3120                 EXPECT_EQ(tts_unset_service_state_changed_cb(g_tts), TTS_ERROR_NOT_SUPPORTED);
3121                 return;
3122         }
3123
3124         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3125
3126         EXPECT_EQ(tts_unset_service_state_changed_cb(g_tts), TTS_ERROR_NONE);
3127 }
3128
3129 /**
3130  * @testcase            utc_tts_unset_service_state_changed_cb_n
3131  * @since_tizen         7.0
3132  * @description         test whether function returns error with NULL parameter.
3133  */
3134 TEST_F(TTSTest, utc_tts_unset_service_state_changed_cb_n)
3135 {
3136         if (g_supported == false) {
3137                 EXPECT_EQ(tts_unset_service_state_changed_cb(NULL), TTS_ERROR_NOT_SUPPORTED);
3138                 return;
3139         }
3140
3141         EXPECT_EQ(tts_unset_service_state_changed_cb(nullptr), TTS_ERROR_INVALID_PARAMETER);
3142 }
3143
3144 /**
3145  * @testcase            utc_tts_unset_service_state_changed_cb_n2
3146  * @since_tizen         7.0
3147  * @description         test whether function returns error when tts handle is already destroyed.
3148  */
3149 TEST_F(TTSTest, utc_tts_unset_service_state_changed_cb_n2)
3150 {
3151         if (g_supported == false) {
3152                 EXPECT_EQ(tts_unset_service_state_changed_cb(g_tts), TTS_ERROR_NOT_SUPPORTED);
3153                 return;
3154         }
3155         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3156
3157         EXPECT_EQ(tts_destroy(g_tts), TTS_ERROR_NONE);
3158         EXPECT_EQ(tts_unset_service_state_changed_cb(g_tts), TTS_ERROR_INVALID_PARAMETER);
3159         EXPECT_EQ(tts_create(&g_tts), TTS_ERROR_NONE);
3160 }
3161
3162 /**
3163  * @testcase            utc_tts_unset_service_state_changed_cb_n3
3164  * @since_tizen         7.0
3165  * @description         test whether function returns error when tts is not in ready state.
3166  */
3167 TEST_F(TTSPreparedTest, utc_tts_unset_service_state_changed_cb_n3)
3168 {
3169         if (g_supported == false) {
3170                 EXPECT_EQ(tts_unset_service_state_changed_cb(g_tts), TTS_ERROR_NOT_SUPPORTED);
3171                 return;
3172         }
3173         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3174
3175         EXPECT_EQ(tts_unset_service_state_changed_cb(g_tts), TTS_ERROR_INVALID_STATE);
3176 }
3177
3178
3179 /**
3180  * @testcase            utc_tts_get_error_message_p
3181  * @since_tizen         3.0
3182  * @description         Positive UTC for get error message
3183  */
3184 TEST_F(TTSTest, utc_tts_get_error_message_p)
3185 {
3186         char* error_message = nullptr;
3187         if (g_supported == false) {
3188                 EXPECT_EQ(tts_get_error_message(g_tts, &error_message), TTS_ERROR_NOT_SUPPORTED);
3189                 free(error_message);
3190                 return;
3191         }
3192
3193         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3194
3195         EXPECT_EQ(tts_get_error_message(g_tts, &error_message), TTS_ERROR_NONE);
3196         free(error_message);
3197 }
3198
3199 /**
3200  * @testcase            utc_tts_get_error_message_p2
3201  * @since_tizen         3.0
3202  * @description         Positive UTC for get error message
3203  */
3204 TEST_F(TTSTest, utc_tts_get_error_message_p2)
3205 {
3206         char* error_message = nullptr;
3207         if (g_supported == false) {
3208                 EXPECT_EQ(tts_get_error_message(g_tts, &error_message), TTS_ERROR_NOT_SUPPORTED);
3209                 free(error_message);
3210                 return;
3211         }
3212
3213         char* engine_id = vconf_get_str(ENGINE_VCONF_KEY);
3214
3215         g_error_cb = false;
3216         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3217         EXPECT_EQ(tts_set_error_cb(g_tts, __tts_error_cb, NULL), TTS_ERROR_NONE);
3218         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
3219         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
3220
3221         EXPECT_EQ(vconf_set_str(ENGINE_VCONF_KEY, g_test_engine), 0);
3222
3223         EXPECT_EQ(__is_error_occur(5), true);
3224
3225         EXPECT_EQ(tts_get_error_message(g_tts, &error_message), TTS_ERROR_NONE);
3226         EXPECT_NE(error_message, nullptr);
3227         free(error_message);
3228
3229         sleep(1);
3230
3231         EXPECT_EQ(vconf_set_str(ENGINE_VCONF_KEY, engine_id), 0);
3232         g_current_state = TTS_STATE_CREATED;
3233         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
3234         EXPECT_EQ(tts_unprepare(g_tts), TTS_ERROR_NONE);
3235 }
3236
3237 /**
3238  * @testcase            utc_tts_get_error_message_n
3239  * @since_tizen         3.0
3240  * @description         Negative UTC for get error message (invalid parameter)
3241  */
3242  TEST_F(TTSTest, utc_tts_get_error_message_n)
3243 {
3244         int ret = TTS_ERROR_NONE;
3245         if (g_supported == false) {
3246                 ret = tts_get_error_message(g_tts, NULL);
3247                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3248                 return;
3249         }
3250
3251         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3252
3253         ret = tts_get_error_message(g_tts, NULL);
3254         EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
3255 }
3256
3257 /**
3258  * @testcase            utc_tts_get_private_data_p
3259  * @since_tizen         3.0
3260  * @description         Positive UTC for get private data
3261  */
3262 TEST_F(TTSPreparedTest, utc_tts_get_private_data_p)
3263 {
3264         int ret = TTS_ERROR_NONE;
3265         if (g_supported == false) {
3266                 ret = tts_get_private_data(g_tts, NULL, NULL);
3267                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3268                 return;
3269         }
3270
3271         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3272
3273         char *data = NULL;
3274         ret = tts_get_private_data(g_tts, "version", &data);
3275         EXPECT_EQ(ret, TTS_ERROR_NONE);
3276         free(data);
3277 }
3278
3279 /**
3280  * @testcase            utc_tts_get_private_data_n
3281  * @since_tizen         3.0
3282  * @description         Negative UTC for get private data (invalid parameter)
3283  */
3284 TEST_F(TTSTest, utc_tts_get_private_data_n)
3285 {
3286         int ret = TTS_ERROR_NONE;
3287         if (g_supported == false) {
3288                 ret = tts_get_private_data(g_tts, NULL, NULL);
3289                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3290                 return;
3291         }
3292
3293         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3294
3295         ret = tts_get_private_data(NULL, NULL, NULL);
3296         EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
3297 }
3298
3299 /**
3300  * @testcase            utc_tts_get_private_data_n2
3301  * @since_tizen         3.0
3302  * @description         Negative UTC for get private data (invalid state)
3303  */
3304 TEST_F(TTSTest, utc_tts_get_private_data_n2)
3305 {
3306         int ret = TTS_ERROR_NONE;
3307         if (g_supported == false) {
3308                 ret = tts_get_private_data(g_tts, NULL, NULL);
3309                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3310                 return;
3311         }
3312
3313         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3314
3315         char* data = NULL;
3316         ret = tts_get_private_data(g_tts, "version", &data);
3317         EXPECT_EQ(ret, TTS_ERROR_INVALID_STATE);
3318 }
3319
3320 /**
3321  * @testcase            utc_tts_get_private_data_n3
3322  * @since_tizen         3.0
3323  * @description         Negative UTC for get private data (invalid parameter)
3324  */
3325 TEST_F(TTSTest, utc_tts_get_private_data_n3)
3326 {
3327         int ret = TTS_ERROR_NONE;
3328         if (g_supported == false) {
3329                 ret = tts_get_private_data(g_tts, NULL, NULL);
3330                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3331                 return;
3332         }
3333
3334         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3335
3336         char* data = NULL;
3337         ret = tts_get_private_data(g_tts, NULL, &data);
3338         EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
3339 }
3340
3341 /**
3342  * @testcase            utc_tts_set_private_data_p
3343  * @since_tizen         3.0
3344  * @description         Positive UTC for set private data
3345  */
3346 TEST_F(TTSPreparedTest, utc_tts_set_private_data_p)
3347 {
3348         int ret = TTS_ERROR_NONE;
3349         if (g_supported == false) {
3350                 ret = tts_set_private_data(g_tts, NULL, NULL);
3351                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3352                 return;
3353         }
3354
3355         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3356
3357         ret = tts_set_private_data(g_tts, "version", "2.0");
3358         EXPECT_EQ(ret, TTS_ERROR_NONE);
3359 }
3360
3361 /**
3362  * @testcase            utc_tts_set_private_data_n
3363  * @since_tizen         3.0
3364  * @description         Negative UTC for set private data (invalid parameter)
3365  */
3366 TEST_F(TTSTest, utc_tts_set_private_data_n)
3367 {
3368         int ret = TTS_ERROR_NONE;
3369         if (g_supported == false) {
3370                 ret = tts_set_private_data(g_tts, NULL, NULL);
3371                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3372                 return;
3373         }
3374
3375         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3376
3377         ret = tts_set_private_data(NULL, NULL, NULL);
3378         EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
3379 }
3380
3381 /**
3382  * @testcase            utc_tts_set_private_data_n2
3383  * @since_tizen         3.0
3384  * @description         Negative UTC for set private data (invalid state)
3385  */
3386 TEST_F(TTSTest, utc_tts_set_private_data_n2)
3387 {
3388         int ret = TTS_ERROR_NONE;
3389         if (g_supported == false) {
3390                 ret = tts_set_private_data(g_tts, NULL, NULL);
3391                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3392                 return;
3393         }
3394
3395         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3396
3397         ret = tts_set_private_data(g_tts, "version", "2.0");
3398         EXPECT_EQ(ret, TTS_ERROR_INVALID_STATE);
3399 }
3400
3401 /**
3402  * @testcase            utc_tts_set_private_data_n3
3403  * @since_tizen         3.0
3404  * @description         Negative UTC for set private data (invalid parameter)
3405  */
3406 TEST_F(TTSTest, utc_tts_set_private_data_n3)
3407 {
3408         int ret = TTS_ERROR_NONE;
3409         if (g_supported == false) {
3410                 ret = tts_set_private_data(g_tts, NULL, NULL);
3411                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3412                 return;
3413         }
3414
3415         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3416
3417         ret = tts_set_private_data(g_tts, NULL, "2.0");
3418         EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
3419 }
3420
3421 /**
3422  * @testcase            utc_tts_set_credential_p
3423  * @since_tizen         3.0
3424  * @description         Positive UTC for set credential
3425  */
3426 TEST_F(TTSTest, utc_tts_set_credential_p)
3427 {
3428         int ret = TTS_ERROR_NONE;
3429         if (g_supported == false) {
3430                 ret = tts_set_credential(g_tts, NULL);
3431                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3432                 return;
3433         }
3434
3435         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3436
3437         ret = tts_set_credential(g_tts, "test");
3438         EXPECT_EQ(ret, TTS_ERROR_NONE);
3439 }
3440
3441 TEST_F(TTSTest, utc_tts_set_credential_n)
3442 {
3443     int ret = tts_set_credential(NULL, "credential");
3444     EXPECT_EQ(ret, TTS_ERROR_INVALID_PARAMETER);
3445 }
3446
3447 /**
3448  * @testcase            utc_tts_set_credential_n2
3449  * @since_tizen         3.0
3450  * @description         Negative UTC for set credential (invalid state)
3451  */
3452 TEST_F(TTSPreparedTest, utc_tts_set_credential_n2)
3453 {
3454         int utt_id;
3455         int ret = TTS_ERROR_NONE;
3456         if (g_supported == false) {
3457                 ret = tts_set_credential(g_tts, NULL);
3458                 EXPECT_EQ(ret, TTS_ERROR_NOT_SUPPORTED);
3459                 return;
3460         }
3461
3462         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3463
3464         ret = tts_add_text(g_tts, "1 2 3", g_language, g_voice_type, TTS_SPEED_AUTO, &utt_id);
3465         EXPECT_EQ(ret, TTS_ERROR_NONE);
3466
3467         ret = tts_play(g_tts);
3468         EXPECT_EQ(ret, TTS_ERROR_NONE);
3469
3470         while (TTS_STATE_PLAYING != g_current_state) {
3471                 ecore_main_loop_iterate();
3472         }
3473
3474         ret = tts_set_credential(g_tts, "test");
3475         EXPECT_EQ(ret, TTS_ERROR_INVALID_STATE);
3476
3477         ret = tts_stop(g_tts);
3478         EXPECT_EQ(ret, TTS_ERROR_NONE);
3479
3480         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
3481 }
3482
3483
3484 /**
3485  * @testcase            utc_tts_set_server_tts_p
3486  * @since_tizen         3.0
3487  * @description         Positive UTC for set server TTS as enabled
3488  */
3489 TEST_F(TTSPreparedTest, utc_tts_set_server_tts_p)
3490 {
3491         if (g_supported == false) {
3492                 EXPECT_EQ(tts_set_server_tts(g_tts, "test"), TTS_ERROR_NOT_SUPPORTED);
3493                 return;
3494         }
3495
3496         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3497
3498         EXPECT_EQ(tts_set_server_tts(g_tts, "test"), TTS_ERROR_NONE);
3499 }
3500
3501 /**
3502  * @testcase            utc_tts_set_server_tts_p2
3503  * @since_tizen         3.0
3504  * @description         Positive UTC for set server TTS as disabled
3505  */
3506 TEST_F(TTSPreparedTest, utc_tts_set_server_tts_p2)
3507 {
3508         if (g_supported == false) {
3509                 EXPECT_EQ(tts_set_server_tts(g_tts, nullptr), TTS_ERROR_NOT_SUPPORTED);
3510                 return;
3511         }
3512
3513         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3514
3515         EXPECT_EQ(tts_set_server_tts(g_tts, nullptr), TTS_ERROR_NONE);
3516 }
3517
3518 /**
3519  * @testcase            utc_tts_set_server_tts_n
3520  * @since_tizen         3.0
3521  * @description         Negative UTC for set server TTS (Invalid parameter)
3522  */
3523 TEST_F(TTSTest, utc_tts_set_server_tts_n)
3524 {
3525         if (g_supported == false) {
3526                 EXPECT_EQ(tts_set_server_tts(nullptr, "test"), TTS_ERROR_NOT_SUPPORTED);
3527                 return;
3528         }
3529
3530         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3531
3532     EXPECT_EQ(tts_set_server_tts(nullptr, "test"), TTS_ERROR_INVALID_PARAMETER);
3533 }
3534
3535 /**
3536  * @testcase            utc_tts_set_server_tts_n2
3537  * @since_tizen         3.0
3538  * @description         Negative UTC for set server TTS (Invalid state)
3539  */
3540 TEST_F(TTSPreparedTest, utc_tts_set_server_tts_n2)
3541 {
3542         if (g_supported == false) {
3543                 EXPECT_EQ(tts_set_server_tts(g_tts, "test"), TTS_ERROR_NOT_SUPPORTED);
3544                 return;
3545         }
3546
3547         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3548
3549         EXPECT_EQ(tts_play(g_tts), TTS_ERROR_NONE);
3550         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
3551
3552     EXPECT_EQ(tts_set_server_tts(g_tts, "test"), TTS_ERROR_INVALID_STATE);
3553
3554         EXPECT_EQ(tts_stop(g_tts), TTS_ERROR_NONE);
3555         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
3556 }
3557
3558 /**
3559  * @testcase            utc_tts_check_screen_reader_on_p
3560  * @since_tizen         6.5
3561  * @description         Positive UTC for checking screen reader on
3562  */
3563 TEST_F(TTSTest, utc_tts_check_screen_reader_on_p)
3564 {
3565         bool is_on = false;
3566         if (g_supported == false) {
3567                 EXPECT_EQ(tts_check_screen_reader_on(g_tts, &is_on), TTS_ERROR_NOT_SUPPORTED);
3568                 return;
3569         }
3570
3571         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3572
3573         EXPECT_EQ(tts_check_screen_reader_on(g_tts, &is_on), TTS_ERROR_NONE);
3574 }
3575
3576 /**
3577  * @testcase            utc_tts_check_screen_reader_on_p2
3578  * @since_tizen         6.5
3579  * @description         Positive UTC for checking screen reader on
3580  */
3581 TEST_F(TTSTest, utc_tts_check_screen_reader_on_p2)
3582 {
3583         bool is_on = false;
3584         if (g_supported == false) {
3585                 EXPECT_EQ(tts_check_screen_reader_on(g_tts, &is_on), TTS_ERROR_NOT_SUPPORTED);
3586                 return;
3587         }
3588
3589         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3590
3591         EXPECT_EQ(tts_set_mode(g_tts, TTS_MODE_SCREEN_READER), TTS_ERROR_NONE);
3592
3593         EXPECT_EQ(vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, false), 0);
3594         EXPECT_EQ(tts_check_screen_reader_on(g_tts, &is_on), TTS_ERROR_NONE);
3595
3596         EXPECT_EQ(is_on, false);
3597 }
3598
3599 /**
3600  * @testcase            utc_tts_check_screen_reader_on_n
3601  * @since_tizen         6.5
3602  * @description         Negative UTC for checking screen reader on (invalid parameter)
3603  */
3604 TEST_F(TTSTest, utc_tts_check_screen_reader_on_n)
3605 {
3606         bool is_on = false;
3607         if (g_supported == false) {
3608                 EXPECT_EQ(tts_check_screen_reader_on(g_tts, nullptr), TTS_ERROR_NOT_SUPPORTED);
3609                 return;
3610         }
3611
3612         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3613
3614         EXPECT_EQ(tts_check_screen_reader_on(g_tts, nullptr), TTS_ERROR_INVALID_PARAMETER);
3615         EXPECT_EQ(tts_check_screen_reader_on(nullptr, &is_on), TTS_ERROR_INVALID_PARAMETER);
3616 }
3617
3618 /**
3619  * @testcase            utc_tts_set_screen_reader_changed_cb_p
3620  * @since_tizen         6.5
3621  * @description         Positive UTC for set screen reader changed callback
3622  */
3623 TEST_F(TTSTest, utc_tts_set_screen_reader_changed_cb_p)
3624 {
3625         if (g_supported == false) {
3626                 EXPECT_EQ(tts_set_screen_reader_changed_cb(g_tts, __tts_screen_reader_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3627                 return;
3628         }
3629
3630         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3631
3632         EXPECT_EQ(tts_set_screen_reader_changed_cb(g_tts, __tts_screen_reader_changed_cb, nullptr), TTS_ERROR_NONE);
3633 }
3634
3635 /**
3636  * @testcase            utc_tts_set_screen_reader_changed_cb_p2
3637  * @since_tizen         6.5
3638  * @description         Positive UTC for invoking screen reader changed callback
3639  */
3640 TEST_F(TTSTest, utc_tts_set_screen_reader_changed_cb_p2)
3641 {
3642         if (g_supported == false) {
3643                 EXPECT_EQ(tts_set_screen_reader_changed_cb(g_tts, __tts_screen_reader_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3644                 return;
3645         }
3646
3647         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3648
3649         g_screen_reader_changed_cb = false;
3650         EXPECT_EQ(vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, true), 0);
3651         EXPECT_EQ(tts_set_screen_reader_changed_cb(g_tts, __tts_screen_reader_changed_cb, nullptr), TTS_ERROR_NONE);
3652
3653         EXPECT_EQ(vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, false), 0);
3654         EXPECT_EQ(__is_screen_reader_changed(5), true);
3655 }
3656
3657 /**
3658  * @testcase            utc_tts_set_screen_reader_changed_cb_n
3659  * @since_tizen         6.5
3660  * @description         Negative UTC for set screen reader changed callback (Invalid handle)
3661  */
3662 TEST_F(TTSTest, utc_tts_set_screen_reader_changed_cb_n)
3663 {
3664         if (g_supported == false) {
3665                 EXPECT_EQ(tts_set_screen_reader_changed_cb(nullptr, __tts_screen_reader_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3666                 return;
3667         }
3668
3669         EXPECT_EQ(tts_set_screen_reader_changed_cb(nullptr, __tts_screen_reader_changed_cb, nullptr), TTS_ERROR_INVALID_PARAMETER);
3670 }
3671
3672 /**
3673  * @testcase            utc_tts_set_screen_reader_changed_cb_n2
3674  * @since_tizen         6.5
3675  * @description         Negative UTC for set screen reader changed callback (Invalid parameter)
3676  */
3677 TEST_F(TTSTest, utc_tts_set_screen_reader_changed_cb_n2)
3678 {
3679         if (g_supported == false) {
3680                 EXPECT_EQ(tts_set_screen_reader_changed_cb(g_tts, nullptr, nullptr), TTS_ERROR_NOT_SUPPORTED);
3681                 return;
3682         }
3683
3684         EXPECT_EQ(tts_set_screen_reader_changed_cb(g_tts, nullptr, nullptr), TTS_ERROR_INVALID_PARAMETER);
3685 }
3686
3687 /**
3688  * @testcase            utc_tts_set_screen_reader_changed_cb_n2
3689  * @since_tizen         6.5
3690  * @description         Negative UTC for set screen reader changed callback (Invalid state)
3691  */
3692 TEST_F(TTSPreparedTest, utc_tts_set_screen_reader_changed_cb_n2)
3693 {
3694         if (g_supported == false) {
3695                 EXPECT_EQ(tts_set_screen_reader_changed_cb(g_tts, __tts_screen_reader_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3696                 return;
3697         }
3698
3699         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3700
3701         EXPECT_EQ(tts_set_screen_reader_changed_cb(g_tts, __tts_screen_reader_changed_cb, nullptr), TTS_ERROR_INVALID_STATE);
3702 }
3703
3704 /**
3705  * @testcase            utc_tts_unset_screen_reader_changed_cb_p
3706  * @since_tizen         6.5
3707  * @description         Positive UTC for unset screen reader changed callback
3708  */
3709 TEST_F(TTSTest, utc_tts_unset_screen_reader_changed_cb_p)
3710 {
3711         if (g_supported == false) {
3712                 EXPECT_EQ(tts_unset_screen_reader_changed_cb(g_tts), TTS_ERROR_NOT_SUPPORTED);
3713                 return;
3714         }
3715
3716         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3717
3718         EXPECT_EQ(tts_set_screen_reader_changed_cb(g_tts, __tts_screen_reader_changed_cb, nullptr), TTS_ERROR_NONE);
3719         EXPECT_EQ(tts_unset_screen_reader_changed_cb(g_tts), TTS_ERROR_NONE);
3720 }
3721
3722 /**
3723  * @testcase            utc_tts_unset_screen_reader_changed_cb_n
3724  * @since_tizen         6.5
3725  * @description         Negative UTC for unset screen reader changed callback (Invalid handle)
3726  */
3727 TEST_F(TTSTest, utc_tts_unset_screen_reader_changed_cb_n)
3728 {
3729         if (g_supported == false) {
3730                 EXPECT_EQ(tts_unset_screen_reader_changed_cb(nullptr), TTS_ERROR_NOT_SUPPORTED);
3731                 return;
3732         }
3733
3734         EXPECT_EQ(tts_unset_screen_reader_changed_cb(nullptr), TTS_ERROR_INVALID_PARAMETER);
3735 }
3736
3737 /**
3738  * @testcase            utc_tts_unset_screen_reader_changed_cb_n2
3739  * @since_tizen         6.5
3740  * @description         Negative UTC for unset screen reader changed callback (Invalid state)
3741  */
3742 TEST_F(TTSTest, utc_tts_unset_screen_reader_changed_cb_n2)
3743 {
3744         if (g_supported == false) {
3745                 EXPECT_EQ(tts_unset_screen_reader_changed_cb(g_tts), TTS_ERROR_NOT_SUPPORTED);
3746                 return;
3747         }
3748
3749         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3750
3751         EXPECT_EQ(tts_set_screen_reader_changed_cb(g_tts, __tts_screen_reader_changed_cb, nullptr), TTS_ERROR_NONE);
3752
3753         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
3754         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
3755
3756         EXPECT_EQ(tts_unset_screen_reader_changed_cb(g_tts), TTS_ERROR_INVALID_STATE);
3757
3758         EXPECT_EQ(tts_unprepare(g_tts), TTS_ERROR_NONE);
3759 }
3760
3761 /**
3762  * @testcase            utc_tts_set_engine_changed_cb_p
3763  * @since_tizen         3.0
3764  * @description         Positive UTC for set current engine changed callback
3765  */
3766 TEST_F(TTSTest, utc_tts_set_engine_changed_cb_p)
3767 {
3768         if (g_supported == false) {
3769                 EXPECT_EQ(tts_set_engine_changed_cb(g_tts, __tts_engine_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3770                 return;
3771         }
3772
3773         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3774
3775         EXPECT_EQ(tts_set_engine_changed_cb(g_tts, __tts_engine_changed_cb, nullptr), TTS_ERROR_NONE);
3776 }
3777
3778 /**
3779  * @testcase            utc_tts_set_engine_changed_cb_n
3780  * @since_tizen         3.0
3781  * @description         Negative UTC for set current engine changed callback (Invalid handle)
3782  */
3783 TEST_F(TTSTest, utc_tts_set_engine_changed_cb_n)
3784 {
3785         if (g_supported == false) {
3786                 EXPECT_EQ(tts_set_engine_changed_cb(nullptr, __tts_engine_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3787                 return;
3788         }
3789
3790         EXPECT_EQ(tts_set_engine_changed_cb(nullptr, __tts_engine_changed_cb, nullptr), TTS_ERROR_INVALID_PARAMETER);
3791 }
3792
3793 /**
3794  * @testcase            utc_tts_set_engine_changed_cb_n2
3795  * @since_tizen         3.0
3796  * @description         Negative UTC for set current engine changed callback (Invalid state)
3797  */
3798 TEST_F(TTSPreparedTest, utc_tts_set_engine_changed_cb_n2)
3799 {
3800         if (g_supported == false) {
3801                 EXPECT_EQ(tts_set_engine_changed_cb(g_tts, __tts_engine_changed_cb, nullptr), TTS_ERROR_NOT_SUPPORTED);
3802                 return;
3803         }
3804
3805         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3806
3807         EXPECT_EQ(tts_set_engine_changed_cb(g_tts, __tts_engine_changed_cb, nullptr), TTS_ERROR_INVALID_STATE);
3808 }
3809
3810 /**
3811  * @testcase            utc_tts_unset_engine_changed_cb_p
3812  * @since_tizen         3.0
3813  * @description         Positive UTC for unset current engine changed callback
3814  */
3815 TEST_F(TTSTest, utc_tts_unset_engine_changed_cb_p)
3816 {
3817         if (g_supported == false) {
3818                 EXPECT_EQ(tts_unset_engine_changed_cb(g_tts), TTS_ERROR_NOT_SUPPORTED);
3819                 return;
3820         }
3821
3822         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3823
3824         EXPECT_EQ(tts_set_engine_changed_cb(g_tts, __tts_engine_changed_cb, nullptr), TTS_ERROR_NONE);
3825         EXPECT_EQ(tts_unset_engine_changed_cb(g_tts), TTS_ERROR_NONE);
3826 }
3827
3828 /**
3829  * @testcase            utc_tts_unset_engine_changed_cb_n
3830  * @since_tizen         3.0
3831  * @description         Negative UTC for unset current engine changed callback (Invalid handle)
3832  */
3833 TEST_F(TTSTest, utc_tts_unset_engine_changed_cb_n)
3834 {
3835         if (g_supported == false) {
3836                 EXPECT_EQ(tts_unset_engine_changed_cb(nullptr), TTS_ERROR_NOT_SUPPORTED);
3837                 return;
3838         }
3839
3840         EXPECT_EQ(tts_unset_engine_changed_cb(nullptr), TTS_ERROR_INVALID_PARAMETER);
3841 }
3842
3843 /**
3844  * @testcase            utc_tts_unset_engine_changed_cb_n2
3845  * @since_tizen         3.0
3846  * @description         Negative UTC for unset current engine changed callback (Invalid state)
3847  */
3848 TEST_F(TTSTest, utc_tts_unset_engine_changed_cb_n2)
3849 {
3850         if (g_supported == false) {
3851                 EXPECT_EQ(tts_unset_engine_changed_cb(g_tts), TTS_ERROR_NOT_SUPPORTED);
3852                 return;
3853         }
3854
3855         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3856
3857         EXPECT_EQ(tts_set_engine_changed_cb(g_tts, __tts_engine_changed_cb, nullptr), TTS_ERROR_NONE);
3858
3859         EXPECT_EQ(tts_prepare(g_tts), TTS_ERROR_NONE);
3860         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
3861
3862         EXPECT_EQ(tts_unset_engine_changed_cb(g_tts), TTS_ERROR_INVALID_STATE);
3863
3864         EXPECT_EQ(tts_unprepare(g_tts), TTS_ERROR_NONE);
3865 }
3866
3867 /**
3868  * @testcase            utc_tts_add_pcm_p
3869  * @since_tizen         2.3
3870  * @description         test whether pcm data is added properly.
3871  */
3872 TEST_F(TTSPreparedTest, utc_tts_add_pcm_p)
3873 {
3874         if (g_supported == false) {
3875                 EXPECT_EQ(tts_add_pcm(g_tts, 1, nullptr, 0, 0, g_sample_rate), TTS_ERROR_NOT_SUPPORTED);
3876                 return;
3877         }
3878
3879         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3880
3881         char data[10] = {0, };
3882         EXPECT_EQ(tts_add_pcm(g_tts, 1, data, 10, 0, g_sample_rate), TTS_ERROR_NONE);
3883         EXPECT_EQ(tts_add_pcm(g_tts, 2, data, 10, 0, g_sample_rate), TTS_ERROR_NONE);
3884 }
3885
3886 /**
3887  * @testcase            utc_tts_add_pcm_p2
3888  * @since_tizen         2.3
3889  * @description         test whether null pcm data is added properly as a final event.
3890  */
3891 TEST_F(TTSPreparedTest, utc_tts_add_pcm_p2)
3892 {
3893         if (g_supported == false) {
3894                 EXPECT_EQ(tts_add_pcm(g_tts, 1, nullptr, 0, 0, g_sample_rate), TTS_ERROR_NOT_SUPPORTED);
3895                 return;
3896         }
3897
3898         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3899
3900         EXPECT_EQ(tts_add_pcm(g_tts, 3, nullptr, 0, 0, g_sample_rate), TTS_ERROR_NONE);
3901 }
3902
3903 /**
3904  * @testcase            utc_tts_add_pcm_n
3905  * @since_tizen         2.3
3906  * @description         test whether function returns error with NULL parameter.
3907  */
3908 TEST_F(TTSPreparedTest, utc_tts_add_pcm_n)
3909 {
3910         if (g_supported == false) {
3911                 EXPECT_EQ(tts_add_pcm(g_tts, 1, nullptr, 0, 0, g_sample_rate), TTS_ERROR_NOT_SUPPORTED);
3912                 return;
3913         }
3914
3915         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3916
3917         char data[10] = {0, };
3918         EXPECT_EQ(tts_add_pcm(nullptr, 1, data, 10, 0, g_sample_rate), TTS_ERROR_INVALID_PARAMETER);
3919 }
3920
3921 /**
3922  * @testcase            utc_tts_add_pcm_n2
3923  * @since_tizen         2.3
3924  * @description         test whether function returns error when tts is in create state.
3925  */
3926 TEST_F(TTSTest, utc_tts_add_pcm_n2)
3927 {
3928         if (g_supported == false) {
3929                 EXPECT_EQ(tts_add_pcm(g_tts, 1, nullptr, 0, 0, g_sample_rate), TTS_ERROR_NOT_SUPPORTED);
3930                 return;
3931         }
3932
3933         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3934
3935         char data[10] = {0, };
3936         EXPECT_EQ(tts_add_pcm(g_tts, 1, data, 10, 0, g_sample_rate), TTS_ERROR_INVALID_STATE);
3937 }
3938
3939 /**
3940  * @testcase            utc_tts_add_pcm_n3
3941  * @since_tizen         2.3
3942  * @description         test whether function returns error with invalid audio type.
3943  */
3944 TEST_F(TTSPreparedTest, utc_tts_add_pcm_n3)
3945 {
3946         if (g_supported == false) {
3947                 EXPECT_EQ(tts_add_pcm(g_tts, 1, nullptr, 0, 0, g_sample_rate), TTS_ERROR_NOT_SUPPORTED);
3948                 return;
3949         }
3950
3951         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3952
3953         char data[10] = {0, };
3954         EXPECT_EQ(tts_add_pcm(g_tts, 1, data, 10, -1, g_sample_rate), TTS_ERROR_INVALID_PARAMETER);
3955 }
3956
3957 /**
3958  * @testcase            utc_tts_add_pcm_n4
3959  * @since_tizen         2.3
3960  * @description         test whether function returns error with invalid sampling rate.
3961  */
3962 TEST_F(TTSPreparedTest, utc_tts_add_pcm_n4)
3963 {
3964         if (g_supported == false) {
3965                 EXPECT_EQ(tts_add_pcm(g_tts, 1, nullptr, 0, 0, g_sample_rate), TTS_ERROR_NOT_SUPPORTED);
3966                 return;
3967         }
3968
3969         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3970
3971         char data[10] = {0, };
3972         EXPECT_EQ(tts_add_pcm(g_tts, 1, data, 10, 0, -1), TTS_ERROR_INVALID_PARAMETER);
3973 }
3974
3975 /**
3976  * @testcase            utc_tts_play_pcm_p
3977  * @since_tizen         2.3
3978  * @description         test whether tts is played properly.
3979  */
3980 TEST_F(TTSPreparedTest, utc_tts_play_pcm_p)
3981 {
3982         if (g_supported == false) {
3983                 EXPECT_EQ(tts_play_pcm(g_tts), TTS_ERROR_NOT_SUPPORTED);
3984                 return;
3985         }
3986
3987         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
3988
3989         EXPECT_EQ(tts_play_pcm(g_tts), TTS_ERROR_NONE);
3990         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
3991
3992         EXPECT_EQ(tts_stop_pcm(g_tts), TTS_ERROR_NONE);
3993         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
3994 }
3995
3996 /**
3997  * @testcase            utc_tts_play_pcm_p2
3998  * @since_tizen         2.3
3999  * @description         test whether tts is played all pcm data properly.
4000  */
4001 TEST_F(TTSPreparedWithUttCbTest, utc_tts_play_pcm_p2)
4002 {
4003         if (g_supported == false) {
4004                 EXPECT_EQ(tts_play_pcm(g_tts), TTS_ERROR_NOT_SUPPORTED);
4005                 return;
4006         }
4007
4008         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
4009
4010         g_utterance_completed_cb = false;
4011         __get_test_PCM_Data();
4012         ASSERT_NE(g_pcm_data, nullptr);
4013         ASSERT_GT(g_pcm_size, 0);
4014
4015         const size_t shift_size = 12000;
4016         int data_num = g_pcm_size / shift_size;
4017         for (int i = 0; i <= data_num; i++ ) {
4018                 if (0 == i) {
4019                         EXPECT_EQ(tts_add_pcm(g_tts, 1, &g_pcm_data[i*shift_size], shift_size, 0, g_sample_rate), TTS_ERROR_NONE);
4020                 } else if (data_num == i) {
4021                         EXPECT_EQ(tts_add_pcm(g_tts, 3, &g_pcm_data[i*shift_size], g_pcm_size % shift_size, 0, g_sample_rate), TTS_ERROR_NONE);
4022                 } else {
4023                         EXPECT_EQ(tts_add_pcm(g_tts, 2, &g_pcm_data[i*shift_size], shift_size, 0, g_sample_rate), TTS_ERROR_NONE);
4024                 }
4025         }
4026
4027         EXPECT_EQ(tts_play_pcm(g_tts), TTS_ERROR_NONE);
4028         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
4029
4030         while (true != g_utterance_completed_cb) {
4031                 ecore_main_loop_iterate();
4032         }
4033
4034         EXPECT_EQ(tts_stop_pcm(g_tts), TTS_ERROR_NONE);
4035         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
4036 }
4037
4038 /**
4039  * @testcase            utc_tts_play_pcm_n
4040  * @since_tizen         2.3
4041  * @description         test whether function returns error with NULL parameter.
4042  */
4043 TEST_F(TTSTest, utc_tts_play_pcm_n)
4044 {
4045         if (g_supported == false) {
4046                 EXPECT_EQ(tts_play_pcm(g_tts), TTS_ERROR_NOT_SUPPORTED);
4047                 return;
4048         }
4049         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
4050         EXPECT_EQ(tts_play_pcm(nullptr), TTS_ERROR_INVALID_PARAMETER);
4051 }
4052
4053 /**
4054  * @testcase            utc_tts_play_pcm_n2
4055  * @since_tizen         2.3
4056  * @description         test whether function returns error when tts is in create state.
4057  */
4058 TEST_F(TTSTest, utc_tts_play_pcm_n2)
4059 {
4060         if (g_supported == false) {
4061                 EXPECT_EQ(tts_play_pcm(g_tts), TTS_ERROR_NOT_SUPPORTED);
4062                 return;
4063         }
4064         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
4065         EXPECT_EQ(tts_play_pcm(g_tts), TTS_ERROR_INVALID_STATE);
4066 }
4067
4068 /**
4069  * @testcase            utc_tts_stop_pcm_p
4070  * @since_tizen         2.3
4071  * @description         test whether tts is stopped properly.
4072  */
4073 TEST_F(TTSPreparedTest, utc_tts_stop_pcm_p)
4074 {
4075         if (g_supported == false) {
4076                 EXPECT_EQ(tts_stop_pcm(g_tts), TTS_ERROR_NOT_SUPPORTED);
4077                 return;
4078         }
4079
4080         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
4081
4082         EXPECT_EQ(tts_play_pcm(g_tts), TTS_ERROR_NONE);
4083         EXPECT_EQ(true, __is_state_changed(TTS_STATE_PLAYING, 5));
4084
4085         EXPECT_EQ(tts_stop_pcm(g_tts), TTS_ERROR_NONE);
4086         EXPECT_EQ(true, __is_state_changed(TTS_STATE_READY, 5));
4087 }
4088
4089 /**
4090  * @testcase            utc_tts_stop_pcm_n
4091  * @since_tizen         2.3
4092  * @description         test whether function returns error with NULL parameter.
4093  */
4094 TEST_F(TTSTest, utc_tts_stop_pcm_n)
4095 {
4096         if (g_supported == false) {
4097                 EXPECT_EQ(tts_stop_pcm(nullptr), TTS_ERROR_NOT_SUPPORTED);
4098                 return;
4099         }
4100         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
4101         EXPECT_EQ(tts_stop_pcm(nullptr), TTS_ERROR_INVALID_PARAMETER);
4102 }
4103
4104 /**
4105  * @testcase            utc_tts_stop_pcm_n2
4106  * @since_tizen         2.3
4107  * @description         test whether function returns error when tts is in create state.
4108  */
4109 TEST_F(TTSTest, utc_tts_stop_pcm_n2)
4110 {
4111         if (g_supported == false) {
4112                 EXPECT_EQ(tts_stop_pcm(g_tts), TTS_ERROR_NOT_SUPPORTED);
4113                 return;
4114         }
4115         EXPECT_EQ(is_created_hndl, TTS_ERROR_NONE);
4116         EXPECT_EQ(tts_stop_pcm(g_tts), TTS_ERROR_INVALID_STATE);
4117 }
4118
4119 } // namespace