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
22void 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
35UBool
36ParsePositionTest::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
50void 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
105void 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
162void 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 */
219void 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