src/XAO/tests/FieldTest.cxx

   1 #include <vector>
   2
   3 #include "FieldTest.hxx"
   4 #include "../XAO_Xao.hxx"
   5 #include "../XAO_XaoUtils.hxx"
   6 #include "../XAO_Field.hxx"
   7 #include "../XAO_Step.hxx"
   8 #include "../XAO_BooleanField.hxx"
   9 #include "../XAO_IntegerField.hxx"
  10 #include "../XAO_DoubleField.hxx"
  11 #include "../XAO_StringField.hxx"
  12
  13 using namespace XAO;
  14
  15
  16 void FieldTest::setUp()
  17 {
  18 }
  19
  20 void FieldTest::tearDown()
  21 {
  22 }
  23
  24 void FieldTest::cleanUp()
  25 {
  26 }
  27
  28 Field* FieldTest::testField(XAO::Type type)
  29 {
  30     Field* f = Field::createField(type, XAO::FACE, 10, 3);
  31
  32     CPPUNIT_ASSERT_EQUAL(0, (int)f->getName().size());
  33     CPPUNIT_ASSERT_EQUAL(type, f->getType());
  34     CPPUNIT_ASSERT_EQUAL(XAO::FACE, f->getDimension());
  35     CPPUNIT_ASSERT_EQUAL(3, f->countComponents());
  36     CPPUNIT_ASSERT_EQUAL(10, f->countElements());
  37     CPPUNIT_ASSERT_EQUAL(30, f->countValues());
  38
  39     f->setName("field1");
  40     CPPUNIT_ASSERT_EQUAL(std::string("field1"), f->getName());
  41
  42     CPPUNIT_ASSERT_EQUAL(0, (int)f->getComponentName(0).size());
  43     f->setComponentName(0, "x");
  44     f->setComponentName(1, "y");
  45     f->setComponentName(2, "z");
  46     CPPUNIT_ASSERT_EQUAL(3, f->countComponents());
  47     CPPUNIT_ASSERT_EQUAL(std::string("x"), f->getComponentName(0));
  48     CPPUNIT_ASSERT_EQUAL(std::string("y"), f->getComponentName(1));
  49     CPPUNIT_ASSERT_EQUAL(std::string("z"), f->getComponentName(2));
  50     CPPUNIT_ASSERT_THROW(f->setComponentName(3, "a"), XAO_Exception);
  51     CPPUNIT_ASSERT_THROW(f->getComponentName(3), XAO_Exception);
  52
  53     CPPUNIT_ASSERT_EQUAL(0, f->countSteps());
  54     Step* step = f->addNewStep(0);
  55     CPPUNIT_ASSERT_EQUAL(type, step->getType());
  56     CPPUNIT_ASSERT_EQUAL(1, f->countSteps());
  57     step = f->addNewStep(1);
  58     step = f->addNewStep(2);
  59     CPPUNIT_ASSERT_EQUAL(3, f->countSteps());
  60     CPPUNIT_ASSERT_THROW(f->addNewStep(2), XAO_Exception); // step already exists
  61
  62     CPPUNIT_ASSERT_EQUAL(true, f->removeStep(step));
  63     CPPUNIT_ASSERT_EQUAL(2, f->countSteps());
  64     CPPUNIT_ASSERT_EQUAL(false, f->removeStep(step)); // remove same
  65     CPPUNIT_ASSERT_EQUAL(2, f->countSteps());
  66
  67     return f;
  68 }
  69
  70 void FieldTest::testBooleanField()
  71 {
  72     BooleanField* f = (BooleanField*)testField(XAO::BOOLEAN);
  73
  74     BooleanStep* step = f->getStep(0);
  75     CPPUNIT_ASSERT_EQUAL(XAO::BOOLEAN, step->getType());
  76     CPPUNIT_ASSERT_MESSAGE("step is NULL", step != NULL);
  77     CPPUNIT_ASSERT_THROW(f->getStep(2), XAO_Exception);
  78
  79     step = f->addStep(10);
  80     CPPUNIT_ASSERT_EQUAL(XAO::BOOLEAN, step->getType());
  81     CPPUNIT_ASSERT_EQUAL(3, f->countSteps());
  82     CPPUNIT_ASSERT_THROW(f->addStep(10), XAO_Exception); // step already exists
  83 }
  84
  85 void FieldTest::testIntegerField()
  86 {
  87     IntegerField* f = (IntegerField*)testField(XAO::INTEGER);
  88
  89     IntegerStep* step = f->getStep(0);
  90     CPPUNIT_ASSERT_EQUAL(XAO::INTEGER, step->getType());
  91     CPPUNIT_ASSERT_MESSAGE("step is NULL", step != NULL);
  92     CPPUNIT_ASSERT_THROW(f->getStep(2), XAO_Exception);
  93
  94     step = f->addStep(10);
  95     CPPUNIT_ASSERT_EQUAL(XAO::INTEGER, step->getType());
  96     CPPUNIT_ASSERT_EQUAL(3, f->countSteps());
  97     CPPUNIT_ASSERT_THROW(f->addStep(10), XAO_Exception); // step already exists
  98 }
  99 void FieldTest::testDoubleField()
 100 {
 101     DoubleField* f = (DoubleField*)testField(XAO::DOUBLE);
 102
 103     DoubleStep* step = f->getStep(0);
 104     CPPUNIT_ASSERT_EQUAL(XAO::DOUBLE, step->getType());
 105     CPPUNIT_ASSERT_MESSAGE("step is NULL", step != NULL);
 106     CPPUNIT_ASSERT_THROW(f->getStep(2), XAO_Exception);
 107
 108     step = f->addStep(10);
 109     CPPUNIT_ASSERT_EQUAL(XAO::DOUBLE, step->getType());
 110     CPPUNIT_ASSERT_EQUAL(3, f->countSteps());
 111     CPPUNIT_ASSERT_THROW(f->addStep(10), XAO_Exception); // step already exists
 112 }
 113 void FieldTest::testStringField()
 114 {
 115     StringField* f = (StringField*)testField(XAO::STRING);
 116
 117     StringStep* step = f->getStep(0);
 118     CPPUNIT_ASSERT_EQUAL(XAO::STRING, step->getType());
 119     CPPUNIT_ASSERT_MESSAGE("step is NULL", step != NULL);
 120     CPPUNIT_ASSERT_THROW(f->getStep(2), XAO_Exception);
 121
 122     step = f->addStep(10);
 123     CPPUNIT_ASSERT_EQUAL(XAO::STRING, step->getType());
 124     CPPUNIT_ASSERT_EQUAL(3, f->countSteps());
 125     CPPUNIT_ASSERT_THROW(f->addStep(10), XAO_Exception); // step already exists
 126 }
 127
 128 void FieldTest::testStep(XAO::Type type, Step* step)
 129 {
 130     CPPUNIT_ASSERT_EQUAL(type, step->getType());
 131
 132     CPPUNIT_ASSERT_EQUAL(0, step->getStep());
 133     step->setStep(10);
 134     CPPUNIT_ASSERT_EQUAL(10, step->getStep());
 135
 136     CPPUNIT_ASSERT_EQUAL(0, step->getStamp());
 137     step->setStamp(100);
 138     CPPUNIT_ASSERT_EQUAL(100, step->getStamp());
 139
 140     CPPUNIT_ASSERT_EQUAL(5, step->countElements());
 141     CPPUNIT_ASSERT_EQUAL(3, step->countComponents());
 142     CPPUNIT_ASSERT_EQUAL(15, step->countValues());
 143 }
 144
 145 void FieldTest::testBooleanStep()
 146 {
 147     Step* step = new BooleanStep(0, 0, 5, 3);
 148     testStep(XAO::BOOLEAN, step);
 149 }
 150 void FieldTest::testIntegerStep()
 151 {
 152     Step* step = new IntegerStep(0, 0, 5, 3);
 153     testStep(XAO::INTEGER, step);
 154 }
 155 void FieldTest::testDoubleStep()
 156 {
 157     Step* step = new DoubleStep(0, 0, 5, 3);
 158     testStep(XAO::DOUBLE, step);
 159 }
 160 void FieldTest::testStringStep()
 161 {
 162     Step* step = new StringStep(0, 0, 5, 3);
 163     testStep(XAO::STRING, step);
 164 }
 165
 166 void FieldTest::testBooleanStepValues()
 167 {
 168     int nbComponents = 3; // > 1
 169     int nbElements = 5;   // > 1
 170
 171     BooleanStep* step = new BooleanStep(0, 0, nbElements, nbComponents);
 172     for (int i = 0; i < step->countElements(); ++i)
 173     {
 174         for (int j = 0; j < step->countComponents(); ++j)
 175         {
 176             step->setValue(i, j, j % 2 == 0);
 177         }
 178     }
 179
 180     CPPUNIT_ASSERT_EQUAL(true, step->getValue(1, 2));
 181     CPPUNIT_ASSERT_EQUAL(std::string("true"), step->getStringValue(1, 2));
 182     CPPUNIT_ASSERT_THROW(step->getValue(nbElements, 2), XAO_Exception);
 183     CPPUNIT_ASSERT_THROW(step->getValue(1, nbComponents), XAO_Exception);
 184
 185     // get all values
 186     std::vector<bool> values;
 187     values = step->getValues();
 188     CPPUNIT_ASSERT_EQUAL(nbElements*nbComponents, (int)values.size());
 189     for (int i = 0; i < nbElements; ++i)
 190     {
 191         for (int j = 0; j < nbComponents; ++j)
 192             CPPUNIT_ASSERT((j % 2 == 0) == values[i*nbComponents+j]);
 193     }
 194
 195     // get one element
 196     values = step->getElement(2);
 197     CPPUNIT_ASSERT_THROW(step->getElement(nbElements), XAO_Exception);
 198     CPPUNIT_ASSERT_EQUAL(nbComponents, (int)values.size());
 199     for (int i = 0; i < nbComponents; ++i)
 200         CPPUNIT_ASSERT((i % 2 == 0) == values[i]);
 201
 202     // get one component
 203     values = step->getComponent(1);
 204     CPPUNIT_ASSERT_THROW(step->getComponent(nbComponents), XAO_Exception);
 205     CPPUNIT_ASSERT_EQUAL(nbElements, (int)values.size());
 206     for (int i = 0; i < nbElements; ++i)
 207         CPPUNIT_ASSERT(false == values[i]);
 208
 209     // set one element
 210     std::vector<bool> newEltValues;
 211     // only one value
 212     newEltValues.push_back(true);
 213     CPPUNIT_ASSERT_THROW(step->setElement(2, newEltValues), XAO_Exception);
 214     // all values
 215     for (int i = 1; i < nbComponents; ++i)
 216         newEltValues.push_back(true);
 217     step->setElement(2, newEltValues);
 218
 219     // set one component
 220     std::vector<bool> newCompValues;
 221     // only one value
 222     newCompValues.push_back(true);
 223     CPPUNIT_ASSERT_THROW(step->setComponent(1, newCompValues), XAO_Exception);
 224     // all values
 225     for (int i = 1; i < nbElements; ++i)
 226         newCompValues.push_back(true);
 227     step->setComponent(1, newCompValues);
 228
 229     // set string value
 230     step->setStringValue(0, 0, "true");
 231     CPPUNIT_ASSERT_THROW(step->setStringValue(0, 0, "aa"), XAO_Exception);
 232
 233     // set all values
 234     std::vector<bool> allValues;
 235     // only one value
 236     allValues.push_back(true);
 237     CPPUNIT_ASSERT_THROW(step->setValues(allValues), XAO_Exception);
 238     // all values
 239     for (int i = 1; i < nbElements*nbComponents; ++i)
 240         allValues.push_back(true);
 241     step->setValues(allValues);
 242 }
 243
 244 void FieldTest::testIntegerStepValues()
 245 {
 246     int nbComponents = 3;
 247     int nbElements = 5;
 248
 249     IntegerStep* step = new IntegerStep(0, 0, nbElements, nbComponents);
 250     for (int i = 0; i < step->countElements(); ++i)
 251     {
 252         for (int j = 0; j < step->countComponents(); ++j)
 253             step->setValue(i, j, i*10 + j);
 254     }
 255
 256     CPPUNIT_ASSERT_EQUAL(12, step->getValue(1, 2));
 257     CPPUNIT_ASSERT_THROW(step->getValue(nbElements, 2), XAO_Exception);
 258     CPPUNIT_ASSERT_THROW(step->getValue(1, nbComponents), XAO_Exception);
 259
 260     // get all values
 261     std::vector<int> values;
 262     values = step->getValues();
 263     CPPUNIT_ASSERT_EQUAL(nbElements*nbComponents, (int)values.size());
 264     for (int i = 0; i < nbElements; ++i)
 265     {
 266         for (int j = 0; j < nbComponents; ++j)
 267             CPPUNIT_ASSERT_EQUAL(10*i+j, values[i*nbComponents+j]);
 268     }
 269
 270     // get one element
 271     values = step->getElement(2);
 272     CPPUNIT_ASSERT_THROW(step->getElement(nbElements), XAO_Exception);
 273     CPPUNIT_ASSERT_EQUAL(nbComponents, (int)values.size());
 274     for (int i = 0; i < nbComponents; ++i)
 275         CPPUNIT_ASSERT_EQUAL(20+i, values[i]);
 276
 277     // get one component
 278     values = step->getComponent(1);
 279     CPPUNIT_ASSERT_THROW(step->getComponent(nbComponents), XAO_Exception);
 280     CPPUNIT_ASSERT_EQUAL(nbElements, (int)values.size());
 281     for (int i = 0; i < nbElements; ++i)
 282         CPPUNIT_ASSERT_EQUAL(10*i+1, values[i]);
 283
 284     // set one element
 285     std::vector<int> newEltValues;
 286     newEltValues.push_back(1);
 287     CPPUNIT_ASSERT_THROW(step->setElement(2, newEltValues), XAO_Exception);
 288     for (int i = 1; i < nbComponents; ++i)
 289         newEltValues.push_back(1);
 290     step->setElement(2, newEltValues);
 291
 292     // set one component
 293     std::vector<int> newCompValues;
 294     newCompValues.push_back(100);
 295     CPPUNIT_ASSERT_THROW(step->setComponent(1, newCompValues), XAO_Exception);
 296     for (int i = 1; i < nbElements; ++i)
 297         newCompValues.push_back(100);
 298     step->setComponent(1, newCompValues);
 299
 300     // set string value
 301     step->setStringValue(0, 0, "0");
 302     CPPUNIT_ASSERT_THROW(step->setStringValue(0, 0, "aa"), XAO_Exception);
 303
 304     // set all values
 305     std::vector<int> allValues;
 306     // only one value
 307     allValues.push_back(11);
 308     CPPUNIT_ASSERT_THROW(step->setValues(allValues), XAO_Exception);
 309     // all values
 310     for (int i = 1; i < nbElements*nbComponents; ++i)
 311         allValues.push_back(11);
 312     step->setValues(allValues);
 313 }
 314
 315 void FieldTest::testDoubleStepValues()
 316 {
 317     int nbComponents = 3;
 318     int nbElements = 5;
 319
 320     DoubleStep* step = new DoubleStep(0, 0, nbElements, nbComponents);
 321     for (int i = 0; i < step->countElements(); ++i)
 322     {
 323         for (int j = 0; j < step->countComponents(); ++j)
 324             step->setValue(i, j, i*10 + j*0.1);
 325     }
 326
 327     CPPUNIT_ASSERT_EQUAL(10.2, step->getValue(1, 2));
 328     CPPUNIT_ASSERT_THROW(step->getValue(nbElements, 2), XAO_Exception);
 329     CPPUNIT_ASSERT_THROW(step->getValue(1, nbComponents), XAO_Exception);
 330
 331     // get all values
 332     std::vector<double> values;
 333     values = step->getValues();
 334     CPPUNIT_ASSERT_EQUAL(nbElements*nbComponents, (int)values.size());
 335     for (int i = 0; i < nbElements; ++i)
 336     {
 337         for (int j = 0; j < nbComponents; ++j)
 338             CPPUNIT_ASSERT_EQUAL(10*i+j*0.1, values[i*nbComponents+j]);
 339     }
 340
 341     // get one element
 342     values = step->getElement(2);
 343     CPPUNIT_ASSERT_THROW(step->getElement(nbElements), XAO_Exception);
 344     CPPUNIT_ASSERT_EQUAL(nbComponents, (int)values.size());
 345     for (int i = 0; i < nbComponents; ++i)
 346         CPPUNIT_ASSERT_EQUAL(20+i*0.1, values[i]);
 347
 348     // get one component
 349     values = step->getComponent(1);
 350     CPPUNIT_ASSERT_THROW(step->getComponent(nbComponents), XAO_Exception);
 351     CPPUNIT_ASSERT_EQUAL(nbElements, (int)values.size());
 352     for (int i = 0; i < nbElements; ++i)
 353         CPPUNIT_ASSERT_EQUAL(10*i+0.1, values[i]);
 354
 355     // set one element
 356     std::vector<double> newEltValues;
 357     newEltValues.push_back(1.);
 358     CPPUNIT_ASSERT_THROW(step->setElement(2, newEltValues), XAO_Exception);
 359     for (int i = 1; i < nbComponents; ++i)
 360         newEltValues.push_back(1.);
 361     step->setElement(2, newEltValues);
 362
 363     // set one component
 364     std::vector<double> newCompValues;
 365     newCompValues.push_back(100.0);
 366     CPPUNIT_ASSERT_THROW(step->setComponent(1, newCompValues), XAO_Exception);
 367     for (int i = 1; i < nbElements; ++i)
 368         newCompValues.push_back(100.0);
 369     step->setComponent(1, newCompValues);
 370
 371     // set string value
 372     step->setStringValue(0, 0, "0.2");
 373     CPPUNIT_ASSERT_THROW(step->setStringValue(0, 0, "aa"), XAO_Exception);
 374
 375     std::vector<double> allValues;
 376     // only one value
 377     allValues.push_back(1.1);
 378     CPPUNIT_ASSERT_THROW(step->setValues(allValues), XAO_Exception);
 379     // all values
 380     for (int i = 1; i < nbElements*nbComponents; ++i)
 381         allValues.push_back(1.1);
 382     step->setValues(allValues);}
 383
 384 void FieldTest::testStringStepValues()
 385 {
 386     int nbComponents = 3;
 387     int nbElements = 5;
 388
 389     StringStep* step = new StringStep(0, 0, nbElements, nbComponents);
 390     for (int i = 0; i < step->countElements(); ++i)
 391     {
 392         for (int j = 0; j < step->countComponents(); ++j)
 393             step->setValue(i, j, XaoUtils::intToString(i*10 + j));
 394     }
 395
 396     CPPUNIT_ASSERT_EQUAL(std::string("12"), step->getValue(1, 2));
 397     CPPUNIT_ASSERT_THROW(step->getValue(nbElements, 2), XAO_Exception);
 398     CPPUNIT_ASSERT_THROW(step->getValue(1, nbComponents), XAO_Exception);
 399
 400     // get all values
 401     std::vector<std::string> values;
 402     values = step->getValues();
 403     CPPUNIT_ASSERT_EQUAL(nbElements*nbComponents, (int)values.size());
 404     for (int i = 0; i < nbElements; ++i)
 405     {
 406         for (int j = 0; j < nbComponents; ++j)
 407             CPPUNIT_ASSERT_EQUAL(XaoUtils::intToString(10*i+j), values[i*nbComponents+j]);
 408     }
 409
 410     // get one element
 411     values = step->getElement(2);
 412     CPPUNIT_ASSERT_THROW(step->getElement(nbElements), XAO_Exception);
 413     CPPUNIT_ASSERT_EQUAL(nbComponents, (int)values.size());
 414     for (int i = 0; i < nbComponents; ++i)
 415         CPPUNIT_ASSERT_EQUAL(XaoUtils::intToString(20+i), values[i]);
 416
 417     // get one component
 418     values = step->getComponent(1);
 419     CPPUNIT_ASSERT_THROW(step->getComponent(nbComponents), XAO_Exception);
 420     CPPUNIT_ASSERT_EQUAL(nbElements, (int)values.size());
 421     for (int i = 0; i < nbElements; ++i)
 422         CPPUNIT_ASSERT_EQUAL(XaoUtils::intToString(10*i+1), values[i]);
 423
 424     // set one element
 425     std::vector<std::string> newEltValues;
 426     newEltValues.push_back("1");
 427     CPPUNIT_ASSERT_THROW(step->setElement(2, newEltValues), XAO_Exception);
 428     for (int i = 1; i < nbComponents; ++i)
 429         newEltValues.push_back("1");
 430     step->setElement(2, newEltValues);
 431
 432     // set one component
 433     std::vector<std::string> newCompValues;
 434     newCompValues.push_back("100");
 435     CPPUNIT_ASSERT_THROW(step->setComponent(1, newCompValues), XAO_Exception);
 436     for (int i = 1; i < nbElements; ++i)
 437         newCompValues.push_back("100");
 438     step->setComponent(1, newCompValues);
 439
 440     // set string value
 441     step->setStringValue(0, 0, "0");
 442
 443     std::vector<std::string> allValues;
 444     // only one value
 445     allValues.push_back("abc");
 446     CPPUNIT_ASSERT_THROW(step->setValues(allValues), XAO_Exception);
 447     // all values
 448     for (int i = 1; i < nbElements*nbComponents; ++i)
 449         allValues.push_back("abc");
 450     step->setValues(allValues);
 451 }
 452
 453 void FieldTest::testSetComponents()
 454 {
 455     // field with 3 components
 456     Field* f = Field::createField(XAO::INTEGER, XAO::FACE, 6, 3);
 457     CPPUNIT_ASSERT_EQUAL(std::string(""), f->getComponentName(0));
 458     CPPUNIT_ASSERT_EQUAL(std::string(""), f->getComponentName(1));
 459     CPPUNIT_ASSERT_EQUAL(std::string(""), f->getComponentName(2));
 460
 461     std::vector<std::string> names;
 462     names.push_back("vx");
 463     f->setComponentsNames(names);
 464     CPPUNIT_ASSERT_EQUAL(std::string("vx"), f->getComponentName(0));
 465     CPPUNIT_ASSERT_EQUAL(std::string(""), f->getComponentName(1));
 466     CPPUNIT_ASSERT_EQUAL(std::string(""), f->getComponentName(2));
 467
 468     names.push_back("vy");
 469     f->setComponentsNames(names);
 470     CPPUNIT_ASSERT_EQUAL(std::string("vx"), f->getComponentName(0));
 471     CPPUNIT_ASSERT_EQUAL(std::string("vy"), f->getComponentName(1));
 472     CPPUNIT_ASSERT_EQUAL(std::string(""), f->getComponentName(2));
 473
 474     names.push_back("vz");
 475     names.push_back("t");
 476     f->setComponentsNames(names);
 477     CPPUNIT_ASSERT_EQUAL(std::string("vx"), f->getComponentName(0));
 478     CPPUNIT_ASSERT_EQUAL(std::string("vy"), f->getComponentName(1));
 479     CPPUNIT_ASSERT_EQUAL(std::string("vz"), f->getComponentName(2));
 480 }