tests/src/vc_mgr_unittests.cpp

   1 /*
   2  * Copyright (c) 2022 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
  22 #include <voice_control_manager.h>
  23 #include <voice_control_manager_internal.h>
  24 #include "system_info_mock.h"
  25 #include "cynara_mock.h"
  26
  27
  28 static const char *TEST_COMMAND_JSON_PATH = tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_APP"), "/org.tizen.vc-unittests/res/test_command.json");
  29 static const char *TEST_DEMANDABLE_LIST_XML_PATH = tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_APP"), "/org.tizen.vc-unittests/res/test_demandable_list.xml");
  30 static const char *TEST_EMPTY_FILE_PATH = tzplatform_mkpath(tzplatform_getid("TZ_SYS_RO_APP"), "/org.tizen.vc-unittests/res/empty_file");
  31 static const char *TEST_DOMAIN = "domain";
  32 static const char *DEFAULT_ENGINE_APP_ID = "org.tizen.vc-engine-default";
  33
  34 static vc_state_e g_vc_mgr_state = VC_STATE_NONE;
  35 static vc_service_state_e g_vc_mgr_service_state = VC_SERVICE_STATE_NONE;
  36
  37 static bool __is_mgr_state_changed(vc_state_e state, int wait_delay)
  38 {
  39         int max_count = wait_delay * 10;
  40         int count = 0;
  41         while (max_count > count && state != g_vc_mgr_state) {
  42                 ecore_main_loop_iterate();
  43                 usleep(100000);
  44                 count++;
  45         }
  46
  47         if (state != g_vc_mgr_state) {
  48                 return false;
  49         }
  50
  51         return true;
  52 }
  53
  54 static bool __is_mgr_service_state_changed(vc_service_state_e state, int wait_delay)
  55 {
  56         int max_count = wait_delay * 10;
  57         int count = 0;
  58         while (max_count > count && state != g_vc_mgr_service_state) {
  59                 ecore_main_loop_iterate();
  60                 usleep(100000);
  61                 count++;
  62         }
  63
  64         if (state != g_vc_mgr_service_state) {
  65                 return false;
  66         }
  67
  68         return true;
  69 }
  70
  71 static void __vc_mgr_specific_engine_result_cb(const char* engine_app_id, const char* event, const char* result, void *user_data)
  72 {
  73 }
  74
  75 static bool __vc_mgr_all_result_cb(vc_result_event_e event, vc_cmd_list_h vc_cmd_list, const char *result, const char *msg, void *user_data)
  76 {
  77         return true;
  78 }
  79
  80 static void __vc_mgr_pre_result_cb(vc_pre_result_event_e event, const char *result, void *user_data)
  81 {
  82 }
  83
  84 static void __vc_mgr_result_cb(vc_result_event_e event, vc_cmd_list_h vc_cmd_list, const char* result, void* user_data)
  85 {
  86 }
  87
  88 static void __vc_mgr_begin_speech_detected_cb(void *user_data)
  89 {
  90 }
  91
  92 static void __vc_mgr_dialog_request_cb(int pid, const char *disp_text, const char *utt_text, bool continuous, void *user_data)
  93 {
  94 }
  95
  96 static int __vc_mgr_private_data_set_cb(const char *key, const char *data, void *user_data)
  97 {
  98         return 0;
  99 }
 100
 101 static int __vc_mgr_private_data_requested_cb(const char *key, char **data, void *user_data)
 102 {
 103         return 0;
 104 }
 105
 106 static void __vc_mgr_feedback_audio_format_cb(int rate, vc_audio_channel_e channel, vc_audio_type_e audio_type, void *user_data)
 107 {
 108 }
 109
 110 static void __vc_mgr_feedback_streaming_cb(vc_feedback_event_e event, char* buffer, int len, void *user_data)
 111 {
 112 }
 113
 114 static void __vc_current_language_changed_cb(const char* previous, const char* current, void* user_data)
 115 {
 116 }
 117
 118 static bool __vc_supported_language_cb(const char* language, void* user_data)
 119 {
 120         return true;
 121 }
 122
 123 static void __vc_mgr_state_changed_cb(vc_state_e previous, vc_state_e current, void* user_data)
 124 {
 125         g_vc_mgr_state = current;
 126 }
 127
 128 static void __vc_mgr_service_state_changed_cb(vc_service_state_e previous, vc_service_state_e current, void* user_data)
 129 {
 130         g_vc_mgr_service_state = current;
 131 }
 132
 133 static void __vc_mgr_error_cb(vc_error_e reason, void* user_data)
 134 {
 135 }
 136
 137 static void __vc_mgr_vc_tts_streaming_cb(int pid, int utt_id, vc_feedback_event_e event, char* buffer, int len, void *user_data)
 138 {
 139 }
 140
 141
 142 static vc_cmd_list_h __create_test_command_list()
 143 {
 144         vc_cmd_h system_command = nullptr;
 145         EXPECT_EQ(vc_cmd_create(&system_command), VC_ERROR_NONE);
 146         EXPECT_EQ(vc_cmd_set_command(system_command, "test"), VC_ERROR_NONE);
 147         EXPECT_EQ(vc_cmd_set_type(system_command, VC_COMMAND_TYPE_SYSTEM), VC_ERROR_NONE);
 148
 149         vc_cmd_list_h commands = nullptr;
 150         EXPECT_EQ(vc_cmd_list_create(&commands), VC_ERROR_NONE);
 151         EXPECT_EQ(vc_cmd_list_add(commands, system_command), VC_ERROR_NONE);
 152
 153         return commands;
 154 }
 155
 156 static void __initialize_ecore()
 157 {
 158         ecore_init();
 159         ecore_main_loop_glib_integrate();
 160 }
 161
 162 static void __shutdown_ecore()
 163 {
 164         ecore_shutdown();
 165 }
 166
 167 static bool __is_vc_mgr_supported()
 168 {
 169         bool is_vc_supported = false;
 170         bool is_mic_supported = false;
 171         if (0 != system_info_get_platform_bool("http://tizen.org/feature/speech.control", &is_vc_supported))
 172         {
 173                 is_vc_supported = false;
 174         }
 175
 176         if (0 != system_info_get_platform_bool("http://tizen.org/feature/microphone", &is_mic_supported))
 177         {
 178                 is_mic_supported = false;
 179         }
 180
 181         if (is_vc_supported && is_mic_supported)
 182         {
 183                 return true;
 184         }
 185
 186         return false;
 187 }
 188
 189 namespace {
 190
 191 class VcMgrTestInNoneState : public testing::Test {
 192         public:
 193                 virtual void SetUp()
 194                 {
 195                         __initialize_ecore();
 196                         g_vc_mgr_state = VC_STATE_NONE;
 197                         g_vc_mgr_service_state = VC_SERVICE_STATE_NONE;
 198                         __is_feature_supported = __is_vc_mgr_supported();
 199                 }
 200
 201                 virtual void TearDown()
 202                 {
 203                         vc_mgr_deinitialize();
 204                         __shutdown_ecore();
 205                 }
 206
 207         public:
 208                 bool __is_feature_supported = false;
 209 };
 210
 211 class VcMgrTestInInitializedState : public testing::Test {
 212         public:
 213                 virtual void SetUp()
 214                 {
 215                         __initialize_ecore();
 216                         g_vc_mgr_state = VC_STATE_NONE;
 217                         g_vc_mgr_service_state = VC_SERVICE_STATE_NONE;
 218                         __is_feature_supported = __is_vc_mgr_supported();
 219
 220                         EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
 221                         EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_NONE);
 222                         EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_NONE);
 223                 }
 224
 225                 virtual void TearDown()
 226                 {
 227                         vc_mgr_unprepare();
 228                         EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_NONE);
 229                         EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_NONE);
 230                         EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
 231
 232                         __shutdown_ecore();
 233                 }
 234
 235         public:
 236                 bool __is_feature_supported = false;
 237 };
 238
 239 class VcMgrTestInReadyState : public testing::Test {
 240         public:
 241                 virtual void SetUp()
 242                 {
 243                         __initialize_ecore();
 244                         g_vc_mgr_state = VC_STATE_NONE;
 245                         g_vc_mgr_service_state = VC_SERVICE_STATE_NONE;
 246                         __is_feature_supported = __is_vc_mgr_supported();
 247
 248                         EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
 249                         EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_NONE);
 250                         EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_NONE);
 251                         EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE);
 252                         ASSERT_EQ(true, __is_mgr_state_changed(VC_STATE_READY, 5));
 253                         ASSERT_EQ(true, __is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5));
 254                 }
 255
 256                 virtual void TearDown()
 257                 {
 258                         EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_NONE);
 259                         EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_NONE);
 260                         EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_NONE);
 261                         EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
 262
 263                         __shutdown_ecore();
 264                 }
 265
 266         public:
 267                 bool __is_feature_supported = false;
 268 };
 269
 270 /**
 271  * @testcase            utc_vc_mgr_initialize_p1
 272  * @since_tizen         5.0
 273  * @description         Positive UTC for initialize voice control manager handle
 274  */
 275 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_initialize_p1)
 276 {
 277         if (false == __is_feature_supported) {
 278                 EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NOT_SUPPORTED);
 279         } else {
 280                 EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
 281         }
 282 }
 283
 284 /**
 285  * @testcase            utc_vc_mgr_initialize_p2
 286  * @since_tizen         5.0
 287  * @description         Positive UTC for initialize voice control manager handle
 288  */
 289 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_initialize_p2)
 290 {
 291         if (false == __is_feature_supported) {
 292                 EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NOT_SUPPORTED);
 293         } else {
 294                 EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
 295                 EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
 296         }
 297 }
 298
 299 /**
 300  * @testcase            utc_vc_mgr_deinitialize_p
 301  * @since_tizen         5.0
 302  * @description         Positive UTC for deinitialize voice control manager handle
 303  */
 304 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_deinitialize_p)
 305 {
 306         if (false == __is_feature_supported) {
 307                 EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NOT_SUPPORTED);
 308         } else {
 309                 EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
 310                 EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
 311         }
 312 }
 313
 314 /**
 315  * @testcase            utc_vc_mgr_deinitialize_n
 316  * @since_tizen         5.0
 317  * @description         Negative UTC for deinitialize voice control manager handle
 318  */
 319 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_deinitialize_n)
 320 {
 321         if (false == __is_feature_supported) {
 322                 EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NOT_SUPPORTED);
 323         } else {
 324                 EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_INVALID_STATE);
 325         }
 326 }
 327
 328 /**
 329  * @testcase            utc_vc_mgr_prepare_p
 330  * @since_tizen         5.0
 331  * @description         Positive UTC for connect service daemon
 332  */
 333 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_prepare_p)
 334 {
 335         if (false == __is_feature_supported) {
 336                 EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NOT_SUPPORTED);
 337                 return;
 338         }
 339
 340         EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE);
 341         ASSERT_EQ(__is_mgr_state_changed(VC_STATE_READY, 5), true);
 342 }
 343
 344 /**
 345  * @testcase            utc_vc_mgr_prepare_n
 346  * @since_tizen         5.0
 347  * @description         Negative UTC for connect service daemon
 348  */
 349 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_prepare_n)
 350 {
 351         if (false == __is_feature_supported) {
 352                 EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NOT_SUPPORTED);
 353                 return;
 354         }
 355
 356         EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE);
 357         ASSERT_EQ(__is_mgr_state_changed(VC_STATE_READY, 5), true);
 358
 359         EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_INVALID_STATE);
 360 }
 361
 362 /**
 363  * @testcase            utc_vc_mgr_unprepare_p
 364  * @since_tizen         5.0
 365  * @description         Positive UTC for disconnect service daemon
 366  */
 367 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unprepare_p)
 368 {
 369         if (false == __is_feature_supported) {
 370                 EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_NOT_SUPPORTED);
 371                 return;
 372         }
 373
 374         EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE);
 375         ASSERT_EQ(__is_mgr_state_changed(VC_STATE_READY, 5), true);
 376
 377         EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_NONE);
 378 }
 379
 380 /**
 381  * @testcase            utc_vc_mgr_unprepare_n
 382  * @since_tizen         5.0
 383  * @description         Negative UTC for disconnect service daemon
 384  */
 385 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unprepare_n)
 386 {
 387         if (false == __is_feature_supported) {
 388                 EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_NOT_SUPPORTED);
 389                 return;
 390         }
 391
 392         EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_INVALID_STATE);
 393 }
 394
 395 /**
 396  * @testcase            utc_vc_mgr_foreach_supported_languages_p
 397  * @since_tizen         5.0
 398  * @description         Positive UTC for get supported language list
 399  */
 400 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_foreach_supported_languages_p)
 401 {
 402         if (false == __is_feature_supported) {
 403                 EXPECT_EQ(vc_mgr_foreach_supported_languages(__vc_supported_language_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
 404                 return;
 405         }
 406
 407         EXPECT_EQ(vc_mgr_foreach_supported_languages(__vc_supported_language_cb, nullptr), VC_ERROR_NONE);
 408 }
 409
 410 /**
 411  * @testcase            utc_vc_mgr_foreach_supported_languages_n1
 412  * @since_tizen         5.0
 413  * @description         Negatvie UTC for get supported language list
 414  */
 415 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_foreach_supported_languages_n1)
 416 {
 417         if (false == __is_feature_supported) {
 418                 EXPECT_EQ(vc_mgr_foreach_supported_languages(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
 419                 return;
 420         }
 421
 422         EXPECT_EQ(vc_mgr_foreach_supported_languages(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
 423 }
 424
 425 /**
 426  * @testcase            utc_vc_mgr_foreach_supported_languages_n2
 427  * @since_tizen         5.0
 428  * @description         Negatvie UTC for get supported language list
 429  */
 430 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_foreach_supported_languages_n2)
 431 {
 432         if (false == __is_feature_supported) {
 433                 EXPECT_EQ(vc_mgr_foreach_supported_languages(__vc_supported_language_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
 434                 return;
 435         }
 436
 437         EXPECT_EQ(vc_mgr_foreach_supported_languages(__vc_supported_language_cb, nullptr), VC_ERROR_INVALID_STATE);
 438 }
 439
 440 /**
 441  * @testcase            utc_vc_mgr_get_current_language_p
 442  * @since_tizen         5.0
 443  * @description         Positive UTC for get current language
 444  */
 445 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_current_language_p)
 446 {
 447         char *language = nullptr;
 448         if (false == __is_feature_supported) {
 449                 EXPECT_EQ(vc_mgr_get_current_language(&language), VC_ERROR_NOT_SUPPORTED);
 450                 free(language);
 451                 return;
 452         }
 453
 454         EXPECT_EQ(vc_mgr_get_current_language(&language), VC_ERROR_NONE);
 455         ASSERT_NE(language, nullptr);
 456         free(language);
 457 }
 458
 459 /**
 460  * @testcase            utc_vc_mgr_get_current_language_n1
 461  * @since_tizen         5.0
 462  * @description         Negatvie UTC for get current language
 463  */
 464 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_current_language_n1)
 465 {
 466         if (false == __is_feature_supported) {
 467                 EXPECT_EQ(vc_mgr_get_current_language(nullptr), VC_ERROR_NOT_SUPPORTED);
 468                 return;
 469         }
 470
 471         EXPECT_EQ(vc_mgr_get_current_language(nullptr), VC_ERROR_INVALID_PARAMETER);
 472 }
 473
 474 /**
 475  * @testcase            utc_vc_mgr_get_current_language_n2
 476  * @since_tizen         5.0
 477  * @description         Negatvie UTC for get current language
 478  */
 479 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_current_language_n2)
 480 {
 481         char *language = nullptr;
 482         if (false == __is_feature_supported) {
 483                 EXPECT_EQ(vc_mgr_get_current_language(&language), VC_ERROR_NOT_SUPPORTED);
 484                 free(language);
 485                 return;
 486         }
 487
 488         EXPECT_EQ(vc_mgr_get_current_language(&language), VC_ERROR_INVALID_STATE);
 489 }
 490
 491 /**
 492  * @testcase            utc_vc_mgr_get_state_p1
 493  * @since_tizen         5.0
 494  * @description         Positive UTC for get current state
 495  */
 496 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_state_p1)
 497 {
 498         vc_state_e state;
 499         if (false == __is_feature_supported) {
 500                 EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_NOT_SUPPORTED);
 501                 return;
 502         }
 503
 504         EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_NONE);
 505         EXPECT_EQ(state, VC_STATE_INITIALIZED);
 506 }
 507
 508 /**
 509  * @testcase            utc_vc_mgr_get_state_p2
 510  * @since_tizen         5.0
 511  * @description         Positive UTC for get current state
 512  */
 513 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_state_p2)
 514 {
 515         vc_state_e state;
 516         if (false == __is_feature_supported) {
 517                 EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_NOT_SUPPORTED);
 518                 return;
 519         }
 520
 521         EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_NONE);
 522         EXPECT_EQ(state, VC_STATE_READY);
 523 }
 524
 525 /**
 526  * @testcase            utc_vc_mgr_get_state_n
 527  * @since_tizen         5.0
 528  * @description         Negative UTC for get current state
 529  */
 530 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_state_n)
 531 {
 532         if (false == __is_feature_supported) {
 533                 EXPECT_EQ(vc_mgr_get_state(nullptr), VC_ERROR_NOT_SUPPORTED);
 534                 return;
 535         }
 536
 537         EXPECT_EQ(vc_mgr_get_state(nullptr), VC_ERROR_INVALID_PARAMETER);
 538 }
 539
 540 /**
 541  * @testcase            utc_vc_mgr_get_state_n2
 542  * @since_tizen         5.0
 543  * @description         Negative UTC for get current state
 544  */
 545 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_state_n2)
 546 {
 547         vc_state_e state;
 548         if (false == __is_feature_supported) {
 549                 EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_NOT_SUPPORTED);
 550                 return;
 551         }
 552
 553         EXPECT_EQ(vc_mgr_get_state(&state), VC_ERROR_INVALID_STATE);
 554 }
 555
 556 /**
 557  * @testcase            utc_vc_mgr_get_service_state_p
 558  * @since_tizen         5.0
 559  * @description         Positive UTC for get current state of service daemon
 560  */
 561 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_service_state_p)
 562 {
 563         vc_service_state_e state;
 564         if (false == __is_feature_supported) {
 565                 EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_NOT_SUPPORTED);
 566                 return;
 567         }
 568
 569         EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_NONE);
 570         EXPECT_EQ(state, VC_SERVICE_STATE_READY);
 571 }
 572
 573 /**
 574  * @testcase            utc_vc_mgr_get_service_state_n1
 575  * @since_tizen         5.0
 576  * @description         Negative UTC for get current state of service daemon
 577  */
 578 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_service_state_n1)
 579 {
 580         if (false == __is_feature_supported) {
 581                 EXPECT_EQ(vc_mgr_get_service_state(nullptr), VC_ERROR_NOT_SUPPORTED);
 582                 return;
 583         }
 584
 585         EXPECT_EQ(vc_mgr_get_service_state(nullptr), VC_ERROR_INVALID_PARAMETER);
 586 }
 587
 588 /**
 589  * @testcase            utc_vc_mgr_get_service_state_n2
 590  * @since_tizen         5.0
 591  * @description         Negative UTC for get current state of service daemon
 592  */
 593 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_service_state_n2)
 594 {
 595         vc_service_state_e state;
 596         if (false == __is_feature_supported) {
 597                 EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_NOT_SUPPORTED);
 598                 return;
 599         }
 600
 601         EXPECT_EQ(vc_mgr_get_service_state(&state), VC_ERROR_INVALID_STATE);
 602 }
 603
 604 /**
 605  * @testcase            utc_vc_mgr_is_command_format_supported_p
 606  * @since_tizen         5.0
 607  * @description         Positive UTC for get supported command format
 608  */
 609 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_is_command_format_supported_p)
 610 {
 611         int format = VC_COMMAND_FORMAT_FIXED;
 612         bool support = false;
 613         if (false == __is_feature_supported) {
 614                 EXPECT_EQ(vc_mgr_is_command_format_supported(format, &support), VC_ERROR_NOT_SUPPORTED);
 615                 return;
 616         }
 617
 618         EXPECT_EQ(vc_mgr_is_command_format_supported(format, &support), VC_ERROR_NONE);
 619 }
 620
 621 /**
 622  * @testcase            utc_vc_mgr_is_command_format_supported_n1
 623  * @since_tizen         5.0
 624  * @description         Negative UTC for get supported command format
 625  */
 626 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_is_command_format_supported_n1)
 627 {
 628         int format = VC_COMMAND_FORMAT_FIXED;
 629         if (false == __is_feature_supported) {
 630                 EXPECT_EQ(vc_mgr_is_command_format_supported(format, nullptr), VC_ERROR_NOT_SUPPORTED);
 631                 return;
 632         }
 633
 634         EXPECT_EQ(vc_mgr_is_command_format_supported(format, nullptr), VC_ERROR_INVALID_PARAMETER);
 635 }
 636
 637 /**
 638  * @testcase            utc_vc_mgr_is_command_format_supported_n2
 639  * @since_tizen         5.0
 640  * @description         Negative UTC for get supported command format
 641  */
 642 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_is_command_format_supported_n2)
 643 {
 644         int format = VC_COMMAND_FORMAT_FIXED;
 645         bool support = false;
 646         if (false == __is_feature_supported) {
 647                 EXPECT_EQ(vc_mgr_is_command_format_supported(format, &support), VC_ERROR_NOT_SUPPORTED);
 648                 return;
 649         }
 650
 651         EXPECT_EQ(vc_mgr_is_command_format_supported(format, &support), VC_ERROR_INVALID_STATE);
 652 }
 653
 654 /**
 655  * @testcase            utc_vc_mgr_set_command_list_p
 656  * @since_tizen         5.0
 657  * @description         Positive UTC for set command list used as candidate set
 658  */
 659 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_p)
 660 {
 661         vc_cmd_list_h commands = __create_test_command_list();
 662         ASSERT_NE(commands, nullptr);
 663
 664         if (false == __is_feature_supported) {
 665                 EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NOT_SUPPORTED);
 666                 vc_cmd_list_destroy(commands, true);
 667                 return;
 668         }
 669
 670         EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
 671         vc_cmd_list_destroy(commands, true);
 672 }
 673
 674 /**
 675  * @testcase            utc_vc_mgr_set_command_list_n1
 676  * @since_tizen         5.0
 677  * @description         Negative UTC for set command list used as candidate set
 678  */
 679 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_n1)
 680 {
 681         if (false == __is_feature_supported) {
 682                 EXPECT_EQ(vc_mgr_set_command_list(nullptr), VC_ERROR_NOT_SUPPORTED);
 683                 return;
 684         }
 685
 686         EXPECT_EQ(vc_mgr_set_command_list(nullptr), VC_ERROR_INVALID_PARAMETER);
 687 }
 688
 689 /**
 690  * @testcase            utc_vc_mgr_set_command_list_n2
 691  * @since_tizen         5.0
 692  * @description         Negative UTC for set command list used as candidate set
 693  */
 694 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_n2)
 695 {
 696         vc_cmd_list_h commands = __create_test_command_list();
 697         ASSERT_NE(commands, nullptr);
 698
 699         if (false == __is_feature_supported) {
 700                 EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NOT_SUPPORTED);
 701                 vc_cmd_list_destroy(commands, true);
 702                 return;
 703         }
 704
 705         EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_INVALID_STATE);
 706         vc_cmd_list_destroy(commands, true);
 707 }
 708
 709 /**
 710  * @testcase            utc_vc_mgr_unset_command_list_p
 711  * @since_tizen         5.0
 712  * @description         Positive UTC for unset command list used as candidate set
 713  */
 714 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_unset_command_list_p)
 715 {
 716         if (false == __is_feature_supported) {
 717                 EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_NOT_SUPPORTED);
 718                 return;
 719         }
 720
 721         vc_cmd_list_h commands = __create_test_command_list();
 722         ASSERT_NE(commands, nullptr);
 723
 724         EXPECT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
 725         EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_NONE);
 726         vc_cmd_list_destroy(commands, true);
 727 }
 728
 729 /**
 730  * @testcase            utc_vc_mgr_unset_command_list_n
 731  * @since_tizen         5.0
 732  * @description         Negative UTC for unset command list used as candidate set
 733  */
 734 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_command_list_n)
 735 {
 736         if (false == __is_feature_supported) {
 737                 EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_NOT_SUPPORTED);
 738                 return;
 739         }
 740
 741         EXPECT_EQ(vc_mgr_unset_command_list(), VC_ERROR_INVALID_STATE);
 742 }
 743
 744 /**
 745  * @testcase            utc_vc_mgr_set_command_list_from_file_p
 746  * @since_tizen         5.0
 747  * @description         Positive UTC for unset command list from file used as candidate set
 748  */
 749 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_from_file_p)
 750 {
 751         if (false == __is_feature_supported) {
 752                 EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
 753                 return;
 754         }
 755
 756         EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NONE);
 757 }
 758
 759 /**
 760  * @testcase            utc_vc_mgr_set_command_list_from_file_n1
 761  * @since_tizen         5.0
 762  * @description         Negative UTC for unset command list from file used as candidate set
 763  */
 764 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_from_file_n1)
 765 {
 766         if (false == __is_feature_supported) {
 767                 EXPECT_EQ(vc_mgr_set_command_list_from_file(nullptr, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
 768                 EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_EMPTY_FILE_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
 769                 return;
 770         }
 771
 772         EXPECT_EQ(vc_mgr_set_command_list_from_file(nullptr, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_PARAMETER);
 773         EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_EMPTY_FILE_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_PARAMETER);
 774 }
 775
 776 /**
 777  * @testcase            utc_vc_mgr_set_command_list_from_file_n2
 778  * @since_tizen         5.0
 779  * @description         Negative UTC for unset command list from file used as candidate set
 780  */
 781 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_command_list_from_file_n2)
 782 {
 783         if (false == __is_feature_supported) {
 784                 EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, -1), VC_ERROR_NOT_SUPPORTED);
 785                 return;
 786         }
 787
 788         EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, -1), VC_ERROR_INVALID_PARAMETER);
 789 }
 790
 791 /**
 792  * @testcase            utc_vc_mgr_set_command_list_from_file_n3
 793  * @since_tizen         5.0
 794  * @description         Negative UTC for unset command list from file used as candidate set
 795  */
 796 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_from_file_n3)
 797 {
 798         if (false == __is_feature_supported) {
 799                 EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
 800                 return;
 801         }
 802
 803         EXPECT_EQ(vc_mgr_set_command_list_from_file(TEST_COMMAND_JSON_PATH, VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
 804 }
 805
 806 /**
 807  * @testcase            utc_vc_mgr_set_preloaded_commands_from_file_p
 808  * @since_tizen         5.0
 809  * @description         Positive UTC for set preloaded commands from file used as candidate set
 810  */
 811 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_preloaded_commands_from_file_p)
 812 {
 813         if (false == __is_feature_supported) {
 814                 EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(TEST_COMMAND_JSON_PATH), VC_ERROR_NOT_SUPPORTED);
 815                 return;
 816         }
 817
 818         EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(TEST_COMMAND_JSON_PATH), VC_ERROR_NONE);
 819 }
 820
 821 /**
 822  * @testcase            utc_vc_mgr_set_preloaded_commands_from_file_n1
 823  * @since_tizen         5.0
 824  * @description         Negative UTC for set preloaded commands from file used as candidate set
 825  */
 826 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_preloaded_commands_from_file_n1)
 827 {
 828         if (false == __is_feature_supported) {
 829                 EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(nullptr), VC_ERROR_NOT_SUPPORTED);
 830                 return;
 831         }
 832
 833         EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(nullptr), VC_ERROR_INVALID_PARAMETER);
 834 }
 835
 836 /**
 837  * @testcase            utc_vc_mgr_set_command_list_from_file_n2
 838  * @since_tizen         5.0
 839  * @description         Negative UTC for unset command list from file used as candidate set
 840  */
 841 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_command_list_from_file_n2)
 842 {
 843         if (false == __is_feature_supported) {
 844                 EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(TEST_COMMAND_JSON_PATH), VC_ERROR_NOT_SUPPORTED);
 845                 return;
 846         }
 847
 848         EXPECT_EQ(vc_mgr_set_preloaded_commands_from_file(TEST_COMMAND_JSON_PATH), VC_ERROR_INVALID_STATE);
 849 }
 850
 851 /**
 852  * @testcase            utc_vc_mgr_get_current_commands_p
 853  * @since_tizen         5.0
 854  * @description         Positive UTC for get command handle of current pointer
 855  */
 856 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_current_commands_p)
 857 {
 858         vc_cmd_list_h commands = nullptr;
 859         if (false == __is_feature_supported) {
 860                 EXPECT_EQ(vc_mgr_get_current_commands(&commands), VC_ERROR_NOT_SUPPORTED);
 861                 return;
 862         }
 863
 864         EXPECT_EQ(vc_mgr_get_current_commands(&commands), VC_ERROR_NONE);
 865 }
 866
 867 /**
 868  * @testcase            utc_vc_mgr_get_current_commands_n1
 869  * @since_tizen         5.0
 870  * @description         Negative UTC for get command handle of current pointer
 871  */
 872 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_current_commands_n1)
 873 {
 874         if (false == __is_feature_supported) {
 875                 EXPECT_EQ(vc_mgr_get_current_commands(nullptr), VC_ERROR_NOT_SUPPORTED);
 876                 return;
 877         }
 878
 879         EXPECT_EQ(vc_mgr_get_current_commands(nullptr), VC_ERROR_INVALID_PARAMETER);
 880 }
 881
 882 /**
 883  * @testcase            utc_vc_mgr_get_current_commands_n2
 884  * @since_tizen         5.0
 885  * @description         Negative UTC for get command handle of current pointer
 886  */
 887 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_current_commands_n2)
 888 {
 889         vc_cmd_list_h commands = nullptr;
 890         if (false == __is_feature_supported) {
 891                 EXPECT_EQ(vc_mgr_get_current_commands(&commands), VC_ERROR_NOT_SUPPORTED);
 892                 return;
 893         }
 894
 895         EXPECT_EQ(vc_mgr_get_current_commands(&commands), VC_ERROR_INVALID_STATE);
 896 }
 897
 898 /**
 899  * @testcase            utc_vc_mgr_set_audio_type_p
 900  * @since_tizen         5.0
 901  * @description         Positive UTC for set audio type
 902  */
 903 TEST_F(VcMgrTestInReadyState, vc_set_result_cb_p)
 904 {
 905         const char *audioType = "audio_id";
 906         if (false == __is_feature_supported) {
 907                 EXPECT_EQ(vc_mgr_set_audio_type(audioType), VC_ERROR_NOT_SUPPORTED);
 908                 return;
 909         }
 910
 911         EXPECT_EQ(vc_mgr_set_audio_type(audioType), VC_ERROR_NONE);
 912 }
 913
 914 /**
 915  * @testcase            utc_vc_mgr_set_audio_type_n1
 916  * @since_tizen         5.0
 917  * @description         Negative UTC for set audio type
 918  */
 919 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_audio_type_n1)
 920 {
 921         if (false == __is_feature_supported) {
 922                 EXPECT_EQ(vc_mgr_set_audio_type(nullptr), VC_ERROR_NOT_SUPPORTED);
 923                 return;
 924         }
 925
 926         EXPECT_EQ(vc_mgr_set_audio_type(nullptr), VC_ERROR_INVALID_PARAMETER);
 927 }
 928
 929 /**
 930  * @testcase            utc_vc_mgr_set_audio_type_n2
 931  * @since_tizen         5.0
 932  * @description         Negative UTC for set audio type
 933  */
 934 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_audio_type_n2)
 935 {
 936         const char *audioType = "audio_id";
 937         if (false == __is_feature_supported) {
 938                 EXPECT_EQ(vc_mgr_set_audio_type(audioType), VC_ERROR_NOT_SUPPORTED);
 939                 return;
 940         }
 941
 942         EXPECT_EQ(vc_mgr_set_audio_type(audioType), VC_ERROR_INVALID_STATE);
 943 }
 944
 945 /**
 946  * @testcase            utc_vc_mgr_get_audio_type_p
 947  * @since_tizen         5.0
 948  * @description         Positive UTC for get audio type
 949  */
 950 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_audio_type_p)
 951 {
 952         char *audioType = nullptr;
 953         if (false == __is_feature_supported) {
 954                 EXPECT_EQ(vc_mgr_get_audio_type(&audioType), VC_ERROR_NOT_SUPPORTED);
 955                 free(audioType);
 956                 return;
 957         }
 958
 959         EXPECT_EQ(vc_mgr_get_audio_type(&audioType), VC_ERROR_NONE);
 960         free(audioType);
 961 }
 962
 963 /**
 964  * @testcase            utc_vc_mgr_get_audio_type_n1
 965  * @since_tizen         5.0
 966  * @description         Positive UTC for get audio type
 967  */
 968 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_audio_type_n1)
 969 {
 970         if (false == __is_feature_supported) {
 971                 EXPECT_EQ(vc_mgr_get_audio_type(nullptr), VC_ERROR_NOT_SUPPORTED);
 972                 return;
 973         }
 974
 975         EXPECT_EQ(vc_mgr_get_audio_type(nullptr), VC_ERROR_INVALID_PARAMETER);
 976 }
 977
 978 /**
 979  * @testcase            utc_vc_mgr_get_audio_type_n2
 980  * @since_tizen         5.0
 981  * @description         Positive UTC for get audio type
 982  */
 983 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_audio_type_n2)
 984 {
 985         char *audioType = nullptr;
 986         if (false == __is_feature_supported) {
 987                 EXPECT_EQ(vc_mgr_get_audio_type(&audioType), VC_ERROR_NOT_SUPPORTED);
 988                 free(audioType);
 989                 return;
 990         }
 991
 992         EXPECT_EQ(vc_mgr_get_audio_type(&audioType), VC_ERROR_INVALID_STATE);
 993         free(audioType);
 994 }
 995
 996 /**
 997  * @testcase            utc_vc_mgr_set_recognition_mode_p
 998  * @since_tizen         5.0
 999  * @description         Positive UTC for set recognition mode
1000  */
1001 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_recognition_mode_p)
1002 {
1003         if (false == __is_feature_supported) {
1004                 EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_NOT_SUPPORTED);
1005                 return;
1006         }
1007
1008         EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_NONE);
1009 }
1010
1011 /**
1012  * @testcase            utc_vc_mgr_set_recognition_mode_n1
1013  * @since_tizen         5.0
1014  * @description         Negative UTC for set recognition mode
1015  */
1016 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_recognition_mode_n1)
1017 {
1018         if (false == __is_feature_supported) {
1019                 EXPECT_EQ(vc_mgr_set_recognition_mode(static_cast<vc_recognition_mode_e>(-1)), VC_ERROR_NOT_SUPPORTED);
1020                 return;
1021         }
1022
1023         EXPECT_EQ(vc_mgr_set_recognition_mode(static_cast<vc_recognition_mode_e>(-1)), VC_ERROR_INVALID_PARAMETER);
1024 }
1025
1026 /**
1027  * @testcase            utc_vc_mgr_set_recognition_mode_n2
1028  * @since_tizen         5.0
1029  * @description         Negative UTC for set recognition mode
1030  */
1031 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_recognition_mode_n2)
1032 {
1033         if (false == __is_feature_supported) {
1034                 EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_NOT_SUPPORTED);
1035                 return;
1036         }
1037
1038         EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_INVALID_STATE);
1039 }
1040
1041 /**
1042  * @testcase            utc_vc_mgr_get_recognition_mode_p
1043  * @since_tizen         5.0
1044  * @description         Positive UTC for get recognition mode
1045  */
1046 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_recognition_mode_p)
1047 {
1048         vc_recognition_mode_e mode = VC_RECOGNITION_MODE_MANUAL;
1049         if (false == __is_feature_supported) {
1050                 EXPECT_EQ(vc_mgr_get_recognition_mode(&mode), VC_ERROR_NOT_SUPPORTED);
1051                 return;
1052         }
1053
1054         EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_STOP_BY_SILENCE), VC_ERROR_NONE);
1055         EXPECT_EQ(vc_mgr_get_recognition_mode(&mode), VC_ERROR_NONE);
1056         EXPECT_EQ(mode, VC_RECOGNITION_MODE_STOP_BY_SILENCE);
1057 }
1058
1059 /**
1060  * @testcase            utc_vc_mgr_get_recognition_mode_n1
1061  * @since_tizen         5.0
1062  * @description         Negative UTC for get recognition mode
1063  */
1064 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_recognition_mode_n1)
1065 {
1066         if (false == __is_feature_supported) {
1067                 EXPECT_EQ(vc_mgr_get_recognition_mode(nullptr), VC_ERROR_NOT_SUPPORTED);
1068                 return;
1069         }
1070
1071         EXPECT_EQ(vc_mgr_get_recognition_mode(nullptr), VC_ERROR_INVALID_PARAMETER);
1072 }
1073
1074 /**
1075  * @testcase            utc_vc_mgr_get_recognition_mode_n2
1076  * @since_tizen         5.0
1077  * @description         Negative UTC for get recognition mode
1078  */
1079 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_recognition_mode_n2)
1080 {
1081         vc_recognition_mode_e mode = VC_RECOGNITION_MODE_MANUAL;
1082         if (false == __is_feature_supported) {
1083                 EXPECT_EQ(vc_mgr_get_recognition_mode(&mode), VC_ERROR_NOT_SUPPORTED);
1084                 return;
1085         }
1086
1087         EXPECT_EQ(vc_mgr_get_recognition_mode(&mode), VC_ERROR_INVALID_STATE);
1088 }
1089
1090 /**
1091  * @testcase            utc_vc_mgr_set_private_data_p
1092  * @since_tizen         5.0
1093  * @description         Positive UTC for set private data
1094  */
1095 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_private_data_p)
1096 {
1097         const char *key = "key";
1098         const char *data = "data";
1099         if (false == __is_feature_supported) {
1100                 EXPECT_EQ(vc_mgr_set_private_data(key, data), VC_ERROR_NOT_SUPPORTED);
1101                 EXPECT_EQ(vc_mgr_set_private_data(key, nullptr), VC_ERROR_NOT_SUPPORTED);
1102                 return;
1103         }
1104
1105         EXPECT_EQ(vc_mgr_set_private_data(key, data), VC_ERROR_NONE);
1106         EXPECT_EQ(vc_mgr_set_private_data(key, nullptr), VC_ERROR_NONE);
1107 }
1108
1109 /**
1110  * @testcase            utc_vc_mgr_set_private_data_n1
1111  * @since_tizen         5.0
1112  * @description         Negative UTC for set private data
1113  */
1114 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_private_data_n1)
1115 {
1116         const char *data = "data";
1117         if (false == __is_feature_supported) {
1118                 EXPECT_EQ(vc_mgr_set_private_data(nullptr, data), VC_ERROR_NOT_SUPPORTED);
1119                 return;
1120         }
1121
1122         EXPECT_EQ(vc_mgr_set_private_data(nullptr, data), VC_ERROR_INVALID_PARAMETER);
1123 }
1124
1125 /**
1126  * @testcase            utc_vc_mgr_set_private_data_n2
1127  * @since_tizen         5.0
1128  * @description         Negative UTC for set private data
1129  */
1130 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_n2)
1131 {
1132         const char *key = "key";
1133         const char *data = "data";
1134         if (false == __is_feature_supported) {
1135                 EXPECT_EQ(vc_mgr_set_private_data(key, data), VC_ERROR_NOT_SUPPORTED);
1136                 return;
1137         }
1138
1139         EXPECT_EQ(vc_mgr_set_private_data(key, data), VC_ERROR_INVALID_STATE);
1140 }
1141
1142 /**
1143  * @testcase            utc_vc_mgr_get_private_data_p
1144  * @since_tizen         5.0
1145  * @description         Positive UTC for get private data
1146  */
1147 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_private_data_p)
1148 {
1149         const char *key = "key";
1150         char *data = nullptr;
1151         if (false == __is_feature_supported) {
1152                 EXPECT_EQ(vc_mgr_get_private_data(key, &data), VC_ERROR_NOT_SUPPORTED);
1153                 free(data);
1154                 return;
1155         }
1156
1157         EXPECT_EQ(vc_mgr_get_private_data(key, &data), VC_ERROR_NONE);
1158         free(data);
1159 }
1160
1161 /**
1162  * @testcase            utc_vc_mgr_get_private_data_n1
1163  * @since_tizen         5.0
1164  * @description         Negative UTC for get private data
1165  */
1166 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_private_data_n1)
1167 {
1168         const char *key = "key";
1169         char *data = nullptr;
1170         if (false == __is_feature_supported) {
1171                 EXPECT_EQ(vc_mgr_get_private_data(nullptr, &data), VC_ERROR_NOT_SUPPORTED);
1172                 EXPECT_EQ(vc_mgr_get_private_data(key, nullptr), VC_ERROR_NOT_SUPPORTED);
1173                 return;
1174         }
1175
1176         EXPECT_EQ(vc_mgr_get_private_data(nullptr, &data), VC_ERROR_INVALID_PARAMETER);
1177         EXPECT_EQ(vc_mgr_get_private_data(key, nullptr), VC_ERROR_INVALID_PARAMETER);
1178 }
1179
1180 /**
1181  * @testcase            utc_vc_mgr_get_private_data_n2
1182  * @since_tizen         5.0
1183  * @description         Negative UTC for get private data
1184  */
1185 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_private_data_n2)
1186 {
1187         const char *key = "key";
1188         char *data = nullptr;
1189         if (false == __is_feature_supported) {
1190                 EXPECT_EQ(vc_mgr_get_private_data(key, &data), VC_ERROR_NOT_SUPPORTED);
1191                 return;
1192         }
1193
1194         EXPECT_EQ(vc_mgr_get_private_data(key, &data), VC_ERROR_INVALID_STATE);
1195 }
1196
1197 /**
1198  * @testcase            utc_vc_mgr_do_action_p
1199  * @since_tizen         5.0
1200  * @description         Positive UTC for requesting the do action
1201  */
1202 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_do_action_p)
1203 {
1204         char *event = strdup("send_event");
1205         if (false == __is_feature_supported) {
1206                 EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, event), VC_ERROR_NOT_SUPPORTED);
1207                 free(event);
1208                 return;
1209         }
1210
1211         EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, event), VC_ERROR_NONE);
1212         free(event);
1213 }
1214
1215 /**
1216  * @testcase            utc_vc_mgr_do_action_n1
1217  * @since_tizen         5.0
1218  * @description         Negative UTC for requesting the do action
1219  */
1220 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_do_action_n1)
1221 {
1222         char *event = strdup("send_event");
1223         if (false == __is_feature_supported) {
1224                 EXPECT_EQ(vc_mgr_do_action(static_cast<vc_send_event_type_e>(-1), event), VC_ERROR_NOT_SUPPORTED);
1225                 EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, nullptr), VC_ERROR_NOT_SUPPORTED);
1226                 free(event);
1227                 return;
1228         }
1229
1230         EXPECT_EQ(vc_mgr_do_action(static_cast<vc_send_event_type_e>(-1), event), VC_ERROR_INVALID_PARAMETER);
1231         EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, nullptr), VC_ERROR_INVALID_PARAMETER);
1232         free(event);
1233 }
1234
1235 /**
1236  * @testcase            utc_vc_mgr_do_action_n2
1237  * @since_tizen         5.0
1238  * @description         Negative UTC for requesting the do action
1239  */
1240 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_do_action_n2)
1241 {
1242         char *event = strdup("send_event");
1243         if (false == __is_feature_supported) {
1244                 EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, event), VC_ERROR_NOT_SUPPORTED);
1245                 free(event);
1246                 return;
1247         }
1248
1249         EXPECT_EQ(vc_mgr_do_action(VC_SEND_EVENT_TYPE_TEXT, event), VC_ERROR_INVALID_STATE);
1250         free(event);
1251 }
1252
1253 /**
1254  * @testcase            utc_vc_mgr_send_specific_engine_request_p
1255  * @since_tizen         5.0
1256  * @description         Positive UTC for send specific engine request
1257  */
1258 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_specific_engine_request_p)
1259 {
1260         const char* engineAppId = DEFAULT_ENGINE_APP_ID;
1261         const char* event = "event";
1262         const char* request = "request";
1263         if (false == __is_feature_supported) {
1264                 EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_NOT_SUPPORTED);
1265                 return;
1266         }
1267
1268         EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_NONE);
1269 }
1270
1271 /**
1272  * @testcase            utc_vc_mgr_send_specific_engine_request_n1
1273  * @since_tizen         5.0
1274  * @description         Negative UTC for send specific engine request
1275  */
1276 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_specific_engine_request_n1)
1277 {
1278         const char* engineAppId = DEFAULT_ENGINE_APP_ID;
1279         const char* event = "event";
1280         const char* request = "request";
1281         if (false == __is_feature_supported) {
1282                 EXPECT_EQ(vc_mgr_send_specific_engine_request(nullptr, event, request), VC_ERROR_NOT_SUPPORTED);
1283                 EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, nullptr, request), VC_ERROR_NOT_SUPPORTED);
1284                 return;
1285         }
1286
1287         EXPECT_EQ(vc_mgr_send_specific_engine_request(nullptr, event, request), VC_ERROR_INVALID_PARAMETER);
1288         EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, nullptr, request), VC_ERROR_INVALID_PARAMETER);
1289 }
1290
1291 /**
1292  * @testcase            utc_vc_mgr_send_specific_engine_request_n2
1293  * @since_tizen         5.0
1294  * @description         Negative UTC for send specific engine request
1295  */
1296 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_send_specific_engine_request_n2)
1297 {
1298         const char* engineAppId = DEFAULT_ENGINE_APP_ID;
1299         const char* event = "event";
1300         const char* request = "request";
1301         if (false == __is_feature_supported) {
1302                 EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_NOT_SUPPORTED);
1303                 return;
1304         }
1305
1306         EXPECT_EQ(vc_mgr_send_specific_engine_request(engineAppId, event, request), VC_ERROR_INVALID_STATE);
1307 }
1308
1309 /**
1310  * @testcase            utc_vc_mgr_start_p
1311  * @since_tizen         5.0
1312  * @description         Positive UTC for start about voice control manager
1313  */
1314 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_start_p)
1315 {
1316         if (false == __is_feature_supported) {
1317                 EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NOT_SUPPORTED);
1318                 return;
1319         }
1320
1321         vc_cmd_list_h commands = __create_test_command_list();
1322         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
1323         EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
1324         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
1325
1326         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
1327         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
1328
1329         vc_cmd_list_destroy(commands, true);
1330 }
1331
1332 /**
1333  * @testcase            utc_vc_mgr_start_n1
1334  * @since_tizen         5.0
1335  * @description         Negative UTC for start about voice control manager
1336  */
1337 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_start_n1)
1338 {
1339         if (false == __is_feature_supported) {
1340                 EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NOT_SUPPORTED);
1341                 return;
1342         }
1343
1344         vc_cmd_list_h commands = __create_test_command_list();
1345         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
1346         EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
1347         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
1348
1349         EXPECT_EQ(vc_mgr_start(false), VC_ERROR_INVALID_STATE);
1350
1351         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
1352         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
1353
1354         vc_cmd_list_destroy(commands, true);
1355 }
1356
1357 /**
1358  * @testcase            utc_vc_mgr_start_n2
1359  * @since_tizen         5.0
1360  * @description         Negative UTC for start about voice control manager
1361  */
1362 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_start_n2)
1363 {
1364         if (false == __is_feature_supported) {
1365                 EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NOT_SUPPORTED);
1366                 return;
1367         }
1368
1369         EXPECT_EQ(vc_mgr_start(false), VC_ERROR_INVALID_STATE);
1370 }
1371
1372 /**
1373  * @testcase            utc_vc_mgr_stop_p
1374  * @since_tizen         5.0
1375  * @description         Positive UTC for stop about voice control manager
1376  */
1377 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_stop_p)
1378 {
1379         if (false == __is_feature_supported) {
1380                 EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NOT_SUPPORTED);
1381                 return;
1382         }
1383
1384         vc_cmd_list_h commands = __create_test_command_list();
1385         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
1386
1387         EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
1388         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
1389
1390         EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NONE);
1391         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_PROCESSING, 5), true);
1392
1393         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
1394         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
1395
1396         vc_cmd_list_destroy(commands, true);
1397 }
1398
1399 /**
1400  * @testcase            utc_vc_mgr_stop_n1
1401  * @since_tizen         5.0
1402  * @description         Negative UTC for stop about voice control manager
1403  */
1404 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_stop_n1)
1405 {
1406         if (false == __is_feature_supported) {
1407                 EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NOT_SUPPORTED);
1408                 return;
1409         }
1410
1411         vc_cmd_list_h commands = __create_test_command_list();
1412         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
1413
1414         EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
1415         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
1416
1417         EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NONE);
1418         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_PROCESSING, 5), true);
1419
1420         EXPECT_EQ(vc_mgr_stop(), VC_ERROR_INVALID_STATE);
1421         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
1422         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
1423
1424         vc_cmd_list_destroy(commands, true);
1425 }
1426
1427 /**
1428  * @testcase            utc_vc_mgr_stop_n2
1429  * @since_tizen         5.0
1430  * @description         Negative UTC for stop about voice control manager
1431  */
1432 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_stop_n2)
1433 {
1434         if (false == __is_feature_supported) {
1435                 EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NOT_SUPPORTED);
1436                 return;
1437         }
1438
1439         EXPECT_EQ(vc_mgr_stop(), VC_ERROR_INVALID_STATE);
1440 }
1441
1442 /**
1443  * @testcase            utc_vc_mgr_cancel_p
1444  * @since_tizen         5.0
1445  * @description         Positive UTC for cancel about voice control manager
1446  */
1447 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_cancel_p)
1448 {
1449         if (false == __is_feature_supported) {
1450                 EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NOT_SUPPORTED);
1451                 return;
1452         }
1453
1454         vc_cmd_list_h commands = __create_test_command_list();
1455         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
1456
1457         ASSERT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
1458         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
1459
1460         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
1461         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
1462
1463         vc_cmd_list_destroy(commands, true);
1464 }
1465
1466 /**
1467  * @testcase            utc_vc_mgr_cancel_n1
1468  * @since_tizen         5.0
1469  * @description         Negative UTC for cancel about voice control manager
1470  */
1471 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_cancel_n1)
1472 {
1473         if (false == __is_feature_supported) {
1474                 EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NOT_SUPPORTED);
1475                 return;
1476         }
1477
1478         vc_cmd_list_h commands = __create_test_command_list();
1479         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
1480
1481         ASSERT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
1482         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
1483
1484         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
1485         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_IN_PROGRESS_TO_READY);
1486         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
1487
1488         vc_cmd_list_destroy(commands, true);
1489 }
1490
1491 /**
1492  * @testcase            utc_vc_mgr_cancel_n2
1493  * @since_tizen         5.0
1494  * @description         Negative UTC for cancel about voice control manager
1495  */
1496 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_cancel_n2)
1497 {
1498         if (false == __is_feature_supported) {
1499                 EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NOT_SUPPORTED);
1500                 return;
1501         }
1502
1503         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_INVALID_STATE);
1504 }
1505
1506 /**
1507  * @testcase            utc_vc_mgr_get_recording_volume_p
1508  * @since_tizen         5.0
1509  * @description         Positive UTC for get recording volume
1510  */
1511 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_recording_volume_p)
1512 {
1513         float volume = 0.0;
1514         if (false == __is_feature_supported) {
1515                 EXPECT_EQ(vc_mgr_get_recording_volume(&volume), VC_ERROR_NOT_SUPPORTED);
1516                 return;
1517         }
1518
1519         vc_cmd_list_h commands = __create_test_command_list();
1520         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
1521
1522         ASSERT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
1523         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
1524
1525         EXPECT_EQ(vc_mgr_get_recording_volume(&volume), VC_ERROR_NONE);
1526
1527         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
1528         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
1529
1530         vc_cmd_list_destroy(commands, true);
1531 }
1532
1533 /**
1534  * @testcase            utc_vc_mgr_get_recording_volume_n1
1535  * @since_tizen         5.0
1536  * @description         Negative UTC for get recording volume
1537  */
1538 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_recording_volume_n1)
1539 {
1540         if (false == __is_feature_supported) {
1541                 EXPECT_EQ(vc_mgr_get_recording_volume(nullptr), VC_ERROR_NOT_SUPPORTED);
1542                 return;
1543         }
1544
1545         EXPECT_EQ(vc_mgr_get_recording_volume(nullptr), VC_ERROR_INVALID_PARAMETER);
1546 }
1547
1548 /**
1549  * @testcase            utc_vc_mgr_get_recording_volume_n2
1550  * @since_tizen         5.0
1551  * @description         Negative UTC for get recording volume
1552  */
1553 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_get_recording_volume_n2)
1554 {
1555         float volume = 0;
1556         if (false == __is_feature_supported) {
1557                 EXPECT_EQ(vc_mgr_get_recording_volume(&volume), VC_ERROR_NOT_SUPPORTED);
1558                 return;
1559         }
1560
1561         EXPECT_EQ(vc_mgr_get_recording_volume(&volume), VC_ERROR_INVALID_STATE);
1562 }
1563
1564 /**
1565  * @testcase            utc_vc_mgr_set_all_result_cb_p
1566  * @since_tizen         5.0
1567  * @description         Positive UTC for set all result callback
1568  */
1569 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_all_result_cb_p)
1570 {
1571         if (false == __is_feature_supported) {
1572                 EXPECT_EQ(vc_mgr_set_all_result_cb(__vc_mgr_all_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1573                 return;
1574         }
1575
1576         EXPECT_EQ(vc_mgr_set_all_result_cb(__vc_mgr_all_result_cb, nullptr), VC_ERROR_NONE);
1577 }
1578
1579 /**
1580  * @testcase            utc_vc_mgr_set_all_result_cb_n1
1581  * @since_tizen         5.0
1582  * @description         Negative UTC for set all result callback
1583  */
1584 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_all_result_cb_n1)
1585 {
1586         if (false == __is_feature_supported) {
1587                 EXPECT_EQ(vc_mgr_set_all_result_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
1588                 return;
1589         }
1590
1591         EXPECT_EQ(vc_mgr_set_all_result_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
1592 }
1593
1594 /**
1595  * @testcase            utc_vc_mgr_set_all_result_cb_n2
1596  * @since_tizen         5.0
1597  * @description         Negative UTC for set all result callback
1598  */
1599 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_all_result_cb_n2)
1600 {
1601         if (false == __is_feature_supported) {
1602                 EXPECT_EQ(vc_mgr_set_all_result_cb(__vc_mgr_all_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1603                 return;
1604         }
1605
1606         EXPECT_EQ(vc_mgr_set_all_result_cb(__vc_mgr_all_result_cb, nullptr), VC_ERROR_INVALID_STATE);
1607 }
1608
1609 /**
1610  * @testcase            utc_vc_mgr_unset_all_result_cb_p
1611  * @since_tizen         5.0
1612  * @description         Positive UTC for unset all result callback
1613  */
1614 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_all_result_cb_p)
1615 {
1616         if (false == __is_feature_supported) {
1617                 EXPECT_EQ(vc_mgr_unset_all_result_cb(), VC_ERROR_NOT_SUPPORTED);
1618                 return;
1619         }
1620
1621         EXPECT_EQ(vc_mgr_unset_all_result_cb(), VC_ERROR_NONE);
1622 }
1623
1624 /**
1625  * @testcase            utc_vc_mgr_unset_all_result_cb_n
1626  * @since_tizen         5.0
1627  * @description         Negative UTC for unset all result callback
1628  */
1629 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_all_result_cb_n)
1630 {
1631         if (false == __is_feature_supported) {
1632                 EXPECT_EQ(vc_mgr_unset_all_result_cb(), VC_ERROR_NOT_SUPPORTED);
1633                 return;
1634         }
1635
1636         EXPECT_EQ(vc_mgr_unset_all_result_cb(), VC_ERROR_INVALID_STATE);
1637 }
1638
1639 /**
1640  * @testcase            utc_vc_mgr_set_pre_result_cb_p
1641  * @since_tizen         5.0
1642  * @description         Positive UTC for set pre result callback
1643  */
1644 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_pre_result_cb_p)
1645 {
1646         if (false == __is_feature_supported) {
1647                 EXPECT_EQ(vc_mgr_set_pre_result_cb(__vc_mgr_pre_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1648                 return;
1649         }
1650
1651         EXPECT_EQ(vc_mgr_set_pre_result_cb(__vc_mgr_pre_result_cb, nullptr), VC_ERROR_NONE);
1652 }
1653
1654 /**
1655  * @testcase            utc_vc_mgr_set_pre_result_cb_n1
1656  * @since_tizen         5.0
1657  * @description         Negative UTC for set pre result callback
1658  */
1659 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_pre_result_cb_n1)
1660 {
1661         if (false == __is_feature_supported) {
1662                 EXPECT_EQ(vc_mgr_set_pre_result_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
1663                 return;
1664         }
1665
1666         EXPECT_EQ(vc_mgr_set_pre_result_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
1667 }
1668
1669 /**
1670  * @testcase            utc_vc_mgr_set_pre_result_cb_n2
1671  * @since_tizen         5.0
1672  * @description         Negative UTC for set pre result callback
1673  */
1674 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_pre_result_cb_n2)
1675 {
1676         if (false == __is_feature_supported) {
1677                 EXPECT_EQ(vc_mgr_set_pre_result_cb(__vc_mgr_pre_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1678                 return;
1679         }
1680
1681         EXPECT_EQ(vc_mgr_set_pre_result_cb(__vc_mgr_pre_result_cb, nullptr), VC_ERROR_INVALID_STATE);
1682 }
1683
1684 /**
1685  * @testcase            utc_vc_mgr_unset_pre_result_cb_p
1686  * @since_tizen         5.0
1687  * @description         Positive UTC for unset pre result callback
1688  */
1689 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_pre_result_cb_p)
1690 {
1691         if (false == __is_feature_supported) {
1692                 EXPECT_EQ(vc_mgr_unset_pre_result_cb(), VC_ERROR_NOT_SUPPORTED);
1693                 return;
1694         }
1695
1696         EXPECT_EQ(vc_mgr_unset_pre_result_cb(), VC_ERROR_NONE);
1697 }
1698
1699 /**
1700  * @testcase            utc_vc_mgr_unset_pre_result_cb_n
1701  * @since_tizen         5.0
1702  * @description         Negative UTC for unset pre result callback
1703  */
1704 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_pre_result_cb_n)
1705 {
1706         if (false == __is_feature_supported) {
1707                 EXPECT_EQ(vc_mgr_unset_pre_result_cb(), VC_ERROR_NOT_SUPPORTED);
1708                 return;
1709         }
1710
1711         EXPECT_EQ(vc_mgr_unset_pre_result_cb(), VC_ERROR_INVALID_STATE);
1712 }
1713
1714 /**
1715  * @testcase            utc_vc_mgr_set_specific_engine_result_cb_p
1716  * @since_tizen         5.0
1717  * @description         Positive UTC for set specific engine result callback
1718  */
1719 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_specific_engine_result_cb_p)
1720 {
1721         if (false == __is_feature_supported) {
1722                 EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(__vc_mgr_specific_engine_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1723                 return;
1724         }
1725
1726         EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(__vc_mgr_specific_engine_result_cb, nullptr), VC_ERROR_NONE);
1727 }
1728
1729 /**
1730  * @testcase            utc_vc_mgr_set_specific_engine_result_cb_n1
1731  * @since_tizen         5.0
1732  * @description         Negative UTC for set specific engine result callback
1733  */
1734 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_specific_engine_result_cb_n1)
1735 {
1736         if (false == __is_feature_supported) {
1737                 EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
1738                 return;
1739         }
1740
1741         EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
1742 }
1743
1744 /**
1745  * @testcase            utc_vc_mgr_set_specific_engine_result_cb_n2
1746  * @since_tizen         5.0
1747  * @description         Negative UTC for set specific engine result callback
1748  */
1749 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_specific_engine_result_cb_n2)
1750 {
1751         if (false == __is_feature_supported) {
1752                 EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(__vc_mgr_specific_engine_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1753                 return;
1754         }
1755
1756         EXPECT_EQ(vc_mgr_set_specific_engine_result_cb(__vc_mgr_specific_engine_result_cb, nullptr), VC_ERROR_INVALID_STATE);
1757 }
1758
1759 /**
1760  * @testcase            utc_vc_mgr_unset_specific_engine_result_cb_p
1761  * @since_tizen         5.0
1762  * @description         Positive UTC for unset specific engine result callback
1763  */
1764 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_specific_engine_result_cb_p)
1765 {
1766         if (false == __is_feature_supported) {
1767                 EXPECT_EQ(vc_mgr_unset_specific_engine_result_cb(), VC_ERROR_NOT_SUPPORTED);
1768                 return;
1769         }
1770
1771         EXPECT_EQ(vc_mgr_unset_specific_engine_result_cb(), VC_ERROR_NONE);
1772 }
1773
1774 /**
1775  * @testcase            utc_vc_mgr_unset_specific_engine_result_cb_n
1776  * @since_tizen         5.0
1777  * @description         Negative UTC for unset specific engine result callback
1778  */
1779 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_specific_engine_result_cb_n)
1780 {
1781         if (false == __is_feature_supported) {
1782                 EXPECT_EQ(vc_mgr_unset_specific_engine_result_cb(), VC_ERROR_NOT_SUPPORTED);
1783                 return;
1784         }
1785
1786         EXPECT_EQ(vc_mgr_unset_specific_engine_result_cb(), VC_ERROR_INVALID_STATE);
1787 }
1788
1789 /**
1790  * @testcase            utc_vc_mgr_set_result_cb_p
1791  * @since_tizen         5.0
1792  * @description         Positive UTC for set result callback
1793  */
1794 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_result_cb_p)
1795 {
1796         if (false == __is_feature_supported) {
1797                 EXPECT_EQ(vc_mgr_set_result_cb(__vc_mgr_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1798                 return;
1799         }
1800
1801         EXPECT_EQ(vc_mgr_set_result_cb(__vc_mgr_result_cb, nullptr), VC_ERROR_NONE);
1802 }
1803
1804 /**
1805  * @testcase            utc_vc_mgr_set_result_cb_n1
1806  * @since_tizen         5.0
1807  * @description         Negative UTC for set result callback
1808  */
1809 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_result_cb_n1)
1810 {
1811         if (false == __is_feature_supported) {
1812                 EXPECT_EQ(vc_mgr_set_result_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
1813                 return;
1814         }
1815
1816         EXPECT_EQ(vc_mgr_set_result_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
1817 }
1818
1819 /**
1820  * @testcase            utc_vc_mgr_set_result_cb_n2
1821  * @since_tizen         5.0
1822  * @description         Negative UTC for set result callback
1823  */
1824 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_result_cb_n2)
1825 {
1826         if (false == __is_feature_supported) {
1827                 EXPECT_EQ(vc_mgr_set_result_cb(__vc_mgr_result_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1828                 return;
1829         }
1830
1831         EXPECT_EQ(vc_mgr_set_result_cb(__vc_mgr_result_cb, nullptr), VC_ERROR_INVALID_STATE);
1832 }
1833
1834 /**
1835  * @testcase            utc_vc_mgr_unset_result_cb_p
1836  * @since_tizen         5.0
1837  * @description         Positive UTC for unset result callback
1838  */
1839 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_result_cb_p)
1840 {
1841         if (false == __is_feature_supported) {
1842                 EXPECT_EQ(vc_mgr_unset_result_cb(), VC_ERROR_NOT_SUPPORTED);
1843                 return;
1844         }
1845
1846         EXPECT_EQ(vc_mgr_unset_result_cb(), VC_ERROR_NONE);
1847 }
1848
1849 /**
1850  * @testcase            utc_vc_mgr_unset_result_cb_n
1851  * @since_tizen         5.0
1852  * @description         Negative UTC for unset result callback
1853  */
1854 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_result_cb_n)
1855 {
1856         if (false == __is_feature_supported) {
1857                 EXPECT_EQ(vc_mgr_unset_result_cb(), VC_ERROR_NOT_SUPPORTED);
1858                 return;
1859         }
1860
1861         EXPECT_EQ(vc_mgr_unset_result_cb(), VC_ERROR_INVALID_STATE);
1862 }
1863
1864 /**
1865  * @testcase            utc_vc_mgr_set_state_changed_cb_p
1866  * @since_tizen         5.0
1867  * @description         Positive UTC for set state changed callback
1868  */
1869 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_state_changed_cb_p)
1870 {
1871         if (false == __is_feature_supported) {
1872                 EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1873                 return;
1874         }
1875
1876         EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_NONE);
1877 }
1878
1879 /**
1880  * @testcase            utc_vc_mgr_set_state_changed_cb_n1
1881  * @since_tizen         5.0
1882  * @description         Negative UTC for set state changed callback
1883  */
1884 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_state_changed_cb_n1)
1885 {
1886         if (false == __is_feature_supported) {
1887                 EXPECT_EQ(vc_mgr_set_state_changed_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
1888                 return;
1889         }
1890
1891         EXPECT_EQ(vc_mgr_set_state_changed_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
1892 }
1893
1894 /**
1895  * @testcase            utc_vc_mgr_set_state_changed_cb_n2
1896  * @since_tizen         5.0
1897  * @description         Negative UTC for set state changed callback
1898  */
1899 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_state_changed_cb_n2)
1900 {
1901         if (false == __is_feature_supported) {
1902                 EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1903                 return;
1904         }
1905
1906         EXPECT_EQ(vc_mgr_set_state_changed_cb(__vc_mgr_state_changed_cb, nullptr), VC_ERROR_INVALID_STATE);
1907 }
1908
1909 /**
1910  * @testcase            utc_vc_mgr_unset_state_changed_cb_p
1911  * @since_tizen         5.0
1912  * @description         Positive UTC for unset state changed callback
1913  */
1914 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_state_changed_cb_p)
1915 {
1916         if (false == __is_feature_supported) {
1917                 EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_NOT_SUPPORTED);
1918                 return;
1919         }
1920
1921         EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_NONE);
1922 }
1923
1924 /**
1925  * @testcase            utc_vc_mgr_unset_state_changed_cb_n
1926  * @since_tizen         5.0
1927  * @description         Negative UTC for unset state changed callback
1928  */
1929 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_state_changed_cb_n)
1930 {
1931         if (false == __is_feature_supported) {
1932                 EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_NOT_SUPPORTED);
1933                 return;
1934         }
1935
1936         EXPECT_EQ(vc_mgr_unset_state_changed_cb(), VC_ERROR_INVALID_STATE);
1937 }
1938
1939 /**
1940  * @testcase            utc_vc_mgr_set_service_state_changed_cb_p
1941  * @since_tizen         5.0
1942  * @description         Positive UTC for set service state changed callback
1943  */
1944 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_service_state_changed_cb_p)
1945 {
1946         if (false == __is_feature_supported) {
1947                 EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1948                 return;
1949         }
1950
1951         EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_NONE);
1952 }
1953
1954 /**
1955  * @testcase            utc_vc_mgr_set_service_state_changed_cb_n1
1956  * @since_tizen         5.0
1957  * @description         Negative UTC for set service state changed callback
1958  */
1959 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_service_state_changed_cb_n1)
1960 {
1961         if (false == __is_feature_supported) {
1962                 EXPECT_EQ(vc_mgr_set_service_state_changed_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
1963                 return;
1964         }
1965
1966         EXPECT_EQ(vc_mgr_set_service_state_changed_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
1967 }
1968
1969 /**
1970  * @testcase            utc_vc_mgr_set_service_state_changed_cb_n2
1971  * @since_tizen         5.0
1972  * @description         Negative UTC for set service state changed callback
1973  */
1974 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_service_state_changed_cb_n2)
1975 {
1976         if (false == __is_feature_supported) {
1977                 EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
1978                 return;
1979         }
1980
1981         EXPECT_EQ(vc_mgr_set_service_state_changed_cb(__vc_mgr_service_state_changed_cb, nullptr), VC_ERROR_INVALID_STATE);
1982 }
1983
1984 /**
1985  * @testcase            utc_vc_mgr_unset_service_state_changed_cb_p
1986  * @since_tizen         5.0
1987  * @description         Positive UTC for unset service state changed callback
1988  */
1989 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_service_state_changed_cb_p)
1990 {
1991         if (false == __is_feature_supported) {
1992                 EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_NOT_SUPPORTED);
1993                 return;
1994         }
1995
1996         EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_NONE);
1997 }
1998
1999 /**
2000  * @testcase            utc_vc_mgr_unset_service_state_changed_cb_n
2001  * @since_tizen         5.0
2002  * @description         Negative UTC for unset service state changed callback
2003  */
2004 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_service_state_changed_cb_n)
2005 {
2006         if (false == __is_feature_supported) {
2007                 EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_NOT_SUPPORTED);
2008                 return;
2009         }
2010
2011         EXPECT_EQ(vc_mgr_unset_service_state_changed_cb(), VC_ERROR_INVALID_STATE);
2012 }
2013
2014 /**
2015  * @testcase            utc_vc_mgr_set_speech_detected_cb_p
2016  * @since_tizen         5.0
2017  * @description         Positive UTC for set speech detected callback
2018  */
2019 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_speech_detected_cb_p)
2020 {
2021         if (false == __is_feature_supported) {
2022                 EXPECT_EQ(vc_mgr_set_speech_detected_cb(__vc_mgr_begin_speech_detected_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2023                 return;
2024         }
2025
2026         EXPECT_EQ(vc_mgr_set_speech_detected_cb(__vc_mgr_begin_speech_detected_cb, nullptr), VC_ERROR_NONE);
2027 }
2028
2029 /**
2030  * @testcase            utc_vc_mgr_set_speech_detected_cb_n1
2031  * @since_tizen         5.0
2032  * @description         Negative UTC for set speech detected callback
2033  */
2034 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_speech_detected_cb_n1)
2035 {
2036         if (false == __is_feature_supported) {
2037                 EXPECT_EQ(vc_mgr_set_speech_detected_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
2038                 return;
2039         }
2040
2041         EXPECT_EQ(vc_mgr_set_speech_detected_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
2042 }
2043
2044 /**
2045  * @testcase            utc_vc_mgr_set_speech_detected_cb_n2
2046  * @since_tizen         5.0
2047  * @description         Negative UTC for set speech detected callback
2048  */
2049 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_speech_detected_cb_n2)
2050 {
2051         if (false == __is_feature_supported) {
2052                 EXPECT_EQ(vc_mgr_set_speech_detected_cb(__vc_mgr_begin_speech_detected_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2053                 return;
2054         }
2055
2056         EXPECT_EQ(vc_mgr_set_speech_detected_cb(__vc_mgr_begin_speech_detected_cb, nullptr), VC_ERROR_INVALID_STATE);
2057 }
2058
2059 /**
2060  * @testcase            utc_vc_mgr_unset_speech_detected_cb_p
2061  * @since_tizen         5.0
2062  * @description         Positive UTC for unset speech detected callback
2063  */
2064 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_speech_detected_cb_p)
2065 {
2066         if (false == __is_feature_supported) {
2067                 EXPECT_EQ(vc_mgr_unset_speech_detected_cb(), VC_ERROR_NOT_SUPPORTED);
2068                 return;
2069         }
2070
2071         EXPECT_EQ(vc_mgr_unset_speech_detected_cb(), VC_ERROR_NONE);
2072 }
2073
2074 /**
2075  * @testcase            utc_vc_mgr_unset_speech_detected_cb_n
2076  * @since_tizen         5.0
2077  * @description         Negative UTC for unset speech detected callback
2078  */
2079 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_speech_detected_cb_n)
2080 {
2081         if (false == __is_feature_supported) {
2082                 EXPECT_EQ(vc_mgr_unset_speech_detected_cb(), VC_ERROR_NOT_SUPPORTED);
2083                 return;
2084         }
2085
2086         EXPECT_EQ(vc_mgr_unset_speech_detected_cb(), VC_ERROR_INVALID_STATE);
2087 }
2088
2089 /**
2090  * @testcase            utc_vc_mgr_set_current_language_changed_cb_p
2091  * @since_tizen         5.0
2092  * @description         Positive UTC for set current language changed callback
2093  */
2094 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_current_language_changed_cb_p)
2095 {
2096         if (false == __is_feature_supported) {
2097                 EXPECT_EQ(vc_mgr_set_current_language_changed_cb(__vc_current_language_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2098                 return;
2099         }
2100
2101         EXPECT_EQ(vc_mgr_set_current_language_changed_cb(__vc_current_language_changed_cb, nullptr), VC_ERROR_NONE);
2102 }
2103
2104 /**
2105  * @testcase            utc_vc_mgr_set_current_language_changed_cb_n1
2106  * @since_tizen         5.0
2107  * @description         Negative UTC for set current language changed callback
2108  */
2109 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_current_language_changed_cb_n1)
2110 {
2111         if (false == __is_feature_supported) {
2112                 EXPECT_EQ(vc_mgr_set_current_language_changed_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
2113                 return;
2114         }
2115
2116         EXPECT_EQ(vc_mgr_set_current_language_changed_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
2117 }
2118
2119 /**
2120  * @testcase            utc_vc_mgr_set_current_language_changed_cb_n2
2121  * @since_tizen         5.0
2122  * @description         Negative UTC for set current language changed callback
2123  */
2124 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_current_language_changed_cb_n2)
2125 {
2126         if (false == __is_feature_supported) {
2127                 EXPECT_EQ(vc_mgr_set_current_language_changed_cb(__vc_current_language_changed_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2128                 return;
2129         }
2130
2131         EXPECT_EQ(vc_mgr_set_current_language_changed_cb(__vc_current_language_changed_cb, nullptr), VC_ERROR_INVALID_STATE);
2132 }
2133
2134 /**
2135  * @testcase            utc_vc_mgr_unset_current_language_changed_cb_p
2136  * @since_tizen         5.0
2137  * @description         Positive UTC for unset current language changed callback
2138  */
2139 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_current_language_changed_cb_p)
2140 {
2141         if (false == __is_feature_supported) {
2142                 EXPECT_EQ(vc_mgr_unset_current_language_changed_cb(), VC_ERROR_NOT_SUPPORTED);
2143                 return;
2144         }
2145
2146         EXPECT_EQ(vc_mgr_unset_current_language_changed_cb(), VC_ERROR_NONE);
2147 }
2148
2149 /**
2150  * @testcase            utc_vc_mgr_unset_current_language_changed_cb_n
2151  * @since_tizen         5.0
2152  * @description         Negative UTC for unset current language changed callback
2153  */
2154 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_current_language_changed_cb_n)
2155 {
2156         if (false == __is_feature_supported) {
2157                 EXPECT_EQ(vc_mgr_unset_current_language_changed_cb(), VC_ERROR_NOT_SUPPORTED);
2158                 return;
2159         }
2160
2161         EXPECT_EQ(vc_mgr_unset_current_language_changed_cb(), VC_ERROR_INVALID_STATE);
2162 }
2163
2164 /**
2165  * @testcase            utc_vc_mgr_get_error_message_n1
2166  * @since_tizen         5.0
2167  * @description         Negative UTC for get error message
2168  */
2169 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_error_message_n1)
2170 {
2171         if (false == __is_feature_supported) {
2172                 EXPECT_EQ(vc_mgr_get_error_message(nullptr), VC_ERROR_NOT_SUPPORTED);
2173                 return;
2174         }
2175
2176         EXPECT_EQ(vc_mgr_get_error_message(nullptr), VC_ERROR_INVALID_PARAMETER);
2177 }
2178
2179 /**
2180  * @testcase            utc_vc_mgr_get_error_message_n2
2181  * @since_tizen         5.0
2182  * @description         Negative UTC for get error message
2183  */
2184 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_get_error_message_n2)
2185 {
2186         char *err_msg = nullptr;
2187         if (false == __is_feature_supported) {
2188                 EXPECT_EQ(vc_mgr_get_error_message(&err_msg), VC_ERROR_NOT_SUPPORTED);
2189                 return;
2190         }
2191
2192         EXPECT_EQ(vc_mgr_get_error_message(&err_msg), VC_ERROR_INVALID_STATE);
2193 }
2194
2195 /**
2196  * @testcase            utc_vc_mgr_get_error_message_n3
2197  * @since_tizen         5.0
2198  * @description         Negative UTC for get error message
2199  */
2200 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_get_error_message_n3)
2201 {
2202         char *err_msg = nullptr;
2203         if (false == __is_feature_supported) {
2204                 EXPECT_EQ(vc_mgr_get_error_message(&err_msg), VC_ERROR_NOT_SUPPORTED);
2205                 return;
2206         }
2207
2208         EXPECT_EQ(vc_mgr_get_error_message(&err_msg), VC_ERROR_OPERATION_FAILED);
2209 }
2210
2211 /**
2212  * @testcase            utc_vc_mgr_set_error_cb_p
2213  * @since_tizen         5.0
2214  * @description         Positive UTC for set error callback
2215  */
2216 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_error_cb_p)
2217 {
2218         if (false == __is_feature_supported) {
2219                 EXPECT_EQ(vc_mgr_set_error_cb(__vc_mgr_error_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2220                 return;
2221         }
2222
2223         EXPECT_EQ(vc_mgr_set_error_cb(__vc_mgr_error_cb, nullptr), VC_ERROR_NONE);
2224 }
2225
2226 /**
2227  * @testcase            utc_vc_mgr_set_error_cb_n1
2228  * @since_tizen         5.0
2229  * @description         Negative UTC for set error callback
2230  */
2231 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_error_cb_n1)
2232 {
2233         if (false == __is_feature_supported) {
2234                 EXPECT_EQ(vc_mgr_set_error_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
2235                 return;
2236         }
2237
2238         EXPECT_EQ(vc_mgr_set_error_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
2239 }
2240
2241 /**
2242  * @testcase            utc_vc_mgr_set_error_cb_n2
2243  * @since_tizen         5.0
2244  * @description         Negative UTC for set error callback
2245  */
2246 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_error_cb_n2)
2247 {
2248         if (false == __is_feature_supported) {
2249                 EXPECT_EQ(vc_mgr_set_error_cb(__vc_mgr_error_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2250                 return;
2251         }
2252
2253         EXPECT_EQ(vc_mgr_set_error_cb(__vc_mgr_error_cb, nullptr), VC_ERROR_INVALID_STATE);
2254 }
2255
2256 /**
2257  * @testcase            utc_vc_mgr_unset_error_cb_p
2258  * @since_tizen         5.0
2259  * @description         Positive UTC for unset error callback
2260  */
2261 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_error_cb_p)
2262 {
2263         if (false == __is_feature_supported) {
2264                 EXPECT_EQ(vc_mgr_unset_error_cb(), VC_ERROR_NOT_SUPPORTED);
2265                 return;
2266         }
2267
2268         EXPECT_EQ(vc_mgr_unset_error_cb(), VC_ERROR_NONE);
2269 }
2270
2271 /**
2272  * @testcase            utc_vc_mgr_unset_error_cb_n
2273  * @since_tizen         5.0
2274  * @description         Negative UTC for unset error callback
2275  */
2276 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_error_cb_n)
2277 {
2278         if (false == __is_feature_supported) {
2279                 EXPECT_EQ(vc_mgr_unset_error_cb(), VC_ERROR_NOT_SUPPORTED);
2280                 return;
2281         }
2282
2283         EXPECT_EQ(vc_mgr_unset_error_cb(), VC_ERROR_INVALID_STATE);
2284 }
2285
2286 /**
2287  * @testcase            utc_vc_mgr_set_dialog_request_cb_p
2288  * @since_tizen         5.0
2289  * @description         Positive UTC for set dialog request callback
2290  */
2291 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_dialog_request_cb_p)
2292 {
2293         if (false == __is_feature_supported) {
2294                 EXPECT_EQ(vc_mgr_set_dialog_request_cb(__vc_mgr_dialog_request_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2295                 return;
2296         }
2297
2298         EXPECT_EQ(vc_mgr_set_dialog_request_cb(__vc_mgr_dialog_request_cb, nullptr), VC_ERROR_NONE);
2299 }
2300
2301 /**
2302  * @testcase            utc_vc_mgr_set_dialog_request_cb_n1
2303  * @since_tizen         5.0
2304  * @description         Negative UTC for set dialog request callback
2305  */
2306 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_dialog_request_cb_n1)
2307 {
2308         if (false == __is_feature_supported) {
2309                 EXPECT_EQ(vc_mgr_set_dialog_request_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
2310                 return;
2311         }
2312
2313         EXPECT_EQ(vc_mgr_set_dialog_request_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
2314 }
2315
2316 /**
2317  * @testcase            utc_vc_mgr_set_dialog_request_cb_n2
2318  * @since_tizen         5.0
2319  * @description         Negative UTC for set dialog request callback
2320  */
2321 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_dialog_request_cb_n2)
2322 {
2323         if (false == __is_feature_supported) {
2324                 EXPECT_EQ(vc_mgr_set_dialog_request_cb(__vc_mgr_dialog_request_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2325                 return;
2326         }
2327
2328         EXPECT_EQ(vc_mgr_set_dialog_request_cb(__vc_mgr_dialog_request_cb, nullptr), VC_ERROR_INVALID_STATE);
2329 }
2330
2331 /**
2332  * @testcase            utc_vc_mgr_unset_dialog_request_cb_p
2333  * @since_tizen         5.0
2334  * @description         Positive UTC for unset dialog request callback
2335  */
2336 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_dialog_request_cb_p)
2337 {
2338         if (false == __is_feature_supported) {
2339                 EXPECT_EQ(vc_mgr_unset_dialog_request_cb(), VC_ERROR_NOT_SUPPORTED);
2340                 return;
2341         }
2342
2343         EXPECT_EQ(vc_mgr_unset_dialog_request_cb(), VC_ERROR_NONE);
2344 }
2345
2346 /**
2347  * @testcase            utc_vc_mgr_unset_dialog_request_cb_n
2348  * @since_tizen         5.0
2349  * @description         Negative UTC for unset dialog request callback
2350  */
2351 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_dialog_request_cb_n)
2352 {
2353         if (false == __is_feature_supported) {
2354                 EXPECT_EQ(vc_mgr_unset_dialog_request_cb(), VC_ERROR_NOT_SUPPORTED);
2355                 return;
2356         }
2357
2358         EXPECT_EQ(vc_mgr_unset_dialog_request_cb(), VC_ERROR_INVALID_STATE);
2359 }
2360
2361 /**
2362  * @testcase            utc_vc_mgr_enable_command_type_p
2363  * @since_tizen         5.0
2364  * @description         Positive UTC for enable command type
2365  */
2366 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_enable_command_type_p)
2367 {
2368         if (false == __is_feature_supported) {
2369                 EXPECT_EQ(vc_mgr_enable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
2370                 return;
2371         }
2372
2373         EXPECT_EQ(vc_mgr_enable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NONE);
2374 }
2375
2376 /**
2377  * @testcase            utc_vc_mgr_enable_command_type_n1
2378  * @since_tizen         5.0
2379  * @description         Negative UTC for enable command type
2380  */
2381 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_enable_command_type_n1)
2382 {
2383         if (false == __is_feature_supported) {
2384                 EXPECT_EQ(vc_mgr_enable_command_type(-1), VC_ERROR_NOT_SUPPORTED);
2385                 return;
2386         }
2387
2388         EXPECT_EQ(vc_mgr_enable_command_type(-1), VC_ERROR_INVALID_PARAMETER);
2389 }
2390
2391 /**
2392  * @testcase            utc_vc_mgr_enable_command_type_n2
2393  * @since_tizen         5.0
2394  * @description         Negative UTC for enable command type
2395  */
2396 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_enable_command_type_n2)
2397 {
2398         if (false == __is_feature_supported) {
2399                 EXPECT_EQ(vc_mgr_enable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
2400                 return;
2401         }
2402
2403         EXPECT_EQ(vc_mgr_enable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
2404         EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
2405         EXPECT_EQ(vc_mgr_enable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
2406         EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
2407 }
2408
2409 /**
2410  * @testcase            utc_vc_mgr_disable_command_type_p
2411  * @since_tizen         5.0
2412  * @description         Positive UTC for disable command type
2413  */
2414 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_disable_command_type_p)
2415 {
2416         if (false == __is_feature_supported) {
2417                 EXPECT_EQ(vc_mgr_disable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
2418                 return;
2419         }
2420
2421         EXPECT_EQ(vc_mgr_disable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NONE);
2422 }
2423
2424 /**
2425  * @testcase            utc_vc_mgr_disable_command_type_n1
2426  * @since_tizen         5.0
2427  * @description         Negative UTC for disable command type
2428  */
2429 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_disable_command_type_n1)
2430 {
2431         if (false == __is_feature_supported) {
2432                 EXPECT_EQ(vc_mgr_disable_command_type(-1), VC_ERROR_NOT_SUPPORTED);
2433                 return;
2434         }
2435
2436         EXPECT_EQ(vc_mgr_disable_command_type(-1), VC_ERROR_INVALID_PARAMETER);
2437 }
2438
2439 /**
2440  * @testcase            utc_vc_mgr_disable_command_type_n2
2441  * @since_tizen         5.0
2442  * @description         Negative UTC for disable command type
2443  */
2444 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_disable_command_type_n2)
2445 {
2446         if (false == __is_feature_supported) {
2447                 EXPECT_EQ(vc_mgr_disable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_NOT_SUPPORTED);
2448                 return;
2449         }
2450
2451         EXPECT_EQ(vc_mgr_disable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
2452         EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
2453         EXPECT_EQ(vc_mgr_disable_command_type(VC_COMMAND_TYPE_FOREGROUND), VC_ERROR_INVALID_STATE);
2454         EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
2455 }
2456
2457 /**
2458  * @testcase            utc_vc_mgr_set_private_data_set_cb_p
2459  * @since_tizen         5.0
2460  * @description         Positive UTC for set private data set callback
2461  */
2462 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_set_cb_p)
2463 {
2464         if (false == __is_feature_supported) {
2465                 EXPECT_EQ(vc_mgr_set_private_data_set_cb(__vc_mgr_private_data_set_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2466                 return;
2467         }
2468
2469         EXPECT_EQ(vc_mgr_set_private_data_set_cb(__vc_mgr_private_data_set_cb, nullptr), VC_ERROR_NONE);
2470 }
2471
2472 /**
2473  * @testcase            utc_vc_mgr_set_private_data_set_cb_n1
2474  * @since_tizen         5.0
2475  * @description         Negative UTC for set private data set callback
2476  */
2477 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_set_cb_n1)
2478 {
2479         if (false == __is_feature_supported) {
2480                 EXPECT_EQ(vc_mgr_set_private_data_set_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
2481                 return;
2482         }
2483
2484         EXPECT_EQ(vc_mgr_set_private_data_set_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
2485 }
2486
2487 /**
2488  * @testcase            utc_vc_mgr_set_private_data_set_cb_n2
2489  * @since_tizen         5.0
2490  * @description         Negative UTC for set private data set callback
2491  */
2492 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_private_data_set_cb_n2)
2493 {
2494         if (false == __is_feature_supported) {
2495                 EXPECT_EQ(vc_mgr_set_private_data_set_cb(__vc_mgr_private_data_set_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2496                 return;
2497         }
2498
2499         EXPECT_EQ(vc_mgr_set_private_data_set_cb(__vc_mgr_private_data_set_cb, nullptr), VC_ERROR_INVALID_STATE);
2500 }
2501
2502 /**
2503  * @testcase            utc_vc_mgr_unset_private_data_set_cb_p
2504  * @since_tizen         5.0
2505  * @description         Positive UTC for unset private data set callback
2506  */
2507 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_private_data_set_cb_p)
2508 {
2509         if (false == __is_feature_supported) {
2510                 EXPECT_EQ(vc_mgr_unset_private_data_set_cb(), VC_ERROR_NOT_SUPPORTED);
2511                 return;
2512         }
2513
2514         EXPECT_EQ(vc_mgr_unset_private_data_set_cb(), VC_ERROR_NONE);
2515 }
2516
2517 /**
2518  * @testcase            utc_vc_mgr_unset_private_data_set_cb_n
2519  * @since_tizen         5.0
2520  * @description         Negative UTC for unset private data set callback
2521  */
2522 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_private_data_set_cb_n)
2523 {
2524         if (false == __is_feature_supported) {
2525                 EXPECT_EQ(vc_mgr_unset_private_data_set_cb(), VC_ERROR_NOT_SUPPORTED);
2526                 return;
2527         }
2528
2529         EXPECT_EQ(vc_mgr_unset_private_data_set_cb(), VC_ERROR_INVALID_STATE);
2530 }
2531
2532 /**
2533  * @testcase            utc_vc_mgr_set_private_data_requested_cb_p
2534  * @since_tizen         5.0
2535  * @description         Positive UTC for set private data requested callback
2536  */
2537 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_requested_cb_p)
2538 {
2539         if (false == __is_feature_supported) {
2540                 EXPECT_EQ(vc_mgr_set_private_data_requested_cb(__vc_mgr_private_data_requested_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2541                 return;
2542         }
2543
2544         EXPECT_EQ(vc_mgr_set_private_data_requested_cb(__vc_mgr_private_data_requested_cb, nullptr), VC_ERROR_NONE);
2545 }
2546
2547 /**
2548  * @testcase            utc_vc_mgr_set_private_data_requested_cb_n1
2549  * @since_tizen         5.0
2550  * @description         Negative UTC for set private data requested callback
2551  */
2552 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_private_data_requested_cb_n1)
2553 {
2554         if (false == __is_feature_supported) {
2555                 EXPECT_EQ(vc_mgr_set_private_data_requested_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
2556                 return;
2557         }
2558
2559         EXPECT_EQ(vc_mgr_set_private_data_requested_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
2560 }
2561
2562 /**
2563  * @testcase            utc_vc_mgr_set_private_data_requested_cb_n2
2564  * @since_tizen         5.0
2565  * @description         Negative UTC for set private data requested callback
2566  */
2567 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_private_data_requested_cb_n2)
2568 {
2569         if (false == __is_feature_supported) {
2570                 EXPECT_EQ(vc_mgr_set_private_data_requested_cb(__vc_mgr_private_data_requested_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2571                 return;
2572         }
2573
2574         EXPECT_EQ(vc_mgr_set_private_data_requested_cb(__vc_mgr_private_data_requested_cb, nullptr), VC_ERROR_INVALID_STATE);
2575 }
2576
2577 /**
2578  * @testcase            utc_vc_mgr_unset_private_data_requested_cb_p
2579  * @since_tizen         5.0
2580  * @description         Positive UTC for unset private data requested callback
2581  */
2582 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_private_data_requested_cb_p)
2583 {
2584         if (false == __is_feature_supported) {
2585                 EXPECT_EQ(vc_mgr_unset_private_data_requested_cb(), VC_ERROR_NOT_SUPPORTED);
2586                 return;
2587         }
2588
2589         EXPECT_EQ(vc_mgr_unset_private_data_requested_cb(), VC_ERROR_NONE);
2590 }
2591
2592 /**
2593  * @testcase            utc_vc_mgr_set_feedback_audio_format_cb_p
2594  * @since_tizen         5.0
2595  * @description         Positive UTC for set feedback audio format callback
2596  */
2597 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_feedback_audio_format_cb_p)
2598 {
2599         if (false == __is_feature_supported) {
2600                 EXPECT_EQ(vc_mgr_unset_private_data_requested_cb(), VC_ERROR_NOT_SUPPORTED);
2601                 return;
2602         }
2603
2604         EXPECT_EQ(vc_mgr_unset_private_data_requested_cb(), VC_ERROR_INVALID_STATE);
2605 }
2606
2607 /**
2608  * @testcase            utc_vc_mgr_set_feedback_audio_format_cb_p
2609  * @since_tizen         5.0
2610  * @description         Positive UTC for set feedback audio format callback
2611  */
2612 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_feedback_audio_format_cb_p)
2613 {
2614         if (false == __is_feature_supported) {
2615                 EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(__vc_mgr_feedback_audio_format_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2616                 return;
2617         }
2618
2619         EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(__vc_mgr_feedback_audio_format_cb, nullptr), VC_ERROR_NONE);
2620 }
2621
2622 /**
2623  * @testcase            utc_vc_mgr_set_feedback_audio_format_cb_n1
2624  * @since_tizen         5.0
2625  * @description         Negative UTC for set feedback audio format callback
2626  */
2627 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_feedback_audio_format_cb_n1)
2628 {
2629         if (false == __is_feature_supported) {
2630                 EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
2631                 return;
2632         }
2633
2634         EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
2635 }
2636
2637 /**
2638  * @testcase            utc_vc_mgr_set_feedback_audio_format_cb_n2
2639  * @since_tizen         5.0
2640  * @description         Negative UTC for set feedback audio format callback
2641  */
2642 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_feedback_audio_format_cb_n2)
2643 {
2644         if (false == __is_feature_supported) {
2645                 EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(__vc_mgr_feedback_audio_format_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2646                 return;
2647         }
2648
2649         EXPECT_EQ(vc_mgr_set_feedback_audio_format_cb(__vc_mgr_feedback_audio_format_cb, nullptr), VC_ERROR_INVALID_STATE);
2650 }
2651
2652 /**
2653  * @testcase            utc_vc_mgr_unset_feedback_audio_format_cb_p
2654  * @since_tizen         5.0
2655  * @description         Positive UTC for unset feedback audio format callback
2656  */
2657 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_feedback_audio_format_cb_p)
2658 {
2659         if (false == __is_feature_supported) {
2660                 EXPECT_EQ(vc_mgr_unset_feedback_audio_format_cb(), VC_ERROR_NOT_SUPPORTED);
2661                 return;
2662         }
2663
2664         EXPECT_EQ(vc_mgr_unset_feedback_audio_format_cb(), VC_ERROR_NONE);
2665 }
2666
2667 /**
2668  * @testcase            utc_vc_mgr_unset_feedback_audio_format_cb_n
2669  * @since_tizen         5.0
2670  * @description         Negative UTC for unset feedback audio format callback
2671  */
2672 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_feedback_audio_format_cb_n)
2673 {
2674         if (false == __is_feature_supported) {
2675                 EXPECT_EQ(vc_mgr_unset_feedback_audio_format_cb(), VC_ERROR_NOT_SUPPORTED);
2676                 return;
2677         }
2678
2679         EXPECT_EQ(vc_mgr_unset_feedback_audio_format_cb(), VC_ERROR_INVALID_STATE);
2680 }
2681
2682 /**
2683  * @testcase            utc_vc_mgr_set_feedback_streaming_cb_p
2684  * @since_tizen         5.0
2685  * @description         Positive UTC for set feedback streaming callback
2686  */
2687 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_feedback_streaming_cb_p)
2688 {
2689         if (false == __is_feature_supported) {
2690                 EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(__vc_mgr_feedback_streaming_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2691                 return;
2692         }
2693
2694         EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(__vc_mgr_feedback_streaming_cb, nullptr), VC_ERROR_NONE);
2695 }
2696
2697 /**
2698  * @testcase            utc_vc_mgr_set_feedback_streaming_cb_n1
2699  * @since_tizen         5.0
2700  * @description         Negative UTC for set feedback streaming callback
2701  */
2702 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_feedback_streaming_cb_n1)
2703 {
2704         if (false == __is_feature_supported) {
2705                 EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
2706                 return;
2707         }
2708
2709         EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
2710 }
2711
2712 /**
2713  * @testcase            utc_vc_mgr_set_feedback_streaming_cb_n2
2714  * @since_tizen         5.0
2715  * @description         Negative UTC for set feedback streaming callback
2716  */
2717 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_feedback_streaming_cb_n2)
2718 {
2719         if (false == __is_feature_supported) {
2720                 EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(__vc_mgr_feedback_streaming_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2721                 return;
2722         }
2723
2724         EXPECT_EQ(vc_mgr_set_feedback_streaming_cb(__vc_mgr_feedback_streaming_cb, nullptr), VC_ERROR_INVALID_STATE);
2725 }
2726
2727 /**
2728  * @testcase            utc_vc_mgr_unset_feedback_streaming_cb_p
2729  * @since_tizen         5.0
2730  * @description         Positive UTC for unset feedback streaming callback
2731  */
2732 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_feedback_streaming_cb_p)
2733 {
2734         if (false == __is_feature_supported) {
2735                 EXPECT_EQ(vc_mgr_unset_feedback_streaming_cb(), VC_ERROR_NOT_SUPPORTED);
2736                 return;
2737         }
2738
2739         EXPECT_EQ(vc_mgr_unset_feedback_streaming_cb(), VC_ERROR_NONE);
2740 }
2741
2742 /**
2743  * @testcase            utc_vc_mgr_unset_feedback_streaming_cb_n
2744  * @since_tizen         5.0
2745  * @description         Negative UTC for unset feedback streaming callback
2746  */
2747 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_feedback_streaming_cb_n)
2748 {
2749         if (false == __is_feature_supported) {
2750                 EXPECT_EQ(vc_mgr_unset_feedback_streaming_cb(), VC_ERROR_NOT_SUPPORTED);
2751                 return;
2752         }
2753
2754         EXPECT_EQ(vc_mgr_unset_feedback_streaming_cb(), VC_ERROR_INVALID_STATE);
2755 }
2756
2757 /**
2758  * @testcase            utc_vc_mgr_start_feedback_p
2759  * @since_tizen         5.0
2760  * @description         Positive UTC for start feedback
2761  */
2762 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_start_feedback_p)
2763 {
2764         if (false == __is_feature_supported) {
2765                 EXPECT_EQ(vc_mgr_start_feedback(), VC_ERROR_NOT_SUPPORTED);
2766                 return;
2767         }
2768
2769         EXPECT_EQ(vc_mgr_start_feedback(), VC_ERROR_NONE);
2770 }
2771
2772 /**
2773  * @testcase            utc_vc_mgr_start_feedback_n
2774  * @since_tizen         5.0
2775  * @description         Negative UTC for start feedback
2776  */
2777 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_start_feedback_n)
2778 {
2779         if (false == __is_feature_supported) {
2780                 EXPECT_EQ(vc_mgr_start_feedback(), VC_ERROR_NOT_SUPPORTED);
2781                 return;
2782         }
2783
2784         EXPECT_EQ(vc_mgr_start_feedback(), VC_ERROR_INVALID_STATE);
2785         EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
2786         EXPECT_EQ(vc_mgr_start_feedback(), VC_ERROR_INVALID_STATE);
2787         EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
2788 }
2789
2790 /**
2791  * @testcase            utc_vc_mgr_stop_feedback_p
2792  * @since_tizen         5.0
2793  * @description         Negative UTC for stop feedback
2794  */
2795 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_stop_feedback_p)
2796 {
2797         if (false == __is_feature_supported) {
2798                 EXPECT_EQ(vc_mgr_stop_feedback(), VC_ERROR_NOT_SUPPORTED);
2799                 return;
2800         }
2801
2802         EXPECT_EQ(vc_mgr_stop_feedback(), VC_ERROR_NONE);
2803 }
2804
2805 /**
2806  * @testcase            utc_vc_mgr_stop_feedback_n
2807  * @since_tizen         5.0
2808  * @description         Negative UTC for stop feedback
2809  */
2810 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_stop_feedback_n)
2811 {
2812         if (false == __is_feature_supported) {
2813                 EXPECT_EQ(vc_mgr_stop_feedback(), VC_ERROR_NOT_SUPPORTED);
2814                 return;
2815         }
2816
2817         EXPECT_EQ(vc_mgr_stop_feedback(), VC_ERROR_INVALID_STATE);
2818         EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
2819         EXPECT_EQ(vc_mgr_stop_feedback(), VC_ERROR_INVALID_STATE);
2820         EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
2821 }
2822
2823 /**
2824  * @testcase            utc_vc_mgr_set_vc_tts_streaming_cb_p
2825  * @since_tizen         5.0
2826  * @description         Positive UTC for set tts streaming callback
2827  */
2828 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_vc_tts_streaming_cb_p)
2829 {
2830         if (false == __is_feature_supported) {
2831                 EXPECT_EQ(vc_mgr_set_vc_tts_streaming_cb(__vc_mgr_vc_tts_streaming_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2832                 return;
2833         }
2834
2835         EXPECT_EQ(vc_mgr_set_vc_tts_streaming_cb(__vc_mgr_vc_tts_streaming_cb, nullptr), VC_ERROR_NONE);
2836 }
2837
2838 /**
2839  * @testcase            utc_vc_mgr_set_vc_tts_streaming_cb_n1
2840  * @since_tizen         5.0
2841  * @description         Negative UTC for set tts streaming callback
2842  */
2843 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_vc_tts_streaming_cb_n1)
2844 {
2845         if (false == __is_feature_supported) {
2846                 EXPECT_EQ(vc_mgr_set_vc_tts_streaming_cb(nullptr, nullptr), VC_ERROR_NOT_SUPPORTED);
2847                 return;
2848         }
2849
2850         EXPECT_EQ(vc_mgr_set_vc_tts_streaming_cb(nullptr, nullptr), VC_ERROR_INVALID_PARAMETER);
2851 }
2852
2853 /**
2854  * @testcase            utc_vc_mgr_set_vc_tts_streaming_cb_n2
2855  * @since_tizen         5.0
2856  * @description         Negative UTC for set tts streaming callback
2857  */
2858 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_vc_tts_streaming_cb_n2)
2859 {
2860         if (false == __is_feature_supported) {
2861                 EXPECT_EQ(vc_mgr_set_vc_tts_streaming_cb(__vc_mgr_vc_tts_streaming_cb, nullptr), VC_ERROR_NOT_SUPPORTED);
2862                 return;
2863         }
2864
2865         EXPECT_EQ(vc_mgr_set_vc_tts_streaming_cb(__vc_mgr_vc_tts_streaming_cb, nullptr), VC_ERROR_INVALID_STATE);
2866 }
2867
2868 /**
2869  * @testcase            utc_vc_mgr_unset_vc_tts_streaming_cb_p
2870  * @since_tizen         5.0
2871  * @description         Positive UTC for unset tts streaming callback
2872  */
2873 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_vc_tts_streaming_cb_p)
2874 {
2875         if (false == __is_feature_supported) {
2876                 EXPECT_EQ(vc_mgr_unset_vc_tts_streaming_cb(), VC_ERROR_NOT_SUPPORTED);
2877                 return;
2878         }
2879
2880         EXPECT_EQ(vc_mgr_unset_vc_tts_streaming_cb(), VC_ERROR_NONE);
2881 }
2882
2883 /**
2884  * @testcase            utc_vc_mgr_unset_vc_tts_streaming_cb_n
2885  * @since_tizen         5.0
2886  * @description         Negative UTC for unset tts streaming callback
2887  */
2888 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_unset_vc_tts_streaming_cb_n)
2889 {
2890         if (false == __is_feature_supported) {
2891                 EXPECT_EQ(vc_mgr_unset_vc_tts_streaming_cb(), VC_ERROR_NOT_SUPPORTED);
2892                 return;
2893         }
2894
2895         EXPECT_EQ(vc_mgr_unset_vc_tts_streaming_cb(), VC_ERROR_INVALID_STATE);
2896 }
2897
2898 /**
2899  * @testcase            utc_vc_mgr_send_utterance_status_p
2900  * @since_tizen         5.0
2901  * @description         Positive UTC for send utterance status
2902  */
2903 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_utterance_status_p)
2904 {
2905         int pid = static_cast<int>(getpid());
2906         int utt_id = 1;
2907         vc_tts_utterance_status_e status = VC_TTS_UTTERANCE_NONE;
2908         if (false == __is_feature_supported) {
2909                 EXPECT_EQ(vc_mgr_send_utterance_status(pid, utt_id, status), VC_ERROR_NOT_SUPPORTED);
2910                 return;
2911         }
2912
2913         EXPECT_EQ(vc_mgr_send_utterance_status(pid, utt_id, status), VC_ERROR_NONE);
2914 }
2915
2916 /**
2917  * @testcase            utc_vc_mgr_send_utterance_status_n1
2918  * @since_tizen         5.0
2919  * @description         Negative UTC for send utterance status
2920  */
2921 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_utterance_status_n1)
2922 {
2923         int pid = static_cast<int>(getpid());
2924         int utt_id = 1;
2925         vc_tts_utterance_status_e status = VC_TTS_UTTERANCE_NONE;
2926         if (false == __is_feature_supported) {
2927                 EXPECT_EQ(vc_mgr_send_utterance_status(pid, utt_id, status), VC_ERROR_NOT_SUPPORTED);
2928                 return;
2929         }
2930
2931         EXPECT_EQ(vc_mgr_send_utterance_status(pid, utt_id, static_cast<vc_tts_utterance_status_e>(0)), VC_ERROR_INVALID_PARAMETER);
2932 }
2933
2934 /**
2935  * @testcase            utc_vc_mgr_send_utterance_status_n2
2936  * @since_tizen         5.0
2937  * @description         Negative UTC for send utterance status
2938  */
2939 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_send_utterance_status_n2)
2940 {
2941         int pid = static_cast<int>(getpid());
2942         int utt_id = 1;
2943         vc_tts_utterance_status_e status = VC_TTS_UTTERANCE_NONE;
2944         if (false == __is_feature_supported) {
2945                 EXPECT_EQ(vc_mgr_send_utterance_status(pid, utt_id, status), VC_ERROR_NOT_SUPPORTED);
2946                 return;
2947         }
2948
2949         EXPECT_EQ(vc_mgr_send_utterance_status(pid, utt_id, status), VC_ERROR_INVALID_STATE);
2950         EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
2951         EXPECT_EQ(vc_mgr_send_utterance_status(pid, utt_id, status), VC_ERROR_INVALID_STATE);
2952         EXPECT_EQ(vc_mgr_deinitialize(), VC_ERROR_NONE);
2953 }
2954
2955 /**
2956  * @testcase            utc_vc_mgr_send_audio_streaming_p
2957  * @since_tizen         5.0
2958  * @description         Positive UTC for send audio streaming
2959  */
2960 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_audio_streaming_p)
2961 {
2962         unsigned char data[10] = {0, };
2963         vc_audio_streaming_event_e event = VC_AUDIO_STREAMING_EVENT_START;
2964         if (false == __is_feature_supported) {
2965                 EXPECT_EQ(vc_mgr_send_audio_streaming(event, data, 10), VC_ERROR_NOT_SUPPORTED);
2966                 return;
2967         }
2968
2969         vc_cmd_list_h commands = __create_test_command_list();
2970         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
2971         vc_cmd_list_destroy(commands, true);
2972
2973         ASSERT_EQ(vc_mgr_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_OUTSIDE), VC_ERROR_NONE);
2974         EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
2975         ASSERT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
2976
2977         EXPECT_EQ(vc_mgr_send_audio_streaming(event, data, 10), VC_ERROR_NONE);
2978         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
2979 }
2980
2981 /**
2982  * @testcase            utc_vc_mgr_send_audio_streaming_n1
2983  * @since_tizen         5.0
2984  * @description         Negative UTC for send audio streaming
2985  */
2986 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_audio_streaming_n1)
2987 {
2988         unsigned char data[10] = {0, };
2989         vc_audio_streaming_event_e event = VC_AUDIO_STREAMING_EVENT_START;
2990         if (false == __is_feature_supported) {
2991                 EXPECT_EQ(vc_mgr_send_audio_streaming(static_cast<vc_audio_streaming_event_e>(0), data, 10), VC_ERROR_NOT_SUPPORTED);
2992                 EXPECT_EQ(vc_mgr_send_audio_streaming(event, nullptr, 10), VC_ERROR_NOT_SUPPORTED);
2993                 return;
2994         }
2995
2996         vc_cmd_list_h commands = __create_test_command_list();
2997         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
2998         vc_cmd_list_destroy(commands, true);
2999
3000         ASSERT_EQ(vc_mgr_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_OUTSIDE), VC_ERROR_NONE);
3001         EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
3002         ASSERT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
3003
3004         EXPECT_EQ(vc_mgr_send_audio_streaming(static_cast<vc_audio_streaming_event_e>(0), data, 10), VC_ERROR_INVALID_PARAMETER);
3005         EXPECT_EQ(vc_mgr_send_audio_streaming(event, nullptr, 10), VC_ERROR_INVALID_PARAMETER);
3006         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
3007 }
3008
3009 /**
3010  * @testcase            utc_vc_mgr_send_audio_streaming_n2
3011  * @since_tizen         5.0
3012  * @description         Negative UTC for send audio streaming
3013  */
3014 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_send_audio_streaming_n2)
3015 {
3016         unsigned char data[10] = {0, };
3017         vc_audio_streaming_event_e event = VC_AUDIO_STREAMING_EVENT_START;
3018         if (false == __is_feature_supported) {
3019                 EXPECT_EQ(vc_mgr_send_audio_streaming(event, data, 10), VC_ERROR_NOT_SUPPORTED);
3020                 return;
3021         }
3022
3023         vc_cmd_list_h commands = __create_test_command_list();
3024         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
3025         vc_cmd_list_destroy(commands, true);
3026
3027         ASSERT_EQ(vc_mgr_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_OUTSIDE), VC_ERROR_NONE);
3028         EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
3029         ASSERT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
3030         EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NONE);
3031         ASSERT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_PROCESSING, 5), true);
3032
3033         EXPECT_EQ(vc_mgr_send_audio_streaming(event, data, 10), VC_ERROR_INVALID_STATE);
3034         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
3035 }
3036
3037 /**
3038  * @testcase            utc_vc_mgr_send_audio_streaming_n3
3039  * @since_tizen         5.0
3040  * @description         Negative UTC for send audio streaming
3041  */
3042 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_send_audio_streaming_n3)
3043 {
3044         unsigned char data[10] = {0, };
3045         vc_audio_streaming_event_e event = VC_AUDIO_STREAMING_EVENT_START;
3046         if (false == __is_feature_supported) {
3047                 EXPECT_EQ(vc_mgr_send_audio_streaming(event, data, 10), VC_ERROR_NOT_SUPPORTED);
3048                 return;
3049         }
3050
3051         EXPECT_EQ(vc_mgr_send_audio_streaming(event, data, 10), VC_ERROR_INVALID_STATE);
3052         EXPECT_EQ(vc_mgr_initialize(), VC_ERROR_NONE);
3053         EXPECT_EQ(vc_mgr_send_audio_streaming(event, data, 10), VC_ERROR_INVALID_STATE);
3054 }
3055
3056 /**
3057  * @testcase            utc_vc_mgr_set_audio_streaming_mode_p
3058  * @since_tizen         5.0
3059  * @description         Positive UTC for set audio streaming mode
3060  */
3061 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_audio_streaming_mode_p)
3062 {
3063         if (false == __is_feature_supported) {
3064                 EXPECT_EQ(vc_mgr_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_VC_SERVICE), VC_ERROR_NOT_SUPPORTED);
3065                 return;
3066         }
3067
3068         EXPECT_EQ(vc_mgr_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_VC_SERVICE), VC_ERROR_NONE);
3069         EXPECT_EQ(vc_mgr_prepare(), VC_ERROR_NONE);
3070         EXPECT_EQ(__is_mgr_state_changed(VC_STATE_READY, 5), true);
3071         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_READY, 5), true);
3072
3073         EXPECT_EQ(vc_mgr_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_VC_SERVICE), VC_ERROR_NONE);
3074         EXPECT_EQ(vc_mgr_unprepare(), VC_ERROR_NONE);
3075 }
3076
3077 /**
3078  * @testcase            utc_vc_mgr_set_audio_streaming_mode_n1
3079  * @since_tizen         5.0
3080  * @description         Negative UTC for set audio streaming mode
3081  */
3082 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_audio_streaming_mode_n1)
3083 {
3084         if (false == __is_feature_supported) {
3085                 EXPECT_EQ(vc_mgr_set_audio_streaming_mode(static_cast<vc_audio_streaming_mode_e>(-1)), VC_ERROR_NOT_SUPPORTED);
3086                 return;
3087         }
3088
3089         EXPECT_EQ(vc_mgr_set_audio_streaming_mode(static_cast<vc_audio_streaming_mode_e>(-1)), VC_ERROR_INVALID_PARAMETER);
3090 }
3091
3092 /**
3093  * @testcase            utc_vc_mgr_set_audio_streaming_mode_n2
3094  * @since_tizen         5.0
3095  * @description         Negative UTC for set audio streaming mode
3096  */
3097 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_set_audio_streaming_mode_n2)
3098 {
3099         if (false == __is_feature_supported) {
3100                 EXPECT_EQ(vc_mgr_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_VC_SERVICE), VC_ERROR_NOT_SUPPORTED);
3101                 return;
3102         }
3103
3104         EXPECT_EQ(vc_mgr_set_audio_streaming_mode(VC_AUDIO_STREAMING_MODE_VC_SERVICE), VC_ERROR_INVALID_STATE);
3105 }
3106
3107 /**
3108  * @testcase            utc_vc_mgr_change_background_volume_p
3109  * @since_tizen         5.0
3110  * @description         Positive UTC for change background volume
3111  */
3112 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_change_background_volume_p)
3113 {
3114         if (false == __is_feature_supported) {
3115                 EXPECT_EQ(vc_mgr_change_background_volume(VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), VC_ERROR_NOT_SUPPORTED);
3116                 return;
3117         }
3118
3119         EXPECT_EQ(vc_mgr_change_background_volume(VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), VC_ERROR_NONE);
3120         EXPECT_EQ(vc_mgr_reset_background_volume(), VC_ERROR_NONE);
3121 }
3122
3123 /**
3124  * @testcase            utc_vc_mgr_change_background_volume_n1
3125  * @since_tizen         5.0
3126  * @description         Negative UTC for change background volume
3127  */
3128 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_change_background_volume_n1)
3129 {
3130         if (false == __is_feature_supported) {
3131                 EXPECT_EQ(vc_mgr_change_background_volume(static_cast<vc_background_volume_event_e>(-1)), VC_ERROR_NOT_SUPPORTED);
3132                 return;
3133         }
3134
3135         EXPECT_EQ(vc_mgr_change_background_volume(static_cast<vc_background_volume_event_e>(-1)), VC_ERROR_INVALID_PARAMETER);
3136 }
3137
3138 /**
3139  * @testcase            utc_vc_mgr_change_background_volume_n2
3140  * @since_tizen         5.0
3141  * @description         Negative UTC for change background volume
3142  */
3143 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_change_background_volume_n2)
3144 {
3145         if (false == __is_feature_supported) {
3146                 EXPECT_EQ(vc_mgr_change_background_volume(VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), VC_ERROR_NOT_SUPPORTED);
3147                 return;
3148         }
3149
3150         EXPECT_EQ(vc_mgr_change_background_volume(VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), VC_ERROR_INVALID_STATE);
3151 }
3152
3153 /**
3154  * @testcase            utc_vc_mgr_reset_background_volume_p
3155  * @since_tizen         5.0
3156  * @description         Positive UTC for change background volume
3157  */
3158 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_reset_background_volume_p)
3159 {
3160         if (false == __is_feature_supported) {
3161                 EXPECT_EQ(vc_mgr_reset_background_volume(), VC_ERROR_NOT_SUPPORTED);
3162                 return;
3163         }
3164
3165         EXPECT_EQ(vc_mgr_change_background_volume(VC_BACKGROUND_VOLUME_EVENT_CHANGE_FOR_NEARFIELD), VC_ERROR_NONE);
3166         EXPECT_EQ(vc_mgr_reset_background_volume(), VC_ERROR_NONE);
3167         EXPECT_EQ(vc_mgr_reset_background_volume(), VC_ERROR_NONE);
3168 }
3169
3170 /**
3171  * @testcase            utc_vc_mgr_reset_background_volume_n
3172  * @since_tizen         5.0
3173  * @description         Negative UTC for change background volume
3174  */
3175 TEST_F(VcMgrTestInNoneState, utc_vc_mgr_reset_background_volume_n)
3176 {
3177         if (false == __is_feature_supported) {
3178                 EXPECT_EQ(vc_mgr_reset_background_volume(), VC_ERROR_NOT_SUPPORTED);
3179                 return;
3180         }
3181
3182         EXPECT_EQ(vc_mgr_reset_background_volume(), VC_ERROR_INVALID_STATE);
3183 }
3184
3185 /**
3186  * @testcase            utc_vc_mgr_set_selected_results_n1
3187  * @since_tizen         5.0
3188  * @description         Negative UTC for set selected results
3189  */
3190 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_selected_results_n1)
3191 {
3192         if (false == __is_feature_supported) {
3193                 EXPECT_EQ(vc_mgr_set_selected_results(nullptr), VC_ERROR_NOT_SUPPORTED);
3194                 return;
3195         }
3196
3197         EXPECT_EQ(vc_mgr_set_recognition_mode(VC_RECOGNITION_MODE_MANUAL), VC_ERROR_NONE);
3198         EXPECT_EQ(vc_mgr_set_selected_results(nullptr), VC_ERROR_INVALID_STATE);
3199 }
3200
3201 /**
3202  * @testcase            utc_vc_mgr_set_selected_results_n2
3203  * @since_tizen         5.0
3204  * @description         Negative UTC for set selected results
3205  */
3206 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_selected_results_n2)
3207 {
3208         if (false == __is_feature_supported) {
3209                 EXPECT_EQ(vc_mgr_set_selected_results(nullptr), VC_ERROR_NOT_SUPPORTED);
3210                 return;
3211         }
3212
3213         vc_cmd_list_h commands = __create_test_command_list();
3214         ASSERT_EQ(vc_mgr_set_command_list(commands), VC_ERROR_NONE);
3215
3216         EXPECT_EQ(vc_mgr_start(false), VC_ERROR_NONE);
3217         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_RECORDING, 5), true);
3218
3219         EXPECT_EQ(vc_mgr_stop(), VC_ERROR_NONE);
3220         EXPECT_EQ(__is_mgr_service_state_changed(VC_SERVICE_STATE_PROCESSING, 5), true);
3221         EXPECT_EQ(vc_mgr_set_selected_results(commands), VC_ERROR_OPERATION_FAILED);
3222
3223         EXPECT_EQ(vc_mgr_cancel(), VC_ERROR_NONE);
3224         vc_cmd_list_destroy(commands, true);
3225 }
3226
3227 /**
3228  * @testcase            utc_vc_mgr_set_demandable_client_rule_p
3229  * @since_tizen         5.0
3230  * @description         Positive UTC for set demandable client rule
3231  */
3232 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_demandable_client_rule_p)
3233 {
3234         if (false == __is_feature_supported) {
3235                 EXPECT_EQ(vc_mgr_set_demandable_client_rule(TEST_DEMANDABLE_LIST_XML_PATH), VC_ERROR_NOT_SUPPORTED);
3236                 return;
3237         }
3238
3239         EXPECT_EQ(vc_mgr_set_demandable_client_rule(TEST_DEMANDABLE_LIST_XML_PATH), VC_ERROR_NONE);
3240 }
3241
3242 /**
3243  * @testcase            utc_vc_mgr_set_demandable_client_rule_n1
3244  * @since_tizen         5.0
3245  * @description         Negative UTC for set demandable client rule
3246  */
3247 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_demandable_client_rule_n1)
3248 {
3249         if (false == __is_feature_supported) {
3250                 EXPECT_EQ(vc_mgr_set_demandable_client_rule(nullptr), VC_ERROR_NOT_SUPPORTED);
3251                 EXPECT_EQ(vc_mgr_set_demandable_client_rule(TEST_EMPTY_FILE_PATH), VC_ERROR_NOT_SUPPORTED);
3252                 return;
3253         }
3254
3255         EXPECT_EQ(vc_mgr_set_demandable_client_rule(nullptr), VC_ERROR_INVALID_PARAMETER);
3256         EXPECT_EQ(vc_mgr_set_demandable_client_rule(TEST_EMPTY_FILE_PATH), VC_ERROR_INVALID_PARAMETER);
3257 }
3258
3259 /**
3260  * @testcase            utc_vc_mgr_set_demandable_client_rule_n2
3261  * @since_tizen         5.0
3262  * @description         Negative UTC for set demandable client rule
3263  */
3264 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_demandable_client_rule_n2)
3265 {
3266         if (false == __is_feature_supported) {
3267                 EXPECT_EQ(vc_mgr_set_demandable_client_rule(TEST_DEMANDABLE_LIST_XML_PATH), VC_ERROR_NOT_SUPPORTED);
3268                 return;
3269         }
3270
3271         EXPECT_EQ(vc_mgr_set_demandable_client_rule(TEST_DEMANDABLE_LIST_XML_PATH), VC_ERROR_INVALID_STATE);
3272 }
3273
3274 /**
3275  * @testcase            utc_vc_mgr_unset_demandable_client_rule_p
3276  * @since_tizen         5.0
3277  * @description         Positive UTC for unset demandable client rule
3278  */
3279 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_unset_demandable_client_rule_p)
3280 {
3281         if (false == __is_feature_supported) {
3282                 EXPECT_EQ(vc_mgr_unset_demandable_client_rule(), VC_ERROR_NOT_SUPPORTED);
3283                 return;
3284         }
3285
3286         EXPECT_EQ(vc_mgr_unset_demandable_client_rule(), VC_ERROR_NONE);
3287 }
3288
3289 /**
3290  * @testcase            utc_vc_mgr_unset_demandable_client_rule_n1
3291  * @since_tizen         5.0
3292  * @description         Negative UTC for unset demandable client rule
3293  */
3294 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_unset_demandable_client_rule_n1)
3295 {
3296         if (false == __is_feature_supported) {
3297                 EXPECT_EQ(vc_mgr_unset_demandable_client_rule(), VC_ERROR_NOT_SUPPORTED);
3298                 return;
3299         }
3300
3301         EXPECT_EQ(vc_mgr_unset_demandable_client_rule(), VC_ERROR_INVALID_STATE);
3302 }
3303
3304 /**
3305  * @testcase            utc_vc_mgr_set_domain_p
3306  * @since_tizen         5.0
3307  * @description         Positive UTC for set domain
3308  */
3309 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_domain_p)
3310 {
3311         if (false == __is_feature_supported) {
3312                 EXPECT_EQ(vc_mgr_set_domain(TEST_DOMAIN), VC_ERROR_NOT_SUPPORTED);
3313                 return;
3314         }
3315
3316         EXPECT_EQ(vc_mgr_set_domain(TEST_DOMAIN), VC_ERROR_NONE);
3317 }
3318
3319 /**
3320  * @testcase            utc_vc_mgr_set_domain_n1
3321  * @since_tizen         5.0
3322  * @description         Negative UTC for set domain
3323  */
3324 TEST_F(VcMgrTestInReadyState, utc_vc_mgr_set_domain_n1)
3325 {
3326         if (false == __is_feature_supported) {
3327                 EXPECT_EQ(vc_mgr_set_domain(nullptr), VC_ERROR_NOT_SUPPORTED);
3328                 return;
3329         }
3330
3331         EXPECT_EQ(vc_mgr_set_domain(nullptr), VC_ERROR_INVALID_PARAMETER);
3332 }
3333
3334 /**
3335  * @testcase            utc_vc_mgr_set_domain_n2
3336  * @since_tizen         5.0
3337  * @description         Negative UTC for set domain
3338  */
3339 TEST_F(VcMgrTestInInitializedState, utc_vc_mgr_set_domain_n2)
3340 {
3341         if (false == __is_feature_supported) {
3342                 EXPECT_EQ(vc_mgr_set_domain(TEST_DOMAIN), VC_ERROR_NOT_SUPPORTED);
3343                 return;
3344         }
3345
3346         EXPECT_EQ(vc_mgr_set_domain(TEST_DOMAIN), VC_ERROR_INVALID_STATE);
3347 }
3348
3349
3350 } // namespace