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