icuSources/test/intltest/pptest.cpp

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 1997-2010, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6
   7 #include "unicode/utypes.h"
   8
   9 #if !UCONFIG_NO_FORMATTING
  10
  11 #include "pptest.h"
  12
  13 #include "unicode/numfmt.h"
  14 #include "unicode/decimfmt.h"
  15
  16 // *****************************************************************************
  17 // class ParsePositionTest
  18 // *****************************************************************************
  19
  20 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break;
  21
  22 void ParsePositionTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
  23 {
  24     // if (exec) logln((UnicodeString)"TestSuite ParsePositionTest");
  25     switch (index) {
  26         CASE(0, TestParsePosition)
  27         CASE(1, TestFieldPosition)
  28         CASE(2, TestFieldPosition_example)
  29         CASE(3, Test4109023)
  30
  31         default: name = ""; break;
  32     }
  33 }
  34
  35 UBool
  36 ParsePositionTest::failure(UErrorCode status, const char* msg, UBool possibleDataError)
  37 {
  38     if(U_FAILURE(status)) {
  39         if (possibleDataError) {
  40             dataerrln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status));
  41         } else {
  42             errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status));
  43         }
  44         return TRUE;
  45     }
  46
  47     return FALSE;
  48 }
  49
  50 void ParsePositionTest::TestParsePosition()
  51 {
  52     ParsePosition pp1(0);
  53     if (pp1.getIndex() == 0) {
  54         logln("PP constructor() tested.");
  55     }else{
  56         errln("*** PP getIndex or constructor() result");
  57     }
  58
  59     {
  60         int to = 5;
  61         ParsePosition pp2( to );
  62         if (pp2.getIndex() == 5) {
  63             logln("PP getIndex and constructor(int32_t) tested.");
  64         }else{
  65             errln("*** PP getIndex or constructor(int32_t) result");
  66         }
  67         pp2.setIndex( 3 );
  68         if (pp2.getIndex() == 3) {
  69             logln("PP setIndex tested.");
  70         }else{
  71             errln("*** PP getIndex or setIndex result");
  72         }
  73     }
  74
  75     ParsePosition pp2(3), pp3(5);
  76     //pp2 = new ParsePosition( 3 );
  77     //pp3 = new ParsePosition( 5 );
  78     ParsePosition pp4(5);
  79     if ( pp2 != pp3) {
  80         logln("PP not equals tested.");
  81     }else{
  82         errln("*** PP not equals fails");
  83     }
  84     if (pp3 == pp4) {
  85         logln("PP equals tested.");
  86     }else{
  87         errln(UnicodeString("*** PP equals fails (") + pp3.getIndex() + " != " + pp4.getIndex() + ")");
  88     }
  89
  90     ParsePosition pp5;
  91     pp5 = pp4;
  92     if (pp4 == pp5) {
  93         logln("PP operator= tested.");
  94     }else{
  95         errln("*** PP operator= operator== or operator != result");
  96     }
  97
  98     ParsePosition *ppp = pp5.clone();
  99     if(ppp == &pp5 || *ppp != pp5) {
 100         errln("ParsePosition.clone() failed");
 101     }
 102     delete ppp;
 103 }
 104
 105 void ParsePositionTest::TestFieldPosition()
 106 {
 107     FieldPosition fp( 7 );
 108
 109     if (fp.getField() == 7) {
 110         logln("FP constructor(int) and getField tested.");
 111     }else{
 112         errln("*** FP constructor(int) or getField");
 113     }
 114
 115     FieldPosition fpc(fp);
 116     if (fpc.getField() == 7) {
 117         logln("FP Constructor(FP&) passed");
 118     } else {
 119         errln("*** FP Constructor(FP&)");
 120     }
 121
 122     FieldPosition fph( 3 );
 123     if ( fph.getField() != 3)
 124         errln("*** FP getField or heap constr.");
 125
 126     UBool err1 = FALSE;
 127     UBool err2 = FALSE;
 128     UBool err3 = FALSE;
 129 //        for (long i = -50; i < 50; i++ ) {
 130 //            fp.setField( i+8 );
 131 //            fp.setBeginIndex( i+6 );
 132 //            fp.setEndIndex( i+7 );
 133 //            if (fp.getField() != i+8)  err1 = TRUE;
 134 //            if (fp.getBeginIndex() != i+6) err2 = TRUE;
 135 //            if (fp.getEndIndex() != i+7) err3 = TRUE;
 136 //        }
 137     if (!err1) {
 138         logln("FP setField and getField tested.");
 139     }else{
 140         errln("*** FP setField or getField");
 141     }
 142     if (!err2) {
 143         logln("FP setBeginIndex and getBeginIndex tested.");
 144     }else{
 145         errln("*** FP setBeginIndex or getBeginIndex");
 146     }
 147     if (!err3) {
 148         logln("FP setEndIndex and getEndIndex tested.");
 149     }else{
 150         errln("*** FP setEndIndex or getEndIndex");
 151     }
 152
 153     logln("");
 154
 155     FieldPosition *pfp = fp.clone();
 156     if(pfp == &fp || *pfp != fp) {
 157         errln("FieldPosition.clone() failed");
 158     }
 159     delete pfp;
 160 }
 161
 162 void ParsePositionTest::TestFieldPosition_example()
 163 {
 164     //***** no error detection yet !!!!!!!
 165     //***** this test is for compiler checks and visual verification only.
 166     double doubleNum[] = {
 167         123456789.0,
 168         -12345678.9,
 169         1234567.89,
 170         -123456.789,
 171         12345.6789,
 172         -1234.56789,
 173         123.456789,
 174         -12.3456789,
 175         1.23456789};
 176     int dNumSize = 9;
 177
 178     UErrorCode status = U_ZERO_ERROR;
 179     NumberFormat *nf = NumberFormat::createInstance(status);
 180     if (failure(status, "NumberFormat::createInstance", TRUE)){
 181         delete nf;
 182         return;
 183     };
 184
 185     DecimalFormat *fmt = dynamic_cast<DecimalFormat *>(nf);
 186     if(fmt == NULL) {
 187         errln("NumberFormat::createInstance returned unexpected class type");
 188         return;
 189     }
 190     fmt->setDecimalSeparatorAlwaysShown(TRUE);
 191
 192     const int tempLen = 20;
 193     UnicodeString temp;
 194
 195     for (int i=0; i < dNumSize; i++) {
 196         temp.remove();
 197         //temp = new StringBuffer(); // Get new buffer
 198
 199         FieldPosition pos(NumberFormat::INTEGER_FIELD);
 200         UnicodeString buf;// = new StringBuffer();
 201         //char fmtText[tempLen];
 202         //ToCharString(fmt->format(doubleNum[i], buf, pos), fmtText);
 203         UnicodeString res;
 204         res = fmt->format(doubleNum[i], buf, pos);
 205         int tempOffset = (tempLen <= (tempLen - pos.getEndIndex())) ?
 206             tempLen : (tempLen - pos.getEndIndex());
 207         for (int j=0; j<tempOffset; j++)
 208             temp += UnicodeString("="/*'='*/); // initialize
 209         logln("FP " + temp + res);
 210     }
 211
 212     logln("");
 213     delete nf;
 214 }
 215
 216 /* @bug 4109023
 217  * Need to override ParsePosition.equals and FieldPosition.equals.
 218  */
 219 void ParsePositionTest::Test4109023()
 220 {
 221     ParsePosition p(3);
 222     ParsePosition p2(3);
 223     if (p != p2)
 224         errln("Error : ParsePosition.equals() failed");
 225     FieldPosition fp(2);
 226     FieldPosition fp2(2);
 227     if (fp != fp2)
 228         errln("Error : FieldPosition.equals() failed");
 229 }
 230
 231 #endif /* #if !UCONFIG_NO_FORMATTING */