src/framework/test/src/suites/unit_test_fw_sequential_id_provider_suite.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <stdio.h>
  19 #include "utility/sync_util.h"
  20 #include "unit_test_common.h"
  21 #include "utility/fw_sequential_id_provider.h"
  22 #include "utility/fw_sequential_id_provider_internal.h"
  23 #include "suites/unit_test_fw_sequential_id_provider_suite.h"
  24
  25 #ifndef SYNC_AGENT_LOG
  26 #undef LOG_TAG
  27 #define LOG_TAG "AF_TEST"
  28 #endif
  29
  30 START_TEST(provide_id_without_delete_id_test1)
  31 {
  32         _EXTERN_FUNC_ENTER;
  33
  34         unsigned int max_id = 100;
  35         util_id_provider_s *pId_provider = util_create_id_provider(max_id, 12, true);
  36
  37         fail_unless(pId_provider->total_free_cnt == max_id + 1);
  38
  39         unsigned int i = 0;
  40         unsigned int id = 0;
  41         util_id_provider_error_e error = UTIL_ID_PROVIDER_OK;
  42
  43         for (i = 0; i <= max_id; i++) {
  44                 error = util_provide_id(pId_provider, &id);
  45                 fail_unless(error == UTIL_ID_PROVIDER_OK);
  46                 fail_unless(i == id);
  47                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
  48         }
  49
  50         error = util_provide_id(pId_provider, &id);
  51         fail_unless(error == UTIL_ID_PROVIDER_NOT_ENOUGH_ID);
  52         fail_unless(pId_provider->total_free_cnt == 0);
  53
  54         util_destroy_id_provider(pId_provider);
  55         fprintf(stderr, "%s\n", "provide_id_without_delete_id_test1 done");
  56
  57         _EXTERN_FUNC_EXIT;
  58 }
  59
  60 END_TEST START_TEST(provide_id_without_delete_id_test2)
  61 {
  62         _EXTERN_FUNC_ENTER;
  63
  64         unsigned int max_id = (1024 * 4) * 8;
  65         util_id_provider_s *pId_provider = util_create_id_provider(max_id, 12, true);
  66
  67         fail_unless(pId_provider->total_free_cnt == max_id + 1);
  68
  69         unsigned int i = 0;
  70         unsigned int id = 0;
  71         util_id_provider_error_e error = UTIL_ID_PROVIDER_OK;
  72         for (i = 0; i <= max_id; i++) {
  73                 error = util_provide_id(pId_provider, &id);
  74                 fail_unless(error == UTIL_ID_PROVIDER_OK);
  75                 fail_unless(i == id);
  76
  77                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
  78         }
  79
  80         error = util_provide_id(pId_provider, &id);
  81         fail_unless(error == UTIL_ID_PROVIDER_NOT_ENOUGH_ID);
  82         fail_unless(pId_provider->total_free_cnt == 0);
  83
  84         util_destroy_id_provider(pId_provider);
  85
  86         fprintf(stderr, "%s\n", "provide_id_without_delete_id_test2 done");
  87
  88         _EXTERN_FUNC_EXIT;
  89 }
  90
  91 END_TEST START_TEST(provide_id_without_delete_id_test3)
  92 {
  93         _EXTERN_FUNC_ENTER;
  94
  95         unsigned int max_id = (1024 * 4) * 8 * 2;
  96         util_id_provider_s *pId_provider = util_create_id_provider(max_id, 12, true);
  97
  98         fail_unless(pId_provider->total_free_cnt == max_id + 1);
  99
 100         unsigned int i = 0;
 101         unsigned int id = 0;
 102         util_id_provider_error_e error = UTIL_ID_PROVIDER_OK;
 103         for (i = 0; i <= max_id; i++) {
 104                 error = util_provide_id(pId_provider, &id);
 105                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 106                 fail_unless(i == id);
 107
 108                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
 109         }
 110
 111         error = util_provide_id(pId_provider, &id);
 112         fail_unless(error == UTIL_ID_PROVIDER_NOT_ENOUGH_ID);
 113         fail_unless(pId_provider->total_free_cnt == 0);
 114
 115         util_destroy_id_provider(pId_provider);
 116         fprintf(stderr, "%s\n", "provide_id_without_delete_id_test3 done");
 117
 118         _EXTERN_FUNC_EXIT;
 119 }
 120
 121 END_TEST START_TEST(provide_id_with_delete_id_test1)
 122 {
 123         _EXTERN_FUNC_ENTER;
 124
 125         unsigned int max_id = 100;
 126         util_id_provider_s *pId_provider = util_create_id_provider(max_id, 12, true);
 127
 128         fail_unless(pId_provider->total_free_cnt == max_id + 1);
 129
 130         unsigned int i = 0;
 131         unsigned int j = 0;
 132         unsigned int id = 0;
 133         util_id_provider_error_e error = UTIL_ID_PROVIDER_OK;
 134
 135         for (i = 0; i <= max_id / 10; i++) {
 136                 error = util_provide_id(pId_provider, &id);
 137                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 138                 fail_unless(i == id);
 139
 140                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
 141         }
 142
 143         for (j = 0; j <= max_id / 20; j++) {
 144                 fail_unless(UTIL_ID_PROVIDER_OK == util_delete_id(pId_provider, j));
 145                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (max_id / 10 + 1)) + j + 1);
 146         }
 147
 148         for (i = max_id / 10 + 1; i <= max_id; i++) {
 149                 error = util_provide_id(pId_provider, &id);
 150                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 151                 fail_unless(i == id);
 152
 153                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)) + max_id / 20 + 1);
 154         }
 155
 156         for (j = 0; j <= max_id / 20; j++) {
 157                 error = util_provide_id(pId_provider, &id);
 158                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 159                 fail_unless(j == id);
 160
 161                 fail_unless(pId_provider->total_free_cnt == (max_id / 20 - j));
 162         }
 163
 164         error = util_provide_id(pId_provider, &id);
 165         fail_unless(error == UTIL_ID_PROVIDER_NOT_ENOUGH_ID);
 166         fail_unless(pId_provider->total_free_cnt == 0);
 167
 168         fail_unless(UTIL_ID_PROVIDER_OK == util_delete_id(pId_provider, 50));
 169         fail_unless(pId_provider->total_free_cnt == 1);
 170
 171         fail_unless(UTIL_ID_PROVIDER_NOT_EXIST_ID == util_delete_id(pId_provider, 50));
 172         fail_unless(pId_provider->total_free_cnt == 1);
 173
 174         fail_unless(UTIL_ID_PROVIDER_OUT_OF_ID_RANGE == util_delete_id(pId_provider, 101));
 175         fail_unless(UTIL_ID_PROVIDER_OUT_OF_ID_RANGE == util_delete_id(pId_provider, 102));
 176         fail_unless(UTIL_ID_PROVIDER_OUT_OF_ID_RANGE == util_delete_id(pId_provider, 2000));
 177
 178         util_destroy_id_provider(pId_provider);
 179         fprintf(stderr, "%s\n", "provide_id_with_delete_id_test1 done");
 180
 181         _EXTERN_FUNC_EXIT;
 182 }
 183
 184 END_TEST START_TEST(provide_id_with_delete_id_test2)
 185 {
 186         _EXTERN_FUNC_ENTER;
 187
 188         unsigned int max_id = (1024 * 4) * 8;
 189         util_id_provider_s *pId_provider = util_create_id_provider(max_id, 12, true);
 190
 191         fail_unless(pId_provider->total_free_cnt == max_id + 1);
 192
 193         unsigned int i = 0;
 194         unsigned int j = 0;
 195         unsigned int id = 0;
 196         util_id_provider_error_e error = UTIL_ID_PROVIDER_OK;
 197
 198         for (i = 0; i <= max_id / 10; i++) {
 199                 error = util_provide_id(pId_provider, &id);
 200                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 201                 fail_unless(i == id);
 202
 203                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
 204         }
 205
 206         for (j = 0; j <= max_id / 20; j++) {
 207                 fail_unless(UTIL_ID_PROVIDER_OK == util_delete_id(pId_provider, j));
 208                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (max_id / 10 + 1)) + j + 1);
 209         }
 210
 211         for (i = max_id / 10 + 1; i <= max_id; i++) {
 212                 error = util_provide_id(pId_provider, &id);
 213                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 214                 fail_unless(i == id);
 215
 216                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)) + max_id / 20 + 1);
 217         }
 218
 219         for (j = max_id / 2; j <= max_id; j++) {
 220                 fail_unless(UTIL_ID_PROVIDER_OK == util_delete_id(pId_provider, j));
 221                 fail_unless(pId_provider->total_free_cnt == max_id / 20 + 1 + (j - max_id / 2) + 1);
 222         }
 223
 224         for (j = 0; j <= max_id / 20; j++) {
 225                 error = util_provide_id(pId_provider, &id);
 226                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 227                 fail_unless(j == id);
 228
 229                 fail_unless(pId_provider->total_free_cnt == max_id / 20 + 1 + (max_id - max_id / 2) + 1 - (j + 1));
 230         }
 231
 232         for (j = max_id / 2; j <= max_id; j++) {
 233                 error = util_provide_id(pId_provider, &id);
 234                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 235                 fail_unless(j == id);
 236
 237                 fail_unless(pId_provider->total_free_cnt == max_id / 20 + 1 + (max_id - max_id / 2) + 1 - (max_id / 20 + 1) - (j - max_id / 2 + 1));
 238         }
 239
 240         error = util_provide_id(pId_provider, &id);
 241         fail_unless(error == UTIL_ID_PROVIDER_NOT_ENOUGH_ID);
 242         fail_unless(pId_provider->total_free_cnt == 0);
 243
 244         fail_unless(UTIL_ID_PROVIDER_OK == util_delete_id(pId_provider, 50));
 245         fail_unless(pId_provider->total_free_cnt == 1);
 246
 247         fail_unless(UTIL_ID_PROVIDER_NOT_EXIST_ID == util_delete_id(pId_provider, 50));
 248         fail_unless(pId_provider->total_free_cnt == 1);
 249
 250         fail_unless(UTIL_ID_PROVIDER_OUT_OF_ID_RANGE == util_delete_id(pId_provider, max_id + 1));
 251         fail_unless(UTIL_ID_PROVIDER_OUT_OF_ID_RANGE == util_delete_id(pId_provider, max_id + 2));
 252         fail_unless(UTIL_ID_PROVIDER_OUT_OF_ID_RANGE == util_delete_id(pId_provider, max_id + 1000));
 253
 254         util_destroy_id_provider(pId_provider);
 255         fprintf(stderr, "%s\n", "provide_id_with_delete_id_test2 done");
 256
 257         _EXTERN_FUNC_EXIT;
 258 }
 259
 260 END_TEST START_TEST(provide_id_without_unchanged_list)
 261 {
 262         _EXTERN_FUNC_ENTER;
 263
 264         unsigned int page_bit_cnt = (1024 * 4) * 8;
 265         unsigned int max_id = 3 * page_bit_cnt - 1;
 266         util_id_provider_s *pId_provider = util_create_id_provider(max_id, 12, true);
 267
 268         unsigned int i = 0;
 269         unsigned int id = 0;
 270
 271         util_id_provider_error_e error = UTIL_ID_PROVIDER_OK;
 272         fail_unless(pId_provider->total_free_cnt == max_id + 1);
 273
 274         for (i = 0; i < page_bit_cnt; i++) {
 275                 error = util_provide_id(pId_provider, &id);
 276                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 277                 fail_unless(i == id);
 278                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
 279
 280                 fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 1);
 281                 fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 282                 fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 0);
 283                 fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 0);
 284         }
 285
 286         for (i = page_bit_cnt; i < 2 * page_bit_cnt; i++) {
 287                 error = util_provide_id(pId_provider, &id);
 288                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 289                 fail_unless(i == id);
 290                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
 291
 292                 fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 2);
 293                 fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 294                 fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 0);
 295                 fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 0);
 296         }
 297
 298         for (i = 2 * page_bit_cnt; i < 3 * page_bit_cnt; i++) {
 299                 error = util_provide_id(pId_provider, &id);
 300                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 301                 fail_unless(i == id);
 302                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
 303
 304                 fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 3);
 305                 fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 306                 fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 0);
 307                 fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 0);
 308         }
 309
 310         for (i = 0; i < page_bit_cnt - 1; i++) {
 311                 error = util_delete_id(pId_provider, i);
 312                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 313                 fail_unless(pId_provider->total_free_cnt == (i + 1));
 314
 315                 fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 3);
 316                 fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 317                 fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 0);
 318                 fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 0);
 319         }
 320
 321         error = util_delete_id(pId_provider, page_bit_cnt - 1);
 322         fail_unless(error == UTIL_ID_PROVIDER_OK);
 323         fail_unless(pId_provider->total_free_cnt == page_bit_cnt);
 324
 325         fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 2);
 326         fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 327         fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 0);
 328         fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 0);
 329
 330         util_destroy_id_provider(pId_provider);
 331
 332         _EXTERN_FUNC_EXIT;
 333 }
 334
 335 END_TEST START_TEST(provide_id_with_unchanged_list)
 336 {
 337         _EXTERN_FUNC_ENTER;
 338
 339         unsigned int page_bit_cnt = (1024 * 4) * 8;
 340         unsigned int max_id = 4 * page_bit_cnt - 1;
 341         util_id_provider_s *pId_provider = util_create_id_provider(max_id, 12, true);
 342
 343         unsigned int i = 0;
 344         unsigned int id = 0;
 345
 346         util_id_provider_error_e error = UTIL_ID_PROVIDER_OK;
 347         fail_unless(pId_provider->total_free_cnt == max_id + 1);
 348
 349         /* prepare test */
 350         for (i = 0; i < page_bit_cnt; i++) {
 351                 error = util_provide_id(pId_provider, &id);
 352                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 353                 fail_unless(i == id);
 354                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
 355
 356                 fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 1);
 357                 fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 358                 fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 0);
 359                 fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 0);
 360         }
 361
 362         for (i = page_bit_cnt; i < 2 * page_bit_cnt; i++) {
 363                 error = util_provide_id(pId_provider, &id);
 364                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 365                 fail_unless(i == id);
 366                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
 367
 368                 fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 2);
 369                 fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 370                 fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 0);
 371                 fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 0);
 372         }
 373
 374         for (i = 2 * page_bit_cnt; i < 3 * page_bit_cnt; i++) {
 375                 error = util_provide_id(pId_provider, &id);
 376                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 377                 fail_unless(i == id);
 378                 fail_unless(pId_provider->total_free_cnt == (max_id + 1 - (i + 1)));
 379
 380                 fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 3);
 381                 fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 382                 fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 0);
 383                 fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 0);
 384         }
 385
 386         /* move all add list to unchaged list for test */
 387         util_id_provider_move_id_page(pId_provider, pId_provider->id_page_array[0], UTIL_ID_PAGE_FLAG_UNCHANGED);
 388         util_id_provider_move_id_page(pId_provider, pId_provider->id_page_array[1], UTIL_ID_PAGE_FLAG_UNCHANGED);
 389         util_id_provider_move_id_page(pId_provider, pId_provider->id_page_array[2], UTIL_ID_PAGE_FLAG_UNCHANGED);
 390
 391         fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 0);
 392         fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 393         fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 0);
 394         fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 3);
 395
 396         /* test started from here */
 397         for (i = 0; i < page_bit_cnt - 1; i++) {
 398                 error = util_delete_id(pId_provider, i);
 399                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 400                 fail_unless(pId_provider->total_free_cnt == page_bit_cnt + (i + 1));
 401
 402                 fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 0);
 403                 fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 1);
 404                 fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 0);
 405                 fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 2);
 406         }
 407
 408         error = util_delete_id(pId_provider, page_bit_cnt - 1);
 409         fail_unless(error == UTIL_ID_PROVIDER_OK);
 410         fail_unless(pId_provider->total_free_cnt == 2 * page_bit_cnt);
 411
 412         fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 0);
 413         fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 414         fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 1);
 415         fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 2);
 416
 417         for (i = 3 * page_bit_cnt; i < 4 * page_bit_cnt; i++) {
 418                 error = util_provide_id(pId_provider, &id);
 419                 fail_unless(error == UTIL_ID_PROVIDER_OK);
 420                 fail_unless(i == id);
 421                 fail_unless(pId_provider->total_free_cnt == (2 * page_bit_cnt - (i - 3 * page_bit_cnt + 1)));
 422
 423                 fail_unless(list_count(&(pId_provider->pTracking->id_page_add_list_head)) == 1);
 424                 fail_unless(list_count(&(pId_provider->pTracking->id_page_update_list_head)) == 0);
 425                 fail_unless(list_count(&(pId_provider->pTracking->id_page_delete_list_head)) == 1);
 426                 fail_unless(list_count(&(pId_provider->pTracking->id_page_unchanged_list_head)) == 2);
 427         }
 428
 429         util_destroy_id_provider(pId_provider);
 430
 431         _EXTERN_FUNC_EXIT;
 432 s}
 433
 434 END_TEST Suite *fw_sequential_id_provider_suite(void)
 435 {
 436         _EXTERN_FUNC_ENTER;
 437
 438         /* create test suite */
 439         Suite *s = suite_create("fw_sequential_id_provider_suite");
 440
 441         /* test case create and add in suite */
 442         {
 443                 TCase *tcase = tcase_create("provide_id_without_delete_id");
 444
 445                 tcase_add_test(tcase, provide_id_without_delete_id_test1);
 446                 tcase_add_test(tcase, provide_id_without_delete_id_test2);
 447                 tcase_add_test(tcase, provide_id_without_delete_id_test3);
 448
 449                 tcase_set_timeout(tcase, 1);
 450
 451                 suite_add_tcase(s, tcase);
 452         }
 453
 454         /* create another test case and add to test suite just like above code */
 455         {
 456                 TCase *tcase = tcase_create("provide_id_with_delete_id");
 457                 tcase_add_test(tcase, provide_id_with_delete_id_test1);
 458                 tcase_add_test(tcase, provide_id_with_delete_id_test2);
 459                 tcase_set_timeout(tcase, 1);
 460                 suite_add_tcase(s, tcase);
 461         }
 462
 463         /* create another test case and add to test suite just like above code */
 464         {
 465                 TCase *tcase = tcase_create("provide_id_tracking_mode");
 466                 tcase_add_test(tcase, provide_id_without_unchanged_list);
 467                 tcase_add_test(tcase, provide_id_with_unchanged_list);
 468                 tcase_set_timeout(tcase, 1);
 469                 suite_add_tcase(s, tcase);
 470         }
 471
 472         _EXTERN_FUNC_EXIT;
 473
 474         return s;
 475 }