+class NumTest : public HowExpensiveTest {
+private:
+ double fExpect;
+ UNumberFormat *fFmt;
+ UnicodeString fPat;
+ UnicodeString fString;
+ const UChar *fStr;
+ int32_t fLen;
+ const char *fFile;
+ int fLine;
+ const char *fCPat;
+ const char *fCStr;
+ char name[100];
+public:
+ virtual const char *getName() {
+ if(name[0]==0) {
+ sprintf(name,"%s:p=|%s|,str=|%s|",getClassName(),fCPat,fCStr);
+ }
+ return name;
+ }
+protected:
+ virtual UNumberFormat* initFmt() {
+ return unum_open(UNUM_PATTERN_DECIMAL, fPat.getTerminatedBuffer(), -1, TEST_LOCALE, 0, &setupStatus);
+ }
+ virtual const char *getClassName() {
+ return "NumTest";
+ }
+public:
+ NumTest(const char *pat, const char *num, double expect, const char *FILE, int LINE)
+ : HowExpensiveTest("(n/a)",FILE, LINE),
+ fExpect(expect),
+ fFmt(0),
+ fPat(pat, -1, US_INV),
+ fString(num,-1,US_INV),
+ fStr(fString.getTerminatedBuffer()),
+ fLen(u_strlen(fStr)),
+ fFile(FILE),
+ fLine(LINE),
+ fCPat(pat),
+ fCStr(num)
+ {
+ name[0]=0;
+ }
+ void warmup() {
+ fFmt = initFmt();
+ if(U_SUCCESS(setupStatus)) {
+ double trial = unum_parseDouble(fFmt,fStr,fLen, NULL, &setupStatus);
+ if(U_SUCCESS(setupStatus) && trial!=fExpect) {
+ setupStatus = U_INTERNAL_PROGRAM_ERROR;
+ printf("%s:%d: warmup() %s got %.8f expected %.8f\n",
+ fFile,fLine,getName(),trial,fExpect);
+ }
+ }
+ }
+ int32_t run() {
+ double trial=0.0;
+ int i;
+ for(i=0;i<U_LOTS_OF_TIMES;i++){
+ trial = unum_parse(fFmt,fStr,fLen, NULL, &setupStatus);
+ }
+ return i;
+ }
+ virtual ~NumTest(){}
+};
+
+#define DO_NumTest(p,n,x) { NumTest t(p,n,x,__FILE__,__LINE__); runTestOn(t); }
+
+
+class AttrNumTest : public NumTest
+{
+private:
+ UNumberFormatAttribute fAttr;
+ int32_t fAttrValue;
+ char name2[100];
+protected:
+ virtual const char *getClassName() {
+ sprintf(name2,"AttrNumTest:%d=%d", fAttr,fAttrValue);
+ return name2;
+ }
+public:
+ AttrNumTest(const char *pat, const char *num, double expect, const char *FILE, int LINE, UNumberFormatAttribute attr, int32_t newValue)
+ : NumTest(pat,num,expect,FILE,LINE),
+ fAttr(attr),
+ fAttrValue(newValue)
+ {
+ }
+ virtual UNumberFormat* initFmt() {
+ UNumberFormat *fmt = NumTest::initFmt();
+ unum_setAttribute(fmt, fAttr,fAttrValue);
+ return fmt;
+ }
+};
+
+#define DO_AttrNumTest(p,n,x,a,v) { AttrNumTest t(p,n,x,__FILE__,__LINE__,a,v); runTestOn(t); }
+
+
+class NOXNumTest : public NumTest
+{
+private:
+ UNumberFormatAttribute fAttr;
+ int32_t fAttrValue;
+ char name2[100];
+protected:
+ virtual const char *getClassName() {
+ sprintf(name2,"NOXNumTest:%d=%d", fAttr,fAttrValue);
+ return name2;
+ }
+public:
+ NOXNumTest(const char *pat, const char *num, double expect, const char *FILE, int LINE /*, UNumberFormatAttribute attr, int32_t newValue */)
+ : NumTest(pat,num,expect,FILE,LINE) /* ,
+ fAttr(attr),
+ fAttrValue(newValue) */
+ {
+ }
+ virtual UNumberFormat* initFmt() {
+ UNumberFormat *fmt = NumTest::initFmt();
+ //unum_setAttribute(fmt, fAttr,fAttrValue);
+ return fmt;
+ }
+};
+
+#define DO_NOXNumTest(p,n,x) { NOXNumTest t(p,n,x,__FILE__,__LINE__); runTestOn(t); }
+
+#define DO_TripleNumTest(p,n,x) DO_AttrNumTest(p,n,x,UNUM_PARSE_ALL_INPUT,UNUM_YES) \
+ DO_AttrNumTest(p,n,x,UNUM_PARSE_ALL_INPUT,UNUM_NO) \
+ DO_AttrNumTest(p,n,x,UNUM_PARSE_ALL_INPUT,UNUM_MAYBE)
+
+
+class NumFmtTest : public HowExpensiveTest {
+private:
+ double fExpect;
+ UNumberFormat *fFmt;
+ UnicodeString fPat;
+ UnicodeString fString;
+ const UChar *fStr;
+ int32_t fLen;
+ const char *fFile;
+ int fLine;
+ const char *fCPat;
+ const char *fCStr;
+ char name[100];
+public:
+ virtual const char *getName() {
+ if(name[0]==0) {
+ sprintf(name,"%s:p=|%s|,str=|%s|",getClassName(),fCPat,fCStr);
+ }
+ return name;
+ }
+protected:
+ virtual UNumberFormat* initFmt() {
+ return unum_open(UNUM_PATTERN_DECIMAL, fPat.getTerminatedBuffer(), -1, TEST_LOCALE, 0, &setupStatus);
+ }
+ virtual const char *getClassName() {
+ return "NumFmtTest";
+ }
+public:
+ NumFmtTest(const char *pat, const char *num, double expect, const char *FILE, int LINE)
+ : HowExpensiveTest("(n/a)",FILE, LINE),
+ fExpect(expect),
+ fFmt(0),
+ fPat(pat, -1, US_INV),
+ fString(num,-1,US_INV),
+ fStr(fString.getTerminatedBuffer()),
+ fLen(u_strlen(fStr)),
+ fFile(FILE),
+ fLine(LINE),
+ fCPat(pat),
+ fCStr(num)
+ {
+ name[0]=0;
+ }
+ void warmup() {
+ fFmt = initFmt();
+ UChar buf[100];
+ if(U_SUCCESS(setupStatus)) {
+ int32_t trial = unum_formatDouble(fFmt,fExpect, buf, 100, NULL, &setupStatus);
+ if(!U_SUCCESS(setupStatus)
+ || trial!=fLen
+ ||trial<=0
+ || u_strncmp(fStr,buf,trial) ) {
+ char strBuf[200];
+ u_strToUTF8(strBuf,200,NULL,buf,trial+1,&setupStatus);
+ printf("%s:%d: warmup() %s got %s expected %s, err %s\n",
+ fFile,fLine,getName(),strBuf,fCStr, u_errorName(setupStatus));
+ setupStatus = U_INTERNAL_PROGRAM_ERROR;
+ }
+ }
+ }
+ int32_t run() {
+ int32_t trial;
+ int i;
+ UChar buf[100];
+ if(U_SUCCESS(setupStatus)) {
+ for(i=0;i<U_LOTS_OF_TIMES;i++){
+ trial = unum_formatDouble(fFmt,fExpect, buf, 100, NULL, &setupStatus);
+ }
+ }
+ return i;
+ }
+ virtual ~NumFmtTest(){}
+};
+
+#define DO_NumFmtTest(p,n,x) { NumFmtTest t(p,n,x,__FILE__,__LINE__); runTestOn(t); }
+
+class NumFmtInt64Test : public HowExpensiveTest {
+public:
+ enum EMode {
+ kDefault,
+ kPattern,
+ kApplyPattern,
+ kGroupOff,
+ kApplyGroupOff
+ };
+private:
+ EMode fMode;
+ int64_t fExpect;
+ UNumberFormat *fFmt;
+ UnicodeString fPat;
+ UnicodeString fString;
+ const UChar *fStr;
+ int32_t fLen;
+ const char *fFile;
+ int fLine;
+ const char *fCPat;
+ const char *fCStr;
+ char name[100];
+public:
+ virtual const char *getName() {
+ if(name[0]==0) {
+ sprintf(name,"%s:p=|%s|,str=|%s|",getClassName(),fCPat,fCStr);
+ }
+ return name;
+ }
+protected:
+ virtual UNumberFormat* initFmt() {
+ switch(fMode) {
+ case kPattern:
+ return unum_open(UNUM_PATTERN_DECIMAL, fPat.getTerminatedBuffer(), -1, TEST_LOCALE, 0, &setupStatus);
+ case kApplyPattern:
+ {
+ UNumberFormat *fmt = unum_open(UNUM_DECIMAL, NULL, -1, TEST_LOCALE, 0, &setupStatus);
+ unum_applyPattern(fmt, FALSE, fPat.getTerminatedBuffer(), -1, NULL, &setupStatus);
+ return fmt;
+ }
+ case kGroupOff:
+ {
+ UNumberFormat *fmt = unum_open(UNUM_PATTERN_DECIMAL, fPat.getTerminatedBuffer(), -1, TEST_LOCALE, 0, &setupStatus);
+ unum_setAttribute(fmt, UNUM_GROUPING_USED, UNUM_NO);
+ return fmt;
+ }
+ case kApplyGroupOff:
+ {
+ UNumberFormat *fmt = unum_open(UNUM_DECIMAL, NULL, -1, TEST_LOCALE, 0, &setupStatus);
+ unum_applyPattern(fmt, FALSE, fPat.getTerminatedBuffer(), -1, NULL, &setupStatus);
+ unum_setAttribute(fmt, UNUM_GROUPING_USED, UNUM_NO);
+ return fmt;
+ }
+ default:
+ case kDefault:
+ return unum_open(UNUM_DEFAULT, NULL, -1, TEST_LOCALE, 0, &setupStatus);
+ }
+ }
+ virtual const char *getClassName() {
+ switch(fMode) {
+ case EMode::kDefault:
+ return "NumFmtInt64Test (default)";
+ case EMode::kPattern:
+ return "NumFmtInt64Test (pattern)";
+ case EMode::kApplyPattern:
+ return "NumFmtInt64Test (applypattern)";
+ case EMode::kGroupOff:
+ return "NumFmtInt64Test (pattern, group=off)";
+ case EMode::kApplyGroupOff:
+ return "NumFmtInt64Test (applypattern, group=off)";
+ default:
+ return "NumFmtInt64Test (? ? ?)";
+ }
+ }
+public:
+ NumFmtInt64Test(const char *pat, const char *num, int64_t expect, const char *FILE, int LINE, EMode mode)
+ : HowExpensiveTest("(n/a)",FILE, LINE),
+ fMode(mode),
+ fExpect(expect),
+ fFmt(0),
+ fPat(pat, -1, US_INV),
+ fString(num,-1,US_INV),
+ fStr(fString.getTerminatedBuffer()),
+ fLen(u_strlen(fStr)),
+ fFile(FILE),
+ fLine(LINE),
+ fCPat(pat),
+ fCStr(num)
+ {
+ name[0]=0;
+ }
+ void warmup() {
+ fFmt = initFmt();
+ UChar buf[100];
+ if(U_SUCCESS(setupStatus)) {
+ int32_t trial = unum_formatInt64(fFmt,fExpect, buf, 100, NULL, &setupStatus);
+ if(!U_SUCCESS(setupStatus)
+ || trial!=fLen
+ ||trial<=0
+ || u_strncmp(fStr,buf,trial) ) {
+ char strBuf[200];
+ u_strToUTF8(strBuf,200,NULL,buf,trial+1,&setupStatus);
+ printf("%s:%d: warmup() %s got %s (len %d) expected %s (len %d), err %s\n",
+ fFile,fLine,getName(),strBuf,trial,fCStr,fLen, u_errorName(setupStatus));
+ setupStatus = U_INTERNAL_PROGRAM_ERROR;
+ }
+ }
+ }
+ int32_t run() {
+ int32_t trial;
+ int i;
+ UChar buf[100];
+ if(U_SUCCESS(setupStatus)) {
+ for(i=0;i<U_LOTS_OF_TIMES;i++){
+ trial = unum_formatInt64(fFmt,fExpect, buf, 100, NULL, &setupStatus);
+ }
+ }
+ return i;
+ }
+ virtual ~NumFmtInt64Test(){}
+};
+
+/**
+ * unum_open .. with pattern, == new DecimalFormat(pattern)
+ */
+#define DO_NumFmtInt64Test(p,n,x) { NumFmtInt64Test t(p,n,x,__FILE__,__LINE__,NumFmtInt64Test::EMode::kPattern); runTestOn(t); }
+/**
+ * unum_open(UNUM_DECIMAL), then
+ */
+#define DO_NumFmtInt64Test_apply(p,n,x) { NumFmtInt64Test t(p,n,x,__FILE__,__LINE__,NumFmtInt64Test::EMode::kApplyPattern); runTestOn(t); }
+
+#define DO_NumFmtInt64Test_default(p,n,x) { NumFmtInt64Test t(p,n,x,__FILE__,__LINE__,NumFmtInt64Test::EMode::kDefault); runTestOn(t); }
+#define DO_NumFmtInt64Test_gr0(p,n,x) { NumFmtInt64Test t(p,n,x,__FILE__,__LINE__,NumFmtInt64Test::EMode::kGroupOff); runTestOn(t); }
+#define DO_NumFmtInt64Test_applygr0(p,n,x) { NumFmtInt64Test t(p,n,x,__FILE__,__LINE__,NumFmtInt64Test::EMode::kApplyGroupOff); runTestOn(t); }
+
+
+class NumFmtStringPieceTest : public HowExpensiveTest {
+private:
+ const StringPiece &fExpect;
+ UNumberFormat *fFmt;
+ UnicodeString fPat;
+ UnicodeString fString;
+ const UChar *fStr;
+ int32_t fLen;
+ const char *fFile;
+ int fLine;
+ const char *fCPat;
+ const char *fCStr;
+ char name[100];
+public:
+ virtual const char *getName() {
+ if(name[0]==0) {
+ sprintf(name,"%s:p=|%s|,str=|%s|,sp=|%s|",getClassName(),fCPat,fCStr, fExpect.data());
+ }
+ return name;
+ }
+protected:
+ virtual UNumberFormat* initFmt() {
+ DecimalFormat *d = new DecimalFormat(setupStatus);
+ UParseError pe;
+ d->applyPattern(fPat, pe, setupStatus);
+ return (UNumberFormat*) d;
+ }
+ virtual const char *getClassName() {
+ return "NumFmtStringPieceTest";
+ }
+public:
+ NumFmtStringPieceTest(const char *pat, const char *num, const StringPiece& expect, const char *FILE, int LINE)
+ : HowExpensiveTest("(n/a)",FILE, LINE),
+ fExpect(expect),
+ fFmt(0),
+ fPat(pat, -1, US_INV),
+ fString(num,-1,US_INV),
+ fStr(fString.getTerminatedBuffer()),
+ fLen(u_strlen(fStr)),
+ fFile(FILE),
+ fLine(LINE),
+ fCPat(pat),
+ fCStr(num)
+ {
+ name[0]=0;
+ }
+ void warmup() {
+ fFmt = initFmt();
+ UnicodeString buf;
+ if(U_SUCCESS(setupStatus)) {
+ buf.remove();
+ ((const DecimalFormat*)fFmt)->format(fExpect, buf, NULL, setupStatus);
+ if(!U_SUCCESS(setupStatus)
+ || fString!=buf
+ ) {
+ char strBuf[200];
+ u_strToUTF8(strBuf,200,NULL,buf.getTerminatedBuffer(),buf.length()+1,&setupStatus);
+ printf("%s:%d: warmup() %s got %s (len %d) expected %s (len %d), err %s\n",
+ fFile,fLine,getName(),strBuf,buf.length(),fCStr,fLen, u_errorName(setupStatus));
+ setupStatus = U_INTERNAL_PROGRAM_ERROR;
+ }
+ }
+ }
+
+ int32_t run() {
+#if U_DEBUG
+ int32_t trial;
+#endif
+ int i=0;
+ UnicodeString buf;
+ if(U_SUCCESS(setupStatus)) {
+ for(i=0;i<U_LOTS_OF_TIMES;i++){
+ buf.remove();
+ ((const DecimalFormat*)fFmt)->format(fExpect, buf, NULL, setupStatus);
+ }
+ }
+ return i;
+ }
+ virtual ~NumFmtStringPieceTest(){}
+};
+
+#define DO_NumFmtStringPieceTest(p,n,x) { NumFmtStringPieceTest t(p,n,x,__FILE__,__LINE__); runTestOn(t); }
+
projects / apple / icu.git / blobdiff