diff options
author | Jonathan Kew <jfkthame@googlemail.com> | 2008-03-04 13:26:36 +0000 |
---|---|---|
committer | Jonathan Kew <jfkthame@googlemail.com> | 2008-03-04 13:26:36 +0000 |
commit | 53790d2a0c50915d8cec71df3e89cd24d887b2fe (patch) | |
tree | 16f6b4df067eb3c2024e0a7735cb7ccea86b3aba /Build/source/libs/icu-xetex/test/intltest/tchcfmt.cpp | |
parent | f483a5de9331a257f597282e611ecfb63f5ab118 (diff) |
update icu-xetex to 3.8.1-based code from xetex repository
git-svn-id: svn://tug.org/texlive/trunk@6842 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/libs/icu-xetex/test/intltest/tchcfmt.cpp')
-rw-r--r-- | Build/source/libs/icu-xetex/test/intltest/tchcfmt.cpp | 652 |
1 files changed, 652 insertions, 0 deletions
diff --git a/Build/source/libs/icu-xetex/test/intltest/tchcfmt.cpp b/Build/source/libs/icu-xetex/test/intltest/tchcfmt.cpp new file mode 100644 index 00000000000..82d237d5102 --- /dev/null +++ b/Build/source/libs/icu-xetex/test/intltest/tchcfmt.cpp @@ -0,0 +1,652 @@ + +/******************************************************************** + * COPYRIGHT: + * Copyright (c) 1997-2005, International Business Machines Corporation and + * others. All Rights Reserved. + ********************************************************************/ + +#include "unicode/utypes.h" + +#if !UCONFIG_NO_FORMATTING + +#include "intltest.h" +#include "tchcfmt.h" +#include "cmemory.h" +#include "unicode/msgfmt.h" +#include "unicode/choicfmt.h" + +#include <float.h> + +// tests have obvious memory leaks! + +void TestChoiceFormat::runIndexedTest(int32_t index, UBool exec, + const char* &name, char* /*par*/) { + switch (index) { + TESTCASE(0,TestSimpleExample); + TESTCASE(1,TestComplexExample); + TESTCASE(2,TestClosures); + TESTCASE(3,TestPatterns); + default: name = ""; break; + } +} + +static UBool chkstatus( UErrorCode &status, const char* msg = NULL ) +{ + UBool ok = U_SUCCESS(status); + if (!ok) it_errln( msg ); + return ok; +} + +void +TestChoiceFormat::TestSimpleExample( void ) +{ + double limits[] = {1,2,3,4,5,6,7}; + UnicodeString monthNames[] = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}; + ChoiceFormat* form = new ChoiceFormat(limits, monthNames, 7); + ParsePosition parse_pos; + // TODO Fix this ParsePosition stuff... + UnicodeString str; + UnicodeString res1, res2; + UErrorCode status; + FieldPosition fpos(0); + Formattable f; + int32_t ix; + //for (double i = 0.0; i <= 8.0; ++i) { + for (ix = 0; ix <= 8; ++ix) { + double i = ix; //nos + status = U_ZERO_ERROR; + fpos = 0; + str = ""; + res1 = form->format(i, str, fpos, status ); + if (!chkstatus( status, "*** test_simple_example format" )) { + delete form; + return; + } + //form->parse(res1, f, parse_pos); + res2 = " ??? "; + it_logln(UnicodeString("") + ix + UnicodeString(" -> ") + res1 + UnicodeString(" -> ") + res2); + } + //Testing ==operator + const double filelimits[] = {0,1,2}; + const UnicodeString filepart[] = {"are no files","is one file","are {2} files"}; + ChoiceFormat* formnew=new ChoiceFormat(filelimits, filepart, 3); + ChoiceFormat* formequal=new ChoiceFormat(limits, monthNames, 7); + if(*formnew == *form){ + errln("ERROR: ==operator failed\n"); + } + if(!(*form == *formequal)){ + errln("ERROR: ==operator failed\n"); + } + delete formequal; + +#ifdef U_USE_CHOICE_FORMAT_DEPRECATES + //Testing adoptChoices() + double *limitsToAdopt = (double *)uprv_malloc(7 * sizeof(double)); + UnicodeString *monthNamesToAdopt = new UnicodeString[7]; + + uprv_arrayCopy(monthNames, monthNamesToAdopt, 7); + uprv_memcpy(limitsToAdopt, limits, (size_t)(7 * sizeof(limits[0]))); + + formnew->adoptChoices(limitsToAdopt, monthNamesToAdopt, 7); + if(!(*formnew == *form)){ + errln("ERROR: ==Operator or adoptChoices failed\n"); + } +#endif + + delete formnew; + + //Testing getLimits() + double *gotLimits=0; + int32_t count=0; + gotLimits=(double*)form->getLimits(count); + if(count != 7){ + errln("getLimits didn't update the count correctly\n"); + } + for(ix=0; ix<count; ix++){ + if(gotLimits[ix] != limits[ix]){ + errln((UnicodeString)"getLimits didn't get the limits correctly. Expected " + limits[ix] + " Got " + gotLimits[ix]); + } + } + //Testing getFormat() + count=0; + UnicodeString *gotFormats=0; + gotFormats=(UnicodeString*)form->getFormats(count); + if(count != 7){ + errln("getFormats didn't update the count correctly\n"); + } + for(ix=0; ix<count; ix++){ + if(gotFormats[ix] != monthNames[ix]){ + errln((UnicodeString)"getFormats didn't get the Formats correctly. Expected " + monthNames[ix] + " Got " + gotFormats[ix]); + } + } + + + delete form; + +} + +void +TestChoiceFormat::TestComplexExample( void ) +{ + UErrorCode status = U_ZERO_ERROR; + const double filelimits[] = {-1, 0,1,2}; + const UnicodeString filepart[] = {"are corrupted files", "are no files","is one file","are {2} files"}; + + ChoiceFormat* fileform = new ChoiceFormat( filelimits, filepart, 4); + + if (!fileform) { + it_errln("*** test_complex_example fileform"); + return; + } + + Format* filenumform = NumberFormat::createInstance( status ); + if (!filenumform) { + it_errln("*** test_complex_example filenumform"); + delete fileform; + return; + } + if (!chkstatus( status, "*** test_simple_example filenumform" )) { + delete fileform; + delete filenumform; + return; + } + + //const Format* testFormats[] = { fileform, NULL, filenumform }; + //pattform->setFormats( testFormats, 3 ); + + MessageFormat* pattform = new MessageFormat("There {0} on {1}", status ); + if (!pattform) { + it_errln("*** test_complex_example pattform"); + delete fileform; + delete filenumform; + return; + } + if (!chkstatus( status, "*** test_complex_example pattform" )) { + delete fileform; + delete filenumform; + delete pattform; + return; + } + + pattform->setFormat( 0, *fileform ); + pattform->setFormat( 2, *filenumform ); + + + Formattable testArgs[] = {(int32_t)0, "Disk_A", (int32_t)0}; + UnicodeString str; + UnicodeString res1, res2; + pattform->toPattern( res1 ); + it_logln("MessageFormat toPattern: " + res1); + fileform->toPattern( res1 ); + it_logln("ChoiceFormat toPattern: " + res1); + if (res1 == "-1.0#are corrupted files|0.0#are no files|1.0#is one file|2.0#are {2} files") { + it_logln("toPattern tested!"); + }else{ + it_errln("*** ChoiceFormat to Pattern result!"); + } + + FieldPosition fpos(0); + + UnicodeString checkstr[] = { + "There are corrupted files on Disk_A", + "There are no files on Disk_A", + "There is one file on Disk_A", + "There are 2 files on Disk_A", + "There are 3 files on Disk_A" + }; + + // if (status != U_ZERO_ERROR) return; // TODO: analyze why we have such a bad bail out here! + + if (U_FAILURE(status)) { + delete fileform; + delete filenumform; + delete pattform; + return; + } + + + int32_t i; + int32_t start = -1; + for (i = start; i < 4; ++i) { + str = ""; + status = U_ZERO_ERROR; + testArgs[0] = Formattable((int32_t)i); + testArgs[2] = testArgs[0]; + res2 = pattform->format(testArgs, 3, str, fpos, status ); + if (!chkstatus( status, "*** test_complex_example format" )) { + delete fileform; + delete filenumform; + delete pattform; + return; + } + it_logln(i + UnicodeString(" -> ") + res2); + if (res2 != checkstr[i - start]) { + it_errln("*** test_complex_example res string"); + it_errln(UnicodeString("*** ") + i + UnicodeString(" -> '") + res2 + UnicodeString("' unlike '") + checkstr[i] + UnicodeString("' ! ")); + } + } + it_logln(); + + it_logln("------ additional testing in complex test ------"); + it_logln(); + // + int32_t retCount; + const double* retLimits = fileform->getLimits( retCount ); + if ((retCount == 4) && (retLimits) + && (retLimits[0] == -1.0) + && (retLimits[1] == 0.0) + && (retLimits[2] == 1.0) + && (retLimits[3] == 2.0)) { + it_logln("getLimits tested!"); + }else{ + it_errln("*** getLimits unexpected result!"); + } + + const UnicodeString* retFormats = fileform->getFormats( retCount ); + if ((retCount == 4) && (retFormats) + && (retFormats[0] == "are corrupted files") + && (retFormats[1] == "are no files") + && (retFormats[2] == "is one file") + && (retFormats[3] == "are {2} files")) { + it_logln("getFormats tested!"); + }else{ + it_errln("*** getFormats unexpected result!"); + } + + UnicodeString checkstr2[] = { + "There is no folder on Disk_A", + "There is one folder on Disk_A", + "There are many folders on Disk_A", + "There are many folders on Disk_A" + }; + + fileform->applyPattern("0#is no folder|1#is one folder|2#are many folders", status ); + if (status == U_ZERO_ERROR) + it_logln("status applyPattern OK!"); + if (!chkstatus( status, "*** test_complex_example pattform" )) { + delete fileform; + delete filenumform; + delete pattform; + return; + } + pattform->setFormat( 0, *fileform ); + fpos = 0; + for (i = 0; i < 4; ++i) { + str = ""; + status = U_ZERO_ERROR; + testArgs[0] = Formattable((int32_t)i); + testArgs[2] = testArgs[0]; + res2 = pattform->format(testArgs, 3, str, fpos, status ); + if (!chkstatus( status, "*** test_complex_example format 2" )) { + delete fileform; + delete filenumform; + delete pattform; + return; + } + it_logln(UnicodeString() + i + UnicodeString(" -> ") + res2); + if (res2 != checkstr2[i]) { + it_errln("*** test_complex_example res string"); + it_errln(UnicodeString("*** ") + i + UnicodeString(" -> '") + res2 + UnicodeString("' unlike '") + checkstr2[i] + UnicodeString("' ! ")); + } + } + + const double limits_A[] = {1,2,3,4,5,6,7}; + const UnicodeString monthNames_A[] = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat"}; + ChoiceFormat* form_A = new ChoiceFormat(limits_A, monthNames_A, 7); + ChoiceFormat* form_A2 = new ChoiceFormat(limits_A, monthNames_A, 7); + const double limits_B[] = {1,2,3,4,5,6,7}; + const UnicodeString monthNames_B[] = {"Sun","Mon","Tue","Wed","Thur","Fri","Sat_BBB"}; + ChoiceFormat* form_B = new ChoiceFormat(limits_B, monthNames_B, 7); + if (!form_A || !form_B || !form_A2) { + it_errln("*** test-choiceFormat not allocatable!"); + }else{ + if (*form_A == *form_A2) { + it_logln("operator== tested."); + }else{ + it_errln("*** operator=="); + } + + if (*form_A != *form_B) { + it_logln("operator!= tested."); + }else{ + it_errln("*** operator!="); + } + + ChoiceFormat* form_A3 = (ChoiceFormat*) form_A->clone(); + if (!form_A3) { + it_errln("*** ChoiceFormat->clone is nil."); + }else{ + if ((*form_A3 == *form_A) && (*form_A3 != *form_B)) { + it_logln("method clone tested."); + }else{ + it_errln("*** ChoiceFormat clone or operator==, or operator!= ."); + } + } + + ChoiceFormat form_Assigned( *form_A ); + UBool ok = (form_Assigned == *form_A) && (form_Assigned != *form_B); + form_Assigned = *form_B; + ok = ok && (form_Assigned != *form_A) && (form_Assigned == *form_B); + if (ok) { + it_logln("copy constructor and operator= tested."); + }else{ + it_errln("*** copy constructor or operator= or operator == or operator != ."); + } + delete form_A3; + } + + + delete form_A; delete form_A2; delete form_B; + + const char* testPattern = "0#none|1#one|2#many"; + ChoiceFormat form_pat( testPattern, status ); + if (!chkstatus( status, "*** ChoiceFormat contructor( newPattern, status)" )) { + delete fileform; + delete filenumform; + delete pattform; + return; + } + + form_pat.toPattern( res1 ); + if (res1 == "0.0#none|1.0#one|2.0#many") { + it_logln("ChoiceFormat contructor( newPattern, status) tested"); + }else{ + it_errln("*** ChoiceFormat contructor( newPattern, status) or toPattern result!"); + } + +#ifdef U_USE_CHOICE_FORMAT_DEPRECATES + double* d_a = (double *)uprv_malloc(2 * sizeof(double)); + if (!d_a) { it_errln("*** allocation error."); return; } + d_a[0] = 1.0; d_a[1] = 2.0; + + UnicodeString* s_a = new UnicodeString[2]; + if (!s_a) { it_errln("*** allocation error."); return; } + s_a[0] = "first"; s_a[1] = "second"; + + form_pat.adoptChoices( d_a, s_a, 2 ); + form_pat.toPattern( res1 ); + it_out << "ChoiceFormat adoptChoices toPattern: " << res1 << endl; + if (res1 == "1.0#first|2.0#second") { + it_logln("ChoiceFormat adoptChoices tested"); + }else{ + it_errln("*** ChoiceFormat adoptChoices result!"); + } +#endif + + double d_a2[] = { 3.0, 4.0 }; + UnicodeString s_a2[] = { "third", "forth" }; + + form_pat.setChoices( d_a2, s_a2, 2 ); + form_pat.toPattern( res1 ); + it_logln(UnicodeString("ChoiceFormat adoptChoices toPattern: ") + res1); + if (res1 == "3.0#third|4.0#forth") { + it_logln("ChoiceFormat adoptChoices tested"); + }else{ + it_errln("*** ChoiceFormat adoptChoices result!"); + } + + str = ""; + fpos = 0; + status = U_ZERO_ERROR; + double arg_double = 3.0; + res1 = form_pat.format( arg_double, str, fpos ); + it_logln(UnicodeString("ChoiceFormat format:") + res1); + if (res1 != "third") it_errln("*** ChoiceFormat format (double, ...) result!"); + + str = ""; + fpos = 0; + status = U_ZERO_ERROR; + int64_t arg_64 = 3; + res1 = form_pat.format( arg_64, str, fpos ); + it_logln(UnicodeString("ChoiceFormat format:") + res1); + if (res1 != "third") it_errln("*** ChoiceFormat format (int64_t, ...) result!"); + + str = ""; + fpos = 0; + status = U_ZERO_ERROR; + int32_t arg_long = 3; + res1 = form_pat.format( arg_long, str, fpos ); + it_logln(UnicodeString("ChoiceFormat format:") + res1); + if (res1 != "third") it_errln("*** ChoiceFormat format (int32_t, ...) result!"); + + Formattable ft( (int32_t)3 ); + str = ""; + fpos = 0; + status = U_ZERO_ERROR; + res1 = form_pat.format( ft, str, fpos, status ); + if (!chkstatus( status, "*** test_complex_example format (int32_t, ...)" )) { + delete fileform; + delete filenumform; + delete pattform; + return; + } + it_logln(UnicodeString("ChoiceFormat format:") + res1); + if (res1 != "third") it_errln("*** ChoiceFormat format (Formattable, ...) result!"); + + Formattable fta[] = { (int32_t)3 }; + str = ""; + fpos = 0; + status = U_ZERO_ERROR; + res1 = form_pat.format( fta, 1, str, fpos, status ); + if (!chkstatus( status, "*** test_complex_example format (int32_t, ...)" )) { + delete fileform; + delete filenumform; + delete pattform; + return; + } + it_logln(UnicodeString("ChoiceFormat format:") + res1); + if (res1 != "third") it_errln("*** ChoiceFormat format (Formattable[], cnt, ...) result!"); + + ParsePosition parse_pos = 0; + Formattable result; + UnicodeString parsetext("third"); + form_pat.parse( parsetext, result, parse_pos ); + double rd = (result.getType() == Formattable::kLong) ? result.getLong() : result.getDouble(); + if (rd == 3.0) { + it_logln("parse( ..., ParsePos ) tested."); + }else{ + it_errln("*** ChoiceFormat parse( ..., ParsePos )!"); + } + + form_pat.parse( parsetext, result, status ); + rd = (result.getType() == Formattable::kLong) ? result.getLong() : result.getDouble(); + if (rd == 3.0) { + it_logln("parse( ..., UErrorCode ) tested."); + }else{ + it_errln("*** ChoiceFormat parse( ..., UErrorCode )!"); + } + + /* + UClassID classID = ChoiceFormat::getStaticClassID(); + if (classID == form_pat.getDynamicClassID()) { + it_out << "getStaticClassID and getDynamicClassID tested." << endl; + }else{ + it_errln("*** getStaticClassID and getDynamicClassID!"); + } + */ + + it_logln(); + + delete fileform; + delete filenumform; + delete pattform; +} + + +/** + * Test new closure API + */ +void TestChoiceFormat::TestClosures(void) { + // Construct open, half-open, half-open (the other way), and closed + // intervals. Do this both using arrays and using a pattern. + + // 'fmt1' is created using arrays + UBool T = TRUE, F = FALSE; + // 0: ,1) + // 1: [1,2] + // 2: (2,3] + // 3: (3,4) + // 4: [4,5) + // 5: [5, + double limits[] = { 0, 1, 2, 3, 4, 5 }; + UBool closures[] = { F, F, T, T, F, F }; + UnicodeString fmts[] = { + ",1)", "[1,2]", "(2,3]", "(3,4)", "[4,5)", "[5," + }; + ChoiceFormat fmt1(limits, closures, fmts, 6); + + // 'fmt2' is created using a pattern; it should be equivalent + UErrorCode status = U_ZERO_ERROR; + const char* PAT = "0.0#,1)|1.0#[1,2]|2.0<(2,3]|3.0<(3,4)|4.0#[4,5)|5.0#[5,"; + ChoiceFormat fmt2(PAT, status); + if (U_FAILURE(status)) { + errln("FAIL: ChoiceFormat constructor failed"); + return; + } + + // Check the patterns + UnicodeString str; + fmt1.toPattern(str); + if (str == PAT) { + logln("Ok: " + str); + } else { + errln("FAIL: " + str + ", expected " + PAT); + } + str.truncate(0); + + // Check equality + if (fmt1 != fmt2) { + errln("FAIL: fmt1 != fmt2"); + } + + int32_t i; + int32_t count2 = 0; + const double *limits2 = fmt2.getLimits(count2); + const UBool *closures2 = fmt2.getClosures(count2); + + if((count2 != 6) || !limits2 || !closures2) { + errln("FAIL: couldn't get limits or closures"); + } else { + for(i=0;i<count2;i++) { + logln("#%d/%d: limit %g closed %s\n", + i, count2, + limits2[i], + closures2[i] ?"T":"F"); + if(limits2[i] != limits[i]) { + errln("FAIL: limit #%d = %g, should be %g\n", i, limits2[i], limits[i]); + } + if((closures2[i]!=0) != (closures[i]!=0)) { + errln("FAIL: closure #%d = %s, should be %s\n", i, closures2[i]?"T":"F", closures[i]?"T":"F"); + } + } + } + + // Now test both format objects + UnicodeString exp[] = { + /*-0.5 => */ ",1)", + /* 0.0 => */ ",1)", + /* 0.5 => */ ",1)", + /* 1.0 => */ "[1,2]", + /* 1.5 => */ "[1,2]", + /* 2.0 => */ "[1,2]", + /* 2.5 => */ "(2,3]", + /* 3.0 => */ "(2,3]", + /* 3.5 => */ "(3,4)", + /* 4.0 => */ "[4,5)", + /* 4.5 => */ "[4,5)", + /* 5.0 => */ "[5,", + /* 5.5 => */ "[5," + }; + + // Each format object should behave exactly the same + ChoiceFormat* FMT[] = { &fmt1, &fmt2 }; + for (int32_t pass=0; pass<2; ++pass) { + int32_t j=0; + for (int32_t ix=-5; ix<=55; ix+=5) { + double x = ix / 10.0; // -0.5 to 5.5 step +0.5 + FMT[pass]->format(x, str); + if (str == exp[j]) { + logln((UnicodeString)"Ok: " + x + " => " + str); + } else { + errln((UnicodeString)"FAIL: " + x + " => " + str + + ", expected " + exp[j]); + } + str.truncate(0); + ++j; + } + } +} + +/** + * Helper for TestPatterns() + */ +void TestChoiceFormat::_testPattern(const char* pattern, + UBool isValid, + double v1, const char* str1, + double v2, const char* str2, + double v3, const char* str3) { + UErrorCode ec = U_ZERO_ERROR; + ChoiceFormat fmt(pattern, ec); + if (!isValid) { + if (U_FAILURE(ec)) { + logln((UnicodeString)"Ok: " + pattern + " failed"); + } else { + logln((UnicodeString)"FAIL: " + pattern + " accepted"); + } + return; + } + if (U_FAILURE(ec)) { + errln((UnicodeString)"FAIL: ChoiceFormat(" + pattern + ") failed"); + return; + } else { + logln((UnicodeString)"Ok: Pattern: " + pattern); + } + UnicodeString out; + logln((UnicodeString)" toPattern: " + fmt.toPattern(out)); + + double v[] = {v1, v2, v3}; + const char* str[] = {str1, str2, str3}; + for (int32_t i=0; i<3; ++i) { + out.truncate(0); + fmt.format(v[i], out); + if (out == str[i]) { + logln((UnicodeString)"Ok: " + v[i] + " => " + out); + } else { + errln((UnicodeString)"FAIL: " + v[i] + " => " + out + + ", expected " + str[i]); + } + } +} + +/** + * Test applyPattern + */ +void TestChoiceFormat::TestPatterns(void) { + // Try a pattern that isolates a single value. Create + // three ranges: [-Inf,1.0) [1.0,1.0] (1.0,+Inf] + _testPattern("0.0#a|1.0#b|1.0<c", TRUE, + 1.0 - 1e-9, "a", + 1.0, "b", + 1.0 + 1e-9, "c"); + + // Try an invalid pattern that isolates a single value. + // [-Inf,1.0) [1.0,1.0) [1.0,+Inf] + _testPattern("0.0#a|1.0#b|1.0#c", FALSE, + 0, 0, 0, 0, 0, 0); + + // Another + // [-Inf,1.0] (1.0,1.0) [1.0,+Inf] + _testPattern("0.0#a|1.0<b|1.0#c", FALSE, + 0, 0, 0, 0, 0, 0); + // Another + // [-Inf,1.0] (1.0,1.0] (1.0,+Inf] + _testPattern("0.0#a|1.0<b|1.0<c", FALSE, + 0, 0, 0, 0, 0, 0); + + // Try a grossly invalid pattern. + // [-Inf,2.0) [2.0,1.0) [1.0,+Inf] + _testPattern("0.0#a|2.0#b|1.0#c", FALSE, + 0, 0, 0, 0, 0, 0); +} + +#endif /* #if !UCONFIG_NO_FORMATTING */ |