tests/test-feedback-internal.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4
   5 #include "test.h"
   6 #include "test-feedback-internal.h"
   7
   8 static int pass;
   9 static int fail;
  10
  11 static int pattern_s[ARRAY_SIZE(test_pattern)] = { -1, };
  12 static int pattern_i_s[ARRAY_SIZE(test_pattern_internal)] = { -1, };
  13 static int pattern_v[ARRAY_SIZE(test_pattern)] = { -1, };
  14 static int pattern_i_v[ARRAY_SIZE(test_pattern_internal)] = { -1, };
  15
  16 static void test_play_type_by_name_p()
  17 {
  18         int i;
  19         char *name;
  20         bool s_end = false, v_end = false;
  21
  22         feedback_initialize();
  23
  24         for (i = 0; i < ARRAY_SIZE(test_pattern); i++)
  25         {
  26                 if (pattern_s[i] == -1) s_end = true;
  27                 if (pattern_v[i] == -1) v_end = true;
  28
  29                 if (s_end && v_end) break;
  30
  31                 if (!s_end && (pattern_s[i] != -1)) {
  32                         name = strdup(test_pattern[pattern_s[i]].name);
  33                         RESULT(feedback_play_type_by_name("FEEDBACK_TYPE_SOUND", name), FEEDBACK_ERROR_NONE, name)
  34                         free(name);
  35                 }
  36
  37                 if (!v_end && (pattern_v[i] != -1)) {
  38                         name = strdup(test_pattern[pattern_v[i]].name);
  39                         RESULT(feedback_play_type_by_name("FEEDBACK_TYPE_VIBRATION", name), FEEDBACK_ERROR_NONE, name);
  40                         free(name);
  41                 }
  42
  43                 usleep(DELAY_TIME);
  44         }
  45
  46         s_end = false;
  47         v_end = false;
  48
  49         for (i = 0; i < ARRAY_SIZE(test_pattern_internal); i++)
  50         {
  51                 if (pattern_i_s[i] == -1)       s_end = true;
  52                 if (pattern_i_v[i] == -1)       v_end = true;
  53
  54                 if (s_end && v_end) break;
  55
  56                 if (!s_end && (pattern_i_s[i] != -1)) {
  57                         name = strdup(test_pattern_internal[pattern_i_s[i]].name);
  58                         RESULT(feedback_play_type_by_name("FEEDBACK_TYPE_SOUND", name), FEEDBACK_ERROR_NONE, name);
  59                         free(name);
  60                 }
  61
  62                 if (!v_end && (pattern_i_v[i] != -1)) {
  63                         name = strdup(test_pattern_internal[pattern_i_v[i]].name);
  64                         RESULT(feedback_play_type_by_name("FEEDBACK_TYPE_VIBRATION", name), FEEDBACK_ERROR_NONE, name);
  65                         free(name);
  66                 }
  67
  68                 usleep(DELAY_TIME);
  69         }
  70
  71         feedback_deinitialize();
  72 }
  73
  74 static void test_play_type_by_name_n()
  75 {
  76         RESULT(feedback_play_type_by_name(NULL, "FEEDBACK_PATTERN_TAP"), FEEDBACK_ERROR_INVALID_PARAMETER, "type is null");
  77
  78         RESULT(feedback_play_type_by_name("FEEDBACK_TYPE_VIBRATION", NULL), FEEDBACK_ERROR_INVALID_PARAMETER, "pattern is null");
  79
  80         RESULT(feedback_play_type_by_name("INVALID_FEEDBACK_TYPE", "FEEDBACK_PATTERN_TAP"), FEEDBACK_ERROR_INVALID_PARAMETER, "invalid feedback type");
  81
  82         RESULT(feedback_play_type_by_name("FEEDBACK_TYPE_SOUND", "INVALID_FEEDBACK_PATTERN"), FEEDBACK_ERROR_INVALID_PARAMETER, "invalid feedback pattern");
  83 }
  84
  85 bool TEST_FEEDBACK_PLAY_TYPE_BY_NAME(void)
  86 {
  87         INIT();
  88
  89         test_play_type_by_name_p();
  90         test_play_type_by_name_n();
  91
  92         REPORT_AND_RETURN();
  93 }
  94
  95 static void test_play_internal_p()
  96 {
  97         int i;
  98
  99         feedback_initialize();
 100
 101         for (i = 0; i < ARRAY_SIZE(test_pattern_internal); i++)
 102         {
 103                 RESULT(feedback_play_internal(test_pattern_internal[i].pattern), FEEDBACK_ERROR_NONE, test_pattern_internal[i].name);
 104                 usleep(DELAY_TIME);
 105         }
 106
 107         feedback_deinitialize();
 108 }
 109
 110 static void test_play_internal_n()
 111 {
 112         RESULT(feedback_play_internal(FEEDBACK_PATTERN_TAP), FEEDBACK_ERROR_NOT_INITIALIZED, "not initialize");
 113
 114         feedback_initialize();
 115         RESULT(feedback_play_internal(FEEDBACK_PATTERN_NONE), FEEDBACK_ERROR_INVALID_PARAMETER, "invalid pattern");
 116         feedback_deinitialize();
 117 }
 118
 119 bool TEST_FEEDBACK_PLAY_INTERNAL(void)
 120 {
 121         INIT();
 122
 123         test_play_internal_p();
 124         test_play_internal_n();
 125
 126         REPORT_AND_RETURN();
 127 }
 128
 129 static void test_play_soundpath_internal_p()
 130 {
 131         int i;
 132         struct _pattern_internal *pattern;
 133
 134         feedback_initialize();
 135
 136         for (i = 0; i < ARRAY_SIZE(test_pattern_internal); i++)
 137         {
 138                 if (pattern_i_s[i] == -1)
 139                         break;
 140
 141                 pattern = &test_pattern_internal[pattern_i_s[i]];
 142                 if (pattern->path == NULL)
 143                         continue;
 144
 145                 RESULT(feedback_play_soundpath_internal(pattern->pattern, pattern->path), FEEDBACK_ERROR_NONE, pattern->name);
 146                 usleep(DELAY_TIME);
 147         }
 148
 149         feedback_deinitialize();
 150 }
 151
 152 static void test_play_soundpath_internal_n()
 153 {
 154         RESULT(feedback_play_soundpath_internal(FEEDBACK_PATTERN_TAP, "/usr/share/feedback/sound/operation/operation.wav"), FEEDBACK_ERROR_NOT_INITIALIZED, "not initialize");
 155
 156         feedback_initialize();
 157
 158         RESULT(feedback_play_soundpath_internal(FEEDBACK_PATTERN_NONE, "/usr/share/feedback/sound/operation/operation.wav"), FEEDBACK_ERROR_INVALID_PARAMETER, "invalid pattern");
 159         RESULT(feedback_play_soundpath_internal(FEEDBACK_PATTERN_TAP, NULL), FEEDBACK_ERROR_INVALID_PARAMETER, "NULL sound path");
 160
 161         feedback_deinitialize();
 162 }
 163
 164 bool TEST_FEEDBACK_PLAY_SOUNDPATH_INTERNAL(void)
 165 {
 166         INIT();
 167
 168         test_play_soundpath_internal_p();
 169         test_play_soundpath_internal_n();
 170
 171         REPORT_AND_RETURN();
 172 }
 173
 174 static void test_play_type_internal_p()
 175 {
 176         int i;
 177         bool s_end = false, v_end = false;
 178
 179         feedback_initialize();
 180
 181         for (i = 0; i < ARRAY_SIZE(test_pattern_internal); i++)
 182         {
 183                 if (pattern_i_s[i] == -1) s_end = true;
 184                 if (pattern_i_v[i] == -1) v_end = true;
 185
 186                 if (s_end && v_end)     break;
 187
 188                 if (!s_end && (pattern_i_s[i] != -1))
 189                         RESULT(feedback_play_type_internal(FEEDBACK_TYPE_SOUND, test_pattern_internal[pattern_i_s[i]].pattern), FEEDBACK_ERROR_NONE, test_pattern_internal[pattern_i_s[i]].name);
 190
 191                 if (!v_end && (pattern_i_v[i] != -1))
 192                         RESULT(feedback_play_type_internal(FEEDBACK_TYPE_VIBRATION, test_pattern_internal[pattern_i_v[i]].pattern), FEEDBACK_ERROR_NONE, test_pattern_internal[pattern_i_v[i]].name);
 193
 194                 usleep(DELAY_TIME);
 195         }
 196
 197         feedback_deinitialize();
 198 }
 199
 200 static void test_play_type_internal_n()
 201 {
 202         RESULT(feedback_play_type_internal(FEEDBACK_TYPE_SOUND, FEEDBACK_PATTERN_TAP), FEEDBACK_ERROR_NOT_INITIALIZED, "not initialize");
 203
 204         feedback_initialize();
 205
 206         RESULT(feedback_play_type_internal(FEEDBACK_TYPE_NONE, FEEDBACK_PATTERN_TAP), FEEDBACK_ERROR_INVALID_PARAMETER, "invalid type");
 207         RESULT(feedback_play_type_internal(FEEDBACK_TYPE_VIBRATION, FEEDBACK_PATTERN_NONE), FEEDBACK_ERROR_INVALID_PARAMETER, "invalid pattern");
 208
 209         feedback_deinitialize();
 210 }
 211
 212 bool TEST_FEEDBACK_PLAY_TYPE_INTERNAL(void)
 213 {
 214         INIT();
 215
 216         test_play_type_internal_p();
 217         test_play_type_internal_n();
 218
 219         REPORT_AND_RETURN();
 220 }
 221 static void test_play_type_soundpath_internal_p()
 222 {
 223         int i;
 224         bool s_end = false, v_end = false;
 225         struct _pattern_internal *pattern;
 226
 227         feedback_initialize();
 228
 229     for (i = 0; i < ARRAY_SIZE(test_pattern_internal); i++)
 230     {
 231                 if (pattern_i_s[i] == -1)       s_end = true;
 232                 if (pattern_i_v[i] == -1)       v_end = true;
 233
 234                 if (s_end && v_end) break;
 235
 236                 if (!s_end && (pattern_i_s[i] != -1)) {
 237                         pattern = &test_pattern_internal[pattern_i_s[i]];
 238                 if (pattern->path != NULL)
 239                                 RESULT(feedback_play_type_soundpath_internal(FEEDBACK_TYPE_SOUND, pattern->pattern, pattern->path), FEEDBACK_ERROR_NONE, pattern->name);
 240                 }
 241
 242                 if (!v_end && (pattern_i_v[i] != -1)) {
 243                         pattern = &test_pattern_internal[pattern_i_v[i]];
 244                         RESULT(feedback_play_type_soundpath_internal(FEEDBACK_TYPE_VIBRATION, pattern->pattern, NULL), FEEDBACK_ERROR_NONE, pattern->name);
 245                 }
 246
 247         usleep(DELAY_TIME);
 248     }
 249
 250         feedback_deinitialize();
 251
 252 }
 253
 254 static void test_play_type_soundpath_internal_n()
 255 {
 256         RESULT(feedback_play_type_soundpath_internal(FEEDBACK_TYPE_SOUND, FEEDBACK_PATTERN_TAP, "/usr/share/feedback/sound/operation/operation.wav"), FEEDBACK_ERROR_NOT_INITIALIZED, "not initialize");
 257
 258         feedback_initialize();
 259
 260         RESULT(feedback_play_type_soundpath_internal(FEEDBACK_TYPE_NONE, FEEDBACK_PATTERN_TAP, "/usr/share/feedback/sound/operation/operation.wav"), FEEDBACK_ERROR_INVALID_PARAMETER, "invalid type");
 261         RESULT(feedback_play_type_soundpath_internal(FEEDBACK_TYPE_VIBRATION, FEEDBACK_PATTERN_NONE, "/usr/share/feedback/sound/operation/operation.wav"), FEEDBACK_ERROR_INVALID_PARAMETER, "invalid pattern");
 262         RESULT(feedback_play_type_soundpath_internal(FEEDBACK_TYPE_SOUND, FEEDBACK_PATTERN_TAP, NULL), FEEDBACK_ERROR_INVALID_PARAMETER, "invalid soundpath");
 263
 264         feedback_deinitialize();
 265 }
 266
 267 bool TEST_FEEDBACK_PLAY_TYPE_SOUNDPATH_INTERNAL(void)
 268 {
 269         INIT();
 270
 271         test_play_type_soundpath_internal_p();
 272         test_play_type_soundpath_internal_n();
 273
 274         REPORT_AND_RETURN();
 275 }
 276
 277 const char *feedback_play_sound_by_name(const char *pattern_name)
 278 {
 279         int ret;
 280
 281         feedback_initialize();
 282         ret = feedback_play_type_by_name("FEEDBACK_TYPE_SOUND", (char *)pattern_name);
 283     usleep(DELAY_TIME*10);
 284         feedback_deinitialize();
 285
 286         return err_to_str(ret);
 287 }
 288
 289 const char *feedback_play_vibration_by_name(const char *pattern_name)
 290 {
 291         int ret;
 292
 293         feedback_initialize();
 294         ret = feedback_play_type_by_name("FEEDBACK_TYPE_VIBRATION", (char *)pattern_name);
 295     usleep(DELAY_TIME*10);
 296         feedback_deinitialize();
 297
 298         return err_to_str(ret);
 299 }
 300
 301 void feedback_play_by_name(const char *pattern_name)
 302 {
 303         feedback_play_sound_by_name(pattern_name);
 304         feedback_play_vibration_by_name(pattern_name);
 305 }
 306
 307 static void init_supported_pattern(feedback_type_e type, int *pattern)
 308 {
 309         int i, ret;
 310         int idx_supported = 0;
 311         bool status;
 312
 313         feedback_initialize();
 314
 315         for(i = 0; i < ARRAY_SIZE(test_pattern); i++) {
 316                 ret = feedback_is_supported_pattern(type, test_pattern[i].pattern, &status);
 317                 if ((ret == FEEDBACK_ERROR_NONE) && status)
 318                         pattern[idx_supported++] = i;
 319         }
 320         pattern[idx_supported] = -1;
 321
 322         feedback_deinitialize();
 323 }
 324
 325 static void init_supported_pattern_i(feedback_type_e type, int *pattern_i)
 326 {
 327         int i, ret;
 328         int idx_supported = 0;
 329         bool status;
 330
 331         feedback_initialize();
 332
 333         for(i = 0; i < ARRAY_SIZE(test_pattern_internal); i++) {
 334                 ret = feedback_is_supported_pattern(type, test_pattern_internal[i].pattern, &status);
 335                 if ((ret == FEEDBACK_ERROR_NONE) && status)
 336                         pattern_i[idx_supported++] = i;
 337         }
 338         pattern_i[idx_supported] = -1;
 339
 340         feedback_deinitialize();
 341 }
 342
 343 static void test_get_count_of_sound_theme_internal(void)
 344 {
 345         unsigned int count_of_theme = 0;
 346
 347         RESULT(feedback_get_count_of_theme_internal(FEEDBACK_TYPE_SOUND, &count_of_theme),
 348                 FEEDBACK_ERROR_NOT_INITIALIZED, "not initialized");
 349
 350         feedback_initialize();
 351         RESULT(feedback_get_count_of_theme_internal(FEEDBACK_TYPE_SOUND, NULL),
 352                 FEEDBACK_ERROR_INVALID_PARAMETER, "invalid parameter");
 353         RESULT(feedback_get_count_of_theme_internal(FEEDBACK_TYPE_VIBRATION, &count_of_theme),
 354                 FEEDBACK_ERROR_NOT_SUPPORTED, "not supported");
 355         RESULT(feedback_get_count_of_theme_internal(FEEDBACK_TYPE_SOUND, &count_of_theme),
 356                 FEEDBACK_ERROR_NONE, "error none");
 357         _D("Feedback type=%d count of theme=%d is get", FEEDBACK_TYPE_SOUND, count_of_theme);
 358         feedback_deinitialize();
 359 }
 360
 361 bool TEST_FEEDBACK_GET_COUNT_OF_SOUND_THEME_INTERNAL(void)
 362 {
 363         INIT();
 364         test_get_count_of_sound_theme_internal();
 365         REPORT_AND_RETURN();
 366 }
 367
 368 static void test_get_sound_theme_id_internal(void)
 369 {
 370         unsigned int id_of_theme = 0;
 371
 372         feedback_initialize();
 373         RESULT(feedback_get_theme_id_internal(FEEDBACK_TYPE_SOUND, NULL),
 374                 FEEDBACK_ERROR_INVALID_PARAMETER, "invalid parameter");
 375         RESULT(feedback_get_theme_id_internal(FEEDBACK_TYPE_VIBRATION, &id_of_theme),
 376                 FEEDBACK_ERROR_NOT_SUPPORTED, "not supported");
 377         RESULT(feedback_get_theme_id_internal(FEEDBACK_TYPE_SOUND, &id_of_theme),
 378                 FEEDBACK_ERROR_NONE, "error none");
 379         _D("Feedback type=%d sound theme id=%d is get", FEEDBACK_TYPE_SOUND, id_of_theme);
 380         feedback_deinitialize();
 381 }
 382
 383 bool TEST_FEEDBACK_GET_SOUND_THEME_ID_INTERNAL(void)
 384 {
 385         INIT();
 386         test_get_sound_theme_id_internal();
 387         REPORT_AND_RETURN();
 388 }
 389
 390 static void test_set_sound_theme_id_internal(void)
 391 {
 392         unsigned int id = 0;
 393
 394         feedback_initialize();
 395         feedback_get_theme_id_internal(FEEDBACK_TYPE_SOUND, &id);
 396
 397         RESULT(feedback_set_theme_id_internal(FEEDBACK_TYPE_SOUND, id),
 398                 FEEDBACK_ERROR_NONE, "error none");
 399
 400         RESULT(feedback_set_theme_id_internal(FEEDBACK_TYPE_VIBRATION, id),
 401                 FEEDBACK_ERROR_NOT_SUPPORTED, "not supported");
 402
 403         feedback_deinitialize();
 404 }
 405
 406 bool TEST_FEEDBACK_SET_SOUND_THEME_ID_INTERNAL(void)
 407 {
 408         INIT();
 409         test_set_sound_theme_id_internal();
 410         REPORT_AND_RETURN();
 411 }
 412
 413 static void test_get_sound_theme_ids_internal(void)
 414 {
 415         unsigned int count_of_theme = 0;
 416         unsigned int *sound_theme_ids = NULL;
 417         int index = 0;
 418
 419         feedback_initialize();
 420         RESULT(feedback_get_theme_ids_internal(FEEDBACK_TYPE_VIBRATION, &count_of_theme, &sound_theme_ids),
 421                 FEEDBACK_ERROR_NOT_SUPPORTED, "not supported");
 422         RESULT(feedback_get_theme_ids_internal(FEEDBACK_TYPE_SOUND, NULL, NULL),
 423                 FEEDBACK_ERROR_INVALID_PARAMETER, "invalid parameter");
 424
 425         feedback_get_theme_ids_internal(FEEDBACK_TYPE_SOUND, &count_of_theme, &sound_theme_ids);
 426
 427         for (index = 0; index < count_of_theme; index++)
 428         {
 429                 _D("Feedback type=Sound, sound theme id=%d is get", sound_theme_ids[index]);
 430                 RESULT(feedback_set_theme_id_internal(FEEDBACK_TYPE_SOUND, sound_theme_ids[index]),
 431                         FEEDBACK_ERROR_NONE, "error none");
 432         }
 433
 434         feedback_deinitialize();
 435 }
 436
 437 bool TEST_FEEDBACK_GET_SOUND_THEME_IDS_INTERNAL(void)
 438 {
 439         INIT();
 440         test_get_sound_theme_ids_internal();
 441         REPORT_AND_RETURN();
 442 }
 443
 444 static void test_put_sound_theme_ids_internal(void)
 445 {
 446         unsigned int count_of_theme = 0;
 447         unsigned int *sound_theme_ids = NULL;
 448
 449         feedback_initialize();
 450         RESULT(feedback_put_theme_ids_internal(&sound_theme_ids),
 451                 FEEDBACK_ERROR_INVALID_PARAMETER, "invalid parameter");
 452         RESULT(feedback_put_theme_ids_internal(NULL),
 453                 FEEDBACK_ERROR_INVALID_PARAMETER, "invalid parameter");
 454
 455         feedback_get_theme_ids_internal(FEEDBACK_TYPE_SOUND, &count_of_theme, &sound_theme_ids);
 456         RESULT(feedback_put_theme_ids_internal(&sound_theme_ids),
 457                 FEEDBACK_ERROR_NONE, "error none");
 458         feedback_deinitialize();
 459 }
 460
 461 bool TEST_FEEDBACK_PUT_SOUND_THEME_IDS_INTERNAL(void)
 462 {
 463         INIT();
 464         test_put_sound_theme_ids_internal();
 465         REPORT_AND_RETURN();
 466 }
 467
 468 static void test_feedback_play_type_with_flags_internal(void)
 469 {
 470         feedback_initialize();
 471         RESULT(feedback_play_type_with_flags_internal(FEEDBACK_TYPE_SOUND, FEEDBACK_PATTERN_TAP, -1), FEEDBACK_ERROR_INVALID_PARAMETER, "invalid parameter");
 472         RESULT(feedback_play_type_with_flags_internal(FEEDBACK_TYPE_VIBRATION, FEEDBACK_PATTERN_TAP, FEEDBACK_FLAG_PRIORITY_BASED_PLAY), FEEDBACK_ERROR_OPERATION_FAILED, "operation failed");
 473         RESULT(feedback_play_type_with_flags_internal(FEEDBACK_TYPE_SOUND, FEEDBACK_PATTERN_TAP, FEEDBACK_FLAG_PRIORITY_BASED_PLAY), FEEDBACK_ERROR_NONE, "error none");
 474         RESULT(feedback_play_type_with_flags_internal(FEEDBACK_TYPE_SOUND, FEEDBACK_PATTERN_TAP, FEEDBACK_FLAG_NONE), FEEDBACK_ERROR_NONE, "error none");
 475         feedback_deinitialize();
 476 }
 477
 478 bool TEST_FEEDBACK_PLAY_TYPE_WITH_FLAGS_INTERNAL(void)
 479 {
 480         INIT();
 481         test_feedback_play_type_with_flags_internal();
 482         REPORT_AND_RETURN();
 483 }
 484
 485 void TEST_INTERNAL_INIT()
 486 {
 487         init_supported_pattern(FEEDBACK_TYPE_SOUND, pattern_s);
 488         init_supported_pattern(FEEDBACK_TYPE_VIBRATION, pattern_v);
 489         init_supported_pattern_i(FEEDBACK_TYPE_SOUND, pattern_i_s);
 490         init_supported_pattern_i(FEEDBACK_TYPE_VIBRATION, pattern_i_v);
 491 }