test/unit/expr/attribute_white.h

   1 /*********************                                                        */
   2 /*! \file attribute_white.h
   3  ** \verbatim
   4  ** Original author: mdeters
   5  ** Major contributors: none
   6  ** Minor contributors (to current version): barrett, dejan, cconway
   7  ** This file is part of the CVC4 prototype.
   8  ** Copyright (c) 2009, 2010  The Analysis of Computer Systems Group (ACSys)
   9  ** Courant Institute of Mathematical Sciences
  10  ** New York University
  11  ** See the file COPYING in the top-level source directory for licensing
  12  ** information.\endverbatim
  13  **
  14  ** \brief White box testing of Node attributes.
  15  **
  16  ** White box testing of Node attributes.
  17  **/
  18
  19 #include <cxxtest/TestSuite.h>
  20
  21 #include <string>
  22
  23 #include "context/context.h"
  24 #include "expr/node_value.h"
  25 #include "expr/node_builder.h"
  26 #include "expr/node_manager.h"
  27 #include "expr/attribute.h"
  28 #include "expr/node.h"
  29 #include "theory/theory_engine.h"
  30 #include "theory/uf/theory_uf.h"
  31 #include "util/Assert.h"
  32
  33 using namespace CVC4;
  34 using namespace CVC4::kind;
  35 using namespace CVC4::context;
  36 using namespace CVC4::expr;
  37 using namespace CVC4::expr::attr;
  38 using namespace std;
  39
  40 struct Test1;
  41 struct Test2;
  42 struct Test3;
  43 struct Test4;
  44 struct Test5;
  45
  46 typedef Attribute<Test1, std::string> TestStringAttr1;
  47 typedef Attribute<Test2, std::string> TestStringAttr2;
  48
  49 // it would be nice to have CDAttribute<> for context-dependence
  50 typedef CDAttribute<Test1, bool> TestCDFlag;
  51
  52 typedef Attribute<Test1, bool> TestFlag1;
  53 typedef Attribute<Test2, bool> TestFlag2;
  54 typedef Attribute<Test3, bool> TestFlag3;
  55 typedef Attribute<Test4, bool> TestFlag4;
  56 typedef Attribute<Test5, bool> TestFlag5;
  57
  58 typedef CDAttribute<Test1, bool> TestFlag1cd;
  59 typedef CDAttribute<Test2, bool> TestFlag2cd;
  60
  61 class AttributeWhite : public CxxTest::TestSuite {
  62
  63   Context* d_ctxt;
  64   NodeManager* d_nm;
  65   NodeManagerScope* d_scope;
  66   TypeNode* d_booleanType;
  67
  68 public:
  69
  70   void setUp() {
  71     d_ctxt = new Context;
  72     d_nm = new NodeManager(d_ctxt);
  73     d_scope = new NodeManagerScope(d_nm);
  74
  75     d_booleanType = new TypeNode(d_nm->booleanType());
  76   }
  77
  78   void tearDown() {
  79     delete d_booleanType;
  80     delete d_scope;
  81     delete d_nm;
  82     delete d_ctxt;
  83   }
  84
  85   void testAttributeIds() {
  86     // Test that IDs for (a subset of) attributes in the system are
  87     // unique and that the LastAttributeId (which would be the next ID
  88     // to assign) is greater than all attribute IDs.
  89
  90     // We used to check ID assignments explicitly.  However, between
  91     // compilation modules, you don't get a strong guarantee
  92     // (initialization order is somewhat implementation-specific, and
  93     // anyway you'd have to change the tests anytime you add an
  94     // attribute).  So we back off, and just test that they're unique
  95     // and that the next ID to be assigned is strictly greater than
  96     // those that have already been assigned.
  97
  98     unsigned lastId = attr::LastAttributeId<string, false>::s_id;
  99     TS_ASSERT_LESS_THAN(VarNameAttr::s_id, lastId);
 100     TS_ASSERT_LESS_THAN(TestStringAttr1::s_id, lastId);
 101     TS_ASSERT_LESS_THAN(TestStringAttr2::s_id, lastId);
 102
 103     TS_ASSERT_DIFFERS(VarNameAttr::s_id, TestStringAttr1::s_id);
 104     TS_ASSERT_DIFFERS(VarNameAttr::s_id, TestStringAttr2::s_id);
 105     TS_ASSERT_DIFFERS(TestStringAttr1::s_id, TestStringAttr2::s_id);
 106
 107     //lastId = attr::LastAttributeId<void*, false>::s_id;
 108     //TS_ASSERT_LESS_THAN(theory::uf::ECAttr::s_id, lastId);
 109
 110     lastId = attr::LastAttributeId<bool, false>::s_id;
 111     TS_ASSERT_LESS_THAN(theory::Theory::PreRegisteredAttr::s_id, lastId);
 112     TS_ASSERT_LESS_THAN(TestFlag1::s_id, lastId);
 113     TS_ASSERT_LESS_THAN(TestFlag2::s_id, lastId);
 114     TS_ASSERT_LESS_THAN(TestFlag3::s_id, lastId);
 115     TS_ASSERT_LESS_THAN(TestFlag4::s_id, lastId);
 116     TS_ASSERT_LESS_THAN(TestFlag5::s_id, lastId);
 117     TS_ASSERT_DIFFERS(theory::Theory::PreRegisteredAttr::s_id, TestFlag1::s_id);
 118     TS_ASSERT_DIFFERS(theory::Theory::PreRegisteredAttr::s_id, TestFlag2::s_id);
 119     TS_ASSERT_DIFFERS(theory::Theory::PreRegisteredAttr::s_id, TestFlag3::s_id);
 120     TS_ASSERT_DIFFERS(theory::Theory::PreRegisteredAttr::s_id, TestFlag4::s_id);
 121     TS_ASSERT_DIFFERS(theory::Theory::PreRegisteredAttr::s_id, TestFlag5::s_id);
 122     TS_ASSERT_DIFFERS(TestFlag1::s_id, TestFlag2::s_id);
 123     TS_ASSERT_DIFFERS(TestFlag1::s_id, TestFlag3::s_id);
 124     TS_ASSERT_DIFFERS(TestFlag1::s_id, TestFlag4::s_id);
 125     TS_ASSERT_DIFFERS(TestFlag1::s_id, TestFlag5::s_id);
 126     TS_ASSERT_DIFFERS(TestFlag2::s_id, TestFlag3::s_id);
 127     TS_ASSERT_DIFFERS(TestFlag2::s_id, TestFlag4::s_id);
 128     TS_ASSERT_DIFFERS(TestFlag2::s_id, TestFlag5::s_id);
 129     TS_ASSERT_DIFFERS(TestFlag3::s_id, TestFlag4::s_id);
 130     TS_ASSERT_DIFFERS(TestFlag3::s_id, TestFlag5::s_id);
 131     TS_ASSERT_DIFFERS(TestFlag4::s_id, TestFlag5::s_id);
 132
 133     lastId = attr::LastAttributeId<bool, true>::s_id;
 134     TS_ASSERT_LESS_THAN(TheoryEngine::RegisteredAttr::s_id, lastId);
 135     TS_ASSERT_LESS_THAN(TestFlag1cd::s_id, lastId);
 136     TS_ASSERT_LESS_THAN(TestFlag2cd::s_id, lastId);
 137     TS_ASSERT_DIFFERS(TheoryEngine::RegisteredAttr::s_id, TestFlag1cd::s_id);
 138     TS_ASSERT_DIFFERS(TheoryEngine::RegisteredAttr::s_id, TestFlag2cd::s_id);
 139     TS_ASSERT_DIFFERS(TestFlag1cd::s_id, TestFlag2cd::s_id);
 140
 141     lastId = attr::LastAttributeId<Node, false>::s_id;
 142     TS_ASSERT_LESS_THAN(theory::PreRewriteCache::s_id, lastId);
 143     TS_ASSERT_LESS_THAN(theory::PostRewriteCache::s_id, lastId);
 144     TS_ASSERT_LESS_THAN(theory::PreRewriteCacheTop::s_id, lastId);
 145     TS_ASSERT_LESS_THAN(theory::PostRewriteCacheTop::s_id, lastId);
 146     TS_ASSERT_DIFFERS(theory::PreRewriteCache::s_id, theory::PostRewriteCache::s_id);
 147     TS_ASSERT_DIFFERS(theory::PreRewriteCache::s_id, theory::PreRewriteCacheTop::s_id);
 148     TS_ASSERT_DIFFERS(theory::PreRewriteCache::s_id, theory::PostRewriteCacheTop::s_id);
 149     TS_ASSERT_DIFFERS(theory::PostRewriteCache::s_id, theory::PreRewriteCacheTop::s_id);
 150     TS_ASSERT_DIFFERS(theory::PostRewriteCache::s_id, theory::PostRewriteCacheTop::s_id);
 151     TS_ASSERT_DIFFERS(theory::PreRewriteCacheTop::s_id, theory::PostRewriteCacheTop::s_id);
 152
 153     lastId = attr::LastAttributeId<TypeNode, false>::s_id;
 154     TS_ASSERT_LESS_THAN(NodeManager::TypeAttr::s_id, lastId);
 155
 156   }
 157
 158   void testCDAttributes() {
 159     //Debug.on("boolattr");
 160
 161     Node a = d_nm->mkVar(*d_booleanType);
 162     Node b = d_nm->mkVar(*d_booleanType);
 163     Node c = d_nm->mkVar(*d_booleanType);
 164
 165     Debug("boolattr", "get flag 1 on a (should be F)\n");
 166     TS_ASSERT(! a.getAttribute(TestFlag1cd()));
 167     Debug("boolattr", "get flag 1 on b (should be F)\n");
 168     TS_ASSERT(! b.getAttribute(TestFlag1cd()));
 169     Debug("boolattr", "get flag 1 on c (should be F)\n");
 170     TS_ASSERT(! c.getAttribute(TestFlag1cd()));
 171
 172     d_ctxt->push(); // level 1
 173
 174     // test that all boolean flags are FALSE to start
 175     Debug("boolattr", "get flag 1 on a (should be F)\n");
 176     TS_ASSERT(! a.getAttribute(TestFlag1cd()));
 177     Debug("boolattr", "get flag 1 on b (should be F)\n");
 178     TS_ASSERT(! b.getAttribute(TestFlag1cd()));
 179     Debug("boolattr", "get flag 1 on c (should be F)\n");
 180     TS_ASSERT(! c.getAttribute(TestFlag1cd()));
 181
 182     // test that they all HAVE the boolean attributes
 183     TS_ASSERT(a.hasAttribute(TestFlag1cd()));
 184     TS_ASSERT(b.hasAttribute(TestFlag1cd()));
 185     TS_ASSERT(c.hasAttribute(TestFlag1cd()));
 186
 187     // test two-arg version of hasAttribute()
 188     bool bb = false;
 189     Debug("boolattr", "get flag 1 on a (should be F)\n");
 190     TS_ASSERT(a.getAttribute(TestFlag1cd(), bb));
 191     TS_ASSERT(! bb);
 192     Debug("boolattr", "get flag 1 on b (should be F)\n");
 193     TS_ASSERT(b.getAttribute(TestFlag1cd(), bb));
 194     TS_ASSERT(! bb);
 195     Debug("boolattr", "get flag 1 on c (should be F)\n");
 196     TS_ASSERT(c.getAttribute(TestFlag1cd(), bb));
 197     TS_ASSERT(! bb);
 198
 199     // setting boolean flags
 200     Debug("boolattr", "set flag 1 on a to T\n");
 201     a.setAttribute(TestFlag1cd(), true);
 202     Debug("boolattr", "set flag 1 on b to F\n");
 203     b.setAttribute(TestFlag1cd(), false);
 204     Debug("boolattr", "set flag 1 on c to F\n");
 205     c.setAttribute(TestFlag1cd(), false);
 206
 207     Debug("boolattr", "get flag 1 on a (should be T)\n");
 208     TS_ASSERT(a.getAttribute(TestFlag1cd()));
 209     Debug("boolattr", "get flag 1 on b (should be F)\n");
 210     TS_ASSERT(! b.getAttribute(TestFlag1cd()));
 211     Debug("boolattr", "get flag 1 on c (should be F)\n");
 212     TS_ASSERT(! c.getAttribute(TestFlag1cd()));
 213
 214     d_ctxt->push(); // level 2
 215
 216     Debug("boolattr", "get flag 1 on a (should be T)\n");
 217     TS_ASSERT(a.getAttribute(TestFlag1cd()));
 218     Debug("boolattr", "get flag 1 on b (should be F)\n");
 219     TS_ASSERT(! b.getAttribute(TestFlag1cd()));
 220     Debug("boolattr", "get flag 1 on c (should be F)\n");
 221     TS_ASSERT(! c.getAttribute(TestFlag1cd()));
 222
 223     Debug("boolattr", "set flag 1 on a to F\n");
 224     a.setAttribute(TestFlag1cd(), false);
 225     Debug("boolattr", "set flag 1 on b to T\n");
 226     b.setAttribute(TestFlag1cd(), true);
 227
 228     Debug("boolattr", "get flag 1 on a (should be F)\n");
 229     TS_ASSERT(! a.getAttribute(TestFlag1cd()));
 230     Debug("boolattr", "get flag 1 on b (should be T)\n");
 231     TS_ASSERT(b.getAttribute(TestFlag1cd()));
 232     Debug("boolattr", "get flag 1 on c (should be F)\n");
 233     TS_ASSERT(! c.getAttribute(TestFlag1cd()));
 234
 235     d_ctxt->push(); // level 3
 236
 237     Debug("boolattr", "get flag 1 on a (should be F)\n");
 238     TS_ASSERT(! a.getAttribute(TestFlag1cd()));
 239     Debug("boolattr", "get flag 1 on b (should be T)\n");
 240     TS_ASSERT(b.getAttribute(TestFlag1cd()));
 241     Debug("boolattr", "get flag 1 on c (should be F)\n");
 242     TS_ASSERT(! c.getAttribute(TestFlag1cd()));
 243
 244     Debug("boolattr", "set flag 1 on c to T\n");
 245     c.setAttribute(TestFlag1cd(), true);
 246
 247     Debug("boolattr", "get flag 1 on a (should be F)\n");
 248     TS_ASSERT(! a.getAttribute(TestFlag1cd()));
 249     Debug("boolattr", "get flag 1 on b (should be T)\n");
 250     TS_ASSERT(b.getAttribute(TestFlag1cd()));
 251     Debug("boolattr", "get flag 1 on c (should be T)\n");
 252     TS_ASSERT(c.getAttribute(TestFlag1cd()));
 253
 254     d_ctxt->pop(); // level 2
 255
 256     Debug("boolattr", "get flag 1 on a (should be F)\n");
 257     TS_ASSERT(! a.getAttribute(TestFlag1cd()));
 258     Debug("boolattr", "get flag 1 on b (should be T)\n");
 259     TS_ASSERT(b.getAttribute(TestFlag1cd()));
 260     Debug("boolattr", "get flag 1 on c (should be F)\n");
 261     TS_ASSERT(! c.getAttribute(TestFlag1cd()));
 262
 263     d_ctxt->pop(); // level 1
 264
 265     Debug("boolattr", "get flag 1 on a (should be T)\n");
 266     TS_ASSERT(a.getAttribute(TestFlag1cd()));
 267     Debug("boolattr", "get flag 1 on b (should be F)\n");
 268     TS_ASSERT(! b.getAttribute(TestFlag1cd()));
 269     Debug("boolattr", "get flag 1 on c (should be F)\n");
 270     TS_ASSERT(! c.getAttribute(TestFlag1cd()));
 271
 272     d_ctxt->pop(); // level 0
 273
 274     Debug("boolattr", "get flag 1 on a (should be F)\n");
 275     TS_ASSERT(! a.getAttribute(TestFlag1cd()));
 276     Debug("boolattr", "get flag 1 on b (should be F)\n");
 277     TS_ASSERT(! b.getAttribute(TestFlag1cd()));
 278     Debug("boolattr", "get flag 1 on c (should be F)\n");
 279     TS_ASSERT(! c.getAttribute(TestFlag1cd()));
 280
 281 #ifdef CVC4_ASSERTIONS
 282     TS_ASSERT_THROWS( d_ctxt->pop(), AssertionException );
 283 #endif /* CVC4_ASSERTIONS */
 284   }
 285
 286   void testAttributes() {
 287     //Debug.on("boolattr");
 288
 289     Node a = d_nm->mkVar(*d_booleanType);
 290     Node b = d_nm->mkVar(*d_booleanType);
 291     Node c = d_nm->mkVar(*d_booleanType);
 292     Node unnamed = d_nm->mkVar(*d_booleanType);
 293
 294     a.setAttribute(VarNameAttr(), "a");
 295     b.setAttribute(VarNameAttr(), "b");
 296     c.setAttribute(VarNameAttr(), "c");
 297
 298     // test that all boolean flags are FALSE to start
 299     Debug("boolattr", "get flag 1 on a (should be F)\n");
 300     TS_ASSERT(! a.getAttribute(TestFlag1()));
 301     Debug("boolattr", "get flag 1 on b (should be F)\n");
 302     TS_ASSERT(! b.getAttribute(TestFlag1()));
 303     Debug("boolattr", "get flag 1 on c (should be F)\n");
 304     TS_ASSERT(! c.getAttribute(TestFlag1()));
 305     Debug("boolattr", "get flag 1 on unnamed (should be F)\n");
 306     TS_ASSERT(! unnamed.getAttribute(TestFlag1()));
 307
 308     Debug("boolattr", "get flag 2 on a (should be F)\n");
 309     TS_ASSERT(! a.getAttribute(TestFlag2()));
 310     Debug("boolattr", "get flag 2 on b (should be F)\n");
 311     TS_ASSERT(! b.getAttribute(TestFlag2()));
 312     Debug("boolattr", "get flag 2 on c (should be F)\n");
 313     TS_ASSERT(! c.getAttribute(TestFlag2()));
 314     Debug("boolattr", "get flag 2 on unnamed (should be F)\n");
 315     TS_ASSERT(! unnamed.getAttribute(TestFlag2()));
 316
 317     Debug("boolattr", "get flag 3 on a (should be F)\n");
 318     TS_ASSERT(! a.getAttribute(TestFlag3()));
 319     Debug("boolattr", "get flag 3 on b (should be F)\n");
 320     TS_ASSERT(! b.getAttribute(TestFlag3()));
 321     Debug("boolattr", "get flag 3 on c (should be F)\n");
 322     TS_ASSERT(! c.getAttribute(TestFlag3()));
 323     Debug("boolattr", "get flag 3 on unnamed (should be F)\n");
 324     TS_ASSERT(! unnamed.getAttribute(TestFlag3()));
 325
 326     Debug("boolattr", "get flag 4 on a (should be F)\n");
 327     TS_ASSERT(! a.getAttribute(TestFlag4()));
 328     Debug("boolattr", "get flag 4 on b (should be F)\n");
 329     TS_ASSERT(! b.getAttribute(TestFlag4()));
 330     Debug("boolattr", "get flag 4 on c (should be F)\n");
 331     TS_ASSERT(! c.getAttribute(TestFlag4()));
 332     Debug("boolattr", "get flag 4 on unnamed (should be F)\n");
 333     TS_ASSERT(! unnamed.getAttribute(TestFlag4()));
 334
 335     Debug("boolattr", "get flag 5 on a (should be F)\n");
 336     TS_ASSERT(! a.getAttribute(TestFlag5()));
 337     Debug("boolattr", "get flag 5 on b (should be F)\n");
 338     TS_ASSERT(! b.getAttribute(TestFlag5()));
 339     Debug("boolattr", "get flag 5 on c (should be F)\n");
 340     TS_ASSERT(! c.getAttribute(TestFlag5()));
 341     Debug("boolattr", "get flag 5 on unnamed (should be F)\n");
 342     TS_ASSERT(! unnamed.getAttribute(TestFlag5()));
 343
 344     // test that they all HAVE the boolean attributes
 345     TS_ASSERT(a.hasAttribute(TestFlag1()));
 346     TS_ASSERT(b.hasAttribute(TestFlag1()));
 347     TS_ASSERT(c.hasAttribute(TestFlag1()));
 348     TS_ASSERT(unnamed.hasAttribute(TestFlag1()));
 349
 350     TS_ASSERT(a.hasAttribute(TestFlag2()));
 351     TS_ASSERT(b.hasAttribute(TestFlag2()));
 352     TS_ASSERT(c.hasAttribute(TestFlag2()));
 353     TS_ASSERT(unnamed.hasAttribute(TestFlag2()));
 354
 355     TS_ASSERT(a.hasAttribute(TestFlag3()));
 356     TS_ASSERT(b.hasAttribute(TestFlag3()));
 357     TS_ASSERT(c.hasAttribute(TestFlag3()));
 358     TS_ASSERT(unnamed.hasAttribute(TestFlag3()));
 359
 360     TS_ASSERT(a.hasAttribute(TestFlag4()));
 361     TS_ASSERT(b.hasAttribute(TestFlag4()));
 362     TS_ASSERT(c.hasAttribute(TestFlag4()));
 363     TS_ASSERT(unnamed.hasAttribute(TestFlag4()));
 364
 365     TS_ASSERT(a.hasAttribute(TestFlag5()));
 366     TS_ASSERT(b.hasAttribute(TestFlag5()));
 367     TS_ASSERT(c.hasAttribute(TestFlag5()));
 368     TS_ASSERT(unnamed.hasAttribute(TestFlag5()));
 369
 370     // test two-arg version of hasAttribute()
 371     bool bb;
 372     Debug("boolattr", "get flag 1 on a (should be F)\n");
 373     TS_ASSERT(a.getAttribute(TestFlag1(), bb));
 374     TS_ASSERT(! bb);
 375     Debug("boolattr", "get flag 1 on b (should be F)\n");
 376     TS_ASSERT(b.getAttribute(TestFlag1(), bb));
 377     TS_ASSERT(! bb);
 378     Debug("boolattr", "get flag 1 on c (should be F)\n");
 379     TS_ASSERT(c.getAttribute(TestFlag1(), bb));
 380     TS_ASSERT(! bb);
 381     Debug("boolattr", "get flag 1 on unnamed (should be F)\n");
 382     TS_ASSERT(unnamed.getAttribute(TestFlag1(), bb));
 383     TS_ASSERT(! bb);
 384
 385     Debug("boolattr", "get flag 2 on a (should be F)\n");
 386     TS_ASSERT(a.getAttribute(TestFlag2(), bb));
 387     TS_ASSERT(! bb);
 388     Debug("boolattr", "get flag 2 on b (should be F)\n");
 389     TS_ASSERT(b.getAttribute(TestFlag2(), bb));
 390     TS_ASSERT(! bb);
 391     Debug("boolattr", "get flag 2 on c (should be F)\n");
 392     TS_ASSERT(c.getAttribute(TestFlag2(), bb));
 393     TS_ASSERT(! bb);
 394     Debug("boolattr", "get flag 2 on unnamed (should be F)\n");
 395     TS_ASSERT(unnamed.getAttribute(TestFlag2(), bb));
 396     TS_ASSERT(! bb);
 397
 398     Debug("boolattr", "get flag 3 on a (should be F)\n");
 399     TS_ASSERT(a.getAttribute(TestFlag3(), bb));
 400     TS_ASSERT(! bb);
 401     Debug("boolattr", "get flag 3 on b (should be F)\n");
 402     TS_ASSERT(b.getAttribute(TestFlag3(), bb));
 403     TS_ASSERT(! bb);
 404     Debug("boolattr", "get flag 3 on c (should be F)\n");
 405     TS_ASSERT(c.getAttribute(TestFlag3(), bb));
 406     TS_ASSERT(! bb);
 407     Debug("boolattr", "get flag 3 on unnamed (should be F)\n");
 408     TS_ASSERT(unnamed.getAttribute(TestFlag3(), bb));
 409     TS_ASSERT(! bb);
 410
 411     Debug("boolattr", "get flag 4 on a (should be F)\n");
 412     TS_ASSERT(a.getAttribute(TestFlag4(), bb));
 413     TS_ASSERT(! bb);
 414     Debug("boolattr", "get flag 4 on b (should be F)\n");
 415     TS_ASSERT(b.getAttribute(TestFlag4(), bb));
 416     TS_ASSERT(! bb);
 417     Debug("boolattr", "get flag 4 on c (should be F)\n");
 418     TS_ASSERT(c.getAttribute(TestFlag4(), bb));
 419     TS_ASSERT(! bb);
 420     Debug("boolattr", "get flag 4 on unnamed (should be F)\n");
 421     TS_ASSERT(unnamed.getAttribute(TestFlag4(), bb));
 422     TS_ASSERT(! bb);
 423
 424     Debug("boolattr", "get flag 5 on a (should be F)\n");
 425     TS_ASSERT(a.getAttribute(TestFlag5(), bb));
 426     TS_ASSERT(! bb);
 427     Debug("boolattr", "get flag 5 on b (should be F)\n");
 428     TS_ASSERT(b.getAttribute(TestFlag5(), bb));
 429     TS_ASSERT(! bb);
 430     Debug("boolattr", "get flag 5 on c (should be F)\n");
 431     TS_ASSERT(c.getAttribute(TestFlag5(), bb));
 432     TS_ASSERT(! bb);
 433     Debug("boolattr", "get flag 5 on unnamed (should be F)\n");
 434     TS_ASSERT(unnamed.getAttribute(TestFlag5(), bb));
 435     TS_ASSERT(! bb);
 436
 437     // setting boolean flags
 438     Debug("boolattr", "set flag 1 on a to T\n");
 439     a.setAttribute(TestFlag1(), true);
 440     Debug("boolattr", "set flag 1 on b to F\n");
 441     b.setAttribute(TestFlag1(), false);
 442     Debug("boolattr", "set flag 1 on c to F\n");
 443     c.setAttribute(TestFlag1(), false);
 444     Debug("boolattr", "set flag 1 on unnamed to T\n");
 445     unnamed.setAttribute(TestFlag1(), true);
 446
 447     Debug("boolattr", "set flag 2 on a to F\n");
 448     a.setAttribute(TestFlag2(), false);
 449     Debug("boolattr", "set flag 2 on b to T\n");
 450     b.setAttribute(TestFlag2(), true);
 451     Debug("boolattr", "set flag 2 on c to T\n");
 452     c.setAttribute(TestFlag2(), true);
 453     Debug("boolattr", "set flag 2 on unnamed to F\n");
 454     unnamed.setAttribute(TestFlag2(), false);
 455
 456     Debug("boolattr", "set flag 3 on a to T\n");
 457     a.setAttribute(TestFlag3(), true);
 458     Debug("boolattr", "set flag 3 on b to T\n");
 459     b.setAttribute(TestFlag3(), true);
 460     Debug("boolattr", "set flag 3 on c to T\n");
 461     c.setAttribute(TestFlag3(), true);
 462     Debug("boolattr", "set flag 3 on unnamed to T\n");
 463     unnamed.setAttribute(TestFlag3(), true);
 464
 465     Debug("boolattr", "set flag 4 on a to T\n");
 466     a.setAttribute(TestFlag4(), true);
 467     Debug("boolattr", "set flag 4 on b to T\n");
 468     b.setAttribute(TestFlag4(), true);
 469     Debug("boolattr", "set flag 4 on c to T\n");
 470     c.setAttribute(TestFlag4(), true);
 471     Debug("boolattr", "set flag 4 on unnamed to T\n");
 472     unnamed.setAttribute(TestFlag4(), true);
 473
 474     Debug("boolattr", "set flag 5 on a to T\n");
 475     a.setAttribute(TestFlag5(), true);
 476     Debug("boolattr", "set flag 5 on b to T\n");
 477     b.setAttribute(TestFlag5(), true);
 478     Debug("boolattr", "set flag 5 on c to F\n");
 479     c.setAttribute(TestFlag5(), false);
 480     Debug("boolattr", "set flag 5 on unnamed to T\n");
 481     unnamed.setAttribute(TestFlag5(), true);
 482
 483     TS_ASSERT(a.getAttribute(VarNameAttr()) == "a");
 484     TS_ASSERT(a.getAttribute(VarNameAttr()) != "b");
 485     TS_ASSERT(a.getAttribute(VarNameAttr()) != "c");
 486     TS_ASSERT(a.getAttribute(VarNameAttr()) != "");
 487
 488     TS_ASSERT(b.getAttribute(VarNameAttr()) != "a");
 489     TS_ASSERT(b.getAttribute(VarNameAttr()) == "b");
 490     TS_ASSERT(b.getAttribute(VarNameAttr()) != "c");
 491     TS_ASSERT(b.getAttribute(VarNameAttr()) != "");
 492
 493     TS_ASSERT(c.getAttribute(VarNameAttr()) != "a");
 494     TS_ASSERT(c.getAttribute(VarNameAttr()) != "b");
 495     TS_ASSERT(c.getAttribute(VarNameAttr()) == "c");
 496     TS_ASSERT(c.getAttribute(VarNameAttr()) != "");
 497
 498     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) != "a");
 499     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) != "b");
 500     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) != "c");
 501     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) == "");
 502
 503     TS_ASSERT(! unnamed.hasAttribute(VarNameAttr()));
 504
 505     TS_ASSERT(! a.hasAttribute(TestStringAttr1()));
 506     TS_ASSERT(! b.hasAttribute(TestStringAttr1()));
 507     TS_ASSERT(! c.hasAttribute(TestStringAttr1()));
 508     TS_ASSERT(! unnamed.hasAttribute(TestStringAttr1()));
 509
 510     TS_ASSERT(! a.hasAttribute(TestStringAttr2()));
 511     TS_ASSERT(! b.hasAttribute(TestStringAttr2()));
 512     TS_ASSERT(! c.hasAttribute(TestStringAttr2()));
 513     TS_ASSERT(! unnamed.hasAttribute(TestStringAttr2()));
 514
 515     Debug("boolattr", "get flag 1 on a (should be T)\n");
 516     TS_ASSERT(a.getAttribute(TestFlag1()));
 517     Debug("boolattr", "get flag 1 on b (should be F)\n");
 518     TS_ASSERT(! b.getAttribute(TestFlag1()));
 519     Debug("boolattr", "get flag 1 on c (should be F)\n");
 520     TS_ASSERT(! c.getAttribute(TestFlag1()));
 521     Debug("boolattr", "get flag 1 on unnamed (should be T)\n");
 522     TS_ASSERT(unnamed.getAttribute(TestFlag1()));
 523
 524     Debug("boolattr", "get flag 2 on a (should be F)\n");
 525     TS_ASSERT(! a.getAttribute(TestFlag2()));
 526     Debug("boolattr", "get flag 2 on b (should be T)\n");
 527     TS_ASSERT(b.getAttribute(TestFlag2()));
 528     Debug("boolattr", "get flag 2 on c (should be T)\n");
 529     TS_ASSERT(c.getAttribute(TestFlag2()));
 530     Debug("boolattr", "get flag 2 on unnamed (should be F)\n");
 531     TS_ASSERT(! unnamed.getAttribute(TestFlag2()));
 532
 533     Debug("boolattr", "get flag 3 on a (should be T)\n");
 534     TS_ASSERT(a.getAttribute(TestFlag3()));
 535     Debug("boolattr", "get flag 3 on b (should be T)\n");
 536     TS_ASSERT(b.getAttribute(TestFlag3()));
 537     Debug("boolattr", "get flag 3 on c (should be T)\n");
 538     TS_ASSERT(c.getAttribute(TestFlag3()));
 539     Debug("boolattr", "get flag 3 on unnamed (should be T)\n");
 540     TS_ASSERT(unnamed.getAttribute(TestFlag3()));
 541
 542     Debug("boolattr", "get flag 4 on a (should be T)\n");
 543     TS_ASSERT(a.getAttribute(TestFlag4()));
 544     Debug("boolattr", "get flag 4 on b (should be T)\n");
 545     TS_ASSERT(b.getAttribute(TestFlag4()));
 546     Debug("boolattr", "get flag 4 on c (should be T)\n");
 547     TS_ASSERT(c.getAttribute(TestFlag4()));
 548     Debug("boolattr", "get flag 4 on unnamed (should be T)\n");
 549     TS_ASSERT(unnamed.getAttribute(TestFlag4()));
 550
 551     Debug("boolattr", "get flag 5 on a (should be T)\n");
 552     TS_ASSERT(a.getAttribute(TestFlag5()));
 553     Debug("boolattr", "get flag 5 on b (should be T)\n");
 554     TS_ASSERT(b.getAttribute(TestFlag5()));
 555     Debug("boolattr", "get flag 5 on c (should be F)\n");
 556     TS_ASSERT(! c.getAttribute(TestFlag5()));
 557     Debug("boolattr", "get flag 5 on unnamed (should be T)\n");
 558     TS_ASSERT(unnamed.getAttribute(TestFlag5()));
 559
 560     a.setAttribute(TestStringAttr1(), "foo");
 561     b.setAttribute(TestStringAttr1(), "bar");
 562     c.setAttribute(TestStringAttr1(), "baz");
 563
 564     TS_ASSERT(a.getAttribute(VarNameAttr()) == "a");
 565     TS_ASSERT(a.getAttribute(VarNameAttr()) != "b");
 566     TS_ASSERT(a.getAttribute(VarNameAttr()) != "c");
 567     TS_ASSERT(a.getAttribute(VarNameAttr()) != "");
 568
 569     TS_ASSERT(b.getAttribute(VarNameAttr()) != "a");
 570     TS_ASSERT(b.getAttribute(VarNameAttr()) == "b");
 571     TS_ASSERT(b.getAttribute(VarNameAttr()) != "c");
 572     TS_ASSERT(b.getAttribute(VarNameAttr()) != "");
 573
 574     TS_ASSERT(c.getAttribute(VarNameAttr()) != "a");
 575     TS_ASSERT(c.getAttribute(VarNameAttr()) != "b");
 576     TS_ASSERT(c.getAttribute(VarNameAttr()) == "c");
 577     TS_ASSERT(c.getAttribute(VarNameAttr()) != "");
 578
 579     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) != "a");
 580     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) != "b");
 581     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) != "c");
 582     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) == "");
 583
 584     TS_ASSERT(! unnamed.hasAttribute(VarNameAttr()));
 585
 586     TS_ASSERT(a.hasAttribute(TestStringAttr1()));
 587     TS_ASSERT(b.hasAttribute(TestStringAttr1()));
 588     TS_ASSERT(c.hasAttribute(TestStringAttr1()));
 589     TS_ASSERT(! unnamed.hasAttribute(TestStringAttr1()));
 590
 591     TS_ASSERT(! a.hasAttribute(TestStringAttr2()));
 592     TS_ASSERT(! b.hasAttribute(TestStringAttr2()));
 593     TS_ASSERT(! c.hasAttribute(TestStringAttr2()));
 594     TS_ASSERT(! unnamed.hasAttribute(TestStringAttr2()));
 595
 596     a.setAttribute(VarNameAttr(), "b");
 597     b.setAttribute(VarNameAttr(), "c");
 598     c.setAttribute(VarNameAttr(), "a");
 599
 600     TS_ASSERT(c.getAttribute(VarNameAttr()) == "a");
 601     TS_ASSERT(c.getAttribute(VarNameAttr()) != "b");
 602     TS_ASSERT(c.getAttribute(VarNameAttr()) != "c");
 603     TS_ASSERT(c.getAttribute(VarNameAttr()) != "");
 604
 605     TS_ASSERT(a.getAttribute(VarNameAttr()) != "a");
 606     TS_ASSERT(a.getAttribute(VarNameAttr()) == "b");
 607     TS_ASSERT(a.getAttribute(VarNameAttr()) != "c");
 608     TS_ASSERT(a.getAttribute(VarNameAttr()) != "");
 609
 610     TS_ASSERT(b.getAttribute(VarNameAttr()) != "a");
 611     TS_ASSERT(b.getAttribute(VarNameAttr()) != "b");
 612     TS_ASSERT(b.getAttribute(VarNameAttr()) == "c");
 613     TS_ASSERT(b.getAttribute(VarNameAttr()) != "");
 614
 615     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) != "a");
 616     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) != "b");
 617     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) != "c");
 618     TS_ASSERT(unnamed.getAttribute(VarNameAttr()) == "");
 619
 620     TS_ASSERT(! unnamed.hasAttribute(VarNameAttr()));
 621   }
 622 };