icuSources/test/intltest/tfsmalls.cpp

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