Home | History | Annotate | Download | only in intltest 
      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 */
    232