[apple/icu.git] / icuSources / test / intltest / itrbnfrt.cpp

/*
 *******************************************************************************
 * Copyright (C) 1996-2009, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 */

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "itrbnfrt.h"

#include "unicode/fmtable.h"
#include <math.h> // fabs
#include <stdio.h>

// current macro not in icu1.8.1
#define TESTCASE(id,test)             \
    case id:                          \
        name = #test;                 \
        if (exec) {                   \
            logln(#test "---");       \
            logln();                  \
            test();                   \
        }                             \
        break

void RbnfRoundTripTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/)
{
    if (exec) logln("TestSuite RuleBasedNumberFormatRT");
    switch (index) {
#if U_HAVE_RBNF
      TESTCASE(0, TestEnglishSpelloutRT);
      TESTCASE(1, TestDurationsRT);
      TESTCASE(2, TestSpanishSpelloutRT);
      TESTCASE(3, TestFrenchSpelloutRT);
      TESTCASE(4, TestSwissFrenchSpelloutRT);
      TESTCASE(5, TestItalianSpelloutRT);
      TESTCASE(6, TestGermanSpelloutRT);
      TESTCASE(7, TestSwedishSpelloutRT);
      TESTCASE(8, TestDutchSpelloutRT);
      TESTCASE(9, TestJapaneseSpelloutRT);
      TESTCASE(10, TestRussianSpelloutRT);
      TESTCASE(11, TestPortugueseSpelloutRT);
#else
      TESTCASE(0, TestRBNFDisabled);
#endif
    default:
      name = "";
      break;
    }
}

#if U_HAVE_RBNF

/**
 * Perform an exhaustive round-trip test on the English spellout rules
 */
void
RbnfRoundTripTest::TestEnglishSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getUS(), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, -12345678, 12345678);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the duration-formatting rules
 */
void
RbnfRoundTripTest::TestDurationsRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_DURATION, Locale::getUS(), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, 0, 12345678);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the Spanish spellout rules
 */
void
RbnfRoundTripTest::TestSpanishSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("es", "es"), status);
 
  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, -12345678, 12345678);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the French spellout rules
 */
void
RbnfRoundTripTest::TestFrenchSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getFrance(), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, -12345678, 12345678);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the Swiss French spellout rules
 */
void
RbnfRoundTripTest::TestSwissFrenchSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("fr", "CH"), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, -12345678, 12345678);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the Italian spellout rules
 */
void
RbnfRoundTripTest::TestItalianSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getItalian(), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, -999999, 999999);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the German spellout rules
 */
void
RbnfRoundTripTest::TestGermanSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getGermany(), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, 0, 12345678);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the Swedish spellout rules
 */
void
RbnfRoundTripTest::TestSwedishSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("sv", "SE"), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, 0, 12345678);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the Dutch spellout rules
 */
void
RbnfRoundTripTest::TestDutchSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("nl", "NL"), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, -12345678, 12345678);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the Japanese spellout rules
 */
void
RbnfRoundTripTest::TestJapaneseSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getJapan(), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, 0, 12345678);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the Russian spellout rules
 */
void
RbnfRoundTripTest::TestRussianSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("ru", "RU"), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, 0, 12345678);
  }
  delete formatter;
}

/**
 * Perform an exhaustive round-trip test on the Portuguese spellout rules
 */
void
RbnfRoundTripTest::TestPortugueseSpelloutRT() 
{
  UErrorCode status = U_ZERO_ERROR;
  RuleBasedNumberFormat* formatter
    = new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("pt", "BR"), status);

  if (U_FAILURE(status)) {
    errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
  } else {
    doTest(formatter, -12345678, 12345678);
  }
  delete formatter;
}

void
RbnfRoundTripTest::doTest(const RuleBasedNumberFormat* formatter,  
                          double lowLimit,
                          double highLimit) 
{
  char buf[128];

  uint32_t count = 0;
  double increment = 1;
  for (double i = lowLimit; i <= highLimit; i += increment) {
    if (count % 1000 == 0) {
      sprintf(buf, "%.12g", i);
      logln(buf);
    }

    if (fabs(i) <  5000)
      increment = 1;
    else if (fabs(i) < 500000)
      increment = 2737;
    else
      increment = 267437;

    UnicodeString formatResult;
    formatter->format(i, formatResult);
    UErrorCode status = U_ZERO_ERROR;
    Formattable parseResult;
    formatter->parse(formatResult, parseResult, status);
    if (U_FAILURE(status)) {
      sprintf(buf, "Round-trip status failure: %.12g, status: %d", i, status);
      errln(buf);
      return;
    } else {
      double rt = (parseResult.getType() == Formattable::kDouble) ? 
        parseResult.getDouble() : 
        (double)parseResult.getLong();

      if (rt != i) {
        sprintf(buf, "Round-trip failed: %.12g -> %.12g", i, rt);
        errln(buf);
        return;
      }
    }

    ++count;
  }

  if (lowLimit < 0) {
    double d = 1.234;
    while (d < 1000) {
      UnicodeString formatResult;
      formatter->format(d, formatResult);
      UErrorCode status = U_ZERO_ERROR;
      Formattable parseResult;
      formatter->parse(formatResult, parseResult, status);
      if (U_FAILURE(status)) {
        sprintf(buf, "Round-trip status failure: %.12g, status: %d", d, status);
        errln(buf);
        return;
      } else {
        double rt = (parseResult.getType() == Formattable::kDouble) ? 
          parseResult.getDouble() : 
          (double)parseResult.getLong();

        if (rt != d) {
          UnicodeString msg;
          sprintf(buf, "Round-trip failed: %.12g -> ", d);
          msg.append(buf);
          msg.append(formatResult);
          sprintf(buf, " -> %.12g", rt);
          msg.append(buf);
          errln(msg);
          return;
        }
      }

      d *= 10;
    }
  }
}

/* U_HAVE_RBNF */
#else

void
RbnfRoundTripTest::TestRBNFDisabled() {
    errln("*** RBNF currently disabled on this platform ***\n");
}

/* U_HAVE_RBNF */
#endif

#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
b75a7d8f A	1	/*
b75a7d8f A	2	*******************************************************************************
729e4ab9	3	* Copyright (C) 1996-2009, International Business Machines Corporation and *
b75a7d8f A	4	* others. All Rights Reserved. *
	5	*******************************************************************************
	6	*/
	7
	8	#include "unicode/utypes.h"
	9
	10	#if !UCONFIG_NO_FORMATTING
	11
	12	#include "itrbnfrt.h"
	13
	14	#include "unicode/fmtable.h"
374ca955 A	15	#include <math.h> // fabs
374ca955 A	16	#include <stdio.h>
b75a7d8f A	17
	18	// current macro not in icu1.8.1
	19	#define TESTCASE(id,test) \
	20	case id: \
	21	name = #test; \
	22	if (exec) { \
	23	logln(#test "---"); \
729e4ab9	24	logln(); \
b75a7d8f A	25	test(); \
	26	} \
	27	break
	28
	29	void RbnfRoundTripTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /par/)
	30	{
	31	if (exec) logln("TestSuite RuleBasedNumberFormatRT");
	32	switch (index) {
	33	#if U_HAVE_RBNF
	34	TESTCASE(0, TestEnglishSpelloutRT);
	35	TESTCASE(1, TestDurationsRT);
	36	TESTCASE(2, TestSpanishSpelloutRT);
	37	TESTCASE(3, TestFrenchSpelloutRT);
	38	TESTCASE(4, TestSwissFrenchSpelloutRT);
	39	TESTCASE(5, TestItalianSpelloutRT);
	40	TESTCASE(6, TestGermanSpelloutRT);
	41	TESTCASE(7, TestSwedishSpelloutRT);
	42	TESTCASE(8, TestDutchSpelloutRT);
	43	TESTCASE(9, TestJapaneseSpelloutRT);
	44	TESTCASE(10, TestRussianSpelloutRT);
46f4442e	45	TESTCASE(11, TestPortugueseSpelloutRT);
b75a7d8f A	46	#else
	47	TESTCASE(0, TestRBNFDisabled);
	48	#endif
	49	default:
	50	name = "";
	51	break;
	52	}
	53	}
	54
	55	#if U_HAVE_RBNF
	56
	57	/**
	58	* Perform an exhaustive round-trip test on the English spellout rules
	59	*/
	60	void
	61	RbnfRoundTripTest::TestEnglishSpelloutRT()
	62	{
	63	UErrorCode status = U_ZERO_ERROR;
	64	RuleBasedNumberFormat* formatter
	65	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getUS(), status);
	66
	67	if (U_FAILURE(status)) {
729e4ab9	68	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	69	} else {
	70	doTest(formatter, -12345678, 12345678);
	71	}
	72	delete formatter;
	73	}
	74
	75	/**
	76	* Perform an exhaustive round-trip test on the duration-formatting rules
	77	*/
	78	void
	79	RbnfRoundTripTest::TestDurationsRT()
	80	{
	81	UErrorCode status = U_ZERO_ERROR;
	82	RuleBasedNumberFormat* formatter
	83	= new RuleBasedNumberFormat(URBNF_DURATION, Locale::getUS(), status);
	84
	85	if (U_FAILURE(status)) {
729e4ab9	86	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	87	} else {
	88	doTest(formatter, 0, 12345678);
	89	}
	90	delete formatter;
	91	}
	92
	93	/**
	94	* Perform an exhaustive round-trip test on the Spanish spellout rules
	95	*/
	96	void
	97	RbnfRoundTripTest::TestSpanishSpelloutRT()
	98	{
	99	UErrorCode status = U_ZERO_ERROR;
	100	RuleBasedNumberFormat* formatter
	101	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("es", "es"), status);
	102
	103	if (U_FAILURE(status)) {
729e4ab9	104	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	105	} else {
	106	doTest(formatter, -12345678, 12345678);
	107	}
	108	delete formatter;
	109	}
	110
	111	/**
	112	* Perform an exhaustive round-trip test on the French spellout rules
	113	*/
	114	void
	115	RbnfRoundTripTest::TestFrenchSpelloutRT()
	116	{
	117	UErrorCode status = U_ZERO_ERROR;
	118	RuleBasedNumberFormat* formatter
	119	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getFrance(), status);
	120
	121	if (U_FAILURE(status)) {
729e4ab9	122	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	123	} else {
	124	doTest(formatter, -12345678, 12345678);
	125	}
	126	delete formatter;
	127	}
	128
	129	/**
	130	* Perform an exhaustive round-trip test on the Swiss French spellout rules
	131	*/
	132	void
	133	RbnfRoundTripTest::TestSwissFrenchSpelloutRT()
	134	{
	135	UErrorCode status = U_ZERO_ERROR;
	136	RuleBasedNumberFormat* formatter
	137	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("fr", "CH"), status);
	138
	139	if (U_FAILURE(status)) {
729e4ab9	140	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	141	} else {
	142	doTest(formatter, -12345678, 12345678);
	143	}
	144	delete formatter;
	145	}
	146
	147	/**
	148	* Perform an exhaustive round-trip test on the Italian spellout rules
	149	*/
	150	void
	151	RbnfRoundTripTest::TestItalianSpelloutRT()
	152	{
	153	UErrorCode status = U_ZERO_ERROR;
	154	RuleBasedNumberFormat* formatter
	155	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getItalian(), status);
	156
	157	if (U_FAILURE(status)) {
729e4ab9	158	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	159	} else {
	160	doTest(formatter, -999999, 999999);
	161	}
	162	delete formatter;
	163	}
	164
	165	/**
	166	* Perform an exhaustive round-trip test on the German spellout rules
	167	*/
	168	void
	169	RbnfRoundTripTest::TestGermanSpelloutRT()
	170	{
	171	UErrorCode status = U_ZERO_ERROR;
	172	RuleBasedNumberFormat* formatter
	173	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getGermany(), status);
	174
	175	if (U_FAILURE(status)) {
729e4ab9	176	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	177	} else {
	178	doTest(formatter, 0, 12345678);
	179	}
	180	delete formatter;
	181	}
	182
	183	/**
	184	* Perform an exhaustive round-trip test on the Swedish spellout rules
	185	*/
	186	void
	187	RbnfRoundTripTest::TestSwedishSpelloutRT()
	188	{
	189	UErrorCode status = U_ZERO_ERROR;
	190	RuleBasedNumberFormat* formatter
	191	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("sv", "SE"), status);
	192
	193	if (U_FAILURE(status)) {
729e4ab9	194	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	195	} else {
	196	doTest(formatter, 0, 12345678);
	197	}
	198	delete formatter;
	199	}
	200
	201	/**
	202	* Perform an exhaustive round-trip test on the Dutch spellout rules
	203	*/
	204	void
	205	RbnfRoundTripTest::TestDutchSpelloutRT()
	206	{
	207	UErrorCode status = U_ZERO_ERROR;
	208	RuleBasedNumberFormat* formatter
	209	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("nl", "NL"), status);
	210
	211	if (U_FAILURE(status)) {
729e4ab9	212	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	213	} else {
	214	doTest(formatter, -12345678, 12345678);
	215	}
	216	delete formatter;
	217	}
	218
	219	/**
	220	* Perform an exhaustive round-trip test on the Japanese spellout rules
	221	*/
	222	void
	223	RbnfRoundTripTest::TestJapaneseSpelloutRT()
	224	{
	225	UErrorCode status = U_ZERO_ERROR;
	226	RuleBasedNumberFormat* formatter
	227	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale::getJapan(), status);
	228
	229	if (U_FAILURE(status)) {
729e4ab9	230	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	231	} else {
	232	doTest(formatter, 0, 12345678);
	233	}
	234	delete formatter;
	235	}
	236
	237	/**
	238	* Perform an exhaustive round-trip test on the Russian spellout rules
	239	*/
	240	void
	241	RbnfRoundTripTest::TestRussianSpelloutRT()
	242	{
	243	UErrorCode status = U_ZERO_ERROR;
	244	RuleBasedNumberFormat* formatter
	245	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("ru", "RU"), status);
	246
	247	if (U_FAILURE(status)) {
729e4ab9	248	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f A	249	} else {
	250	doTest(formatter, 0, 12345678);
	251	}
	252	delete formatter;
	253	}
	254
	255	/**
46f4442e	256	* Perform an exhaustive round-trip test on the Portuguese spellout rules
b75a7d8f A	257	*/
b75a7d8f A	258	void
46f4442e	259	RbnfRoundTripTest::TestPortugueseSpelloutRT()
b75a7d8f A	260	{
	261	UErrorCode status = U_ZERO_ERROR;
	262	RuleBasedNumberFormat* formatter
46f4442e	263	= new RuleBasedNumberFormat(URBNF_SPELLOUT, Locale("pt", "BR"), status);
b75a7d8f A	264
b75a7d8f A	265	if (U_FAILURE(status)) {
729e4ab9	266	errcheckln(status, "failed to construct formatter - %s", u_errorName(status));
b75a7d8f	267	} else {
46f4442e	268	doTest(formatter, -12345678, 12345678);
b75a7d8f A	269	}
	270	delete formatter;
	271	}
	272
	273	void
	274	RbnfRoundTripTest::doTest(const RuleBasedNumberFormat* formatter,
	275	double lowLimit,
	276	double highLimit)
	277	{
	278	char buf[128];
	279
	280	uint32_t count = 0;
	281	double increment = 1;
	282	for (double i = lowLimit; i <= highLimit; i += increment) {
	283	if (count % 1000 == 0) {
	284	sprintf(buf, "%.12g", i);
	285	logln(buf);
	286	}
	287
	288	if (fabs(i) < 5000)
	289	increment = 1;
	290	else if (fabs(i) < 500000)
	291	increment = 2737;
	292	else
	293	increment = 267437;
	294
	295	UnicodeString formatResult;
	296	formatter->format(i, formatResult);
	297	UErrorCode status = U_ZERO_ERROR;
	298	Formattable parseResult;
	299	formatter->parse(formatResult, parseResult, status);
	300	if (U_FAILURE(status)) {
	301	sprintf(buf, "Round-trip status failure: %.12g, status: %d", i, status);
	302	errln(buf);
	303	return;
	304	} else {
	305	double rt = (parseResult.getType() == Formattable::kDouble) ?
	306	parseResult.getDouble() :
	307	(double)parseResult.getLong();
	308
	309	if (rt != i) {
	310	sprintf(buf, "Round-trip failed: %.12g -> %.12g", i, rt);
	311	errln(buf);
	312	return;
	313	}
	314	}
	315
	316	++count;
	317	}
	318
	319	if (lowLimit < 0) {
	320	double d = 1.234;
	321	while (d < 1000) {
	322	UnicodeString formatResult;
	323	formatter->format(d, formatResult);
	324	UErrorCode status = U_ZERO_ERROR;
	325	Formattable parseResult;
	326	formatter->parse(formatResult, parseResult, status);
	327	if (U_FAILURE(status)) {
	328	sprintf(buf, "Round-trip status failure: %.12g, status: %d", d, status);
	329	errln(buf);
	330	return;
	331	} else {
	332	double rt = (parseResult.getType() == Formattable::kDouble) ?
333	parseResult.getDouble() :
334	(double)parseResult.getLong();
335
336	if (rt != d) {
337	UnicodeString msg;
338	sprintf(buf, "Round-trip failed: %.12g -> ", d);
339	msg.append(buf);
340	msg.append(formatResult);
341	sprintf(buf, " -> %.12g", rt);
342	msg.append(buf);
343	errln(msg);
344	return;
345	}
346	}
347
348	d *= 10;
349	}
350	}
351	}
352
353	/* U_HAVE_RBNF */
354	#else
355
356	void
357	RbnfRoundTripTest::TestRBNFDisabled() {
358	errln("* RBNF currently disabled on this platform *\n");
359	}
360
361	/* U_HAVE_RBNF */
362	#endif
363
364	#endif /* #if !UCONFIG_NO_FORMATTING */