scuffed-code/icu4c/source/test/cintltst/cnmdptst.c

455 lines
14 KiB
C
Raw Normal View History

1999-08-16 21:50:52 +00:00
/*
*******************************************************************************
* *
* COPYRIGHT: *
* (C) Copyright Taligent, Inc., 1996 *
* (C) Copyright International Business Machines Corporation, 1999 *
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
* US Government Users Restricted Rights - Use, duplication, or disclosure *
* restricted by GSA ADP Schedule Contract with IBM Corp. *
* *
*******************************************************************************
*
* File CNMDPTST.C
*
* Madhu Katragadda Creation
* Modification History:
*
* Date Name Description
* 06/24/99 helena Integrated Alan's NF enhancements and Java2 bug fixes
*******************************************************************************
*/
/* C DEPTH TEST FOR NUMBER FORMAT */
#include "uloc.h"
#include "utypes.h"
#include "unum.h"
#include "ustring.h"
#include "cintltst.h"
#include "cnmdptst.h"
#include <stdio.h>
#include <string.h>
void addNumFrDepTest(TestNode** root)
{
addTest(root, &TestPatterns, "tsformat/cnmdptst/TestPatterns");
addTest(root, &TestQuotes, "tsformat/cnmdptst/TestQuotes");
addTest(root, &TestExponential, "tsformat/cnmdptst/TestExponential");
addTest(root, &TestCurrencySign, "tsformat/cnmdptst/TestCurrencySign");
addTest(root, &TestCurrency, "tsformat/cnmdptst/TestCurrency");
addTest(root, &TestRounding487, "tsformat/cnmdptst/TestRounding487");
}
/*Test Various format patterns*/
void TestPatterns()
{
int32_t pat_length, i, lneed;
UNumberFormat *fmt;
UFieldPosition pos;
UChar upat[5];
UChar unewpat[5];
UChar unum[5];
UChar *unewp;
UChar *str;
UErrorCode status = ZERO_ERROR;
const char* pat[] = { "#.#", "#.", ".#", "#" };
const char* newpat[] = { "#0.#", "#0.", "#.0", "#" };
const char* num[] = { "0", "0.", ".0", "0" };
log_verbose("\nTesting different format patterns\n");
pat_length = sizeof(pat) / sizeof(pat[0]);
for (i=0; i < pat_length; ++i)
{
status = ZERO_ERROR;
u_uastrcpy(upat, pat[i]);
fmt= unum_openPattern(upat, u_strlen(upat), "en_US", &status);
if (FAILURE(status)) {
log_err("FAIL: Number format constructor failed for pattern %s\n", pat[i]);
continue;
}
lneed=0;
lneed=unum_toPattern(fmt, FALSE, NULL, lneed, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status= ZERO_ERROR;
unewp=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_toPattern(fmt, FALSE, unewp, lneed+1, &status);
}
if(FAILURE(status)){
log_err("FAIL: Number format extracting the pattern failed for %s\n", pat[i]);
}
u_uastrcpy(unewpat, newpat[i]);
if(u_strcmp(unewp, unewpat) != 0)
log_err("FAIL: Pattern %s should be transmute to %s; %s seen instead\n", pat[i], newpat[i], austrdup(unewp) );
lneed=0;
lneed=unum_format(fmt, 0, NULL, lneed, &pos, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status=ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_format(fmt, 0, str, lneed+1, &pos, &status);
}
if(FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
u_uastrcpy(unum, num[i]);
if (u_strcmp(str, unum) != 0)
{
log_err("FAIL: Pattern %s should format zero as %s; %s Seen instead\n", pat[i], num[i], austrdup(str) );
}
}
}
/* Test the handling of quotes*/
void TestQuotes()
{
int32_t lneed;
UErrorCode status;
UFieldPosition pos;
UChar pat[15];
UChar res[15];
UChar *str;
UNumberFormat *fmt;
status=ZERO_ERROR;
log_verbose("\nTestting the handling of quotes in number format\n");
u_uastrcpy(pat, "a'fo''o'b#");
fmt =unum_openPattern(pat, u_strlen(pat), "en_US", &status);
if(FAILURE(status)){
log_err("Error in number format costruction using pattern \"a'fo''o'b#\"\n");
}
lneed=0;
lneed=unum_format(fmt, 123, NULL, lneed, &pos, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status=ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_format(fmt, 123, str, lneed+1, &pos, &status);
}
if(FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
log_verbose("Pattern \"%s\" \n", austrdup(pat) );
log_verbose("Format 123 -> %s\n", austrdup(str) );
u_uastrcpy(res, "afo'ob123");
if(u_strcmp(str, res) != 0)
log_err("FAIL: Expected afo'ob123");
free(str);
unum_close(fmt);
u_uastrcpy(pat, "");
u_uastrcpy(pat, "a''b#");
fmt =unum_openPattern(pat, u_strlen(pat), "en_US", &status);
if(FAILURE(status)){
log_err("Error in number format costruction using pattern \"a''b#\"\n");
}
lneed=0;
lneed=unum_format(fmt, 123, NULL, lneed, &pos, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status=ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_format(fmt, 123, str, lneed+1, &pos, &status);
}
if(FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
log_verbose("Pattern \"%s\" \n", austrdup(pat) );
log_verbose("Format 123 -> %s\n", austrdup(str) );
u_uastrcpy(res, "");
u_uastrcpy(res, "a'b123");
if(u_strcmp(str, res) != 0)
log_err("FAIL: Expected a'b123\n");
free(str);
unum_close(fmt);
}
/* Test exponential pattern*/
void TestExponential()
{
int32_t pat_length, val_length, lval_length;
int32_t ival, ilval, p, v, lneed;
UNumberFormat *fmt;
UFieldPosition pos;
int32_t ppos;
UChar *upat;
UChar pattern[20];
UChar *str;
UChar uvalfor[20], ulvalfor[20];
double a;
UErrorCode status = ZERO_ERROR;
double val[] = { 0.01234, 123456789, 1.23e300, -3.141592653e-271 };
char* pat[] = { "0.####E0", "00.000E00", "##0.######E000", "0.###E0;[0.###E0]" };
int32_t lval[] = { 0, -1, 1, 123456789 };
char* valFormat[] =
{
"1.234E-2", "1.2346E8", "1.23E300", "-3.1416E-271",
"12.340E-03", "12.346E07", "12.300E299", "-31.416E-272",
"12.34E-003", "123.4568E006", "1.23E300", "-314.1593E-273",
"1.234E-2", "1.235E8", "1.23E300", "[3.142E-271]"
};
char* lvalFormat[] =
{
"0E0", "-1E0", "1E0", "1.2346E8",
"00.000E00", "-10.000E-01", "10.000E-01", "12.346E07",
"0E000", "-1E000", "1E000", "123.4568E006",
"0E0", "[1E0]", "1E0", "1.235E8"
};
double valParse[] =
{
0.01234, 123460000, 1.23E300, -3.1416E-271,
0.01234, 123460000, 1.23E300, -3.1416E-271,
0.01234, 123456800, 1.23E300, -3.141593E-271,
0.01234, 123500000, 1.23E300, -3.142E-271,
};
int32_t lvalParse[] =
{
0, -1, 1, 123460000,
0, -1, 1, 123460000,
0, -1, 1, 123456800,
0, -1, 1, 123500000,
};
pat_length = sizeof(pat) / sizeof(pat[0]);
val_length = sizeof(val) / sizeof(val[0]);
lval_length = sizeof(lval) / sizeof(lval[0]);
ival = 0;
ilval = 0;
for (p=0; p < pat_length; ++p)
{
upat=(UChar*)malloc(sizeof(UChar) * (strlen(pat[p])+1) );
u_uastrcpy(upat, pat[p]);
fmt=unum_openPattern(upat, u_strlen(upat), "en_US", &status);
if (FAILURE(status)) {
log_err("FAIL: Bad status returned by Number format construction with pattern %s\n, pat[i]");
continue;
}
lneed= u_strlen(upat) + 1;
unum_toPattern(fmt, FALSE, pattern, lneed, &status);
log_verbose("Pattern \" %s \" -toPattern-> \" %s \" \n", upat, austrdup(pattern) );
for (v=0; v<val_length; ++v)
{
/*format*/
lneed=0;
lneed=unum_formatDouble(fmt, val[v], NULL, lneed, &pos, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status=ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_formatDouble(fmt, val[v], str, lneed+1, &pos, &status);
}
if(FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
u_uastrcpy(uvalfor, valFormat[v+ival]);
if(u_strcmp(str, uvalfor) != 0)
log_verbose("FAIL: Expected %s ( %s )\n", valFormat[v+ival], austrdup(uvalfor) );
/*parsing*/
ppos=0;
a=unum_parseDouble(fmt, str, u_strlen(str), &ppos, &status);
if (ppos== u_strlen(str)) {
if (a != valParse[v+ival])
printf("FAIL: Expected : %e\n", valParse[v+ival]);
}
else
printf(" FAIL: Partial parse ( %d chars ) -> %e\n", ppos, a);
free(str);
}
for (v=0; v<lval_length; ++v)
{
/*format*/
lneed=0;
lneed=unum_formatDouble(fmt, lval[v], NULL, lneed, &pos, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status=ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_formatDouble(fmt, lval[v], str, lneed+1, &pos, &status);
}
if(FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
/*printf(" Format %e -> %s\n", lval[v], austrdup(str) );*/
u_uastrcpy(ulvalfor, lvalFormat[v+ilval]);
if(u_strcmp(str, ulvalfor) != 0)
log_err("FAIL: Expected %s ( %s )\n", valFormat[v+ilval], austrdup(ulvalfor) );
/*parsing*/
ppos=0;
a=unum_parseDouble(fmt, str, u_strlen(str), &ppos, &status);
if (ppos== u_strlen(str)) {
/*printf(" Parse -> %e\n", a);*/
if (a != lvalParse[v+ilval])
printf("FAIL: Expected : %e\n", valParse[v+ival]);
}
else
printf(" FAIL: Partial parse ( %d chars ) -> %e\n", ppos, a);
free(str);
}
ival += val_length;
ilval += lval_length;
unum_close(fmt);
free(upat);
}
}
/**
* Test the handling of the currency symbol in patterns.
*/
void TestCurrencySign()
{
int32_t lneed;
UNumberFormat *fmt;
UChar *pattern;
UChar *str;
UChar *pat;
UChar *res;
UFieldPosition pos;
UErrorCode status = ZERO_ERROR;
pattern=(UChar*)malloc(sizeof(UChar) * (strlen("\xA4#,##0.00;-\xA4#,##0.00") + 1) );
u_uastrcpy(pattern, "\xA4#,##0.00;-\xA4#,##0.00");
fmt = unum_openPattern(pattern, u_strlen(pattern), "en_US", &status);
if(FAILURE(status)){
log_err("Error in number format construction with pattern \"\\xA4#,##0.00;-\\xA4#,##0.00\\\" \n");
}
lneed=0;
lneed=unum_formatDouble(fmt, 1234.56, NULL, lneed, &pos, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status=ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_formatDouble(fmt, 1234.56, str, lneed+1, &pos, &status);
}
if(FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
lneed=0;
lneed=unum_toPattern(fmt, FALSE, NULL, lneed, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status=ZERO_ERROR;
pat=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_formatDouble(fmt, FALSE, pat, lneed+1, &pos, &status);
}
log_verbose("Pattern \" %s \" \n", austrdup(pat));
log_verbose("Format 1234.56 -> %s\n", austrdup(str) );
res=(UChar*)malloc(sizeof(UChar) * (strlen("$1,234.56")+1) );
u_uastrcpy(res, "$1,234.56");
if (u_strcmp(str, res) !=0) log_err("FAIL: Expected $1,234.56\n");
free(str);
free(res);
free(pat);
lneed=0;
lneed=unum_formatDouble(fmt, -1234.56, NULL, lneed, &pos, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status=ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_formatDouble(fmt, -1234.56, str, lneed+1, &pos, &status);
}
if(FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
res=(UChar*)malloc(sizeof(UChar) * (strlen("-$1,234.56")+1) );
u_uastrcpy(res, "-$1,234.56");
if (u_strcmp(str, res) != 0) log_err("FAIL: Expected -$1,234.56\n");
free(str);
free(res);
unum_close(fmt);
free(pattern);
}
/**
* Test localized currency patterns.
*/
void TestCurrency()
{
UNumberFormat *currencyFmt;
UChar *str, *res;
int32_t lneed, i;
UFieldPosition pos;
UErrorCode status = ZERO_ERROR;
const char* locale[]={"fr_CA", "de_DE", "fr_FR"};
const char* result[]={"1,50 $", "1,50 DM", "1,50 F"};
log_verbose("\nTesting the number format with different currency patterns\n");
for(i=0; i < 3; i++)
{
currencyFmt = unum_open(UNUM_CURRENCY, locale[i], &status);
if(FAILURE(status)){log_err("Error in the construction of number format with style currency:\n%s\n",
myErrorName(status));
}
lneed=0;
lneed= unum_formatDouble(currencyFmt, 1.50, NULL, lneed, &pos, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status=ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_formatDouble(currencyFmt, 1.50, str, lneed+1, &pos, &status);
}
if(FAILURE(status)) {
log_err("Error in formatting using unum_formatDouble(.....): %s\n", myErrorName(status) );
}
res=(UChar*)malloc(sizeof(UChar) * (strlen(result[i])+1) );
u_uastrcpy(res, result[i]);
if (u_strcmp(str, res) != 0) log_err("FAIL: Expected %s\n", result[i]);
unum_close(currencyFmt);
free(str);
}
}
/**
* Test proper rounding by the format method.
*/
void TestRounding487()
{
UNumberFormat *nnf;
UErrorCode status = ZERO_ERROR;
nnf = unum_open(UNUM_DEFAULT, NULL, &status);
if(FAILURE(status)){
log_err("FAIL: failure in the construction of number format: %s\n", myErrorName(status));
}
roundingTest(nnf, 0.00159999, 4, "0.0016");
roundingTest(nnf, 0.00995, 4, "0.01");
roundingTest(nnf, 12.3995, 3, "12.4");
roundingTest(nnf, 12.4999, 0, "12");
roundingTest(nnf, - 19.5, 0, "-20");
unum_close(nnf);
}
/*-------------------------------------*/
void roundingTest(UNumberFormat* nf, double x, int32_t maxFractionDigits, const char* expected)
{
UChar *out;
UChar *res;
UFieldPosition pos;
UErrorCode status;
int32_t lneed;
status=ZERO_ERROR;
unum_setAttribute(nf, UNUM_MAX_FRACTION_DIGITS, maxFractionDigits);
lneed=0;
lneed=unum_formatDouble(nf, x, NULL, lneed, &pos, &status);
if(status==BUFFER_OVERFLOW_ERROR){
status=ZERO_ERROR;
out=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_formatDouble(nf, x, out, lneed+1, &pos, &status);
}
if(FAILURE(status)) {
log_err("Error in formatting using unum_formatDouble(.....): %s\n", myErrorName(status) );
}
/*Need to use log_verbose here. Problem with the float*/
/*printf("%f format with %d fraction digits to %s\n", x, maxFractionDigits, austrdup(out) );*/
res=(UChar*)malloc(sizeof(UChar) * (strlen(expected)+1) );
u_uastrcpy(res, expected);
if (u_strcmp(out, res) != 0) log_err("FAIL: Expected: %s or %s\n", expected, austrdup(res) );
}