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