icuSources/test/intltest/dcfmtest.cpp

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 2002-2014, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6
   7 //
   8 //   dcfmtest.cpp
   9 //
  10 //     Decimal Formatter tests, data driven.
  11 //
  12
  13 #include "intltest.h"
  14
  15 #if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_REGULAR_EXPRESSIONS
  16
  17 #include "unicode/regex.h"
  18 #include "unicode/uchar.h"
  19 #include "unicode/ustring.h"
  20 #include "unicode/unistr.h"
  21 #include "unicode/dcfmtsym.h"
  22 #include "unicode/decimfmt.h"
  23 #include "unicode/locid.h"
  24 #include "cmemory.h"
  25 #include "dcfmtest.h"
  26 #include "util.h"
  27 #include "cstring.h"
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <stdio.h>
  31
  32 #if !defined(_MSC_VER)
  33 namespace std { class type_info; } // WORKAROUND: http://llvm.org/bugs/show_bug.cgi?id=13364
  34 #endif
  35
  36 #include <string>
  37 #include <iostream>
  38
  39 //---------------------------------------------------------------------------
  40 //
  41 //  Test class boilerplate
  42 //
  43 //---------------------------------------------------------------------------
  44 DecimalFormatTest::DecimalFormatTest()
  45 {
  46 }
  47
  48
  49 DecimalFormatTest::~DecimalFormatTest()
  50 {
  51 }
  52
  53
  54
  55 void DecimalFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
  56 {
  57     if (exec) logln("TestSuite DecimalFormatTest: ");
  58     switch (index) {
  59
  60 #if !UCONFIG_NO_FILE_IO
  61         case 0: name = "DataDrivenTests";
  62             if (exec) DataDrivenTests();
  63             break;
  64 #else
  65         case 0: name = "skip";
  66             break;
  67 #endif
  68
  69         default: name = "";
  70             break; //needed to end loop
  71     }
  72 }
  73
  74
  75 //---------------------------------------------------------------------------
  76 //
  77 //   Error Checking / Reporting macros used in all of the tests.
  78 //
  79 //---------------------------------------------------------------------------
  80 #define DF_CHECK_STATUS {if (U_FAILURE(status)) \
  81     {dataerrln("DecimalFormatTest failure at line %d.  status=%s", \
  82     __LINE__, u_errorName(status)); return 0;}}
  83
  84 #define DF_ASSERT(expr) {if ((expr)==FALSE) {errln("DecimalFormatTest failure at line %d.\n", __LINE__);};}
  85
  86 #define DF_ASSERT_FAIL(expr, errcode) {UErrorCode status=U_ZERO_ERROR; (expr);\
  87 if (status!=errcode) {dataerrln("DecimalFormatTest failure at line %d.  Expected status=%s, got %s", \
  88     __LINE__, u_errorName(errcode), u_errorName(status));};}
  89
  90 #define DF_CHECK_STATUS_L(line) {if (U_FAILURE(status)) {errln( \
  91     "DecimalFormatTest failure at line %d, from %d.  status=%d\n",__LINE__, (line), status); }}
  92
  93 #define DF_ASSERT_L(expr, line) {if ((expr)==FALSE) { \
  94     errln("DecimalFormatTest failure at line %d, from %d.", __LINE__, (line)); return;}}
  95
  96
  97
  98 //
  99 //  InvariantStringPiece
 100 //    Wrap a StringPiece around the extracted invariant data of a UnicodeString.
 101 //    The data is guaranteed to be nul terminated.  (This is not true of StringPiece
 102 //    in general, but is true of InvariantStringPiece)
 103 //
 104 class InvariantStringPiece: public StringPiece {
 105   public:
 106     InvariantStringPiece(const UnicodeString &s);
 107     ~InvariantStringPiece() {};
 108   private:
 109     MaybeStackArray<char, 20>  buf;
 110 };
 111
 112 InvariantStringPiece::InvariantStringPiece(const UnicodeString &s) {
 113     int32_t  len = s.length();
 114     if (len+1 > buf.getCapacity()) {
 115         buf.resize(len+1);
 116     }
 117     // Buffer size is len+1 so that s.extract() will nul-terminate the string.
 118     s.extract(0, len, buf.getAlias(), len+1, US_INV);
 119     this->set(buf.getAlias(), len);
 120 }
 121
 122
 123 //  UnicodeStringPiece
 124 //    Wrap a StringPiece around the extracted (to the default charset) data of
 125 //    a UnicodeString.  The extracted data is guaranteed to be nul terminated.
 126 //    (This is not true of StringPiece in general, but is true of UnicodeStringPiece)
 127 //
 128 class UnicodeStringPiece: public StringPiece {
 129   public:
 130     UnicodeStringPiece(const UnicodeString &s);
 131     ~UnicodeStringPiece() {};
 132   private:
 133     MaybeStackArray<char, 20>  buf;
 134 };
 135
 136 UnicodeStringPiece::UnicodeStringPiece(const UnicodeString &s) {
 137     int32_t  len = s.length();
 138     int32_t  capacity = buf.getCapacity();
 139     int32_t requiredCapacity = s.extract(0, len, buf.getAlias(), capacity) + 1;
 140     if (capacity < requiredCapacity) {
 141         buf.resize(requiredCapacity);
 142         capacity = requiredCapacity;
 143         s.extract(0, len, buf.getAlias(), capacity);
 144     }
 145     this->set(buf.getAlias(), requiredCapacity - 1);
 146 }
 147
 148
 149
 150 //---------------------------------------------------------------------------
 151 //
 152 //      DataDrivenTests
 153 //             The test cases are in a separate data file,
 154 //
 155 //---------------------------------------------------------------------------
 156
 157 // Translate a Formattable::type enum value to a string, for error message formatting.
 158 static const char *formattableType(Formattable::Type typ) {
 159     static const char *types[] = {"kDate",
 160                                   "kDouble",
 161                                   "kLong",
 162                                   "kString",
 163                                   "kArray",
 164                                   "kInt64",
 165                                   "kObject"
 166                                   };
 167     if (typ<0 || typ>Formattable::kObject) {
 168         return "Unknown";
 169     }
 170     return types[typ];
 171 }
 172
 173 const char *
 174 DecimalFormatTest::getPath(char *buffer, const char *filename) {
 175     UErrorCode status=U_ZERO_ERROR;
 176     const char *testDataDirectory = IntlTest::getSourceTestData(status);
 177     DF_CHECK_STATUS;
 178
 179     strcpy(buffer, testDataDirectory);
 180     strcat(buffer, filename);
 181     return buffer;
 182 }
 183
 184 void DecimalFormatTest::DataDrivenTests() {
 185     char tdd[2048];
 186     const char *srcPath;
 187     UErrorCode  status  = U_ZERO_ERROR;
 188     int32_t     lineNum = 0;
 189
 190     //
 191     //  Open and read the test data file.
 192     //
 193     srcPath=getPath(tdd, "dcfmtest.txt");
 194     if(srcPath==NULL) {
 195         return; /* something went wrong, error already output */
 196     }
 197
 198     int32_t    len;
 199     UChar *testData = ReadAndConvertFile(srcPath, len, status);
 200     if (U_FAILURE(status)) {
 201         return; /* something went wrong, error already output */
 202     }
 203
 204     //
 205     //  Put the test data into a UnicodeString
 206     //
 207     UnicodeString testString(FALSE, testData, len);
 208
 209     RegexMatcher    parseLineMat(UnicodeString(
 210             "(?i)\\s*parse\\s+"
 211             "\"([^\"]*)\"\\s+"           // Capture group 1: input text
 212             "([ild])\\s+"                // Capture group 2: expected parsed type
 213             "\"([^\"]*)\"\\s+"           // Capture group 3: expected parsed decimal
 214             "\\s*(?:#.*)?"),             // Trailing comment
 215          0, status);
 216
 217     RegexMatcher    formatLineMat(UnicodeString(
 218             "(?i)\\s*format\\s+"
 219             "(\\S+)\\s+"                 // Capture group 1: pattern
 220             "(ceiling|floor|down|up|halfeven|halfdown|halfup|default|unnecessary)\\s+"  // Capture group 2: Rounding Mode
 221             "\"([^\"]*)\"\\s+"           // Capture group 3: input
 222             "\"([^\"]*)\""               // Capture group 4: expected output
 223             "\\s*(?:#.*)?"),             // Trailing comment
 224          0, status);
 225
 226     RegexMatcher    commentMat    (UNICODE_STRING_SIMPLE("\\s*(#.*)?$"), 0, status);
 227     RegexMatcher    lineMat(UNICODE_STRING_SIMPLE("(?m)^(.*?)$"), testString, 0, status);
 228
 229     if (U_FAILURE(status)){
 230         dataerrln("Construct RegexMatcher() error.");
 231         delete [] testData;
 232         return;
 233     }
 234
 235     //
 236     //  Loop over the test data file, once per line.
 237     //
 238     while (lineMat.find()) {
 239         lineNum++;
 240         if (U_FAILURE(status)) {
 241             dataerrln("File dcfmtest.txt, line %d: ICU Error \"%s\"", lineNum, u_errorName(status));
 242         }
 243
 244         status = U_ZERO_ERROR;
 245         UnicodeString testLine = lineMat.group(1, status);
 246         // printf("%s\n", UnicodeStringPiece(testLine).data());
 247         if (testLine.length() == 0) {
 248             continue;
 249         }
 250
 251         //
 252         // Parse the test line.  Skip blank and comment only lines.
 253         // Separate out the three main fields - pattern, flags, target.
 254         //
 255
 256         commentMat.reset(testLine);
 257         if (commentMat.lookingAt(status)) {
 258             // This line is a comment, or blank.
 259             continue;
 260         }
 261
 262
 263         //
 264         //  Handle "parse" test case line from file
 265         //
 266         parseLineMat.reset(testLine);
 267         if (parseLineMat.lookingAt(status)) {
 268             execParseTest(lineNum,
 269                           parseLineMat.group(1, status),    // input
 270                           parseLineMat.group(2, status),    // Expected Type
 271                           parseLineMat.group(3, status),    // Expected Decimal String
 272                           status
 273                           );
 274             continue;
 275         }
 276
 277         //
 278         //  Handle "format" test case line
 279         //
 280         formatLineMat.reset(testLine);
 281         if (formatLineMat.lookingAt(status)) {
 282             execFormatTest(lineNum,
 283                            formatLineMat.group(1, status),    // Pattern
 284                            formatLineMat.group(2, status),    // rounding mode
 285                            formatLineMat.group(3, status),    // input decimal number
 286                            formatLineMat.group(4, status),    // expected formatted result
 287                            kFormattable,
 288                            status);
 289
 290             execFormatTest(lineNum,
 291                            formatLineMat.group(1, status),    // Pattern
 292                            formatLineMat.group(2, status),    // rounding mode
 293                            formatLineMat.group(3, status),    // input decimal number
 294                            formatLineMat.group(4, status),    // expected formatted result
 295                            kStringPiece,
 296                            status);
 297             continue;
 298         }
 299
 300         //
 301         //  Line is not a recognizable test case.
 302         //
 303         errln("Badly formed test case at line %d.\n%s\n",
 304              lineNum, UnicodeStringPiece(testLine).data());
 305
 306     }
 307
 308     delete [] testData;
 309 }
 310
 311
 312
 313 void DecimalFormatTest::execParseTest(int32_t lineNum,
 314                                      const UnicodeString &inputText,
 315                                      const UnicodeString &expectedType,
 316                                      const UnicodeString &expectedDecimal,
 317                                      UErrorCode &status) {
 318
 319     if (U_FAILURE(status)) {
 320         return;
 321     }
 322
 323     DecimalFormatSymbols symbols(Locale::getUS(), status);
 324     UnicodeString pattern = UNICODE_STRING_SIMPLE("####");
 325     DecimalFormat format(pattern, symbols, status);
 326     Formattable   result;
 327     if (U_FAILURE(status)) {
 328         dataerrln("file dcfmtest.txt, line %d: %s error creating the formatter.",
 329             lineNum, u_errorName(status));
 330         return;
 331     }
 332
 333     ParsePosition pos;
 334     int32_t expectedParseEndPosition = inputText.length();
 335
 336     format.parse(inputText, result, pos);
 337
 338     if (expectedParseEndPosition != pos.getIndex()) {
 339         errln("file dcfmtest.txt, line %d: Expected parse position afeter parsing: %d.  "
 340               "Actual parse position: %d", expectedParseEndPosition, pos.getIndex());
 341         return;
 342     }
 343
 344     char   expectedTypeC[2];
 345     expectedType.extract(0, 1, expectedTypeC, 2, US_INV);
 346     Formattable::Type expectType = Formattable::kDate;
 347     switch (expectedTypeC[0]) {
 348       case 'd': expectType = Formattable::kDouble; break;
 349       case 'i': expectType = Formattable::kLong;   break;
 350       case 'l': expectType = Formattable::kInt64;  break;
 351       default:
 352           errln("file dcfmtest.tx, line %d: unrecongized expected type \"%s\"",
 353               lineNum, InvariantStringPiece(expectedType).data());
 354           return;
 355     }
 356     if (result.getType() != expectType) {
 357         errln("file dcfmtest.txt, line %d: expectedParseType(%s) != actual parseType(%s)",
 358              lineNum, formattableType(expectType), formattableType(result.getType()));
 359         return;
 360     }
 361
 362     StringPiece decimalResult = result.getDecimalNumber(status);
 363     if (U_FAILURE(status)) {
 364         errln("File %s, line %d: error %s.  Line in file dcfmtest.txt:  %d:",
 365             __FILE__, __LINE__, u_errorName(status), lineNum);
 366         return;
 367     }
 368
 369     InvariantStringPiece expectedResults(expectedDecimal);
 370     if (decimalResult != expectedResults) {
 371         errln("file dcfmtest.txt, line %d: expected \"%s\", got \"%s\"",
 372             lineNum, expectedResults.data(), decimalResult.data());
 373     }
 374
 375     return;
 376 }
 377
 378
 379 void DecimalFormatTest::execFormatTest(int32_t lineNum,
 380                            const UnicodeString &pattern,     // Pattern
 381                            const UnicodeString &round,       // rounding mode
 382                            const UnicodeString &input,       // input decimal number
 383                            const UnicodeString &expected,    // expected formatted result
 384                            EFormatInputType inType,          // input number type
 385                            UErrorCode &status) {
 386     if (U_FAILURE(status)) {
 387         return;
 388     }
 389
 390     DecimalFormatSymbols symbols(Locale::getUS(), status);
 391     // printf("Pattern = %s\n", UnicodeStringPiece(pattern).data());
 392     DecimalFormat fmtr(pattern, symbols, status);
 393     if (U_FAILURE(status)) {
 394         dataerrln("file dcfmtest.txt, line %d: %s error creating the formatter.",
 395             lineNum, u_errorName(status));
 396         return;
 397     }
 398     if (round=="ceiling") {
 399         fmtr.setRoundingMode(DecimalFormat::kRoundCeiling);
 400     } else if (round=="floor") {
 401         fmtr.setRoundingMode(DecimalFormat::kRoundFloor);
 402     } else if (round=="down") {
 403         fmtr.setRoundingMode(DecimalFormat::kRoundDown);
 404     } else if (round=="up") {
 405         fmtr.setRoundingMode(DecimalFormat::kRoundUp);
 406     } else if (round=="halfeven") {
 407         fmtr.setRoundingMode(DecimalFormat::kRoundHalfEven);
 408     } else if (round=="halfdown") {
 409         fmtr.setRoundingMode(DecimalFormat::kRoundHalfDown);
 410     } else if (round=="halfup") {
 411         fmtr.setRoundingMode(DecimalFormat::kRoundHalfUp);
 412     } else if (round=="default") {
 413         // don't set any value.
 414     } else if (round=="unnecessary") {
 415         fmtr.setRoundingMode(DecimalFormat::kRoundUnnecessary);
 416     } else {
 417         fmtr.setRoundingMode(DecimalFormat::kRoundFloor);
 418         errln("file dcfmtest.txt, line %d: Bad rounding mode \"%s\"",
 419                 lineNum, UnicodeStringPiece(round).data());
 420     }
 421
 422     const char *typeStr = "Unknown";
 423     UnicodeString result;
 424     UnicodeStringPiece spInput(input);
 425
 426     switch (inType) {
 427     case kFormattable:
 428         {
 429             typeStr = "Formattable";
 430             Formattable fmtbl;
 431             fmtbl.setDecimalNumber(spInput, status);
 432             fmtr.format(fmtbl, result, NULL, status);
 433         }
 434         break;
 435     case kStringPiece:
 436         typeStr = "StringPiece";
 437         fmtr.format(spInput, result, NULL, status);
 438         break;
 439     }
 440
 441     if ((status == U_FORMAT_INEXACT_ERROR) && (result == "") && (expected == "Inexact")) {
 442         // Test succeeded.
 443         status = U_ZERO_ERROR;
 444         return;
 445     }
 446
 447     if (U_FAILURE(status)) {
 448         errln("[%s] file dcfmtest.txt, line %d: format() returned %s.",
 449             typeStr, lineNum, u_errorName(status));
 450         status = U_ZERO_ERROR;
 451         return;
 452     }
 453
 454     if (result != expected) {
 455         errln("[%s] file dcfmtest.txt, line %d: expected \"%s\", got \"%s\"",
 456             typeStr, lineNum, UnicodeStringPiece(expected).data(), UnicodeStringPiece(result).data());
 457     }
 458 }
 459
 460
 461 //-------------------------------------------------------------------------------
 462 //
 463 //  Read a text data file, convert it from UTF-8 to UChars, and return the data
 464 //    in one big UChar * buffer, which the caller must delete.
 465 //
 466 //    (Lightly modified version of a similar function in regextst.cpp)
 467 //
 468 //--------------------------------------------------------------------------------
 469 UChar *DecimalFormatTest::ReadAndConvertFile(const char *fileName, int32_t &ulen,
 470                                      UErrorCode &status) {
 471     UChar       *retPtr  = NULL;
 472     char        *fileBuf = NULL;
 473     const char  *fileBufNoBOM = NULL;
 474     FILE        *f       = NULL;
 475
 476     ulen = 0;
 477     if (U_FAILURE(status)) {
 478         return retPtr;
 479     }
 480
 481     //
 482     //  Open the file.
 483     //
 484     f = fopen(fileName, "rb");
 485     if (f == 0) {
 486         dataerrln("Error opening test data file %s\n", fileName);
 487         status = U_FILE_ACCESS_ERROR;
 488         return NULL;
 489     }
 490     //
 491     //  Read it in
 492     //
 493     int32_t            fileSize;
 494     int32_t            amtRead;
 495     int32_t            amtReadNoBOM;
 496
 497     fseek( f, 0, SEEK_END);
 498     fileSize = ftell(f);
 499     fileBuf = new char[fileSize];
 500     fseek(f, 0, SEEK_SET);
 501     amtRead = fread(fileBuf, 1, fileSize, f);
 502     if (amtRead != fileSize || fileSize <= 0) {
 503         errln("Error reading test data file.");
 504         goto cleanUpAndReturn;
 505     }
 506
 507     //
 508     // Look for a UTF-8 BOM on the data just read.
 509     //    The test data file is UTF-8.
 510     //    The BOM needs to be there in the source file to keep the Windows &
 511     //    EBCDIC machines happy, so force an error if it goes missing.
 512     //    Many Linux editors will silently strip it.
 513     //
 514     fileBufNoBOM = fileBuf + 3;
 515     amtReadNoBOM = amtRead - 3;
 516     if (fileSize<3 || uprv_strncmp(fileBuf, "\xEF\xBB\xBF", 3) != 0) {
 517         // TODO:  restore this check.
 518         errln("Test data file %s is missing its BOM", fileName);
 519         fileBufNoBOM = fileBuf;
 520         amtReadNoBOM = amtRead;
 521     }
 522
 523     //
 524     // Find the length of the input in UTF-16 UChars
 525     //  (by preflighting the conversion)
 526     //
 527     u_strFromUTF8(NULL, 0, &ulen, fileBufNoBOM, amtReadNoBOM, &status);
 528
 529     //
 530     // Convert file contents from UTF-8 to UTF-16
 531     //
 532     if (status == U_BUFFER_OVERFLOW_ERROR) {
 533         // Buffer Overflow is expected from the preflight operation.
 534         status = U_ZERO_ERROR;
 535         retPtr = new UChar[ulen+1];
 536         u_strFromUTF8(retPtr, ulen+1, NULL, fileBufNoBOM, amtReadNoBOM, &status);
 537     }
 538
 539 cleanUpAndReturn:
 540     fclose(f);
 541     delete[] fileBuf;
 542     if (U_FAILURE(status)) {
 543         errln("ICU Error \"%s\"\n", u_errorName(status));
 544         delete retPtr;
 545         retPtr = NULL;
 546     };
 547     return retPtr;
 548 }
 549
 550 #endif  /* !UCONFIG_NO_REGULAR_EXPRESSIONS  */
 551