tests/ace/TestSuite02.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /*
  17  * @file    TestSuite02.cpp
  18  * @author  unknown
  19  * @version 1.0
  20  * @brief   Test cases for Attribute class.
  21  */
  22 #include <string>
  23
  24 #include <dpl/log/log.h>
  25 #include <dpl/test/test_runner.h>
  26
  27 #include <dpl/ace/Attribute.h>
  28 #include <dpl/ace-dao-ro/BaseAttribute.h>
  29
  30 #include <dpl/ace/PolicyEvaluator.h>
  31
  32 #include "PEPSingleton.h"
  33
  34 #define POLICY_ATTR_EXAMPLE  "/usr/etc/ace/attr_policy-example.xml"
  35 #define POLICY_ATTR_EXAMPLE1 "/usr/etc/ace/attr_policy-example1.xml"
  36 #define POLICY_ATTR_EXAMPLE2 "/usr/etc/ace/attr_policy-example2.xml"
  37 #define POLICY_ATTR_EXAMPLE3 "/usr/etc/ace/attr_policy-example3.xml"
  38 #define POLICY_ATTR_EXAMPLE4 "/usr/etc/ace/attr_policy-example4.xml"
  39 #define POLICY_ATTR_EXAMPLE5 "/usr/etc/ace/attr_policy-example5.xml"
  40 #define POLICY_ATTR_EXAMPLE6 "/usr/etc/ace/attr_policy-example6.xml"
  41 #define POLICY_ATTR_EXAMPLE7 "/usr/etc/ace/attr_policy-example7.xml"
  42 #define POLICY_ATTR_EXAMPLE8 "/usr/etc/ace/attr_policy-example8.xml"
  43
  44 #define CLEANENV(d)                                                         \
  45     do{                                                                     \
  46         if (PEPSingleton::Instance().getPdp()->getCurrentPolicy() != (d)) { \
  47             PEPSingleton::Instance().getPdp()->updatePolicy(d);             \
  48         }                                                                   \
  49     }while(0)
  50
  51 #define PEPTR PEPSingleton::Instance().getPdp()
  52
  53 #define TESTSUITE02(n) \
  54 RUNNER_TEST(ts02_extract_attributes_tests_ ## n)
  55
  56 using namespace AceDB;
  57
  58 bool AttrEqual(const AttributeSet &actual, AttributeSet * expected)
  59 {
  60     bool match = false;
  61     for (AttributeSet::const_iterator ita = actual.begin();
  62          ita != actual.end();
  63          ++ita)
  64     {
  65         match = false;
  66         for (AttributeSet::const_iterator ite = expected->begin();
  67              ite != expected->end();
  68              ++ite)
  69         {
  70             if ((*(*ita)->getName() == *(*ite)->getName()) &&
  71                 ((*ita)->getType() == (*ite)->getType()))
  72             {
  73                 match = true;
  74             }
  75         }
  76         if (!match)
  77         {
  78             LogError("Not found " <<
  79                  *(*ita)->getName() <<
  80                  " " << static_cast<int>((*ita)->getType()));
  81             return false;
  82         }
  83     }
  84     return true;
  85 }
  86
  87 TESTSUITE02(01){
  88     CLEANENV(POLICY_ATTR_EXAMPLE);
  89
  90     AttributeSet attrSet;
  91     std::string n1("name");
  92     BaseAttributePtr a1(new Attribute(&n1,
  93                                       Attribute::Match::Equal,
  94                                       Attribute::Type::Subject));
  95     attrSet.insert(a1);
  96
  97
  98     std::string n2("resource-id");
  99     BaseAttributePtr a2(new Attribute(&n2,
 100                                       Attribute::Match::Equal,
 101                                       Attribute::Type::Resource));
 102     attrSet.insert(a2);
 103
 104     PEPTR->extractAttributesTest();
 105
 106     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 107     RUNNER_ASSERT(result);
 108 }
 109
 110 TESTSUITE02(02){
 111     CLEANENV(POLICY_ATTR_EXAMPLE1);
 112
 113     AttributeSet attrSet;
 114
 115     std::string n3("uri.host");
 116     BaseAttributePtr a3(new Attribute(&n3,
 117                                       Attribute::Match::Equal,
 118                                       Attribute::Type::Subject));
 119     attrSet.insert(a3);
 120
 121     std::string n4("key-root-trust");
 122     BaseAttributePtr a4(new Attribute(&n4,
 123                                       Attribute::Match::Equal,
 124                                       Attribute::Type::Subject));
 125     attrSet.insert(a4);
 126
 127     std::string n5("id");
 128     BaseAttributePtr a5(new Attribute(&n5,
 129                                       Attribute::Match::Equal,
 130                                       Attribute::Type::Subject));
 131     attrSet.insert(a5);
 132
 133     std::string n6("signer-id");
 134     BaseAttributePtr a6(new Attribute(&n6,
 135                                       Attribute::Match::Equal,
 136                                       Attribute::Type::Subject));
 137     attrSet.insert(a6);
 138
 139     std::string n7("version");
 140     BaseAttributePtr a7(new Attribute(&n7,
 141                                       Attribute::Match::Equal,
 142                                       Attribute::Type::Subject));
 143     attrSet.insert(a7);
 144
 145     std::string n8("r8v2");
 146     BaseAttributePtr a8(new Attribute(&n8,
 147                                       Attribute::Match::Equal,
 148                                       Attribute::Type::Resource));
 149     attrSet.insert(a8);
 150
 151     std::string n9("author");
 152     BaseAttributePtr a9(new Attribute(&n9,
 153                                       Attribute::Match::Equal,
 154                                       Attribute::Type::Resource));
 155     attrSet.insert(a9);
 156
 157     std::string n10("r9a.scheme");
 158     BaseAttributePtr a10(new Attribute(&n10,
 159                                        Attribute::Match::Equal,
 160                                        Attribute::Type::Resource));
 161     attrSet.insert(a10);
 162
 163     std::string n11("r9b.authority");
 164     BaseAttributePtr a11(new Attribute(&n11,
 165                                        Attribute::Match::Equal,
 166                                        Attribute::Type::Resource));
 167     attrSet.insert(a11);
 168
 169     std::string n12("r9c.scheme-authority");
 170     BaseAttributePtr a12(new Attribute(&n12,
 171                                        Attribute::Match::Equal,
 172                                        Attribute::Type::Resource));
 173     attrSet.insert(a12);
 174
 175     PEPTR->extractAttributesTest();
 176
 177     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 178     RUNNER_ASSERT(result);
 179 }
 180
 181 TESTSUITE02(03){
 182     CLEANENV(POLICY_ATTR_EXAMPLE2);
 183
 184     AttributeSet attrSet;
 185
 186     std::string n1("id");
 187     BaseAttributePtr a1(new Attribute(&n1,
 188                                       Attribute::Match::Equal,
 189                                       Attribute::Type::Subject));
 190     attrSet.insert(a1);
 191
 192     std::string n3("version");
 193     BaseAttributePtr a3(new Attribute(&n3,
 194                                       Attribute::Match::Equal,
 195                                       Attribute::Type::Subject));
 196     attrSet.insert(a3);
 197
 198     std::string n2("resource-id");
 199     BaseAttributePtr a2(new Attribute(&n2,
 200                                       Attribute::Match::Equal,
 201                                       Attribute::Type::Resource));
 202     attrSet.insert(a2);
 203
 204     std::string n4("author");
 205     BaseAttributePtr a4(new Attribute(&n4,
 206                                       Attribute::Match::Equal,
 207                                       Attribute::Type::Resource));
 208     attrSet.insert(a4);
 209
 210     PEPTR->extractAttributesTest();
 211
 212     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 213     RUNNER_ASSERT(result);
 214 }
 215
 216 TESTSUITE02(04){
 217     CLEANENV(POLICY_ATTR_EXAMPLE3);
 218
 219     AttributeSet attrSet;
 220
 221     std::string n1("id");
 222     BaseAttributePtr a1(new Attribute(&n1,
 223                                       Attribute::Match::Equal,
 224                                       Attribute::Type::Subject));
 225     attrSet.insert(a1);
 226
 227     std::string n3("version");
 228     BaseAttributePtr a3(new Attribute(&n3,
 229                                       Attribute::Match::Equal,
 230                                       Attribute::Type::Subject));
 231     attrSet.insert(a3);
 232
 233     std::string n2("resource-id");
 234     BaseAttributePtr a2(new Attribute(&n2,
 235                                       Attribute::Match::Equal,
 236                                       Attribute::Type::Resource));
 237     attrSet.insert(a2);
 238
 239     std::string n4("author");
 240     BaseAttributePtr a4(new Attribute(&n4,
 241                                       Attribute::Match::Equal,
 242                                       Attribute::Type::Resource));
 243     attrSet.insert(a4);
 244
 245     PEPTR->extractAttributesTest();
 246
 247     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 248     RUNNER_ASSERT(result);
 249 }
 250
 251 TESTSUITE02(05){
 252     CLEANENV(POLICY_ATTR_EXAMPLE4);
 253
 254     AttributeSet attrSet;
 255
 256     std::string n1("id");
 257     BaseAttributePtr a1(new Attribute(&n1,
 258                                       Attribute::Match::Equal,
 259                                       Attribute::Type::Subject));
 260     attrSet.insert(a1);
 261
 262     std::string n3("version");
 263     BaseAttributePtr a3(new Attribute(&n3,
 264                                       Attribute::Match::Equal,
 265                                       Attribute::Type::Subject));
 266     attrSet.insert(a3);
 267
 268
 269     std::string n2("resource-id");
 270     BaseAttributePtr a2(new Attribute(&n2,
 271                                       Attribute::Match::Equal,
 272                                       Attribute::Type::Resource));
 273     attrSet.insert(a2);
 274
 275     std::string n4("author");
 276     BaseAttributePtr a4(new Attribute(&n4,
 277                                       Attribute::Match::Equal,
 278                                       Attribute::Type::Resource));
 279     attrSet.insert(a4);
 280
 281     std::string n5("author");
 282     BaseAttributePtr a5(new Attribute(&n5,
 283                                       Attribute::Match::Equal,
 284                                       Attribute::Type::Environment));
 285     attrSet.insert(a5);
 286
 287     std::string n6("version");
 288     BaseAttributePtr a6(new Attribute(&n6,
 289                                       Attribute::Match::Equal,
 290                                       Attribute::Type::Environment));
 291     attrSet.insert(a6);
 292
 293     std::string n7("ver");
 294     BaseAttributePtr a7(new Attribute(&n7,
 295                                       Attribute::Match::Equal,
 296                                       Attribute::Type::Environment));
 297     attrSet.insert(a7);
 298
 299     PEPTR->extractAttributesTest();
 300
 301     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 302     RUNNER_ASSERT(result);
 303 }
 304
 305 TESTSUITE02(06){
 306     CLEANENV(POLICY_ATTR_EXAMPLE5);
 307
 308     AttributeSet attrSet;
 309
 310     std::string n3("uri.host");
 311     BaseAttributePtr a3(new Attribute(&n3,
 312                                       Attribute::Match::Equal,
 313                                       Attribute::Type::Subject));
 314     attrSet.insert(a3);
 315
 316     std::string n4("key-root-trust");
 317     BaseAttributePtr a4(new Attribute(&n4,
 318                                       Attribute::Match::Equal,
 319                                       Attribute::Type::Subject));
 320     attrSet.insert(a4);
 321
 322     std::string n5("id");
 323     BaseAttributePtr a5(new Attribute(&n5,
 324                                       Attribute::Match::Equal,
 325                                       Attribute::Type::Subject));
 326     attrSet.insert(a5);
 327
 328     std::string n6("signer-id");
 329     BaseAttributePtr a6(new Attribute(&n6,
 330                                       Attribute::Match::Equal,
 331                                       Attribute::Type::Subject));
 332     attrSet.insert(a6);
 333
 334     std::string n7("version");
 335     BaseAttributePtr a7(new Attribute(&n7,
 336                                       Attribute::Match::Equal,
 337                                       Attribute::Type::Subject));
 338     attrSet.insert(a7);
 339
 340     std::string n13("name");
 341     BaseAttributePtr a13(new Attribute(&n13,
 342                                        Attribute::Match::Equal,
 343                                        Attribute::Type::Subject));
 344     attrSet.insert(a13);
 345
 346     std::string n14("resource-id");
 347     BaseAttributePtr a14(new Attribute(&n14,
 348                                        Attribute::Match::Equal,
 349                                        Attribute::Type::Subject));
 350     attrSet.insert(a14);
 351
 352     std::string n15("r8v2");
 353     BaseAttributePtr a15(new Attribute(&n15,
 354                                        Attribute::Match::Equal,
 355                                        Attribute::Type::Subject));
 356     attrSet.insert(a15);
 357
 358     std::string n16("author");
 359     BaseAttributePtr a16(new Attribute(&n16,
 360                                        Attribute::Match::Equal,
 361                                        Attribute::Type::Subject));
 362     attrSet.insert(a16);
 363
 364     std::string n17("r9a.scheme");
 365     BaseAttributePtr a17(new Attribute(&n17,
 366                                        Attribute::Match::Equal,
 367                                        Attribute::Type::Subject));
 368     attrSet.insert(a17);
 369
 370     std::string n18("r9b.authority");
 371     BaseAttributePtr a18(new Attribute(&n18,
 372                                        Attribute::Match::Equal,
 373                                        Attribute::Type::Subject));
 374     attrSet.insert(a18);
 375
 376     std::string n19("r9c.scheme-authority");
 377     BaseAttributePtr a19(new Attribute(&n19,
 378                                        Attribute::Match::Equal,
 379                                        Attribute::Type::Subject));
 380     attrSet.insert(a19);
 381
 382     std::string n20("resource-id");
 383     BaseAttributePtr a20(new Attribute(&n20,
 384                                        Attribute::Match::Equal,
 385                                        Attribute::Type::Resource));
 386     attrSet.insert(a20);
 387
 388     std::string n8("r8v2");
 389     BaseAttributePtr a8(new Attribute(&n8,
 390                                       Attribute::Match::Equal,
 391                                       Attribute::Type::Resource));
 392     attrSet.insert(a8);
 393
 394     std::string n9("author");
 395     BaseAttributePtr a9(new Attribute(&n9,
 396                                       Attribute::Match::Equal,
 397                                       Attribute::Type::Resource));
 398     attrSet.insert(a9);
 399
 400     std::string n10("r9a.scheme");
 401     BaseAttributePtr a10(new Attribute(&n10,
 402                                        Attribute::Match::Equal,
 403                                        Attribute::Type::Resource));
 404     attrSet.insert(a10);
 405
 406     std::string n11("r9b.authority");
 407     BaseAttributePtr a11(new Attribute(&n11,
 408                                        Attribute::Match::Equal,
 409                                        Attribute::Type::Resource));
 410     attrSet.insert(a11);
 411
 412     std::string n12("r9c.scheme-authority");
 413     BaseAttributePtr a12(new Attribute(&n12,
 414                                        Attribute::Match::Equal,
 415                                        Attribute::Type::Resource));
 416     attrSet.insert(a12);
 417
 418     std::string n21("resource-id");
 419     BaseAttributePtr a21(new Attribute(&n21,
 420                                        Attribute::Match::Equal,
 421                                        Attribute::Type::Environment));
 422     attrSet.insert(a21);
 423
 424     std::string n22("r8v2");
 425     BaseAttributePtr a22(new Attribute(&n22,
 426                                        Attribute::Match::Equal,
 427                                        Attribute::Type::Environment));
 428     attrSet.insert(a22);
 429
 430     std::string n23("author");
 431     BaseAttributePtr a23(new Attribute(&n23,
 432                                        Attribute::Match::Equal,
 433                                        Attribute::Type::Environment));
 434     attrSet.insert(a23);
 435
 436     std::string n24("r9a.scheme");
 437     BaseAttributePtr a24(new Attribute(&n24,
 438                                        Attribute::Match::Equal,
 439                                        Attribute::Type::Environment));
 440     attrSet.insert(a24);
 441
 442     std::string n25("r9b.authority");
 443     BaseAttributePtr a25(new Attribute(&n25,
 444                                        Attribute::Match::Equal,
 445                                        Attribute::Type::Environment));
 446     attrSet.insert(a25);
 447
 448     std::string n26("r9c.scheme-authority");
 449     BaseAttributePtr a26(new Attribute(&n26,
 450                                        Attribute::Match::Equal,
 451                                        Attribute::Type::Environment));
 452     attrSet.insert(a26);
 453
 454     PEPTR->extractAttributesTest();
 455
 456     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 457     RUNNER_ASSERT(result);
 458 }
 459
 460 TESTSUITE02(07){
 461     CLEANENV(POLICY_ATTR_EXAMPLE6);
 462
 463     AttributeSet attrSet;
 464
 465     std::string n3("s-uri.host");
 466     BaseAttributePtr a3(new Attribute(&n3,
 467                                       Attribute::Match::Equal,
 468                                       Attribute::Type::Subject));
 469     attrSet.insert(a3);
 470
 471     std::string n4("s-key-root-trust");
 472     BaseAttributePtr a4(new Attribute(&n4,
 473                                       Attribute::Match::Equal,
 474                                       Attribute::Type::Subject));
 475     attrSet.insert(a4);
 476
 477     std::string n5("s-id");
 478     BaseAttributePtr a5(new Attribute(&n5,
 479                                       Attribute::Match::Equal,
 480                                       Attribute::Type::Subject));
 481     attrSet.insert(a5);
 482
 483     std::string n6("s-signer-id");
 484     BaseAttributePtr a6(new Attribute(&n6,
 485                                       Attribute::Match::Equal,
 486                                       Attribute::Type::Subject));
 487     attrSet.insert(a6);
 488
 489     std::string n7("s-version");
 490     BaseAttributePtr a7(new Attribute(&n7,
 491                                       Attribute::Match::Equal,
 492                                       Attribute::Type::Subject));
 493     attrSet.insert(a7);
 494
 495     std::string n13("s-name");
 496     BaseAttributePtr a13(new Attribute(&n13,
 497                                        Attribute::Match::Equal,
 498                                        Attribute::Type::Subject));
 499     attrSet.insert(a13);
 500
 501     std::string n14("s-resource-id");
 502     BaseAttributePtr a14(new Attribute(&n14,
 503                                        Attribute::Match::Equal,
 504                                        Attribute::Type::Subject));
 505     attrSet.insert(a14);
 506
 507     std::string n15("s-r8v2");
 508     BaseAttributePtr a15(new Attribute(&n15,
 509                                        Attribute::Match::Equal,
 510                                        Attribute::Type::Subject));
 511     attrSet.insert(a15);
 512
 513     std::string n16("s-author");
 514     BaseAttributePtr a16(new Attribute(&n16,
 515                                        Attribute::Match::Equal,
 516                                        Attribute::Type::Subject));
 517     attrSet.insert(a16);
 518
 519     std::string n17("s-r9a.scheme");
 520     BaseAttributePtr a17(new Attribute(&n17,
 521                                        Attribute::Match::Equal,
 522                                        Attribute::Type::Subject));
 523     attrSet.insert(a17);
 524
 525     std::string n18("s-r9b.authority");
 526     BaseAttributePtr a18(new Attribute(&n18,
 527                                        Attribute::Match::Equal,
 528                                        Attribute::Type::Subject));
 529     attrSet.insert(a18);
 530
 531     std::string n19("s-r9c.scheme-authority");
 532     BaseAttributePtr a19(new Attribute(&n19,
 533                                        Attribute::Match::Equal,
 534                                        Attribute::Type::Subject));
 535     attrSet.insert(a19);
 536
 537     std::string n20("r-resource-id");
 538     BaseAttributePtr a20(new Attribute(&n20,
 539                                        Attribute::Match::Equal,
 540                                        Attribute::Type::Resource));
 541     attrSet.insert(a20);
 542
 543     std::string n8("r-r8v2");
 544     BaseAttributePtr a8(new Attribute(&n8,
 545                                       Attribute::Match::Equal,
 546                                       Attribute::Type::Resource));
 547     attrSet.insert(a8);
 548
 549     std::string n9("r-author");
 550     BaseAttributePtr a9(new Attribute(&n9,
 551                                       Attribute::Match::Equal,
 552                                       Attribute::Type::Resource));
 553     attrSet.insert(a9);
 554
 555     std::string n10("r-r9a.scheme");
 556     BaseAttributePtr a10(new Attribute(&n10,
 557                                        Attribute::Match::Equal,
 558                                        Attribute::Type::Resource));
 559     attrSet.insert(a10);
 560
 561     std::string n11("r-r9b.authority");
 562     BaseAttributePtr a11(new Attribute(&n11,
 563                                        Attribute::Match::Equal,
 564                                        Attribute::Type::Resource));
 565     attrSet.insert(a11);
 566
 567     std::string n12("r-r9c.scheme-authority");
 568     BaseAttributePtr a12(new Attribute(&n12,
 569                                        Attribute::Match::Equal,
 570                                        Attribute::Type::Resource));
 571     attrSet.insert(a12);
 572
 573     std::string n21("e-resource-id");
 574     BaseAttributePtr a21(new Attribute(&n21,
 575                                        Attribute::Match::Equal,
 576                                        Attribute::Type::Environment));
 577     attrSet.insert(a21);
 578
 579     std::string n22("e-r8v2");
 580     BaseAttributePtr a22(new Attribute(&n22,
 581                                        Attribute::Match::Equal,
 582                                        Attribute::Type::Environment));
 583     attrSet.insert(a22);
 584
 585     std::string n23("e-author");
 586     BaseAttributePtr a23(new Attribute(&n23,
 587                                        Attribute::Match::Equal,
 588                                        Attribute::Type::Environment));
 589     attrSet.insert(a23);
 590
 591     std::string n24("e-r9a.scheme");
 592     BaseAttributePtr a24(new Attribute(&n24,
 593                                        Attribute::Match::Equal,
 594                                        Attribute::Type::Environment));
 595     attrSet.insert(a24);
 596
 597     std::string n25("e-r9b.authority");
 598     BaseAttributePtr a25(new Attribute(&n25,
 599                                        Attribute::Match::Equal,
 600                                        Attribute::Type::Environment));
 601     attrSet.insert(a25);
 602
 603     std::string n26("e-r9c.scheme-authority");
 604     BaseAttributePtr a26(new Attribute(&n26,
 605                                        Attribute::Match::Equal,
 606                                        Attribute::Type::Environment));
 607     attrSet.insert(a26);
 608
 609     PEPTR->extractAttributesTest();
 610
 611     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 612     RUNNER_ASSERT(result);
 613 }
 614
 615 TESTSUITE02(08){
 616     CLEANENV(POLICY_ATTR_EXAMPLE2);
 617
 618     AttributeSet attrSet;
 619
 620     std::string n1("id");
 621     BaseAttributePtr a1(new Attribute(&n1,
 622                                       Attribute::Match::Glob,
 623                                       Attribute::Type::Subject));
 624     attrSet.insert(a1);
 625
 626     std::string n3("version");
 627     BaseAttributePtr a3(new Attribute(&n3,
 628                                       Attribute::Match::Glob,
 629                                       Attribute::Type::Subject));
 630     attrSet.insert(a3);
 631
 632
 633     std::string n2("resource-id");
 634     BaseAttributePtr a2(new Attribute(&n2,
 635                                       Attribute::Match::Glob,
 636                                       Attribute::Type::Resource));
 637     attrSet.insert(a2);
 638
 639     std::string n4("author");
 640     BaseAttributePtr a4(new Attribute(&n4,
 641                                       Attribute::Match::Glob,
 642                                       Attribute::Type::Resource));
 643     attrSet.insert(a4);
 644
 645     PEPTR->extractAttributesTest();
 646
 647     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 648     RUNNER_ASSERT(result);
 649 }
 650
 651 TESTSUITE02(09){
 652     CLEANENV(POLICY_ATTR_EXAMPLE2);
 653
 654     AttributeSet attrSet;
 655
 656     std::string n1("id");
 657     BaseAttributePtr a1(new Attribute(&n1,
 658                                       Attribute::Match::Regexp,
 659                                       Attribute::Type::Subject));
 660     attrSet.insert(a1);
 661
 662     std::string n3("version");
 663     BaseAttributePtr a3(new Attribute(&n3,
 664                                       Attribute::Match::Regexp,
 665                                       Attribute::Type::Subject));
 666     attrSet.insert(a3);
 667
 668
 669     std::string n2("resource-id");
 670     BaseAttributePtr a2(new Attribute(&n2,
 671                                       Attribute::Match::Regexp,
 672                                       Attribute::Type::Resource));
 673     attrSet.insert(a2);
 674
 675     std::string n4("author");
 676     BaseAttributePtr a4(new Attribute(&n4,
 677                                       Attribute::Match::Regexp,
 678                                       Attribute::Type::Resource));
 679     attrSet.insert(a4);
 680
 681     PEPTR->extractAttributesTest();
 682
 683     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 684     RUNNER_ASSERT(result);
 685 }
 686
 687 TESTSUITE02(10){
 688     CLEANENV(POLICY_ATTR_EXAMPLE2);
 689
 690     AttributeSet attrSet;
 691
 692     std::string n1("id");
 693     BaseAttributePtr a1(new Attribute(&n1,
 694                                       Attribute::Match::Regexp,
 695                                       Attribute::Type::Subject));
 696     attrSet.insert(a1);
 697
 698     std::string n3("version");
 699     BaseAttributePtr a3(new Attribute(&n3,
 700                                       Attribute::Match::Equal,
 701                                       Attribute::Type::Subject));
 702     attrSet.insert(a3);
 703
 704
 705     std::string n2("resource-id");
 706     BaseAttributePtr a2(new Attribute(&n2,
 707                                       Attribute::Match::Glob,
 708                                       Attribute::Type::Resource));
 709     attrSet.insert(a2);
 710
 711     std::string n4("author");
 712     BaseAttributePtr a4(new Attribute(&n4,
 713                                       Attribute::Match::Regexp,
 714                                       Attribute::Type::Resource));
 715     attrSet.insert(a4);
 716
 717     PEPTR->extractAttributesTest();
 718
 719     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 720     RUNNER_ASSERT(result);
 721 }
 722
 723 TESTSUITE02(11){
 724     CLEANENV(POLICY_ATTR_EXAMPLE7);
 725
 726     AttributeSet attrSet;
 727
 728     std::string n3("uri.host");
 729     BaseAttributePtr a3(new Attribute(&n3,
 730                                       Attribute::Match::Equal,
 731                                       Attribute::Type::Subject));
 732     attrSet.insert(a3);
 733
 734     std::string n4("key-root-trust");
 735     BaseAttributePtr a4(new Attribute(&n4,
 736                                       Attribute::Match::Equal,
 737                                       Attribute::Type::Subject));
 738     attrSet.insert(a4);
 739
 740     std::string n5("id");
 741     BaseAttributePtr a5(new Attribute(&n5,
 742                                       Attribute::Match::Equal,
 743                                       Attribute::Type::Subject));
 744     attrSet.insert(a5);
 745
 746     std::string n6("signer-id");
 747     BaseAttributePtr a6(new Attribute(&n6,
 748                                       Attribute::Match::Equal,
 749                                       Attribute::Type::Subject));
 750     attrSet.insert(a6);
 751
 752     std::string n7("version");
 753     BaseAttributePtr a7(new Attribute(&n7,
 754                                       Attribute::Match::Equal,
 755                                       Attribute::Type::Subject));
 756     attrSet.insert(a7);
 757
 758     std::string n13("name");
 759     BaseAttributePtr a13(new Attribute(&n13,
 760                                        Attribute::Match::Equal,
 761                                        Attribute::Type::Subject));
 762     attrSet.insert(a13);
 763
 764     std::string n14("resource-id");
 765     BaseAttributePtr a14(new Attribute(&n14,
 766                                        Attribute::Match::Equal,
 767                                        Attribute::Type::Subject));
 768     attrSet.insert(a14);
 769
 770     std::string n15("r8v2");
 771     BaseAttributePtr a15(new Attribute(&n15,
 772                                        Attribute::Match::Equal,
 773                                        Attribute::Type::Subject));
 774     attrSet.insert(a15);
 775
 776     std::string n16("author");
 777     BaseAttributePtr a16(new Attribute(&n16,
 778                                        Attribute::Match::Equal,
 779                                        Attribute::Type::Subject));
 780     attrSet.insert(a16);
 781
 782     std::string n17("r9a.scheme");
 783     BaseAttributePtr a17(new Attribute(&n17,
 784                                        Attribute::Match::Equal,
 785                                        Attribute::Type::Subject));
 786     attrSet.insert(a17);
 787
 788     std::string n18("r9b.authority");
 789     BaseAttributePtr a18(new Attribute(&n18,
 790                                        Attribute::Match::Equal,
 791                                        Attribute::Type::Subject));
 792     attrSet.insert(a18);
 793
 794     std::string n19("r9c.scheme-authority");
 795     BaseAttributePtr a19(new Attribute(&n19,
 796                                        Attribute::Match::Equal,
 797                                        Attribute::Type::Subject));
 798     attrSet.insert(a19);
 799
 800     std::string n20("resource-id");
 801     BaseAttributePtr a20(new Attribute(&n20,
 802                                        Attribute::Match::Equal,
 803                                        Attribute::Type::Resource));
 804     attrSet.insert(a20);
 805
 806     std::string n8("r8v2");
 807     BaseAttributePtr a8(new Attribute(&n8,
 808                                       Attribute::Match::Equal,
 809                                       Attribute::Type::Resource));
 810     attrSet.insert(a8);
 811
 812     std::string n9("author");
 813     BaseAttributePtr a9(new Attribute(&n9,
 814                                       Attribute::Match::Equal,
 815                                       Attribute::Type::Resource));
 816     attrSet.insert(a9);
 817
 818     std::string n10("r9a.scheme");
 819     BaseAttributePtr a10(new Attribute(&n10,
 820                                        Attribute::Match::Equal,
 821                                        Attribute::Type::Resource));
 822     attrSet.insert(a10);
 823
 824     std::string n11("r9b.authority");
 825     BaseAttributePtr a11(new Attribute(&n11,
 826                                        Attribute::Match::Equal,
 827                                        Attribute::Type::Resource));
 828     attrSet.insert(a11);
 829
 830     std::string n12("r9c.scheme-authority");
 831     BaseAttributePtr a12(new Attribute(&n12,
 832                                        Attribute::Match::Equal,
 833                                        Attribute::Type::Resource));
 834     attrSet.insert(a12);
 835
 836     std::string n21("resource-id");
 837     BaseAttributePtr a21(new Attribute(&n21,
 838                                        Attribute::Match::Equal,
 839                                        Attribute::Type::Environment));
 840     attrSet.insert(a21);
 841
 842     std::string n22("r8v2");
 843     BaseAttributePtr a22(new Attribute(&n22,
 844                                        Attribute::Match::Equal,
 845                                        Attribute::Type::Environment));
 846     attrSet.insert(a22);
 847
 848     std::string n23("author");
 849     BaseAttributePtr a23(new Attribute(&n23,
 850                                        Attribute::Match::Equal,
 851                                        Attribute::Type::Environment));
 852     attrSet.insert(a23);
 853
 854     std::string n24("r9a.scheme");
 855     BaseAttributePtr a24(new Attribute(&n24,
 856                                        Attribute::Match::Equal,
 857                                        Attribute::Type::Environment));
 858     attrSet.insert(a24);
 859
 860     std::string n25("r9b.authority");
 861     BaseAttributePtr a25(new Attribute(&n25,
 862                                        Attribute::Match::Equal,
 863                                        Attribute::Type::Environment));
 864     attrSet.insert(a25);
 865
 866     std::string n26("r9c.scheme-authority");
 867     BaseAttributePtr a26(new Attribute(&n26,
 868                                        Attribute::Match::Equal,
 869                                        Attribute::Type::Environment));
 870     attrSet.insert(a26);
 871
 872     PEPTR->extractAttributesTest();
 873
 874     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 875     RUNNER_ASSERT(result);
 876 }
 877
 878 TESTSUITE02(12){
 879     CLEANENV(POLICY_ATTR_EXAMPLE8);
 880
 881     AttributeSet attrSet;
 882
 883     std::string n1("id");
 884     BaseAttributePtr a1(new Attribute(&n1,
 885                                       Attribute::Match::Regexp,
 886                                       Attribute::Type::Subject));
 887     attrSet.insert(a1);
 888
 889     std::string n3("version");
 890     BaseAttributePtr a3(new Attribute(&n3,
 891                                       Attribute::Match::Equal,
 892                                       Attribute::Type::Subject));
 893     attrSet.insert(a3);
 894
 895
 896     std::string n2("resource-id");
 897     BaseAttributePtr a2(new Attribute(&n2,
 898                                       Attribute::Match::Glob,
 899                                       Attribute::Type::Resource));
 900     attrSet.insert(a2);
 901
 902     std::string n4("author");
 903     BaseAttributePtr a4(new Attribute(&n4,
 904                                       Attribute::Match::Regexp,
 905                                       Attribute::Type::Resource));
 906     attrSet.insert(a4);
 907
 908     PEPTR->extractAttributesTest();
 909
 910     bool result = AttrEqual(attrSet, PEPTR->getAttributeSet());
 911     RUNNER_ASSERT(result);
 912 }
 913