Home | History | Annotate | Download | only in intltest
      1 /********************************************************************
      2  * COPYRIGHT:
      3  * Copyright (c) 2004-2011, International Business Machines Corporation and
      4  * others. All Rights Reserved.
      5  ********************************************************************/
      6 
      7 //      Test parts of UVector and UStack
      8 
      9 #include "intltest.h"
     10 
     11 #include "uvectest.h"
     12 #include "cstring.h"
     13 #include "hash.h"
     14 #include "uelement.h"
     15 #include "uvector.h"
     16 
     17 //---------------------------------------------------------------------------
     18 //
     19 //  Test class boilerplate
     20 //
     21 //---------------------------------------------------------------------------
     22 UVectorTest::UVectorTest()
     23 {
     24 }
     25 
     26 
     27 UVectorTest::~UVectorTest()
     28 {
     29 }
     30 
     31 
     32 
     33 void UVectorTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
     34 {
     35     if (exec) logln("TestSuite UVectorTest: ");
     36     switch (index) {
     37 
     38         case 0: name = "UVector_API";
     39             if (exec) UVector_API();
     40             break;
     41         case 1: name = "UStack_API";
     42             if (exec) UStack_API();
     43             break;
     44         case 2: name = "Hashtable_API";
     45             if (exec) Hashtable_API();
     46             break;
     47         default: name = "";
     48             break; //needed to end loop
     49     }
     50 }
     51 
     52 
     53 //---------------------------------------------------------------------------
     54 //
     55 //   Error Checking / Reporting macros used in all of the tests.
     56 //
     57 //---------------------------------------------------------------------------
     58 #define TEST_CHECK_STATUS(status) \
     59     if (U_FAILURE(status)) {\
     60         errln("UVectorTest failure at line %d.  status=%s\n", __LINE__, u_errorName(status));\
     61         return;\
     62     }
     63 
     64 #define TEST_ASSERT(expr) \
     65     if ((expr)==FALSE) {\
     66         errln("UVectorTest failure at line %d.\n", __LINE__);\
     67     }
     68 
     69 static int8_t U_CALLCONV
     70 UVectorTest_compareInt32(UElement key1, UElement key2) {
     71     if (key1.integer > key2.integer) {
     72         return 1;
     73     }
     74     else if (key1.integer < key2.integer) {
     75         return -1;
     76     }
     77     return 0;
     78 }
     79 
     80 U_CDECL_BEGIN
     81 static int8_t U_CALLCONV
     82 UVectorTest_compareCstrings(const UElement key1, const UElement key2) {
     83     return !strcmp((const char *)key1.pointer, (const char *)key2.pointer);
     84 }
     85 U_CDECL_END
     86 
     87 //---------------------------------------------------------------------------
     88 //
     89 //      UVector_API      Check for basic functionality of UVector.
     90 //
     91 //---------------------------------------------------------------------------
     92 void UVectorTest::UVector_API() {
     93 
     94     UErrorCode  status = U_ZERO_ERROR;
     95     UVector     *a;
     96 
     97     a = new UVector(status);
     98     TEST_CHECK_STATUS(status);
     99     delete a;
    100 
    101     status = U_ZERO_ERROR;
    102     a = new UVector(2000, status);
    103     TEST_CHECK_STATUS(status);
    104     delete a;
    105 
    106     status = U_ZERO_ERROR;
    107     a = new UVector(status);
    108     a->sortedInsert((int32_t)10, UVectorTest_compareInt32, status);
    109     a->sortedInsert((int32_t)20, UVectorTest_compareInt32, status);
    110     a->sortedInsert((int32_t)30, UVectorTest_compareInt32, status);
    111     a->sortedInsert((int32_t)15, UVectorTest_compareInt32, status);
    112     TEST_CHECK_STATUS(status);
    113     TEST_ASSERT(a->elementAti(0) == 10);
    114     TEST_ASSERT(a->elementAti(1) == 15);
    115     TEST_ASSERT(a->elementAti(2) == 20);
    116     TEST_ASSERT(a->elementAti(3) == 30);
    117     TEST_ASSERT(a->indexOf((int32_t)3) == -1);
    118     TEST_ASSERT(a->indexOf((int32_t)15) == 1);
    119     TEST_ASSERT(a->indexOf((int32_t)15, 2) == -1);
    120     TEST_ASSERT(a->contains((int32_t)15));
    121     TEST_ASSERT(!a->contains((int32_t)5));
    122     delete a;
    123 }
    124 
    125 void UVectorTest::UStack_API() {
    126     UErrorCode  status = U_ZERO_ERROR;
    127     UStack     *a;
    128 
    129     a = new UStack(status);
    130     TEST_CHECK_STATUS(status);
    131     delete a;
    132 
    133     status = U_ZERO_ERROR;
    134     a = new UStack(2000, status);
    135     TEST_CHECK_STATUS(status);
    136     delete a;
    137 
    138     status = U_ZERO_ERROR;
    139     a = new UStack(NULL, NULL, 2000, status);
    140     TEST_CHECK_STATUS(status);
    141     delete a;
    142 
    143     status = U_ZERO_ERROR;
    144     a = new UStack(NULL, UVectorTest_compareCstrings, status);
    145     TEST_ASSERT(a->empty());
    146     a->push((void*)"abc", status);
    147     TEST_ASSERT(!a->empty());
    148     a->push((void*)"bcde", status);
    149     a->push((void*)"cde", status);
    150     TEST_CHECK_STATUS(status);
    151     TEST_ASSERT(strcmp("cde", (const char *)a->peek()) == 0);
    152     TEST_ASSERT(a->search((void*)"cde") == 1);
    153     TEST_ASSERT(a->search((void*)"bcde") == 2);
    154     TEST_ASSERT(a->search((void*)"abc") == 3);
    155     TEST_ASSERT(strcmp("abc", (const char *)a->firstElement()) == 0);
    156     TEST_ASSERT(strcmp("cde", (const char *)a->lastElement()) == 0);
    157     TEST_ASSERT(strcmp("cde", (const char *)a->pop()) == 0);
    158     TEST_ASSERT(strcmp("bcde", (const char *)a->pop()) == 0);
    159     TEST_ASSERT(strcmp("abc", (const char *)a->pop()) == 0);
    160     delete a;
    161 }
    162 
    163 U_CDECL_BEGIN
    164 static UBool U_CALLCONV neverTRUE(const UElement /*key1*/, const UElement /*key2*/) {
    165     return FALSE;
    166 }
    167 
    168 U_CDECL_END
    169 
    170 void UVectorTest::Hashtable_API() {
    171     UErrorCode status = U_ZERO_ERROR;
    172     Hashtable *a = new Hashtable(status);
    173     TEST_ASSERT((a->puti("a", 1, status) == 0));
    174     TEST_ASSERT((a->find("a") != NULL));
    175     TEST_ASSERT((a->find("b") == NULL));
    176     TEST_ASSERT((a->puti("b", 2, status) == 0));
    177     TEST_ASSERT((a->find("b") != NULL));
    178     TEST_ASSERT((a->removei("a") == 1));
    179     TEST_ASSERT((a->find("a") == NULL));
    180 
    181     /* verify that setValueComparator works */
    182     Hashtable b(status);
    183     TEST_ASSERT((!a->equals(b)));
    184     TEST_ASSERT((b.puti("b", 2, status) == 0));
    185     TEST_ASSERT((!a->equals(b))); // Without a value comparator, this will be FALSE by default.
    186     b.setValueComparator(uhash_compareLong);
    187     TEST_ASSERT((!a->equals(b)));
    188     a->setValueComparator(uhash_compareLong);
    189     TEST_ASSERT((a->equals(b)));
    190     TEST_ASSERT((a->equals(*a))); // This better be reflexive.
    191 
    192     /* verify that setKeyComparator works */
    193     TEST_ASSERT((a->puti("a", 1, status) == 0));
    194     TEST_ASSERT((a->find("a") != NULL));
    195     a->setKeyComparator(neverTRUE);
    196     TEST_ASSERT((a->find("a") == NULL));
    197 
    198     delete a;
    199 }
    200 
    201