1999-08-16 21:50:52 +00:00
|
|
|
|
2000-01-15 02:00:06 +00:00
|
|
|
/********************************************************************
|
|
|
|
* COPYRIGHT:
|
2003-06-03 20:58:22 +00:00
|
|
|
* Copyright (c) 1997-2003, International Business Machines Corporation and
|
2000-01-15 02:00:06 +00:00
|
|
|
* others. All Rights Reserved.
|
|
|
|
********************************************************************/
|
1999-08-16 21:50:52 +00:00
|
|
|
|
1999-12-28 23:57:50 +00:00
|
|
|
#include "unicode/utypes.h"
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2002-09-21 00:43:14 +00:00
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
#include "intltest.h"
|
|
|
|
#include "tchcfmt.h"
|
2000-06-29 19:42:17 +00:00
|
|
|
#include "cmemory.h"
|
1999-12-28 23:57:50 +00:00
|
|
|
#include "unicode/msgfmt.h"
|
|
|
|
#include "unicode/choicfmt.h"
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
#include <float.h>
|
|
|
|
|
|
|
|
// tests have obvious memory leaks!
|
|
|
|
|
2001-06-11 17:22:24 +00:00
|
|
|
void TestChoiceFormat::runIndexedTest(int32_t index, UBool exec,
|
|
|
|
const char* &name, char* /*par*/) {
|
|
|
|
switch (index) {
|
|
|
|
TESTCASE(0,TestSimpleExample);
|
|
|
|
TESTCASE(1,TestComplexExample);
|
2001-06-11 19:11:24 +00:00
|
|
|
TESTCASE(2,TestClosures);
|
|
|
|
TESTCASE(3,TestPatterns);
|
2001-06-11 17:22:24 +00:00
|
|
|
default: name = ""; break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-08-16 01:28:16 +00:00
|
|
|
static UBool chkstatus( UErrorCode &status, const char* msg = NULL )
|
1999-08-16 21:50:52 +00:00
|
|
|
{
|
2000-05-18 22:08:39 +00:00
|
|
|
UBool ok = U_SUCCESS(status);
|
1999-08-16 21:50:52 +00:00
|
|
|
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;
|
2000-07-08 00:10:02 +00:00
|
|
|
int32_t ix;
|
1999-08-16 21:50:52 +00:00
|
|
|
//for (double i = 0.0; i <= 8.0; ++i) {
|
2000-07-08 00:10:02 +00:00
|
|
|
for (ix = 0; ix <= 8; ++ix) {
|
1999-08-16 21:50:52 +00:00
|
|
|
double i = ix; //nos
|
1999-10-07 00:07:53 +00:00
|
|
|
status = U_ZERO_ERROR;
|
1999-08-16 21:50:52 +00:00
|
|
|
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_out << ix << " -> " << res1 << " -> " << res2 << endl;
|
|
|
|
}
|
2000-06-27 22:26:03 +00:00
|
|
|
//Testing ==operator
|
|
|
|
const double filelimits[] = {0,1,2};
|
|
|
|
const UnicodeString filepart[] = {"are no files","is one file","are {2} files"};
|
2000-06-29 19:42:17 +00:00
|
|
|
ChoiceFormat* formnew=new ChoiceFormat(filelimits, filepart, 3);
|
|
|
|
ChoiceFormat* formequal=new ChoiceFormat(limits, monthNames, 7);
|
2000-06-27 22:26:03 +00:00
|
|
|
if(*formnew == *form){
|
|
|
|
errln("ERROR: ==operator failed\n");
|
|
|
|
}
|
|
|
|
if(!(*form == *formequal)){
|
|
|
|
errln("ERROR: ==operator failed\n");
|
|
|
|
}
|
|
|
|
delete formequal;
|
|
|
|
|
2003-05-01 01:31:28 +00:00
|
|
|
#ifdef U_USE_CHOICE_FORMAT_DEPRECATES
|
2000-06-27 22:26:03 +00:00
|
|
|
//Testing adoptChoices()
|
2002-03-23 00:25:51 +00:00
|
|
|
double *limitsToAdopt = (double *)uprv_malloc(7 * sizeof(double));
|
2000-06-29 19:42:17 +00:00
|
|
|
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);
|
2000-06-27 22:26:03 +00:00
|
|
|
if(!(*formnew == *form)){
|
|
|
|
errln("ERROR: ==Operator or adoptChoices failed\n");
|
|
|
|
}
|
2003-05-01 01:31:28 +00:00
|
|
|
#endif
|
2000-06-29 19:42:17 +00:00
|
|
|
|
|
|
|
delete formnew;
|
2000-06-27 22:26:03 +00:00
|
|
|
|
|
|
|
//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]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
delete form;
|
2000-06-27 22:26:03 +00:00
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
TestChoiceFormat::TestComplexExample( void )
|
|
|
|
{
|
1999-10-07 00:07:53 +00:00
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
2001-08-30 01:55:50 +00:00
|
|
|
const double filelimits[] = {-1, 0,1,2};
|
|
|
|
const UnicodeString filepart[] = {"are corrupted files", "are no files","is one file","are {2} files"};
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2001-08-30 01:55:50 +00:00
|
|
|
ChoiceFormat* fileform = new ChoiceFormat( filelimits, filepart, 4);
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
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 );
|
|
|
|
|
|
|
|
|
2000-06-29 18:42:34 +00:00
|
|
|
Formattable testArgs[] = {(int32_t)0, "Disk_A", (int32_t)0};
|
1999-08-16 21:50:52 +00:00
|
|
|
UnicodeString str;
|
|
|
|
UnicodeString res1, res2;
|
|
|
|
pattform->toPattern( res1 );
|
|
|
|
it_out << "MessageFormat toPattern: " << res1 << endl;
|
|
|
|
fileform->toPattern( res1 );
|
|
|
|
it_out << "ChoiceFormat toPattern: " << res1 << endl;
|
2001-08-30 01:55:50 +00:00
|
|
|
if (res1 == "-1.0#are corrupted files|0.0#are no files|1.0#is one file|2.0#are {2} files") {
|
1999-08-16 21:50:52 +00:00
|
|
|
it_out << "toPattern tested!" << endl;
|
|
|
|
}else{
|
|
|
|
it_errln("*** ChoiceFormat to Pattern result!");
|
|
|
|
}
|
|
|
|
|
|
|
|
FieldPosition fpos(0);
|
|
|
|
|
|
|
|
UnicodeString checkstr[] = {
|
2001-08-30 01:55:50 +00:00
|
|
|
"There are corrupted files on Disk_A",
|
1999-08-16 21:50:52 +00:00
|
|
|
"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"
|
|
|
|
};
|
|
|
|
|
2000-06-29 19:42:17 +00:00
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
int32_t i;
|
2001-08-30 01:55:50 +00:00
|
|
|
int32_t start = -1;
|
|
|
|
for (i = start; i < 4; ++i) {
|
1999-08-16 21:50:52 +00:00
|
|
|
str = "";
|
1999-10-07 00:07:53 +00:00
|
|
|
status = U_ZERO_ERROR;
|
1999-08-16 21:50:52 +00:00
|
|
|
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_out << i << " -> " << res2 << endl;
|
2001-08-30 01:55:50 +00:00
|
|
|
if (res2 != checkstr[i - start]) {
|
1999-08-16 21:50:52 +00:00
|
|
|
it_errln("*** test_complex_example res string");
|
|
|
|
it_out << "*** " << i << " -> '" << res2 << "' unlike '" << checkstr[i] << "' ! " << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
it_out << endl;
|
|
|
|
|
|
|
|
it_out << "------ additional testing in complex test ------" << endl << endl;
|
|
|
|
//
|
|
|
|
int32_t retCount;
|
|
|
|
const double* retLimits = fileform->getLimits( retCount );
|
2001-08-30 01:55:50 +00:00
|
|
|
if ((retCount == 4) && (retLimits)
|
|
|
|
&& (retLimits[0] == -1.0)
|
|
|
|
&& (retLimits[1] == 0.0)
|
|
|
|
&& (retLimits[2] == 1.0)
|
|
|
|
&& (retLimits[3] == 2.0)) {
|
1999-08-16 21:50:52 +00:00
|
|
|
it_out << "getLimits tested!" << endl;
|
|
|
|
}else{
|
|
|
|
it_errln("*** getLimits unexpected result!");
|
|
|
|
}
|
|
|
|
|
|
|
|
const UnicodeString* retFormats = fileform->getFormats( retCount );
|
2001-08-30 01:55:50 +00:00
|
|
|
if ((retCount == 4) && (retFormats)
|
|
|
|
&& (retFormats[0] == "are corrupted files")
|
|
|
|
&& (retFormats[1] == "are no files")
|
|
|
|
&& (retFormats[2] == "is one file")
|
|
|
|
&& (retFormats[3] == "are {2} files")) {
|
1999-08-16 21:50:52 +00:00
|
|
|
it_out << "getFormats tested!" << endl;
|
|
|
|
}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 );
|
1999-10-07 00:07:53 +00:00
|
|
|
if (status == U_ZERO_ERROR) it_out << "status applyPattern OK!" << endl;
|
1999-08-16 21:50:52 +00:00
|
|
|
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 = "";
|
1999-10-07 00:07:53 +00:00
|
|
|
status = U_ZERO_ERROR;
|
1999-08-16 21:50:52 +00:00
|
|
|
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_out << i << " -> " << res2 << endl;
|
|
|
|
if (res2 != checkstr2[i]) {
|
|
|
|
it_errln("*** test_complex_example res string");
|
|
|
|
it_out << "*** " << i << " -> '" << res2 << "' unlike '" << checkstr2[i] << "' ! " << endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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_out << "operator== tested." << endl;
|
|
|
|
}else{
|
|
|
|
it_errln("*** operator==");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*form_A != *form_B) {
|
|
|
|
it_out << "operator!= tested." << endl;
|
|
|
|
}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_out << "method clone tested." << endl;
|
|
|
|
}else{
|
|
|
|
it_errln("*** ChoiceFormat clone or operator==, or operator!= .");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ChoiceFormat form_Assigned( *form_A );
|
2000-05-18 22:08:39 +00:00
|
|
|
UBool ok = (form_Assigned == *form_A) && (form_Assigned != *form_B);
|
1999-08-16 21:50:52 +00:00
|
|
|
form_Assigned = *form_B;
|
|
|
|
ok = ok && (form_Assigned != *form_A) && (form_Assigned == *form_B);
|
|
|
|
if (ok) {
|
|
|
|
it_out << "copy constructor and operator= tested." << endl;
|
|
|
|
}else{
|
|
|
|
it_errln("*** copy constructor or operator= or operator == or operator != .");
|
|
|
|
}
|
|
|
|
delete form_A3;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
delete form_A; delete form_A2; delete form_B;
|
|
|
|
|
2000-08-24 01:12:12 +00:00
|
|
|
const char* testPattern = "0#none|1#one|2#many";
|
1999-08-16 21:50:52 +00:00
|
|
|
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_out << "ChoiceFormat contructor( newPattern, status) tested" << endl;
|
|
|
|
}else{
|
|
|
|
it_errln("*** ChoiceFormat contructor( newPattern, status) or toPattern result!");
|
|
|
|
}
|
|
|
|
|
2003-05-01 01:31:28 +00:00
|
|
|
#ifdef U_USE_CHOICE_FORMAT_DEPRECATES
|
2002-03-23 00:25:51 +00:00
|
|
|
double* d_a = (double *)uprv_malloc(2 * sizeof(double));
|
1999-08-16 21:50:52 +00:00
|
|
|
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_out << "ChoiceFormat adoptChoices tested" << endl;
|
|
|
|
}else{
|
|
|
|
it_errln("*** ChoiceFormat adoptChoices result!");
|
|
|
|
}
|
2003-05-01 01:31:28 +00:00
|
|
|
#endif
|
1999-08-16 21:50:52 +00:00
|
|
|
|
|
|
|
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_out << "ChoiceFormat adoptChoices toPattern: " << res1 << endl;
|
|
|
|
if (res1 == "3.0#third|4.0#forth") {
|
|
|
|
it_out << "ChoiceFormat adoptChoices tested" << endl;
|
|
|
|
}else{
|
|
|
|
it_errln("*** ChoiceFormat adoptChoices result!");
|
|
|
|
}
|
|
|
|
|
|
|
|
str = "";
|
|
|
|
fpos = 0;
|
1999-10-07 00:07:53 +00:00
|
|
|
status = U_ZERO_ERROR;
|
1999-08-16 21:50:52 +00:00
|
|
|
double arg_double = 3.0;
|
|
|
|
res1 = form_pat.format( arg_double, str, fpos );
|
|
|
|
it_out << "ChoiceFormat format:" << res1 << endl;
|
|
|
|
if (res1 != "third") it_errln("*** ChoiceFormat format (double, ...) result!");
|
|
|
|
|
|
|
|
str = "";
|
|
|
|
fpos = 0;
|
1999-10-07 00:07:53 +00:00
|
|
|
status = U_ZERO_ERROR;
|
1999-08-16 21:50:52 +00:00
|
|
|
int32_t arg_long = 3;
|
|
|
|
res1 = form_pat.format( arg_long, str, fpos );
|
|
|
|
it_out << "ChoiceFormat format:" << res1 << endl;
|
|
|
|
if (res1 != "third") it_errln("*** ChoiceFormat format (int32_t, ...) result!");
|
|
|
|
|
2000-06-29 18:42:34 +00:00
|
|
|
Formattable ft( (int32_t)3 );
|
1999-08-16 21:50:52 +00:00
|
|
|
str = "";
|
|
|
|
fpos = 0;
|
1999-10-07 00:07:53 +00:00
|
|
|
status = U_ZERO_ERROR;
|
1999-08-16 21:50:52 +00:00
|
|
|
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_out << "ChoiceFormat format:" << res1 << endl;
|
|
|
|
if (res1 != "third") it_errln("*** ChoiceFormat format (Formattable, ...) result!");
|
|
|
|
|
2000-06-29 18:42:34 +00:00
|
|
|
Formattable fta[] = { (int32_t)3 };
|
1999-08-16 21:50:52 +00:00
|
|
|
str = "";
|
|
|
|
fpos = 0;
|
1999-10-07 00:07:53 +00:00
|
|
|
status = U_ZERO_ERROR;
|
1999-08-16 21:50:52 +00:00
|
|
|
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_out << "ChoiceFormat format:" << res1 << endl;
|
|
|
|
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_out << "parse( ..., ParsePos ) tested." << endl;
|
|
|
|
}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_out << "parse( ..., UErrorCode ) tested." << endl;
|
|
|
|
}else{
|
|
|
|
it_errln("*** ChoiceFormat parse( ..., UErrorCode )!");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1999-10-18 22:48:32 +00:00
|
|
|
UClassID classID = ChoiceFormat::getStaticClassID();
|
1999-08-16 21:50:52 +00:00
|
|
|
if (classID == form_pat.getDynamicClassID()) {
|
|
|
|
it_out << "getStaticClassID and getDynamicClassID tested." << endl;
|
|
|
|
}else{
|
|
|
|
it_errln("*** getStaticClassID and getDynamicClassID!");
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
it_out << endl;
|
|
|
|
|
|
|
|
delete fileform;
|
|
|
|
delete filenumform;
|
|
|
|
delete pattform;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-11 17:22:24 +00:00
|
|
|
/**
|
|
|
|
* 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);
|
1999-08-16 21:50:52 +00:00
|
|
|
|
2001-06-11 17:22:24 +00:00
|
|
|
// '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;
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2001-06-11 17:22:24 +00:00
|
|
|
|
|
|
|
// 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");
|
|
|
|
}
|
|
|
|
|
2003-06-12 18:02:40 +00:00
|
|
|
int32_t i;
|
|
|
|
int32_t count2 = 0;
|
|
|
|
const double *limits2 = fmt2.getLimits(count2);
|
|
|
|
const UBool *closures2 = fmt2.getClosures(count2);
|
|
|
|
|
2003-06-12 20:34:13 +00:00
|
|
|
if((count2 != 6) || !limits2 || !closures2) {
|
2003-06-12 18:02:40 +00:00
|
|
|
errln("FAIL: couldn't get limits or closures");
|
|
|
|
} else {
|
|
|
|
for(i=0;i<count2;i++) {
|
2003-06-12 20:34:13 +00:00
|
|
|
logln("#%d/%d: limit %g closed %s\n",
|
|
|
|
i, count2,
|
2003-06-12 18:02:40 +00:00
|
|
|
limits2[i],
|
|
|
|
closures2[i] ?"T":"F");
|
2003-06-12 20:34:13 +00:00
|
|
|
if(limits2[i] != limits[i]) {
|
2003-06-12 18:02:40 +00:00
|
|
|
errln("FAIL: limit #%d = %g, should be %g\n", i, limits2[i], limits[i]);
|
2003-06-12 20:34:13 +00:00
|
|
|
}
|
|
|
|
if((closures2[i]!=0) != (closures[i]!=0)) {
|
2003-06-12 18:02:40 +00:00
|
|
|
errln("FAIL: closure #%d = %s, should be %s\n", i, closures2[i]?"T":"F", closures[i]?"T":"F");
|
2003-06-12 20:34:13 +00:00
|
|
|
}
|
2003-06-12 18:02:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-06-11 17:22:24 +00:00
|
|
|
// 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);
|
1999-08-16 21:50:52 +00:00
|
|
|
}
|
2002-09-21 00:43:14 +00:00
|
|
|
|
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|