Home | History | Annotate | Download | only in intltest 
      1 
      2 /***********************************************************************
      3  * COPYRIGHT:
      4  * Copyright (c) 1997-2012, International Business Machines Corporation
      5  * and others. All Rights Reserved.
      6  ***********************************************************************/
      7 
      8 #include "unicode/utypes.h"
      9 
     10 #if !UCONFIG_NO_FORMATTING
     11 
     12 #include "intltest.h"
     13 #include "tfsmalls.h"
     14 
     15 #include "unicode/msgfmt.h"
     16 #include "unicode/choicfmt.h"
     17 
     18 #include "unicode/parsepos.h"
     19 #include "unicode/fieldpos.h"
     20 #include "unicode/fmtable.h"
     21 
     22 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
     23 
     24 /*static UBool chkstatus( UErrorCode &status, char* msg = NULL )
     25 {
     26     UBool ok = (status == U_ZERO_ERROR);
     27     if (!ok) it_errln( msg );
     28     return ok;
     29 }*/
     30 
     31 void test_ParsePosition( void )
     32 {
     33     ParsePosition* pp1 = new ParsePosition();
     34     if (pp1 && (pp1->getIndex() == 0)) {
     35         it_logln("PP constructor() tested.");
     36     }else{
     37         it_errln("*** PP getIndex or constructor() result");
     38     }
     39     delete pp1;
     40 
     41 
     42     {
     43         int32_t to = 5;
     44         ParsePosition pp2( to );
     45         if (pp2.getIndex() == 5) {
     46             it_logln("PP getIndex and constructor(int32_t) tested.");
     47         }else{
     48             it_errln("*** PP getIndex or constructor(int32_t) result");
     49         }
     50         pp2.setIndex( 3 );
     51         if (pp2.getIndex() == 3) {
     52             it_logln("PP setIndex tested.");
     53         }else{
     54             it_errln("*** PP getIndex or setIndex result");
     55         }
     56     }
     57 
     58     ParsePosition pp2, pp3;
     59     pp2 = 3;
     60     pp3 = 5;
     61     ParsePosition pp4( pp3 );
     62     if ((pp2 != pp3) && (pp3 == pp4)) {
     63         it_logln("PP copy contructor, operator== and operator != tested.");
     64     }else{
     65         it_errln("*** PP operator== or operator != result");
     66     }
     67 
     68     ParsePosition pp5;
     69     pp5 = pp4;
     70     if ((pp4 == pp5) && (!(pp4 != pp5))) {
     71         it_logln("PP operator= tested.");
     72     }else{
     73         it_errln("*** PP operator= operator== or operator != result");
     74     }
     75 
     76 
     77 }
     78 
     79 #include "unicode/decimfmt.h"
     80 
     81 void test_FieldPosition_example( void )
     82 {
     83     //***** no error detection yet !!!!!!!
     84     //***** this test is for compiler checks and visual verification only.
     85     double doubleNum[] = { 123456789.0, -12345678.9, 1234567.89, -123456.789,
     86         12345.6789, -1234.56789, 123.456789, -12.3456789, 1.23456789};
     87     int32_t dNumSize = (int32_t)(sizeof(doubleNum)/sizeof(double));
     88 
     89     UErrorCode status = U_ZERO_ERROR;
     90     DecimalFormat* fmt = (DecimalFormat*) NumberFormat::createInstance(status);
     91     if (U_FAILURE(status)) {
     92         it_dataerrln("NumberFormat::createInstance() error");
     93         return;
     94     }
     95     fmt->setDecimalSeparatorAlwaysShown(TRUE);
     96 
     97     const int32_t tempLen = 20;
     98     char temp[tempLen];
     99 
    100     for (int32_t i=0; i<dNumSize; i++) {
    101         FieldPosition pos(NumberFormat::INTEGER_FIELD);
    102         UnicodeString buf;
    103         //char fmtText[tempLen];
    104         //ToCharString(fmt->format(doubleNum[i], buf, pos), fmtText);
    105         UnicodeString res = fmt->format(doubleNum[i], buf, pos);
    106         for (int32_t j=0; j<tempLen; j++) temp[j] = '='; // clear with spaces
    107         int32_t tempOffset = (tempLen <= (tempLen - pos.getEndIndex())) ?
    108             tempLen : (tempLen - pos.getEndIndex());
    109         temp[tempOffset] = '\0';
    110         it_logln(UnicodeString("FP ") + UnicodeString(temp) + res);
    111     }
    112     delete fmt;
    113 
    114     it_logln("");
    115 
    116 }
    117 
    118 void test_FieldPosition( void )
    119 {
    120 
    121     FieldPosition fp( 7 );
    122 
    123     if (fp.getField() == 7) {
    124         it_logln("FP constructor(int32_t) and getField tested.");
    125     }else{
    126         it_errln("*** FP constructor(int32_t) or getField");
    127     }
    128 
    129     FieldPosition* fph = new FieldPosition( 3 );
    130     if ( fph->getField() != 3) it_errln("*** FP getField or heap constr.");
    131     delete fph;
    132 
    133     UBool err1 = FALSE;
    134     UBool err2 = FALSE;
    135     UBool err3 = FALSE;
    136     for (int32_t i = -50; i < 50; i++ ) {
    137         fp.setField( i+8 );
    138         fp.setBeginIndex( i+6 );
    139         fp.setEndIndex( i+7 );
    140         if (fp.getField() != i+8)  err1 = TRUE;
    141         if (fp.getBeginIndex() != i+6) err2 = TRUE;
    142         if (fp.getEndIndex() != i+7) err3 = TRUE;
    143     }
    144     if (!err1) {
    145         it_logln("FP setField and getField tested.");
    146     }else{
    147         it_errln("*** FP setField or getField");
    148     }
    149     if (!err2) {
    150         it_logln("FP setBeginIndex and getBeginIndex tested.");
    151     }else{
    152         it_errln("*** FP setBeginIndex or getBeginIndex");
    153     }
    154     if (!err3) {
    155         it_logln("FP setEndIndex and getEndIndex tested.");
    156     }else{
    157         it_errln("*** FP setEndIndex or getEndIndex");
    158     }
    159 
    160     it_logln("");
    161 
    162 }
    163 
    164 void test_Formattable( void )
    165 {
    166     UErrorCode status = U_ZERO_ERROR;
    167     Formattable* ftp = new Formattable();
    168     if (!ftp || !(ftp->getType() == Formattable::kLong) || !(ftp->getLong() == 0)) {
    169         it_errln("*** Formattable constructor or getType or getLong");
    170     }
    171     delete ftp;
    172 
    173     Formattable fta, ftb;
    174     fta.setLong(1); ftb.setLong(2);
    175     if ((fta != ftb) || !(fta == ftb)) {
    176         it_logln("FT setLong, operator== and operator!= tested.");
    177         status = U_ZERO_ERROR;
    178         fta.getLong(&status);
    179         if ( status == U_INVALID_FORMAT_ERROR){
    180             it_errln("*** FT getLong(UErrorCode* status) failed on real Long");
    181         } else {
    182             it_logln("FT getLong(UErrorCode* status) tested.");
    183         }
    184     }else{
    185         it_errln("*** Formattable setLong or operator== or !=");
    186     }
    187     fta = ftb;
    188     if ((fta == ftb) || !(fta != ftb)) {
    189         it_logln("FT operator= tested.");
    190     }else{
    191         it_errln("*** FT operator= or operator== or operator!=");
    192     }
    193 
    194     fta.setDouble( 3.0 );
    195     if ((fta.getType() == Formattable::kDouble) && (fta.getDouble() == 3.0)) {
    196         it_logln("FT set- and getDouble tested.");
    197     }else{
    198         it_errln("*** FT set- or getDouble");
    199     }
    200 
    201     fta.getDate(status = U_ZERO_ERROR);
    202     if (status != U_INVALID_FORMAT_ERROR){
    203         it_errln("*** FT getDate with status should fail on non-Date");
    204     }
    205     fta.setDate( 4.0 );
    206     if ((fta.getType() == Formattable::kDate) && (fta.getDate() == 4.0)) {
    207         it_logln("FT set- and getDate tested.");
    208         status = U_ZERO_ERROR;
    209         fta.getDate(status);
    210         if ( status == U_INVALID_FORMAT_ERROR){
    211             it_errln("*** FT getDate with status failed on real Date");
    212         } else {
    213             it_logln("FT getDate with status tested.");
    214         }
    215     }else{
    216         it_errln("*** FT set- or getDate");
    217     }
    218 
    219     status = U_ZERO_ERROR;
    220     fta.getLong(&status);
    221     if (status != U_INVALID_FORMAT_ERROR){
    222         it_errln("*** FT getLong(UErrorCode* status) should fail on non-Long");
    223     }
    224 
    225     fta.setString("abc");
    226     const Formattable ftc(fta);
    227     UnicodeString res;
    228 
    229     {
    230         UBool t;
    231         t = (fta.getType() == Formattable::kString)
    232             && (fta.getString(res) == "abc")
    233             && (fta.getString() == "abc");
    234         res = fta.getString(status = U_ZERO_ERROR);
    235         t = t && (status != U_INVALID_FORMAT_ERROR && res == "abc");
    236         res = ftc.getString(status = U_ZERO_ERROR);
    237         t = t && (status != U_INVALID_FORMAT_ERROR && res == "abc");
    238         ftc.getString(res,status = U_ZERO_ERROR);
    239         t = t && (status != U_INVALID_FORMAT_ERROR && res == "abc");
    240         if (t) {
    241             it_logln("FT set- and getString tested.");
    242         }else{
    243             it_errln("*** FT set- or getString");
    244         }
    245     }
    246 
    247     UnicodeString ucs = "unicode-string";
    248     UnicodeString* ucs_ptr = new UnicodeString("pointed-to-unicode-string");
    249 
    250     const Formattable ftarray[] =
    251     {
    252         Formattable( 1.0, Formattable::kIsDate ),
    253         2.0,
    254         (int32_t)3,
    255         ucs,
    256         ucs_ptr
    257     };
    258     const int32_t ft_cnt = LENGTHOF(ftarray);
    259     Formattable ft_arr( ftarray, ft_cnt );
    260     UnicodeString temp;
    261     if ((ft_arr[0].getType() == Formattable::kDate)   && (ft_arr[0].getDate()   == 1.0)
    262      && (ft_arr[1].getType() == Formattable::kDouble) && (ft_arr[1].getDouble() == 2.0)
    263      && (ft_arr[2].getType() == Formattable::kLong)   && (ft_arr[2].getLong()   == (int32_t)3)
    264      && (ft_arr[3].getType() == Formattable::kString) && (ft_arr[3].getString(temp) == ucs)
    265      && (ft_arr[4].getType() == Formattable::kString) && (ft_arr[4].getString(temp) == *ucs_ptr) ) {
    266         it_logln("FT constr. for date, double, long, ustring, ustring* and array tested");
    267     }else{
    268         it_errln("*** FT constr. for date, double, long, ustring, ustring* or array");
    269     }
    270 
    271     int32_t i, res_cnt;
    272     const Formattable* res_array = ft_arr.getArray( res_cnt );
    273     if (res_cnt == ft_cnt) {
    274         UBool same  = TRUE;
    275         for (i = 0; i < res_cnt; i++ ) {
    276             if (res_array[i] != ftarray[i]) {
    277                 same = FALSE;
    278             }
    279         }
    280         if (same) {
    281             it_logln("FT getArray tested");
    282             res_array = ft_arr.getArray( res_cnt, status = U_ZERO_ERROR);
    283             if (status == U_INVALID_FORMAT_ERROR){
    284                 it_errln("*** FT getArray with status failed on real array");
    285             } else {
    286                 it_logln("FT getArray with status tested on real array");
    287             }
    288         }else{
    289             it_errln("*** FT getArray comparison");
    290         }
    291     }else{
    292         it_errln(UnicodeString("*** FT getArray count res_cnt=") + res_cnt + UnicodeString("ft_cnt=") + ft_cnt);
    293     }
    294 
    295     res_array = fta.getArray(res_cnt, status = U_ZERO_ERROR);
    296     if (status == U_INVALID_FORMAT_ERROR){
    297         if (res_cnt == 0 && res_array == NULL){
    298             it_logln("FT getArray with status tested on non array");
    299         } else {
    300             it_errln("*** FT getArray with status return values are not consistent");
    301         }
    302     } else {
    303         it_errln("*** FT getArray with status should fail on non-array");
    304     }
    305 
    306 
    307     Formattable *pf;
    308     for(i = 0; i < ft_cnt; ++i) {
    309         pf = ftarray[i].clone();
    310         if(pf == (ftarray + i) || *pf != ftarray[i]) {
    311             it_errln(UnicodeString("Formattable.clone() failed for item ") + i);
    312         }
    313         delete pf;
    314     }
    315 
    316     const Formattable ftarr1[] = { Formattable( (int32_t)1 ), Formattable( (int32_t)2 ) };
    317     const Formattable ftarr2[] = { Formattable( (int32_t)3 ), Formattable( (int32_t)4 ) };
    318 
    319     const int32_t ftarr1_cnt = (int32_t)(sizeof(ftarr1) / sizeof(Formattable));
    320     const int32_t ftarr2_cnt = (int32_t)(sizeof(ftarr2) / sizeof(Formattable));
    321 
    322     ft_arr.setArray( ftarr1, ftarr1_cnt );
    323     if ((ft_arr[0].getType() == Formattable::kLong) && (ft_arr[0].getLong() == (int32_t)1)) {
    324         it_logln("FT setArray tested");
    325     }else{
    326         it_errln("*** FT setArray");
    327     }
    328 
    329     Formattable* ft_dynarr = new Formattable[ftarr2_cnt];
    330     for (i = 0; i < ftarr2_cnt; i++ ) {
    331         ft_dynarr[i] = ftarr2[i];
    332     }
    333     if ((ft_dynarr[0].getType() == Formattable::kLong) && (ft_dynarr[0].getLong() == (int32_t)3)
    334      && (ft_dynarr[1].getType() == Formattable::kLong) && (ft_dynarr[1].getLong() == (int32_t)4)) {
    335         it_logln("FT operator= and array operations tested");
    336     }else{
    337         it_errln("*** FT operator= or array operations");
    338     }
    339 
    340     ft_arr.adoptArray( ft_dynarr, ftarr2_cnt );
    341     if ((ft_arr[0].getType() == Formattable::kLong) && (ft_arr[0].getLong() == (int32_t)3)
    342      && (ft_arr[1].getType() == Formattable::kLong) && (ft_arr[1].getLong() == (int32_t)4)) {
    343         it_logln("FT adoptArray tested");
    344     }else{
    345         it_errln("*** FT adoptArray or operator[]");
    346     }
    347 
    348     ft_arr.setLong(0);   // calls 'dispose' and deletes adopted array !
    349 
    350     UnicodeString* ucs_dyn = new UnicodeString("ttt");
    351     UnicodeString tmp2;
    352 
    353     fta.adoptString( ucs_dyn );
    354     if ((fta.getType() == Formattable::kString) && (fta.getString(tmp2) == "ttt")) {
    355         it_logln("FT adoptString tested");
    356     }else{
    357         it_errln("*** FT adoptString or getString");
    358     }
    359     fta.setLong(0);   // calls 'dispose' and deletes adopted string !
    360 
    361     it_logln();
    362 }
    363 
    364 void TestFormatSmallClasses::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
    365 {
    366     switch (index) {
    367         case 0: name = "pp";
    368                 if (exec) logln("TestSuite Format/SmallClasses/ParsePosition (f/chc/sma/pp): ");
    369                 if (exec) test_ParsePosition();
    370                 break;
    371         case 1: name = "fp";
    372                 if (exec) logln("TestSuite Format/SmallClasses/FieldPosition (f/chc/sma/fp): ");
    373                 if (exec) test_FieldPosition();
    374                 break;
    375         case 2: name = "fpe";
    376                 if (exec) logln("TestSuite Format/SmallClasses/FieldPositionExample (f/chc/sma/fpe): ");
    377                 if (exec) test_FieldPosition_example();
    378                 break;
    379         case 3: name = "ft";
    380                 if (exec) logln("TestSuite Format/SmallClasses/Formattable (f/chc/sma/ft): ");
    381                 if (exec) test_Formattable();
    382                 break;
    383         default: name = ""; break; //needed to end loop
    384     }
    385 }
    386 
    387 #endif /* #if !UCONFIG_NO_FORMATTING */
    388