test/tc-privilege-info.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <privilege_info.h>
   4 #include <tc-common.h>
   5
   6 static void __check_get_privilege_display_name_result(privilege_manager_error_e expected_result, privilege_manager_error_e result, const char *display_name)
   7 {
   8         printf("expected result = %s, result = %s\n", __get_result_string('m', expected_result), __get_result_string('m', result));
   9
  10         if (expected_result != result) {
  11                 printf("not matched\n");
  12                 printf_red("test fail\n");
  13                 fail_cnt++;
  14         } else {
  15                 printf("matched\n");
  16                 if (result == PRVMGR_ERR_NONE) {
  17                         printf("display_name = %s\n", display_name);
  18                 } else {
  19                         if (display_name != NULL) {
  20                                 printf("display_name = %s\n", display_name);
  21                                 printf("display_name must be NULL\n");
  22                                 printf_red("test fail\n");
  23                                 fail_cnt++;
  24                                 return;
  25                         }
  26                 }
  27                 printf_green("test success\n");
  28                 success_cnt++;
  29         }
  30 }
  31
  32 static void __check_get_privilege_description_result(privilege_manager_error_e expected_result, privilege_manager_error_e result, const char *description)
  33 {
  34         printf("expected result = %s, result = %s\n", __get_result_string('m', expected_result), __get_result_string('m', result));
  35
  36         if (expected_result != result) {
  37                 printf("not matched\n");
  38                 printf_red("test fail\n");
  39                 fail_cnt++;
  40         } else {
  41                 printf("matched\n");
  42                 if (result == PRVMGR_ERR_NONE) {
  43                         printf("description = %s\n", description);
  44                 } else {
  45                         if (description != NULL) {
  46                                 printf("description = %s\n", description);
  47                                 printf("description must be NULL\n");
  48                                 printf_red("test fail\n");
  49                                 fail_cnt++;
  50                                 return;
  51                         }
  52                 }
  53                 printf_green("test success\n");
  54                 success_cnt++;
  55         }
  56 }
  57
  58 static void __check_get_privilege_group_display_name_result(privilege_manager_error_e expected_result, privilege_manager_error_e result, const char *group_name)
  59 {
  60         printf("expected result = %s, result = %s\n", __get_result_string('m', expected_result), __get_result_string('m', result));
  61
  62         if (expected_result != result) {
  63                 printf("not matched\n");
  64                 printf_red("test fail\n");
  65                 fail_cnt++;
  66         } else {
  67                 printf("matched\n");
  68
  69                 if (result == PRVMGR_ERR_NONE) {
  70                         if (group_name == NULL) {
  71                                 printf("group_name must not be NULL\n");
  72                                 printf_red("test fail\n");
  73                                 fail_cnt++;
  74                                 return;
  75                         } else {
  76                                 printf("group_name = %s\n", group_name);
  77                         }
  78                 } else {
  79                         if (group_name != NULL) {
  80                                 printf("group_name = %s\n", group_name);
  81                                 printf("group_name must be NULL\n");
  82                                 printf_red("test fail\n");
  83                                 fail_cnt++;
  84                                 return;
  85                         }
  86                 }
  87                 printf_green("test success\n");
  88                 success_cnt++;
  89         }
  90 }
  91
  92 static void __test_privilege_info_is_valid()
  93 {
  94         int ret;
  95         printf("privilege : http://tizen.org/privilege/account.read\n");
  96         ret = privilege_info_is_valid("http://tizen.org/privilege/account.read");
  97         if (ret == 1) {
  98                 success_cnt++;
  99                 printf_green("SUCCESS: http://tizen.org/privilege/account.read is valid\n");
 100         } else {
 101                 fail_cnt++;
 102                 printf_red("Test FAILED. ret =  %d\n", ret);
 103         }
 104         __print_line();
 105
 106         printf("privilege : http://tizen.org/privilege/internal/default/public\n");
 107         ret = privilege_info_is_valid("http://tizen.org/privilege/internal/default/public");
 108         if (ret == 1) {
 109                 success_cnt++;
 110                 printf_green("SUCCESS: http://tizen.org/privilege/internal/default/public is valid\n");
 111         } else {
 112                 fail_cnt++;
 113                 printf_red("Test FAILED. ret =  %d\n", ret);
 114         }
 115         __print_line();
 116
 117         printf("privilege : http://tizen.org/privilege/internettttttt\n");
 118         ret = privilege_info_is_valid("http://tizen.org/privilege/internettttttt");
 119         if (ret == 0) {
 120                 success_cnt++;
 121                 printf_green("SUCCESS: http://tizen.org/privilege/internettttttt is invalid\n");
 122         } else {
 123                 fail_cnt++;
 124                 printf_red("Test FAILED. ret = %d\n", ret);
 125         }
 126         __print_line();
 127
 128 }
 129
 130 static void __test_privilege_info_is_internal()
 131 {
 132         int ret;
 133         printf("privilege : http://tizen.org/privilege/internal/default/public\n");
 134         ret = privilege_info_is_internal("http://tizen.org/privilege/internal/default/public");
 135         if (ret == 1) {
 136                 success_cnt++;
 137                 printf_green("SUCCESS: http://tizen.org/privilege/internal/default/public is internal\n");
 138         } else {
 139                 fail_cnt++;
 140                 printf_red("Test FAILED. ret =  %d\n", ret);
 141         }
 142         __print_line();
 143
 144         printf("privilege : http://tizen.org/privilege/internal/dbus\n");
 145         ret = privilege_info_is_internal("http://tizen.org/privilege/internal/dbus");
 146         if (ret == 1) {
 147                 success_cnt++;
 148                 printf_green("SUCCESS: http://tizen.org/privilege/internal/dbus is internal\n");
 149         } else {
 150                 fail_cnt++;
 151                 printf_red("Test FAILED. ret = %d\n", ret);
 152         }
 153         __print_line();
 154
 155         printf("privilege : http://tizen.org/privilege/internet\n");
 156         ret = privilege_info_is_internal("http://tizen.org/privilege/internet");
 157         if (ret == 0) {
 158                 success_cnt++;
 159                 printf_green("SUCCESS: http://tizen.org/privilege/internet is NOT internal\n");
 160         } else {
 161                 fail_cnt++;
 162                 printf_red("Test FAILED. ret = %d\n", ret);
 163         }
 164         __print_line();
 165         printf("privilege : http://tizen.org/privilege/internettttt\n");
 166         ret = privilege_info_is_internal("http://tizen.org/privilege/internettttt");
 167         if (ret == 0) {
 168                 success_cnt++;
 169                 printf_green("SUCCESS: http://tizen.org/privilege/internettttt is NOT internal\n");
 170         } else {
 171                 fail_cnt++;
 172                 printf_red("Test FAILED. ret = %d\n", ret);
 173         }
 174         __print_line();
 175 }
 176 static void __test_privilege_info_is_privacy()
 177 {
 178         int ret;
 179         printf("privilege : http://tizen.org/privilege/account.read\n");
 180         ret = privilege_info_is_privacy("http://tizen.org/privilege/account.read");
 181         if (ret == 1) {
 182                 success_cnt++;
 183                 printf_green("SUCCESS: http://tizen.org/privilege/account.read is PRIVACY\n");
 184         } else {
 185                 fail_cnt++;
 186                 printf_red("Test FAILED. ret =  %d\n", ret);
 187         }
 188         __print_line();
 189
 190         printf("privilege : http://tizen.org/privilege/internet\n");
 191         ret = privilege_info_is_privacy("http://tizen.org/privilege/internet");
 192         if (ret == 0) {
 193                 success_cnt++;
 194                 printf_green("SUCCESS: http://tizen.org/privilege/internet is NOT PRIVACY\n");
 195         } else {
 196                 fail_cnt++;
 197                 printf_red("Test FAILED. ret = %d\n", ret);
 198         }
 199         __print_line();
 200
 201         /* Do not treat internal privileges as privacy related
 202         printf("privilege : http://tizen.org/privilege/internal/buxton/account.read\n");
 203         ret = privilege_info_is_privacy("http://tizen.org/privilege/internal/buxton/account.read");
 204         if (ret == 1) {
 205                 success_cnt++;
 206                 printf("SUCCESS: http://tizen.org/privilege/internal/buxton/account.read is PRIVACY\n");
 207         } else {
 208                 fail_cnt++;
 209                 printf("Test FAILED. ret = %d\n", ret);
 210         }
 211         __print_line();*/
 212
 213         printf("privilege : http://tizen.org/privilege/internettttt\n");
 214         ret = privilege_info_is_privacy("http://tizen.org/privilege/internettttt");
 215         if (ret == 0) {
 216                 success_cnt++;
 217                 printf_green("SUCCESS: http://tizen.org/privilege/internettttt is NOT PRIVACY\n");
 218         } else {
 219                 fail_cnt++;
 220                 printf_red("Test FAILED. ret = %d\n", ret);
 221         }
 222         __print_line();
 223 }
 224
 225 static void __test_privilege_info_get_privacy_display()
 226 {
 227         char* privacy_display = NULL;
 228         int ret;
 229
 230         printf("VALID privacy: http://tizen.org/privacy/account\n");
 231         ret = privilege_info_get_privacy_display("http://tizen.org/privacy/account", &privacy_display);
 232         if (ret == PRVMGR_ERR_NONE && privacy_display != NULL) {
 233                 success_cnt++;
 234                 printf_green("SUCCESS: privacy_display = %s\n", privacy_display);
 235         } else {
 236                 fail_cnt++;
 237                 printf_red("FAIL: ret = %d, privacy_display = %s\n", ret, privacy_display);
 238         }
 239
 240         free(privacy_display);
 241         privacy_display = NULL;
 242
 243         printf("WRONG privacy: http://tizen.org/privilege/account.read\n");
 244         ret = privilege_info_get_privacy_display("http://tizen.org/privilege/account.read", &privacy_display);
 245         if (ret == PRVMGR_ERR_INVALID_PARAMETER && privacy_display == NULL) {
 246                 success_cnt++;
 247                 printf_green("SUCCESS\n");
 248         } else {
 249                 fail_cnt++;
 250                 printf_red("FAIL: ret = %d, privacy_display = %s\n", ret, privacy_display);
 251         }
 252
 253         free(privacy_display);
 254         privacy_display = NULL;
 255
 256         printf("NULL param\n");
 257         ret = privilege_info_get_privacy_display(NULL, &privacy_display);
 258         if (ret == PRVMGR_ERR_INVALID_PARAMETER && privacy_display == NULL) {
 259                 success_cnt++;
 260                 printf_green("SUCCESS\n");
 261         } else {
 262                 fail_cnt++;
 263                 printf_red("FAIL: ret = %d, privacy_display = %s\n", ret, privacy_display);
 264         }
 265
 266         free(privacy_display);
 267 }
 268
 269 static void __test_privilege_info_get_privacy_list()
 270 {
 271         GList* privacy_list = NULL;
 272         GList* l;
 273         int ret = privilege_info_get_privacy_list(&privacy_list);
 274         if (ret == 0) {
 275                 success_cnt++;
 276                 for (l = privacy_list; l != NULL; l = l->next) {
 277                         char *privacy_name = (char*)l->data;
 278                         printf("%s\n", privacy_name);
 279                 }
 280                 printf_green("Test SUCCEEDED\n");
 281         } else {
 282                 fail_cnt++;
 283                 printf_red("Test FAILED\n");
 284         }
 285         gfree(privacy_list);
 286         __print_line();
 287 }
 288
 289 static void __test_privilege_info_get_privilege_list_by_privacy()
 290 {
 291         GList* privilege_list = NULL;
 292         GList* l;
 293         printf("privacy : http://tizen.org/privacy/account\n");
 294         int ret = privilege_info_get_privilege_list_by_privacy("http://tizen.org/privacy/account", &privilege_list);
 295         if (ret == 0) {
 296                 success_cnt++;
 297                 for (l = privilege_list; l != NULL; l = l->next) {
 298                         char *privilege_name = (char*)l->data;
 299                         printf("%s\n", privilege_name);
 300                 }
 301                 printf_green("Test SUCCEEDED\n");
 302         } else {
 303                 fail_cnt++;
 304                 printf_red("Test FAILED\n");
 305         }
 306
 307         if (privilege_list != NULL)
 308                 gfree(privilege_list);
 309
 310         __print_line();
 311
 312         printf("privacy : http://tizen.org/privacy/location\n");
 313         ret = privilege_info_get_privilege_list_by_privacy("http://tizen.org/privacy/location", &privilege_list);
 314         if (ret == 0) {
 315                 success_cnt++;
 316                 for (l = privilege_list; l != NULL; l = l->next) {
 317                         char *privilege_name = (char*)l->data;
 318                         printf("%s\n", privilege_name);
 319                 }
 320                 printf_green("Test SUCCEEDED\n");
 321         } else {
 322                 fail_cnt++;
 323                 printf_red("Test FAILED\n");
 324         }
 325
 326         if (privilege_list != NULL)
 327                 gfree(privilege_list);
 328
 329         __print_line();
 330
 331         printf("privacy : http://tizen.org/privacy/userhistory\n");
 332         ret = privilege_info_get_privilege_list_by_privacy("http://tizen.org/privacy/userhistory", &privilege_list);
 333         if (ret == 0) {
 334                 success_cnt++;
 335                 for (l = privilege_list; l != NULL; l = l->next) {
 336                         char *privilege_name = (char*)l->data;
 337                         printf("%s\n", privilege_name);
 338                 }
 339                 printf_green("Test SUCCEEDED\n");
 340         } else {
 341                 fail_cnt++;
 342                 printf_red("Test FAILED\n");
 343         }
 344
 345         gfree(privilege_list);
 346
 347         __print_line();
 348 }
 349
 350 static void __test_privilege_info_get_privacy_by_privilege()
 351 {
 352         printf("privilege : http://tizen.org/privilege/apphistory.read\n");
 353         char* privacy = NULL;
 354         int ret = privilege_info_get_privacy_by_privilege("http://tizen.org/privilege/apphistory.read", &privacy);
 355         if (ret == PRVMGR_ERR_NONE) {
 356                 success_cnt++;
 357                 printf_green("Test SUCCEEDED, privacy id: %s\n", privacy);
 358         } else {
 359                 fail_cnt++;
 360                 printf_red("Test FAILED\n");
 361         }
 362
 363         free(privacy);
 364         privacy = NULL;
 365
 366         __print_line();
 367
 368         printf("privilege : http://tizen.org/privilege/internet\n");
 369         ret = privilege_info_get_privacy_by_privilege("http://tizen.org/privilege/internet", &privacy);
 370         if (ret == PRVMGR_ERR_INVALID_PARAMETER) {
 371                 success_cnt++;
 372                 printf_green("Test SUCCEEDED, privilege: http://tizen.org/privilege/internet is not a privacy related.\n");
 373         } else {
 374                 fail_cnt++;
 375                 printf_red("Test FAILED\n");
 376         }
 377         free(privacy);
 378         __print_line();
 379 }
 380
 381 static void __test_privilege_info_get_privilege_display_name()
 382 {
 383         int ret;
 384         char *display_name = NULL;
 385
 386         printf("privilege : http://tizen.org/privilege/account.read\n");
 387         display_name = NULL;
 388         ret = privilege_info_get_privilege_display_name("http://tizen.org/privilege/account.read", &display_name);
 389         __check_get_privilege_display_name_result(PRVMGR_ERR_NONE, ret, display_name);
 390         free(display_name);
 391         __print_line();
 392
 393         printf("privilege : http://tizen.org/privilege/badge.admin\n");
 394         display_name = NULL;
 395         ret = privilege_info_get_privilege_display_name("http://tizen.org/privilege/badge.admin", &display_name);
 396         __check_get_privilege_display_name_result(PRVMGR_ERR_NONE, ret, display_name);
 397         free(display_name);
 398         __print_line();
 399
 400         printf("privilege : http://tizen.org/privilege/accousdfsdnt.resdfsdfad\n");
 401         display_name = NULL;
 402         ret = privilege_info_get_privilege_display_name("http://tizen.org/privilege/accousdfsdnt.resdfsdfad", &display_name);
 403         __check_get_privilege_display_name_result(PRVMGR_ERR_NONE, ret, display_name);
 404         free(display_name);
 405         __print_line();
 406
 407         printf("privilege : NULL\n");
 408         display_name = NULL;
 409         ret = privilege_info_get_privilege_display_name(NULL, &display_name);
 410         __check_get_privilege_display_name_result(PRVMGR_ERR_INVALID_PARAMETER, ret, display_name);
 411         free(display_name);
 412         __print_line();
 413 }
 414
 415 static void __test_privilege_info_get_privilege_description()
 416 {
 417         int ret;
 418         char *description = NULL;
 419
 420         printf("privilege : http://tizen.org/privilege/account.read\n");
 421         ret = privilege_info_get_privilege_description("http://tizen.org/privilege/account.read", &description);
 422         __check_get_privilege_description_result(PRVMGR_ERR_NONE, ret, description);
 423         __print_line();
 424
 425         printf("privilege : http://tizen.org/privilege/badge.admin\n");
 426         if (description != NULL) {
 427                 free(description);
 428                 description = NULL;
 429         }
 430         ret = privilege_info_get_privilege_description("http://tizen.org/privilege/badge.admin", &description);
 431         __check_get_privilege_description_result(PRVMGR_ERR_NONE, ret, description);
 432         __print_line();
 433
 434         printf("privilege : http://tizen.org/privilege/accousdfsdnt.resdfsdfad\n");
 435         if (description != NULL) {
 436                 free(description);
 437                 description = NULL;
 438         }
 439         ret = privilege_info_get_privilege_description("http://tizen.org/privilege/accousdfsdnt.resdfsdfad", &description);
 440         __check_get_privilege_description_result(PRVMGR_ERR_NONE, ret, description);
 441         __print_line();
 442
 443         printf("privilege : NULL\n");
 444         if (description != NULL) {
 445                 free(description);
 446                 description = NULL;
 447         }
 448         ret = privilege_info_get_privilege_description(NULL, &description);
 449         __check_get_privilege_description_result(PRVMGR_ERR_INVALID_PARAMETER, ret, description);
 450         free(description);
 451         __print_line();
 452 }
 453
 454 static void __test_privilege_info_get_privilege_group_display_name()
 455 {
 456         int ret;
 457         char *group_name = NULL;
 458
 459         printf("privilege : http://tizen.org/privilege/group/group0\n");
 460         ret = privilege_info_get_privilege_group_display_name("http://tizen.org/privilege/group/group0", &group_name);
 461         __check_get_privilege_group_display_name_result(PRVMGR_ERR_NONE, ret, group_name);
 462         free(group_name);
 463
 464         printf("privilege : http://tizen.org/privilege/group/group01232\n");
 465         group_name = NULL;
 466         ret = privilege_info_get_privilege_group_display_name("http://tizen.org/privilege/group/group01232", &group_name);
 467         __check_get_privilege_group_display_name_result(PRVMGR_ERR_NONE, ret, group_name);
 468         free(group_name);
 469
 470         printf("privilege : unknowngroup\n");
 471         group_name = NULL;
 472         ret = privilege_info_get_privilege_group_display_name("unknowngroup", &group_name);
 473         __check_get_privilege_group_display_name_result(PRVMGR_ERR_NONE, ret, group_name);
 474         free(group_name);
 475
 476         printf("privilege : NULL\n");
 477         group_name = NULL;
 478         ret = privilege_info_get_privilege_group_display_name(NULL, &group_name);
 479         __check_get_privilege_group_display_name_result(PRVMGR_ERR_INVALID_PARAMETER, ret, group_name);
 480         free(group_name);
 481
 482 }
 483
 484 static void __test_privilege_info_get_privilege_type()
 485 {
 486         int ret = 0;
 487         int test = 0;
 488         privilege_manager_privilege_type_e type;
 489
 490         __print_line();
 491         printf("uid = 5001\n");
 492         printf("pkgid = org.tizen.contacts\norg.tizen.contacts");
 493         printf("privilege = http://tizen.org/privilege/internet\n");
 494         printf("expected type = PRIVILEGE_MANAGER_PRIVILEGE_TYPE_NORMAL\n");
 495         ret = privilege_info_get_privilege_type(5001, "org.tizen.contacts", "http://tizen.org/privilege/internet", &type);
 496         if (ret == PRVMGR_ERR_NONE && type == PRIVILEGE_MANAGER_PRIVILEGE_TYPE_NORMAL) {
 497                 success_cnt++;
 498                 printf_green("success\n");
 499         } else {
 500                 fail_cnt++;
 501                 printf_red("fail. ret = %s, type = %s\n", __get_result_string('m', ret), __get_privilege_type_string(type));
 502         }
 503
 504         __print_line();
 505         printf("uid = 201\n");
 506         printf("pkgid = org.tizen.camera-app\n");
 507         printf("privilege = http://tizen.org/privilege/location\n");
 508         ret = privilege_info_get_privilege_type(201, "org.tizen.camera-app", "http://tizen.org/privilege/location", &type);
 509         if (DISABLE_ASKUSER) {
 510                 printf("expected type = PRIVILEGE_MANAGER_PRIVILEGE_TYPE_NORMAL\n");
 511                 test = (ret == PRVMGR_ERR_NONE && type == PRIVILEGE_MANAGER_PRIVILEGE_TYPE_NORMAL);
 512         } else {
 513                 printf("expected type = PRIVILEGE_MANAGER_PRIVILEGE_TYPE_PRIVACY\n");
 514                 test = (ret == PRVMGR_ERR_NONE && type == PRIVILEGE_MANAGER_PRIVILEGE_TYPE_PRIVACY);
 515         }
 516         if (test) {
 517                 success_cnt++;
 518                 printf_green("success\n");
 519         } else {
 520                 fail_cnt++;
 521                 printf_red("fail. ret = %s, type = %s\n", __get_result_string('m', ret), __get_privilege_type_string(type));
 522         }
 523
 524         __print_line();
 525         printf("uid = 0\n");
 526         printf("pkgid = org.tizen.testtest\n");
 527         printf("privilege = http://tizen.org/privilege/yyyyy\n");
 528         printf("set mdm black list for above condition\n");
 529         gfree(privilege_list);
 530         __print_line();
 531         __privinfo("http://tizen.org/privilege/yyyyy", NULL, NULL);
 532         __tcinfo(expect, PRVMGR_ERR_NONE);
 533         ret = privilege_manager_set_mdm_black_list(0, privilege_list);
 534         __print_result('m', ret);
 535         __print_line();
 536         printf("check privilege type\n");
 537         ret = privilege_info_get_privilege_type(0, "org.tizen.testtest", "http://tizen.org/privilege/yyyyy", &type);
 538         printf("expected type = PRIVILEGE_MANAGER_PRIVILEGE_TYPE_BLACKLIST\n");
 539         if (ret == PRVMGR_ERR_NONE && type == PRIVILEGE_MANAGER_PRIVILEGE_TYPE_BLACKLIST) {
 540                 success_cnt++;
 541                 printf_green("success\n");
 542         } else {
 543                 fail_cnt++;
 544                 printf_red("fail. ret = %s, type = %s\n", __get_result_string('m', ret), __get_privilege_type_string(type));
 545         }
 546         __print_line();
 547         printf("unset mdm black list for above condition\n");
 548         __tcinfo(expect, PRVMGR_ERR_NONE);
 549         ret = privilege_manager_unset_mdm_black_list(0, privilege_list);
 550         __print_result('m', ret);
 551         gfree(privilege_list);
 552
 553         __print_line();
 554         printf("uid = 5001\n");
 555         printf("pkgid = NULL\n");
 556         printf("privilege = \n");
 557         ret = privilege_info_get_privilege_type(5001, NULL, NULL, &type);
 558         printf("expected ret = PRVMGR_ERR_INVALID_PARAMETER\n");
 559         if (ret == PRVMGR_ERR_INVALID_PARAMETER) {
 560                 success_cnt++;
 561                 printf_green("success\n");
 562         } else {
 563                 fail_cnt++;
 564                 printf_red("fail. ret = %s, type = %s\n", __get_result_string('m', ret), __get_privilege_type_string(type));
 565         }
 566
 567         __print_line();
 568         printf("uid = 5001\n");
 569         printf("pkgid = org.tizen.testtest\n");
 570         printf("privilege = http://tizen.org/privilege/yyyyy\n");
 571         ret = privilege_info_get_privilege_type(5001, "org.tizen.testtest", "http://tizen.org/privilege/yyyyy", &type);
 572         printf("expected type = PRIVILEGE_MANAGER_PRIVILEGE_TYPE_NORMAL\n");
 573         if (ret == PRVMGR_ERR_NONE && type == PRIVILEGE_MANAGER_PRIVILEGE_TYPE_NORMAL) {
 574                 success_cnt++;
 575                 printf_green("success\n");
 576         } else {
 577                 fail_cnt++;
 578                 printf_red("fail. ret = %s, type = %s\n", __get_result_string('m', ret), __get_privilege_type_string(type));
 579         }
 580         __print_line();
 581 }
 582
 583 void __test_privilege_info_is_user_settable()
 584 {
 585         int ret = 0;
 586
 587         __print_line();
 588         printf("pkgid = ise-default\n");
 589         printf("privacy = http://tizen.org/privacy/location\n");
 590         ret = privilege_info_is_user_settable("ise-default", "http://tizen.org/privacy/location");
 591         printf("is user settable\n");
 592         if (ret == 1) {
 593                 success_cnt++;
 594                 printf_green("success\n");
 595         } else {
 596                 fail_cnt++;
 597                 printf_red("fail. ret = %d\n", ret);
 598         }
 599
 600         __print_line();
 601         printf("pkgid = ise-default\n");
 602         printf("privacy = http://tizen.org/privacy/camera\n");
 603         ret = privilege_info_is_user_settable("ise-default", "http://tizen.org/privacy/camera");
 604         printf("is not user settable\n");
 605         if (ret == 0) {
 606                 success_cnt++;
 607                 printf_green("success\n");
 608         } else {
 609                 fail_cnt++;
 610                 printf_red("fail. ret = %d\n", ret);
 611         }
 612
 613         __print_line();
 614         printf("pkgid = org.tizen.testtest\n");
 615         printf("privacy = http://tizen.org/privacy/userhistory\n");
 616         ret = privilege_info_is_user_settable("org.tizen.testtest", "http://tizen.org/privacy/userhistory");
 617         printf("is user settable\n");
 618         if (ret == 1) {
 619                 success_cnt++;
 620                 printf_green("success\n");
 621         } else {
 622                 fail_cnt++;
 623                 printf_red("fail. ret = %d\n", ret);
 624         }
 625
 626         __print_line();
 627         printf("pkgid = org.tizen.testtest\n");
 628         printf("privacy = http://tizen.org/privacy/xxxxx\n");
 629         ret = privilege_info_is_user_settable("org.tizen.testtest", "http://tizen.org/privacy/xxxxx");
 630         printf("error must be occurred\n");
 631         if (ret == -1) {
 632                 success_cnt++;
 633                 printf_green("success\n");
 634         } else {
 635                 fail_cnt++;
 636                 printf_red("fail. ret = %d\n", ret);
 637         }
 638         __print_line();
 639 }
 640
 641 void __test_privilege_info_get_same_privacy_grouped_privileges()
 642 {
 643         int ret = 0;
 644         GList *privilege_list = NULL;
 645
 646         __print_line();
 647         printf("privilege = http://tizen.org/privilege/account.read\n");
 648         ret = privilege_info_get_same_privacy_grouped_privileges("http://tizen.org/privilege/account.read", &privilege_list);
 649
 650         if (ENABLE_ASKUSER) {
 651                 printf("privacy = account\n");
 652                 if (ret == PRVMGR_ERR_NONE && privilege_list != NULL) {
 653                         success_cnt++;
 654                         printf_green("success\n");
 655                 } else {
 656                         fail_cnt++;
 657                         printf_red("failed. ret = %s\n", __get_result_string('m', ret));
 658                 }
 659         } else {
 660                 printf("not privacy\n");
 661                 if (ret == PRVMGR_ERR_NONE && privilege_list == NULL) {
 662                         success_cnt++;
 663                         printf_green("success\n");
 664                 } else {
 665                         fail_cnt++;
 666                         printf_red("failed. ret = %s\n", __get_result_string('m', ret));
 667                 }
 668         }
 669
 670         if (privilege_list != NULL) {
 671                 __print_glist(privilege_list);
 672                 g_list_free_full(privilege_list, free);
 673                 privilege_list = NULL;
 674         }
 675
 676         __print_line();
 677         printf("privilege = http://tizen.org/privilege/internet\n");
 678         printf("not privacy\n");
 679
 680         ret = privilege_info_get_same_privacy_grouped_privileges("http://tizen.org/privilege/internet", &privilege_list);
 681         if (ret == PRVMGR_ERR_NONE && privilege_list == NULL) {
 682                 success_cnt++;
 683                 printf_green("success\n");
 684         } else {
 685                 fail_cnt++;
 686                 printf_red("failed. internet privilege is not privacy. ret = %s\n", __get_result_string('m', ret));
 687         }
 688
 689         if (privilege_list != NULL) {
 690                 __print_glist(privilege_list);
 691                 g_list_free_full(privilege_list, free);
 692                 privilege_list = NULL;
 693         }
 694
 695         __print_line();
 696         printf("privilege = http://tizen.org/privilege/internal/buxton/message.read\n");
 697         printf("not privacy\n");
 698
 699         ret = privilege_info_get_same_privacy_grouped_privileges("http://tizen.org/privilege/internal/buxton/message.read", &privilege_list);
 700         if (ret == PRVMGR_ERR_NONE && privilege_list == NULL) {
 701                 success_cnt++;
 702                 printf_green("success\n");
 703         } else {
 704                 fail_cnt++;
 705                 printf_red("failed. internal/buxton/message.read privilege is not privacy. ret = %s\n", __get_result_string('m', ret));
 706         }
 707
 708         if (privilege_list != NULL) {
 709                 __print_glist(privilege_list);
 710                 g_list_free_full(privilege_list, free);
 711         }
 712 }
 713
 714 int main()
 715 {
 716         __tcinfo(function, "privilege_info_is_privacy");
 717         __test_privilege_info_is_privacy();
 718
 719         __tcinfo(function, "privilege_info_is_internal");
 720         __test_privilege_info_is_internal();
 721
 722         __tcinfo(function, "privilege_info_is_valid");
 723         __test_privilege_info_is_valid();
 724
 725         __tcinfo(function, "privilege_info_get_privilege_display_name");
 726         __test_privilege_info_get_privilege_display_name();
 727
 728         __tcinfo(function, "privilege_info_get_privilege_description");
 729         __test_privilege_info_get_privilege_description();
 730
 731         __tcinfo(function, "privilege_info_get_privilege_group_display_name");
 732         __test_privilege_info_get_privilege_group_display_name();
 733
 734         __tcinfo(function, "privilege_info_get_privacy_list");
 735         __test_privilege_info_get_privacy_list();
 736
 737         __tcinfo(function, "privilege_info_get_privilege_list_by_privacy");
 738         __test_privilege_info_get_privilege_list_by_privacy();
 739
 740         __tcinfo(function, "privilege_info_get_privacy_by_privilege");
 741         __test_privilege_info_get_privacy_by_privilege();
 742
 743         __tcinfo(function, "privilege_info_get_privacy_display");
 744         __test_privilege_info_get_privacy_display();
 745
 746         __tcinfo(function, "privilege_info_get_privilege_type");
 747         __test_privilege_info_get_privilege_type();
 748
 749         __tcinfo(function, "privilege_info_is_user_settable");
 750         __test_privilege_info_is_user_settable();
 751
 752         __tcinfo(function, "privilege_info_get_same_privacy_grouped_privileges");
 753         __test_privilege_info_get_same_privacy_grouped_privileges();
 754
 755         printf_green("Test Complete\n");
 756         printf_green("success : %d, ", success_cnt);
 757
 758         printf_red("fail : %d\n", fail_cnt);
 759
 760         return 0;
 761 }