icuSources/test/intltest/v32test.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /********************************************************************
   4  * COPYRIGHT:
   5  * Copyright (c) 2002-2007, International Business Machines Corporation and
   6  * others. All Rights Reserved.
   7  ********************************************************************/
   8
   9 //
  10 //   regextst.cpp
  11 //
  12 //      ICU Regular Expressions test, part of intltest.
  13 //
  14
  15 #include "intltest.h"
  16
  17 #include "v32test.h"
  18 #include "uvectr32.h"
  19 #include "uvector.h"
  20 #include "util.h"
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23
  24
  25 //---------------------------------------------------------------------------
  26 //
  27 //  Test class boilerplate
  28 //
  29 //---------------------------------------------------------------------------
  30 UVector32Test::UVector32Test()
  31 {
  32 }
  33
  34
  35 UVector32Test::~UVector32Test()
  36 {
  37 }
  38
  39
  40
  41 void UVector32Test::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
  42 {
  43     if (exec) logln("TestSuite UVector32Test: ");
  44     switch (index) {
  45
  46         case 0: name = "UVector32_API";
  47             if (exec) UVector32_API();
  48             break;
  49         default: name = "";
  50             break; //needed to end loop
  51     }
  52 }
  53
  54
  55 //---------------------------------------------------------------------------
  56 //
  57 //   Error Checking / Reporting macros used in all of the tests.
  58 //
  59 //---------------------------------------------------------------------------
  60 #define TEST_CHECK_STATUS(status) \
  61     if (U_FAILURE(status)) {\
  62         errln("UVector32Test failure at line %d.  status=%s\n", __LINE__, u_errorName(status));\
  63         return;\
  64     }
  65
  66 #define TEST_ASSERT(expr) \
  67     if ((expr)==FALSE) {\
  68         errln("UVector32Test failure at line %d.\n", __LINE__);\
  69     }
  70
  71 //---------------------------------------------------------------------------
  72 //
  73 //      UVector32_API      Check for basic functionality of UVector32.
  74 //
  75 //---------------------------------------------------------------------------
  76 void UVector32Test::UVector32_API() {
  77
  78     UErrorCode  status = U_ZERO_ERROR;
  79     UVector32     *a;
  80     UVector32     *b;
  81
  82     a = new UVector32(status);
  83     TEST_CHECK_STATUS(status);
  84     delete a;
  85
  86     status = U_ZERO_ERROR;
  87     a = new UVector32(2000, status);
  88     TEST_CHECK_STATUS(status);
  89     delete a;
  90
  91     //
  92     //  assign()
  93     //
  94     status = U_ZERO_ERROR;
  95     a = new UVector32(status);
  96     a->addElement(10, status);
  97     a->addElement(20, status);
  98     a->addElement(30, status);
  99     b = new UVector32(status);
 100     b->assign(*a, status);
 101     TEST_ASSERT(b->size() == 3);
 102     TEST_ASSERT(b->elementAti(1) == 20);
 103     TEST_CHECK_STATUS(status);
 104     delete a;
 105     delete b;
 106
 107     //
 108     //  operator == and != and equals()
 109     //
 110     status = U_ZERO_ERROR;
 111     a = new UVector32(status);
 112     a->addElement(10, status);
 113     a->addElement(20, status);
 114     a->addElement(30, status);
 115     b = new UVector32(status);
 116     TEST_ASSERT(*b != *a);
 117     TEST_ASSERT(!(*b == *a));
 118     TEST_ASSERT(!b->equals(*a));
 119     b->assign(*a, status);
 120     TEST_ASSERT(*b == *a);
 121     TEST_ASSERT(!(*b != *a));
 122     TEST_ASSERT(b->equals(*a));
 123     b->addElement(666, status);
 124     TEST_ASSERT(*b != *a);
 125     TEST_ASSERT(!(*b == *a));
 126     TEST_ASSERT(!b->equals(*a));
 127     TEST_CHECK_STATUS(status);
 128     delete b;
 129     delete a;
 130
 131     //
 132     //  addElement().   Covered by above tests.
 133     //
 134
 135     //
 136     // setElementAt()
 137     //
 138     status = U_ZERO_ERROR;
 139     a = new UVector32(status);
 140     a->addElement(10, status);
 141     a->addElement(20, status);
 142     a->addElement(30, status);
 143     a->setElementAt(666, 1);
 144     TEST_ASSERT(a->elementAti(0) == 10);
 145     TEST_ASSERT(a->elementAti(1) == 666);
 146     TEST_ASSERT(a->size() == 3);
 147     TEST_CHECK_STATUS(status);
 148     delete a;
 149
 150     //
 151     // insertElementAt()
 152     //
 153     status = U_ZERO_ERROR;
 154     a = new UVector32(status);
 155     a->addElement(10, status);
 156     a->addElement(20, status);
 157     a->addElement(30, status);
 158     a->insertElementAt(666, 1, status);
 159     TEST_ASSERT(a->elementAti(0) == 10);
 160     TEST_ASSERT(a->elementAti(1) == 666);
 161     TEST_ASSERT(a->elementAti(2) == 20);
 162     TEST_ASSERT(a->elementAti(3) == 30);
 163     TEST_ASSERT(a->size() == 4);
 164     TEST_CHECK_STATUS(status);
 165     delete a;
 166
 167     //
 168     //  elementAti()    covered by above tests
 169     //
 170
 171     //
 172     //  lastElementi
 173     //
 174     status = U_ZERO_ERROR;
 175     a = new UVector32(status);
 176     a->addElement(10, status);
 177     a->addElement(20, status);
 178     a->addElement(30, status);
 179     TEST_ASSERT(a->lastElementi() == 30);
 180     TEST_CHECK_STATUS(status);
 181     delete a;
 182
 183
 184     //
 185     //  indexOf
 186     //
 187     status = U_ZERO_ERROR;
 188     a = new UVector32(status);
 189     a->addElement(10, status);
 190     a->addElement(20, status);
 191     a->addElement(30, status);
 192     TEST_ASSERT(a->indexOf(30, 0) == 2);
 193     TEST_ASSERT(a->indexOf(40, 0) == -1);
 194     TEST_ASSERT(a->indexOf(10, 0) == 0);
 195     TEST_ASSERT(a->indexOf(10, 1) == -1);
 196     TEST_CHECK_STATUS(status);
 197     delete a;
 198
 199
 200     //
 201     //  contains
 202     //
 203     status = U_ZERO_ERROR;
 204     a = new UVector32(status);
 205     a->addElement(10, status);
 206     a->addElement(20, status);
 207     a->addElement(30, status);
 208     TEST_ASSERT(a->contains(10) == TRUE);
 209     TEST_ASSERT(a->contains(11) == FALSE);
 210     TEST_ASSERT(a->contains(20) == TRUE);
 211     TEST_ASSERT(a->contains(-10) == FALSE);
 212     TEST_CHECK_STATUS(status);
 213     delete a;
 214
 215
 216     //
 217     //  containsAll
 218     //
 219     status = U_ZERO_ERROR;
 220     a = new UVector32(status);
 221     a->addElement(10, status);
 222     a->addElement(20, status);
 223     a->addElement(30, status);
 224     b = new UVector32(status);
 225     TEST_ASSERT(a->containsAll(*b) == TRUE);
 226     b->addElement(2, status);
 227     TEST_ASSERT(a->containsAll(*b) == FALSE);
 228     b->setElementAt(10, 0);
 229     TEST_ASSERT(a->containsAll(*b) == TRUE);
 230     TEST_ASSERT(b->containsAll(*a) == FALSE);
 231     b->addElement(30, status);
 232     b->addElement(20, status);
 233     TEST_ASSERT(a->containsAll(*b) == TRUE);
 234     TEST_ASSERT(b->containsAll(*a) == TRUE);
 235     b->addElement(2, status);
 236     TEST_ASSERT(a->containsAll(*b) == FALSE);
 237     TEST_ASSERT(b->containsAll(*a) == TRUE);
 238     TEST_CHECK_STATUS(status);
 239     delete a;
 240     delete b;
 241
 242     //
 243     //  removeAll
 244     //
 245     status = U_ZERO_ERROR;
 246     a = new UVector32(status);
 247     a->addElement(10, status);
 248     a->addElement(20, status);
 249     a->addElement(30, status);
 250     b = new UVector32(status);
 251     a->removeAll(*b);
 252     TEST_ASSERT(a->size() == 3);
 253     b->addElement(20, status);
 254     a->removeAll(*b);
 255     TEST_ASSERT(a->size() == 2);
 256     TEST_ASSERT(a->contains(10)==TRUE);
 257     TEST_ASSERT(a->contains(30)==TRUE);
 258     b->addElement(10, status);
 259     a->removeAll(*b);
 260     TEST_ASSERT(a->size() == 1);
 261     TEST_ASSERT(a->contains(30) == TRUE);
 262     TEST_CHECK_STATUS(status);
 263     delete a;
 264     delete b;
 265
 266     //
 267     // retainAll
 268     //
 269     status = U_ZERO_ERROR;
 270     a = new UVector32(status);
 271     a->addElement(10, status);
 272     a->addElement(20, status);
 273     a->addElement(30, status);
 274     b = new UVector32(status);
 275     b->addElement(10, status);
 276     b->addElement(20, status);
 277     b->addElement(30, status);
 278     b->addElement(15, status);
 279     a->retainAll(*b);
 280     TEST_ASSERT(a->size() == 3);
 281     b->removeElementAt(1);
 282     a->retainAll(*b);
 283     TEST_ASSERT(a->contains(20) == FALSE);
 284     TEST_ASSERT(a->size() == 2);
 285     b->removeAllElements();
 286     TEST_ASSERT(b->size() == 0);
 287     a->retainAll(*b);
 288     TEST_ASSERT(a->size() == 0);
 289     TEST_CHECK_STATUS(status);
 290     delete a;
 291     delete b;
 292
 293     //
 294     //  removeElementAt   Tested above.
 295     //
 296
 297     //
 298     //  removeAllElments   Tested above
 299     //
 300
 301     //
 302     //  size()   tested above
 303     //
 304
 305     //
 306     //  isEmpty
 307     //
 308     status = U_ZERO_ERROR;
 309     a = new UVector32(status);
 310     TEST_ASSERT(a->isEmpty() == TRUE);
 311     a->addElement(10, status);
 312     TEST_ASSERT(a->isEmpty() == FALSE);
 313     a->addElement(20, status);
 314     a->removeElementAt(0);
 315     TEST_ASSERT(a->isEmpty() == FALSE);
 316     a->removeElementAt(0);
 317     TEST_ASSERT(a->isEmpty() == TRUE);
 318     TEST_CHECK_STATUS(status);
 319     delete a;
 320
 321
 322     //
 323     // ensureCapacity, expandCapacity
 324     //
 325     status = U_ZERO_ERROR;
 326     a = new UVector32(status);
 327     TEST_ASSERT(a->isEmpty() == TRUE);
 328     a->addElement(10, status);
 329     TEST_ASSERT(a->ensureCapacity(5000, status)== TRUE);
 330     TEST_ASSERT(a->expandCapacity(20000, status) == TRUE);
 331     TEST_CHECK_STATUS(status);
 332     delete a;
 333
 334     //
 335     // setSize
 336     //
 337     status = U_ZERO_ERROR;
 338     a = new UVector32(status);
 339     a->addElement(10, status);
 340     a->addElement(20, status);
 341     a->addElement(30, status);
 342     a->setSize(100);
 343     TEST_ASSERT(a->size() == 100);
 344     TEST_ASSERT(a->elementAti(0) == 10);
 345     TEST_ASSERT(a->elementAti(1) == 20);
 346     TEST_ASSERT(a->elementAti(2) == 30);
 347     TEST_ASSERT(a->elementAti(3) == 0);
 348     a->setElementAt(666, 99);
 349     a->setElementAt(777, 100);
 350     TEST_ASSERT(a->elementAti(99) == 666);
 351     TEST_ASSERT(a->elementAti(100) == 0);
 352     a->setSize(2);
 353     TEST_ASSERT(a->elementAti(1) == 20);
 354     TEST_ASSERT(a->elementAti(2) == 0);
 355     TEST_ASSERT(a->size() == 2);
 356     a->setSize(0);
 357     TEST_ASSERT(a->empty() == TRUE);
 358     TEST_ASSERT(a->size() == 0);
 359
 360     TEST_CHECK_STATUS(status);
 361     delete a;
 362
 363     //
 364     // containsNone
 365     //
 366     status = U_ZERO_ERROR;
 367     a = new UVector32(status);
 368     a->addElement(10, status);
 369     a->addElement(20, status);
 370     a->addElement(30, status);
 371     b = new UVector32(status);
 372     TEST_ASSERT(a->containsNone(*b) == TRUE);
 373     b->addElement(5, status);
 374     TEST_ASSERT(a->containsNone(*b) == TRUE);
 375     b->addElement(30, status);
 376     TEST_ASSERT(a->containsNone(*b) == FALSE);
 377
 378     TEST_CHECK_STATUS(status);
 379     delete a;
 380     delete b;
 381
 382     //
 383     // sortedInsert
 384     //
 385     status = U_ZERO_ERROR;
 386     a = new UVector32(status);
 387     a->sortedInsert(30, status);
 388     a->sortedInsert(20, status);
 389     a->sortedInsert(10, status);
 390     TEST_ASSERT(a->elementAti(0) == 10);
 391     TEST_ASSERT(a->elementAti(1) == 20);
 392     TEST_ASSERT(a->elementAti(2) == 30);
 393
 394     TEST_CHECK_STATUS(status);
 395     delete a;
 396
 397     //
 398     // getBuffer
 399     //
 400     status = U_ZERO_ERROR;
 401     a = new UVector32(status);
 402     a->addElement(10, status);
 403     a->addElement(20, status);
 404     int32_t *buf = a->getBuffer();
 405     TEST_ASSERT(buf[0] == 10);
 406     TEST_ASSERT(buf[1] == 20);
 407     a->setSize(20000);
 408     int32_t *resizedBuf;
 409     resizedBuf = a->getBuffer();
 410     //TEST_ASSERT(buf != resizedBuf); // The buffer might have been realloc'd
 411     TEST_ASSERT(resizedBuf[0] == 10);
 412     TEST_ASSERT(resizedBuf[1] == 20);
 413
 414     TEST_CHECK_STATUS(status);
 415     delete a;
 416
 417
 418     //
 419     //  empty
 420     //
 421     status = U_ZERO_ERROR;
 422     a = new UVector32(status);
 423     TEST_ASSERT(a->empty() == TRUE);
 424     a->addElement(10, status);
 425     TEST_ASSERT(a->empty() == FALSE);
 426     a->addElement(20, status);
 427     a->removeElementAt(0);
 428     TEST_ASSERT(a->empty() == FALSE);
 429     a->removeElementAt(0);
 430     TEST_ASSERT(a->empty() == TRUE);
 431     TEST_CHECK_STATUS(status);
 432     delete a;
 433
 434
 435     //
 436     //  peeki
 437     //
 438     status = U_ZERO_ERROR;
 439     a = new UVector32(status);
 440     a->addElement(10, status);
 441     TEST_ASSERT(a->peeki() == 10);
 442     a->addElement(20, status);
 443     TEST_ASSERT(a->peeki() == 20);
 444     a->addElement(30, status);
 445     TEST_ASSERT(a->peeki() == 30);
 446     TEST_CHECK_STATUS(status);
 447     delete a;
 448
 449
 450     //
 451     // popi
 452     //
 453     status = U_ZERO_ERROR;
 454     a = new UVector32(status);
 455     a->addElement(10, status);
 456     a->addElement(20, status);
 457     a->addElement(30, status);
 458     TEST_ASSERT(a->popi() == 30);
 459     TEST_ASSERT(a->popi() == 20);
 460     TEST_ASSERT(a->popi() == 10);
 461     TEST_ASSERT(a->popi() == 0);
 462     TEST_ASSERT(a->isEmpty());
 463     TEST_CHECK_STATUS(status);
 464     delete a;
 465
 466     //
 467     // push
 468     //
 469     status = U_ZERO_ERROR;
 470     a = new UVector32(status);
 471     TEST_ASSERT(a->push(10, status) == 10);
 472     TEST_ASSERT(a->push(20, status) == 20);
 473     TEST_ASSERT(a->push(30, status) == 30);
 474     TEST_ASSERT(a->size() == 3);
 475     TEST_ASSERT(a->popi() == 30);
 476     TEST_ASSERT(a->popi() == 20);
 477     TEST_ASSERT(a->popi() == 10);
 478     TEST_ASSERT(a->isEmpty());
 479     TEST_CHECK_STATUS(status);
 480     delete a;
 481
 482
 483     //
 484     // reserveBlock
 485     //
 486     status = U_ZERO_ERROR;
 487     a = new UVector32(status);
 488     a->ensureCapacity(1000, status);
 489
 490     // TODO:
 491
 492     TEST_CHECK_STATUS(status);
 493     delete a;
 494
 495 }
 496
 497