tests/ace/TestSuite03.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    TestSuite03.cpp
  18  * @author  Piotr Fatyga (p.fatyga@samsung.com)
  19  * @version 0.1
  20  * @brief   Test cases for Condition class.
  21  */
  22
  23 #include <string>
  24
  25 #include <dpl/log/log.h>
  26 #include <dpl/test/test_runner.h>
  27
  28 #include <dpl/ace/Attribute.h>
  29 #include <dpl/ace-dao-ro/BaseAttribute.h>
  30 #include <dpl/ace/Condition.h>
  31
  32 #define TESTSUITE03(n) \
  33 RUNNER_TEST(ts03_condtitions_tests_ ## n)
  34
  35 using namespace AceDB;
  36
  37 BaseAttributePtr createAttribute(
  38         const char *name,
  39         const char * value,
  40         const Attribute::Type type = Attribute::Type::Subject)
  41 {
  42     std::string aName(name);
  43     BaseAttributePtr attr(new Attribute(&aName, Attribute::Match::Equal, type));
  44     if(value != NULL){
  45         std::string aValue(value);
  46         DPL::StaticPointerCast<Attribute>(attr)->addValue(&aValue);
  47     }
  48     return attr;
  49 }
  50
  51 BaseAttributePtr createAttribute(
  52         const char *name,
  53         const char *value,
  54         const char *value2,
  55         const Attribute::Type type = Attribute::Type::Subject)
  56 {
  57     std::string aName(name);
  58     BaseAttributePtr attr(new Attribute(&aName, Attribute::Match::Equal, type));
  59     if(value != NULL && value2 != NULL ){
  60         std::string aValue(value), aValue2(value2);
  61         DPL::StaticPointerCast<Attribute>(attr)->addValue(&aValue);
  62         DPL::StaticPointerCast<Attribute>(attr)->addValue(&aValue2);
  63     }
  64     return attr;
  65 }
  66
  67
  68 bool MatchResultEqual(
  69         Attribute::MatchResult actual,
  70         Attribute::MatchResult  expected)
  71 {
  72     return actual == expected;
  73 }
  74
  75 bool evaluateResult(
  76         Condition con,
  77         AttributeSet & attrs,
  78         Attribute::MatchResult expectedResult)
  79 {
  80     Attribute::MatchResult matchResult = con.evaluateCondition(&attrs);
  81     return MatchResultEqual(matchResult ,expectedResult);
  82 }
  83
  84 TESTSUITE03(01){
  85     Condition con(Condition::OR);
  86     AttributeSet attrSet;
  87
  88     BaseAttributePtr a1 = createAttribute("version","var1");
  89     BaseAttributePtr a2 = createAttribute("r8v2","var2");
  90     BaseAttributePtr a3 = createAttribute("author","va3");
  91
  92     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
  93     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
  94     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
  95
  96     attrSet.insert(a1);
  97     attrSet.insert(a2);
  98     attrSet.insert(a3);
  99
 100     RUNNER_ASSERT(
 101         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 102 }
 103
 104 TESTSUITE03(02){
 105     Condition con(Condition::AND);
 106     AttributeSet attrSet;
 107
 108     BaseAttributePtr a1 = createAttribute("version","var1");
 109     BaseAttributePtr a2 = createAttribute("r8v2","var2");
 110     BaseAttributePtr a3 = createAttribute("author","va3");
 111
 112     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 113     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 114     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 115
 116     attrSet.insert(a1);
 117     attrSet.insert(a2);
 118     attrSet.insert(a3);
 119
 120     RUNNER_ASSERT(
 121         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 122 }
 123
 124 TESTSUITE03(03){
 125     Condition con(Condition::OR);
 126     AttributeSet attrSet;
 127
 128     BaseAttributePtr a1 = createAttribute("version","var1");
 129     BaseAttributePtr a2 = createAttribute("r8v2","var2");
 130     BaseAttributePtr a3 = createAttribute("author","va3");
 131     BaseAttributePtr a4 = createAttribute("version","wrongValue");
 132
 133     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 134     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 135     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 136
 137     attrSet.insert(a2);
 138     attrSet.insert(a3);
 139     attrSet.insert(a4);
 140
 141     RUNNER_ASSERT(
 142         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 143 }
 144
 145 TESTSUITE03(04){
 146     Condition con(Condition::AND);
 147     AttributeSet attrSet;
 148
 149     BaseAttributePtr a1 = createAttribute("version","var1");
 150     BaseAttributePtr a2 = createAttribute("r8v2","var2");
 151     BaseAttributePtr a3 = createAttribute("author","va3");
 152     BaseAttributePtr a4 = createAttribute("version","bad");
 153     BaseAttributePtr a5 = createAttribute("version","var1", Attribute::Type::Resource);
 154
 155     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 156     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 157     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 158
 159     attrSet.insert(a2);
 160     attrSet.insert(a3);
 161     attrSet.insert(a4);
 162     attrSet.insert(a5);
 163
 164     RUNNER_ASSERT(
 165         evaluateResult(con,attrSet,Attribute::MatchResult::MRFalse));
 166 }
 167
 168 TESTSUITE03(05){
 169     Condition con(Condition::OR);
 170     AttributeSet attrSet;
 171
 172     BaseAttributePtr a1 = createAttribute("version","var1");
 173     BaseAttributePtr a2 = createAttribute("r8v2","var2");
 174     BaseAttributePtr a3 = createAttribute("author","va3");
 175
 176     BaseAttributePtr a4 = createAttribute("version","var1");
 177     BaseAttributePtr a5 = createAttribute("r8v2","var2");
 178     BaseAttributePtr a6 = createAttribute("author","va3");
 179
 180     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 181     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 182     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 183
 184     attrSet.insert(a4);
 185     attrSet.insert(a5);
 186     attrSet.insert(a6);
 187
 188     RUNNER_ASSERT(
 189         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 190 }
 191
 192 TESTSUITE03(06){
 193     Condition con(Condition::OR);
 194     AttributeSet attrSet;
 195
 196     BaseAttributePtr a1 = createAttribute("version","var1");
 197     BaseAttributePtr a2 = createAttribute("r8v2","var2");
 198     BaseAttributePtr a3 = createAttribute("author","va3");
 199
 200     BaseAttributePtr a4 = createAttribute("version","var2");
 201     BaseAttributePtr a5 = createAttribute("r8v2","var3");
 202     BaseAttributePtr a6 = createAttribute("author","va4");
 203
 204     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 205     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 206     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 207
 208     attrSet.insert(a4);
 209     attrSet.insert(a5);
 210     attrSet.insert(a6);
 211
 212     RUNNER_ASSERT(
 213         evaluateResult(con,attrSet,Attribute::MatchResult::MRFalse));
 214 }
 215
 216 TESTSUITE03(07){
 217     Condition con(Condition::OR);
 218     AttributeSet attrSet;
 219
 220     BaseAttributePtr a1 = createAttribute("version","var1");
 221     BaseAttributePtr a2 = createAttribute("r8v2","var2");
 222     BaseAttributePtr a3 = createAttribute("author","va3");
 223
 224     BaseAttributePtr a4 = createAttribute("version","var1", Attribute::Type::Resource );
 225     BaseAttributePtr a5 = createAttribute("r8v2","var2", Attribute::Type::Resource);
 226     BaseAttributePtr a6 = createAttribute("author","va3", Attribute::Type::Resource);
 227
 228     BaseAttributePtr a7 = createAttribute("version","var2" );
 229     BaseAttributePtr a8 = createAttribute("r8v2","var3");
 230     BaseAttributePtr a9 = createAttribute("author","va4");
 231
 232     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 233     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 234     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 235
 236     attrSet.insert(a4);
 237     attrSet.insert(a5);
 238     attrSet.insert(a6);
 239     attrSet.insert(a7);
 240     attrSet.insert(a8);
 241     attrSet.insert(a9);
 242
 243     //Despite that there are attribute a4,a5,a6 that matches the value of attributes
 244     //a1,a2,a3 the type of the attributes is different
 245     RUNNER_ASSERT(
 246         evaluateResult(con,attrSet,Attribute::MatchResult::MRFalse));
 247 }
 248
 249 //Test if the same attributes (but other instances) passes the test
 250
 251 TESTSUITE03(08){
 252     Condition con(Condition::OR);
 253     AttributeSet attrSet;
 254
 255     BaseAttributePtr a1 = createAttribute("version","var1");
 256     BaseAttributePtr a2 = createAttribute("r8v2","var2");
 257     BaseAttributePtr a3 = createAttribute("author","va3");
 258
 259     BaseAttributePtr a4 = createAttribute("version","var1");
 260     BaseAttributePtr a5 = createAttribute("r8v2","var2", Attribute::Type::Resource);
 261     BaseAttributePtr a6 = createAttribute("author","va3", Attribute::Type::Resource);
 262     BaseAttributePtr a7 = createAttribute("r8v2","aaa");
 263     BaseAttributePtr a8 = createAttribute("author","aaa");
 264
 265     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 266     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 267     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 268
 269     attrSet.insert(a4);
 270     attrSet.insert(a5);
 271     attrSet.insert(a6);
 272     attrSet.insert(a7);
 273     attrSet.insert(a8);
 274
 275     RUNNER_ASSERT(
 276         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 277 }
 278
 279 TESTSUITE03(09){
 280     Condition con(Condition::OR);
 281     AttributeSet attrSet;
 282
 283     BaseAttributePtr a1 = createAttribute("version", NULL); //empty bag
 284     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 285     attrSet.insert(a1);
 286
 287     RUNNER_ASSERT(
 288         evaluateResult(con,attrSet,Attribute::MatchResult::MRFalse));
 289 }
 290
 291 TESTSUITE03(10){
 292     Condition con(Condition::OR);
 293     AttributeSet attrSet;
 294
 295     BaseAttributePtr a1 =  createAttribute("version","var1","var2");
 296
 297     BaseAttributePtr a4 =  createAttribute("version","var1");
 298
 299     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 300     attrSet.insert(a4);
 301     //It's enough that one value from string bag matches
 302     RUNNER_ASSERT(
 303         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 304 }
 305
 306 TESTSUITE03(11){
 307     Condition con(Condition::AND);
 308     AttributeSet attrSet;
 309
 310     BaseAttributePtr a1 =  createAttribute("version","var1","var2");
 311     BaseAttributePtr a2 =  createAttribute("version","var3","var1");
 312
 313     BaseAttributePtr a4 =  createAttribute("version","var1");
 314
 315     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 316     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 317     attrSet.insert(a4);
 318     //It's enough that one value from string bag matches
 319     RUNNER_ASSERT(
 320         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 321 }
 322
 323
 324 TESTSUITE03(12){
 325     Condition con(Condition::OR);
 326     AttributeSet attrSet;
 327
 328     BaseAttributePtr a1 =  createAttribute("version","var1");
 329     BaseAttributePtr a2 = createAttribute("r8v2","var2");
 330     BaseAttributePtr a3 = createAttribute("author","va3");
 331
 332     BaseAttributePtr a4 =  createAttribute("version","var1");
 333     BaseAttributePtr a5 = createAttribute("r8v2","var2", Attribute::Type::Resource);
 334     BaseAttributePtr a6 = createAttribute("author","va3", Attribute::Type::Resource);
 335
 336     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 337     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 338     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 339
 340     attrSet.insert(a4);
 341     attrSet.insert(a5);
 342     attrSet.insert(a6);
 343     RUNNER_ASSERT(
 344         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 345 }
 346
 347 TESTSUITE03(13){
 348     Condition con(Condition::AND);
 349     AttributeSet attrSet;
 350
 351     BaseAttributePtr a1 =  createAttribute("version",NULL);
 352     a1->setUndetermind(true);
 353     BaseAttributePtr a4 =  createAttribute("version","var1");
 354     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a4));
 355     attrSet.insert(a1);
 356
 357     RUNNER_ASSERT(
 358         evaluateResult(con,attrSet,Attribute::MatchResult::MRUndetermined));
 359 }
 360
 361 TESTSUITE03(14){
 362     Condition con(Condition::OR);
 363     AttributeSet attrSet;
 364
 365     BaseAttributePtr a1 =  createAttribute("version",NULL);
 366     a1->setUndetermind(true);
 367     BaseAttributePtr a2 =  createAttribute("author","good");
 368     BaseAttributePtr a4 =  createAttribute("version","var1");
 369     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a4));
 370     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 371     attrSet.insert(a1);
 372     attrSet.insert(a2);
 373
 374     RUNNER_ASSERT(
 375         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 376 }
 377
 378 TESTSUITE03(15){
 379     Condition con(Condition::OR);
 380     AttributeSet attrSet;
 381
 382     BaseAttributePtr a1 = createAttribute("version",NULL,NULL);
 383     a1->setUndetermind(true);
 384     BaseAttributePtr a4 = createAttribute("version","var1");
 385     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a4));
 386     attrSet.insert(a1);
 387
 388     RUNNER_ASSERT(
 389         evaluateResult(con,attrSet,Attribute::MatchResult::MRUndetermined));
 390 }
 391
 392 TESTSUITE03(16){
 393     Condition con(Condition::OR);
 394     AttributeSet attrSet;
 395
 396     BaseAttributePtr a1 =  createAttribute("version","var1","aaa");
 397     a1->setUndetermind(true);
 398     BaseAttributePtr a4 =  createAttribute("version","var1");
 399     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a4));
 400     attrSet.insert(a1);
 401
 402     RUNNER_ASSERT(
 403         evaluateResult(con,attrSet,Attribute::MatchResult::MRUndetermined));
 404 }
 405
 406 TESTSUITE03(17){
 407     Condition con(Condition::AND);
 408     AttributeSet attrSet;
 409
 410     BaseAttributePtr a1 = createAttribute("version","var1");
 411     BaseAttributePtr a2 = createAttribute("version1","var1");
 412     BaseAttributePtr a3 = createAttribute("version2","var1");
 413     BaseAttributePtr a4 = createAttribute("version3","var1");
 414     BaseAttributePtr a5 = createAttribute("version1","var2");
 415
 416     Condition con2(Condition::AND);
 417     con2.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 418     Condition con3(Condition::OR);
 419     con3.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 420     con3.addAttribute(*DPL::StaticPointerCast<Attribute>(a4));
 421
 422     con.addCondition(con2);
 423     con.addCondition(con3);
 424
 425     con.addAttribute(*DPL::StaticPointerCast<Attribute>(a4));
 426     attrSet.insert(a1);
 427     attrSet.insert(a3);
 428     attrSet.insert(a4);
 429     attrSet.insert(a5);
 430
 431     RUNNER_ASSERT(
 432         evaluateResult(con,attrSet,Attribute::MatchResult::MRFalse));
 433 }
 434
 435 TESTSUITE03(18){
 436     Condition con(Condition::OR);
 437     AttributeSet attrSet;
 438
 439     BaseAttributePtr a1 = createAttribute("version","var1");
 440     BaseAttributePtr a2 = createAttribute("version1","var1");
 441     BaseAttributePtr a3 = createAttribute("version2","var1");
 442     BaseAttributePtr a4 = createAttribute("version3","var1");
 443     BaseAttributePtr a5 = createAttribute("version1","var2");
 444
 445     Condition con2(Condition::AND);
 446     con2.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 447     con2.addAttribute(*DPL::StaticPointerCast<Attribute>(a5));
 448     Condition con3(Condition::AND);
 449     con3.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 450     con3.addAttribute(*DPL::StaticPointerCast<Attribute>(a4));
 451     Condition con4(Condition::AND);
 452     con4.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 453
 454     con3.addCondition(con4);
 455     con.addCondition(con2);
 456     con.addCondition(con3);
 457
 458     attrSet.insert(a1);
 459     attrSet.insert(a3);
 460     attrSet.insert(a4);
 461     attrSet.insert(a5);
 462
 463     RUNNER_ASSERT(
 464         evaluateResult(con,attrSet,Attribute::MatchResult::MRFalse));
 465 }
 466
 467 TESTSUITE03(19){
 468     Condition con(Condition::OR);
 469     AttributeSet attrSet;
 470
 471     BaseAttributePtr a1 = createAttribute("version","var1");
 472     BaseAttributePtr a2 = createAttribute("version1","var1");
 473     BaseAttributePtr a3 = createAttribute("version2","var1");
 474     BaseAttributePtr a4 = createAttribute("version3","var1");
 475     BaseAttributePtr a5 = createAttribute("version1","var2");
 476
 477     Condition con2(Condition::AND);
 478     con2.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 479     con2.addAttribute(*DPL::StaticPointerCast<Attribute>(a5));
 480     Condition con3(Condition::OR);
 481     con3.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 482     con3.addAttribute(*DPL::StaticPointerCast<Attribute>(a4));
 483
 484     con.addCondition(con2);
 485     con.addCondition(con3);
 486
 487     attrSet.insert(a1);
 488     attrSet.insert(a3);
 489     attrSet.insert(a4);
 490     attrSet.insert(a5);
 491
 492     RUNNER_ASSERT(
 493         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 494 }
 495
 496 TESTSUITE03(20){
 497     Condition con(Condition::OR);
 498     AttributeSet attrSet;
 499
 500     BaseAttributePtr a1 = createAttribute("version","var1");
 501     BaseAttributePtr a2 = createAttribute("version1","var1");
 502     BaseAttributePtr a3 = createAttribute("version2","var1");
 503     BaseAttributePtr a4 = createAttribute("version3","var1");
 504
 505     BaseAttributePtr a5 = createAttribute("version1","var2");
 506     BaseAttributePtr a6 = createAttribute("version2","var2");
 507     BaseAttributePtr a7 = createAttribute("version3","var2");
 508     BaseAttributePtr a8 = createAttribute("version4","var2");
 509
 510     Condition con2(Condition::OR);
 511     Condition con3(Condition::OR);
 512     Condition con4(Condition::OR);
 513     Condition con5(Condition::OR);
 514
 515     con2.addAttribute(*DPL::StaticPointerCast<Attribute>(a2));
 516     con3.addAttribute(*DPL::StaticPointerCast<Attribute>(a3));
 517     con4.addAttribute(*DPL::StaticPointerCast<Attribute>(a4));
 518     con5.addAttribute(*DPL::StaticPointerCast<Attribute>(a1));
 519
 520     con2.addCondition(con4);
 521     con3.addCondition(con5);
 522     con.addCondition(con2);
 523     con.addCondition(con3);
 524
 525     attrSet.insert(a1);
 526     attrSet.insert(a5);
 527     attrSet.insert(a6);
 528     attrSet.insert(a7);
 529     attrSet.insert(a8);
 530
 531     RUNNER_ASSERT(
 532         evaluateResult(con,attrSet,Attribute::MatchResult::MRTrue));
 533 }