自学教程：C++ u_uastrcpy函数代码示例

void TestPartialParse994(){    int32_t pos;    UDateFormat *f;    UErrorCode status = U_ZERO_ERROR;    UChar *s;    UChar *fmtChars;    UDate d, null;    null=0;    /* this is supposed to open default date format, but later on it treats it like it is "en_US"        - very bad if you try to run the tests on machine where default locale is NOT "en_US" */    /* f = udat_open(UDAT_DEFAULT, UDAT_SHORT, NULL, NULL, 0, &status); */    f = udat_open(UDAT_DEFAULT, UDAT_SHORT, "en_US", NULL, 0,  NULL, 0,&status);    if(U_FAILURE(status)){        log_data_err("FAIL: ErrorCode received during test: %s (Are you missing data?)/n", myErrorName(status));        return;    }    s=(UChar*)malloc(sizeof(UChar) * (strlen("01/01/1997 10:11:42 AM")+1) );    u_uastrcpy(s, "01/01/1997 10:11:42 AM");    pos=0;    d = udat_parse(f, s, u_strlen(s), &pos, &status);    if(U_FAILURE(status)) {      log_data_err("FAIL: could not parse - exitting");      return;    }    fmtChars = myDateFormat(f, d);    if(fmtChars) {      log_verbose("%s/n", fmtChars);    } else {      log_data_err("FAIL: could not format /n");      return;    }    tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/01 10:11:42", d);    tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/01 10:", null);    tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/01 10", null);    tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/01 ", null);    tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/01", null);    udat_close(f);    free(s);}

static void VerifysetSymbols(UDateFormat* datfor, UDateFormatSymbolType type, int32_t idx, const char* expected){    UChar *result=NULL;    UChar *value=NULL;    int32_t resultlength, resultlengthout;    UErrorCode status = U_ZERO_ERROR;    value=(UChar*)malloc(sizeof(UChar) * (strlen(expected) + 1));    u_uastrcpy(value, expected);    udat_setSymbols(datfor, type, idx, value, u_strlen(value), &status);    if(U_FAILURE(status))        {            log_err("FAIL: Error in udat_setSymbols()  %s/n", myErrorName(status) );            return;        }    resultlength=0;    resultlengthout=udat_getSymbols(datfor, type, idx, NULL, resultlength, &status);    if(status==U_BUFFER_OVERFLOW_ERROR){        status=U_ZERO_ERROR;        resultlength=resultlengthout+1;        result=(UChar*)malloc(sizeof(UChar) * resultlength);        udat_getSymbols(datfor, type, idx, result, resultlength, &status);    }    if(U_FAILURE(status)){        log_err("FAIL: error in retrieving the value using getSymbols after setting it previously/n %s/n",             myErrorName(status) );        return;    }        if(u_strcmp(result, value)!=0){        log_err("FAIL:Error in setting and then getting symbols/n Expected %s Got %s/n", austrdup(value),            austrdup(result) );    }    else        log_verbose("PASS: setSymbols successful/n");    free(value);    free(result);}

static void TestIdentical(){    int32_t i;    int32_t len;    UCollator *myCollation;    UErrorCode status=U_ZERO_ERROR;    static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";    UChar rules[sizeof(str)];    len = strlen(str);    u_uastrcpy(rules, str);    myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_IDENTICAL, NULL,&status);    if(U_FAILURE(status)){        log_err_status(status, "ERROR: in creation of rule based collator :%s/n", myErrorName(status));        return;    }    for(i= 34; i<37; i++)    {        doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);    }    ucol_close(myCollation);    myCollation = 0;}

/*test u_parseMessage() with various test patterns */static void TestParseMessage(){    UChar pattern[100];    UChar source[100];    UErrorCode status = U_ZERO_ERROR;    int32_t value;    UChar str[10];    UChar res[10];    log_verbose("/nTesting a sample for parse Message test#9/n");    u_uastrcpy(source, "You deposited an amount of $500.00");    u_uastrcpy(pattern, "You {0} an amount of {1,number,currency}");    u_uastrcpy(res,"deposited");    u_parseMessage( "en_US", pattern, u_strlen(pattern), source, u_strlen(source), &status, str, &value);    if(U_FAILURE(status)) {        log_err("ERROR: failure in parse Message on test#9: %s/n", myErrorName(status));    }    if(value==500.00  && u_strcmp(str,res)==0)        log_verbose("PASS: parseMessage successful on test#9/n");    else        log_err("FAIL: Error in parseMessage on test#9 /n");    log_verbose("/nTesting a sample for parse Message test#10/n");    u_uastrcpy(source, "There are 123 files on MyDisk created");    u_uastrcpy(pattern, "There are {0,number,integer} files on {1} created");    u_uastrcpy(res,"MyDisk");    u_parseMessage( "en_US", pattern, u_strlen(pattern), source, u_strlen(source), &status, &value, str);    if(U_FAILURE(status)) {        log_err("ERROR: failure in parse Message on test#10: %s/n", myErrorName(status));    }    if(value==123.00 && u_strcmp(str,res)==0)        log_verbose("PASS: parseMessage successful on test#10/n");    else        log_err("FAIL: Error in parseMessage on test#10 /n");}

static void TestTertiary(){    int32_t len,i;    UCollator *myCollation;    UErrorCode status=U_ZERO_ERROR;    static const char str[]="& C < ch, cH, Ch, CH & Five, 5 & Four, 4 & one, 1 & Ampersand; '&' & Two, 2 ";    UChar rules[sizeof(str)];    len = strlen(str);    u_uastrcpy(rules, str);    myCollation=ucol_openRules(rules, len, UCOL_OFF, UCOL_DEFAULT_STRENGTH, NULL, &status);    if(U_FAILURE(status)){        log_err_status(status, "ERROR: in creation of rule based collator :%s/n", myErrorName(status));        return;    }       ucol_setStrength(myCollation, UCOL_TERTIARY);    for (i = 0; i < 17 ; i++)    {        doTest(myCollation, testSourceCases[i], testTargetCases[i], results[i]);    }    ucol_close(myCollation);    myCollation = 0;}

/*test u_formatMessage() with sample patterns */static void TestSampleMessageFormat(void){    UChar *str;    UChar *result;    UChar pattern[100], expected[100];    int32_t resultLengthOut, resultlength;    UDate d = 837039928046.0;    UErrorCode status = U_ZERO_ERROR;    ctest_setTimeZone(NULL, &status);    str=(UChar*)malloc(sizeof(UChar) * 15);    u_uastrcpy(str, "abc");            u_uastrcpy(pattern, "There are {0} files on {1,date}");    u_uastrcpy(expected, "There are abc files on Jul 10, 1996");    result=(UChar*)malloc(sizeof(UChar) * 1);    log_verbose("/nTesting a sample for Message format test#1/n");    resultlength=1;    resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, d);    if(status==U_BUFFER_OVERFLOW_ERROR)    {        status=U_ZERO_ERROR;        resultlength=resultLengthOut+1;        result=(UChar*)realloc(result, sizeof(UChar) * resultlength);        u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, d);    }    if(U_FAILURE(status)){        log_data_err("Error: failure in message format on test#1: %s (Are you missing data?)/n", myErrorName(status));    }    else if(u_strcmp(result, expected)==0)        log_verbose("PASS: MessagFormat successful on test#1/n");    else{        log_err("FAIL: Error in MessageFormat on test#1 /n GOT: %s EXPECTED: %s/n",             austrdup(result), austrdup(expected) );    }    log_verbose("/nTesting message format with another pattern test#2/n");    u_uastrcpy(pattern, "The disk /"{0}/" contains {1,number,integer} file(s)");    u_uastrcpy(expected, "The disk /"MyDisk/" contains 23 file(s)");    u_uastrcpy(str, "MyDisk");    resultLengthOut=u_formatMessage( "en_US",         pattern,         u_strlen(pattern),        result,        resultlength,        &status,         str,        235);    if(status==U_BUFFER_OVERFLOW_ERROR)    {        status=U_ZERO_ERROR;        resultlength=resultLengthOut+1;        result=(UChar*)realloc(result, sizeof(UChar) * (resultlength+1));        u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, 23);    }    if(U_FAILURE(status)){        log_data_err("Error: failure in message format on test#2 : %s (Are you missing data?)/n", myErrorName(status));    }    else if(u_strcmp(result, expected)==0)        log_verbose("PASS: MessagFormat successful on test#2/n");    else{        log_err("FAIL: Error in MessageFormat on test#2/n GOT: %s EXPECTED: %s/n",             austrdup(result), austrdup(expected) );    }    log_verbose("/nTesting message format with another pattern test#3/n");    u_uastrcpy(pattern, "You made a {0} of {1,number,currency}");    u_uastrcpy(expected, "You made a deposit of $500.00");    u_uastrcpy(str, "deposit");    resultlength=0;    resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, str, 500.00);    if(status==U_BUFFER_OVERFLOW_ERROR)    {        status=U_ZERO_ERROR;        resultlength=resultLengthOut+1;        result=(UChar*)realloc(result, sizeof(UChar) * resultlength);        u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, 500.00);    }    if(U_FAILURE(status)){        log_data_err("Error: failure in message format on test#3 : %s (Are you missing data?)/n", myErrorName(status));    }    else if(u_strcmp(result, expected)==0)        log_verbose("PASS: MessagFormat successful on test#3/n");    else{        log_err("FAIL: Error in MessageFormat on test#3/n GOT: %s EXPECTED %s/n", austrdup(result),             austrdup(expected) );    }        free(result);    free(str);    ctest_resetTimeZone();}

/** * Test the functioning of the secondary grouping value. */static void TestSecondaryGrouping(void) {    UErrorCode status = U_ZERO_ERROR;    UNumberFormat *f = NULL, *g= NULL;    UNumberFormat *us = unum_open(UNUM_DECIMAL,NULL,0, "en_US", NULL,&status);    UFieldPosition pos;    UChar resultBuffer[512];    int32_t l = 1876543210L;    UBool ok = TRUE;    UChar buffer[512];    int32_t i;    UBool expectGroup = FALSE, isGroup = FALSE;    u_uastrcpy(buffer, "#,##,###");    f = unum_open(UNUM_IGNORE,buffer, -1, "en_US",NULL, &status);    if (U_FAILURE(status)) {        log_data_err("Error DecimalFormat ct -> %s (Are you missing data?)/n", u_errorName(status));        return;    }    pos.field = 0;    unum_format(f, (int32_t)123456789L, resultBuffer, 512 , &pos, &status);    u_uastrcpy(buffer, "12,34,56,789");    if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status))    {        log_err("Fail: Formatting /"#,##,###/" pattern with 123456789 got %s, expected %s/n", austrdup(resultBuffer), "12,34,56,789");    }    if (pos.beginIndex != 0 && pos.endIndex != 12) {        log_err("Fail: Formatting /"#,##,###/" pattern pos = (%d, %d) expected pos = (0, 12)/n", pos.beginIndex, pos.endIndex);    }    memset(resultBuffer,0, sizeof(UChar)*512);    unum_toPattern(f, FALSE, resultBuffer, 512, &status);    u_uastrcpy(buffer, "#,##,##0");    if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status))    {        log_err("Fail: toPattern() got %s, expected %s/n", austrdup(resultBuffer), "#,##,##0");    }    memset(resultBuffer,0, sizeof(UChar)*512);    u_uastrcpy(buffer, "#,###");    unum_applyPattern(f, FALSE, buffer, -1,NULL,NULL);    if (U_FAILURE(status))    {        log_err("Fail: applyPattern call failed/n");    }    unum_setAttribute(f, UNUM_SECONDARY_GROUPING_SIZE, 4);    unum_format(f, (int32_t)123456789L, resultBuffer, 512 , &pos, &status);    u_uastrcpy(buffer, "12,3456,789");    if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status))    {        log_err("Fail: Formatting /"#,###/" pattern with 123456789 got %s, expected %s/n", austrdup(resultBuffer), "12,3456,789");    }    memset(resultBuffer,0, sizeof(UChar)*512);    unum_toPattern(f, FALSE, resultBuffer, 512, &status);    u_uastrcpy(buffer, "#,####,##0");    if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status))    {        log_err("Fail: toPattern() got %s, expected %s/n", austrdup(resultBuffer), "#,####,##0");    }    memset(resultBuffer,0, sizeof(UChar)*512);    g = unum_open(UNUM_DECIMAL, NULL,0,"hi_IN",NULL, &status);    if (U_FAILURE(status))    {        log_err("Fail: Cannot create UNumberFormat for /"hi_IN/" locale./n");    }    unum_format(g, l, resultBuffer, 512, &pos, &status);    unum_close(g);    /* expect "1,87,65,43,210", but with Hindi digits */    /*         01234567890123                         */    if (u_strlen(resultBuffer) != 14) {        ok = FALSE;    } else {        for (i=0; i<u_strlen(resultBuffer); ++i) {            expectGroup = FALSE;            switch (i) {            case 1:            case 4:            case 7:            case 10:                expectGroup = TRUE;                break;            }            /* Later -- fix this to get the actual grouping */            /* character from the resource bundle.          */            isGroup = (UBool)(resultBuffer[i] == 0x002C);            if (isGroup != expectGroup) {                ok = FALSE;                break;            }        }    }    if (!ok) {        log_err("FAIL  Expected %s x hi_IN -> /"1,87,65,43,210/" (with Hindi digits), got %s/n", "1876543210L", resultBuffer);    }    unum_close(f);    unum_close(us);}

/*** Tests the [variable top] tag in rule syntax. Since the default [alternate]* tag has the value shifted, any codepoints before [variable top] should give* a primary ce of 0.*/static void TestVariableTop(void){#if 0    /*     * Starting with ICU 53, setting the variable top via a pseudo relation string     * is not supported any more.     * It was replaced by the [maxVariable symbol] setting.     * See ICU tickets #9958 and #8032.     */    static const char       str[]          = "&z = [variable top]";          int         len          = strlen(str);          UChar      rules[sizeof(str)];          UCollator  *myCollation;          UCollator  *enCollation;          UErrorCode  status       = U_ZERO_ERROR;          UChar       source[1];          UChar       ch;          uint8_t     result[20];          uint8_t     expected[20];    u_uastrcpy(rules, str);    enCollation = ucol_open("en_US", &status);    if (U_FAILURE(status)) {        log_err_status(status, "ERROR: in creation of collator :%s/n",                 myErrorName(status));        return;    }    myCollation = ucol_openRules(rules, len, UCOL_OFF,                                  UCOL_PRIMARY,NULL, &status);    if (U_FAILURE(status)) {        ucol_close(enCollation);        log_err("ERROR: in creation of rule based collator :%s/n",                 myErrorName(status));        return;    }    ucol_setStrength(enCollation, UCOL_PRIMARY);    ucol_setAttribute(enCollation, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED,                      &status);    ucol_setAttribute(myCollation, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED,                      &status);            if (ucol_getAttribute(myCollation, UCOL_ALTERNATE_HANDLING, &status) !=        UCOL_SHIFTED || U_FAILURE(status)) {        log_err("ERROR: ALTERNATE_HANDLING value can not be set to SHIFTED/n");    }    uprv_memset(expected, 0, 20);    /* space is supposed to be a variable */    source[0] = ' ';    len = ucol_getSortKey(enCollation, source, 1, result,                           sizeof(result));    if (uprv_memcmp(expected, result, len) != 0) {        log_err("ERROR: SHIFTED alternate does not return 0 for primary of space/n");    }    ch = 'a';    while (ch < 'z') {        source[0] = ch;        len = ucol_getSortKey(myCollation, source, 1, result,                              sizeof(result));        if (uprv_memcmp(expected, result, len) != 0) {            log_err("ERROR: SHIFTED alternate does not return 0 for primary of %c/n",                     ch);        }        ch ++;    }      ucol_close(enCollation);    ucol_close(myCollation);    enCollation = NULL;    myCollation = NULL;#endif}

static void TestDateFormatCalendar() {    UDateFormat *date=0, *time=0, *full=0;    UCalendar *cal=0;    UChar buf[256];    char cbuf[256];    int32_t pos;    UDate when;    UErrorCode ec = U_ZERO_ERROR;    ctest_setTimeZone(NULL, &ec);    /* Create a formatter for date fields. */    date = udat_open(UDAT_NONE, UDAT_SHORT, "en_US", NULL, 0, NULL, 0, &ec);    if (U_FAILURE(ec)) {        log_data_err("FAIL: udat_open(NONE, SHORT, en_US) failed with %s (Are you missing data?)/n",                 u_errorName(ec));        goto FAIL;    }    /* Create a formatter for time fields. */    time = udat_open(UDAT_SHORT, UDAT_NONE, "en_US", NULL, 0, NULL, 0, &ec);    if (U_FAILURE(ec)) {        log_err("FAIL: udat_open(SHORT, NONE, en_US) failed with %s/n",                 u_errorName(ec));        goto FAIL;    }    /* Create a full format for output */    full = udat_open(UDAT_FULL, UDAT_FULL, "en_US", NULL, 0, NULL, 0, &ec);    if (U_FAILURE(ec)) {        log_err("FAIL: udat_open(FULL, FULL, en_US) failed with %s/n",                 u_errorName(ec));        goto FAIL;    }    /* Create a calendar */    cal = ucal_open(NULL, 0, "en_US", UCAL_GREGORIAN, &ec);    if (U_FAILURE(ec)) {        log_err("FAIL: ucal_open(en_US) failed with %s/n",                 u_errorName(ec));        goto FAIL;    }    /* Parse the date */    ucal_clear(cal);    u_uastrcpy(buf, "4/5/2001");    pos = 0;    udat_parseCalendar(date, cal, buf, -1, &pos, &ec);    if (U_FAILURE(ec)) {        log_err("FAIL: udat_parseCalendar(4/5/2001) failed at %d with %s/n",                pos, u_errorName(ec));        goto FAIL;    }    /* Parse the time */    u_uastrcpy(buf, "5:45 PM");    pos = 0;    udat_parseCalendar(time, cal, buf, -1, &pos, &ec);    if (U_FAILURE(ec)) {        log_err("FAIL: udat_parseCalendar(17:45) failed at %d with %s/n",                pos, u_errorName(ec));        goto FAIL;    }        /* Check result */    when = ucal_getMillis(cal, &ec);    if (U_FAILURE(ec)) {        log_err("FAIL: ucal_getMillis() failed with %s/n", u_errorName(ec));        goto FAIL;    }    udat_format(full, when, buf, sizeof(buf), NULL, &ec);    if (U_FAILURE(ec)) {        log_err("FAIL: udat_format() failed with %s/n", u_errorName(ec));        goto FAIL;    }    u_austrcpy(cbuf, buf);    /* Thursday, April 5, 2001 5:45:00 PM PDT 986517900000 */    if (when == 986517900000.0) {        log_verbose("Ok: Parsed result: %s/n", cbuf);    } else {        log_err("FAIL: Parsed result: %s, exp 4/5/2001 5:45 PM/n", cbuf);    } FAIL:        udat_close(date);    udat_close(time);    udat_close(full);    ucal_close(cal);    ctest_resetTimeZone();}

/* Testing the DateFormat API */static void TestDateFormat(){    UDateFormat *def, *fr, *it, *de, *def1, *fr_pat;    UDateFormat *any;    UDateFormat *copy;    UErrorCode status = U_ZERO_ERROR;    UChar* result = NULL;    const UCalendar *cal;    const UNumberFormat *numformat1, *numformat2;    UChar temp[50];    int32_t numlocales;    UDate d1;    int i;    int32_t resultlength;    int32_t resultlengthneeded;    int32_t parsepos;    UDate d = 837039928046.0;    double num = -10456.37;    /*const char* str="yyyy.MM.dd G 'at' hh:mm:ss z";    const char t[]="2/3/76 2:50 AM";*/    /*Testing udat_open() to open a dateformat */    ctest_setTimeZone(NULL, &status);    log_verbose("/nTesting udat_open() with various parameters/n");    fr = udat_open(UDAT_FULL, UDAT_DEFAULT, "fr_FR", NULL,0, NULL, 0,&status);    if(U_FAILURE(status))    {        log_data_err("FAIL: error in creating the dateformat using full time style with french locale -> %s (Are you missing data?)/n",             myErrorName(status) );        return;    }    /* this is supposed to open default date format, but later on it treats it like it is "en_US"        - very bad if you try to run the tests on machine where default locale is NOT "en_US" */    /* def = udat_open(UDAT_SHORT, UDAT_SHORT, NULL, NULL, 0, &status); */    def = udat_open(UDAT_SHORT, UDAT_SHORT, "en_US", NULL, 0,NULL, 0, &status);    if(U_FAILURE(status))    {        log_err("FAIL: error in creating the dateformat using short date and time style/n %s/n",             myErrorName(status) );        return;    }    it = udat_open(UDAT_DEFAULT, UDAT_MEDIUM, "it_IT", NULL, 0, NULL, 0,&status);    if(U_FAILURE(status))    {        log_err("FAIL: error in creating the dateformat using medium date style with italian locale/n %s/n",             myErrorName(status) );        return;    }    de = udat_open(UDAT_LONG, UDAT_LONG, "de_DE", NULL, 0, NULL, 0,&status);    if(U_FAILURE(status))    {        log_err("FAIL: error in creating the dateformat using long time and date styles with german locale/n %s/n",            myErrorName(status));        return;    }    /*creating a default dateformat */    def1 = udat_open(UDAT_SHORT, UDAT_SHORT, NULL, NULL, 0,NULL, 0, &status);    if(U_FAILURE(status))    {        log_err("FAIL: error in creating the dateformat using short date and time style/n %s/n",             myErrorName(status) );        return;    }    /*Testing udat_getAvailable() and udat_countAvailable()*/     log_verbose("/nTesting getAvailableLocales and countAvailable()/n");    numlocales=udat_countAvailable();    /* use something sensible w/o hardcoding the count */    if(numlocales < 0)        log_data_err("FAIL: error in countAvailable/n");    log_verbose("The number of locales for which date/time formatting patterns are available is %d/n", numlocales);        for(i=0;i<numlocales;i++) {      UErrorCode subStatus = U_ZERO_ERROR;      log_verbose("Testing open of %s/n", udat_getAvailable(i));      any = udat_open(UDAT_SHORT, UDAT_SHORT, udat_getAvailable(i), NULL ,0, NULL, 0, &subStatus);      if(U_FAILURE(subStatus)) {        log_data_err("FAIL: date format %s (getAvailable(%d)) is not instantiable: %s/n", udat_getAvailable(i), i, u_errorName(subStatus));      }      udat_close(any);    }    /*Testing udat_clone()*/    log_verbose("/nTesting the udat_clone() function of date format/n");    copy=udat_clone(def, &status);    if(U_FAILURE(status)){        log_err("Error in creating the clone using udat_clone: %s/n", myErrorName(status) );    }    /*if(def != copy)        log_err("Error in udat_clone");*/ /*how should i check for equality???? */        /*Testing udat_format()*/    log_verbose("/nTesting the udat_format() function of date format/n");    u_uastrcpy(temp, "7/10/96 4:05 PM");    /*format using def */    resultlength=0;    resultlengthneeded=udat_format(def, d, NULL, resultlength, NULL, &status);//.........这里部分代码省略.........

//.........这里部分代码省略.........            actual_bundle = i;        expected_resource_status = U_MISSING_RESOURCE_ERROR;        for (j=e_te_IN; j>=e_Root; --j)        {            if (is_in[j] && param[i].inherits[j])            {                if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */                    expected_resource_status = U_ZERO_ERROR;                else if(j == 0)                    expected_resource_status = U_USING_DEFAULT_WARNING;                else                    expected_resource_status = U_USING_FALLBACK_WARNING;                log_verbose("%s[%d]::%s: in<%d:%s> inherits<%d:%s>.  actual_bundle=%s/n",                            param[i].name,                             i,                            frag,                            j,                            is_in[j]?"Yes":"No",                            j,                            param[i].inherits[j]?"Yes":"No",                            param[actual_bundle].name);                break;            }        }        for (j=param[i].where; j>=0; --j)        {            if (is_in[j])            {                if(base != NULL) {                    free(base);                    base = NULL;                }                base=(UChar*)malloc(sizeof(UChar)*(strlen(NAME[j]) + 1));                u_uastrcpy(base,NAME[j]);                break;            }            else {                if(base != NULL) {                    free(base);                    base = NULL;                }                base = (UChar*) malloc(sizeof(UChar) * 1);                *base = 0x0000;            }        }        /*-------------------------------------------------------------------- */        /* string */        strcpy(tag,"string_");        strcat(tag,frag);        strcpy(action,param[i].name);        strcat(action, ".ures_get(" );        strcat(action,tag);        strcat(action, ")");        string=    kERROR;        status = U_ZERO_ERROR;        ures_getStringByKey(theBundle, tag, &resultLen, &status);        if(U_SUCCESS(status))        {            status = U_ZERO_ERROR;            string=ures_getStringByKey(theBundle, tag, &resultLen, &status);        }        log_verbose("%s got %d, expected %d/n", action, status, expected_resource_status);        CONFIRM_ErrorCode(status, expected_resource_status);        if(U_SUCCESS(status)){            expected_string=(UChar*)malloc(sizeof(UChar)*(u_strlen(base) + 3));            u_strcpy(expected_string,base);        }        else        {            expected_string = (UChar*)malloc(sizeof(UChar)*(u_strlen(kERROR) + 1));            u_strcpy(expected_string,kERROR);        }        CONFIRM_EQ(string, expected_string);        free(expected_string);        ures_close(theBundle);    }    free(base);    return (UBool)(passNum == pass);}

/* test message format with a choice option */static void TestMsgFormatChoice(void){    UChar* str;    UErrorCode status = U_ZERO_ERROR;    UChar *result;    UChar pattern[100];    UChar expected[100];    int32_t resultlength,resultLengthOut;        str=(UChar*)malloc(sizeof(UChar) * 25);    u_uastrcpy(str, "MyDisk");    log_verbose("Testing message format with choice test #6/n:");    /*There {0,choice,0#are no files|1#is one file|1<are {0,number,integer} files}.*/    u_uastrcpy(pattern, "The disk {1} contains {0,choice,0#no files|1#one file|1<{0,number,integer} files}");    u_uastrcpy(expected, "The disk MyDisk contains 100 files");    resultlength=0;    resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 100., str);    if(status==U_BUFFER_OVERFLOW_ERROR)    {        status=U_ZERO_ERROR;        resultlength=resultLengthOut+1;        result=(UChar*)malloc(sizeof(UChar) * resultlength);        u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 100., str);        if(u_strcmp(result, expected)==0)            log_verbose("PASS: MessagFormat successful on test#6/n");        else{            log_err("FAIL: Error in MessageFormat on test#6/n GOT %s EXPECTED %s/n", austrdup(result),                austrdup(expected) );        }        free(result);    }    if(U_FAILURE(status)){        log_data_err("ERROR: failure in message format on test#6 : %s (Are you missing data?)/n", myErrorName(status));    }    log_verbose("Testing message format with choice test #7/n:");    u_uastrcpy(expected, "The disk MyDisk contains no files");    resultlength=0;    resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 0., str);    if(status==U_BUFFER_OVERFLOW_ERROR)    {        status=U_ZERO_ERROR;        resultlength=resultLengthOut+1;        result=(UChar*)malloc(sizeof(UChar) * resultlength);        u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 0., str);        if(u_strcmp(result, expected)==0)            log_verbose("PASS: MessagFormat successful on test#7/n");        else{            log_err("FAIL: Error in MessageFormat on test#7/n GOT: %s EXPECTED %s/n", austrdup(result),                 austrdup(expected) );        }        free(result);    }    if(U_FAILURE(status)){        log_data_err("ERROR: failure in message format on test#7 : %s (Are you missing data?)/n", myErrorName(status));    }    log_verbose("Testing message format with choice test #8/n:");    u_uastrcpy(expected, "The disk MyDisk contains one file");    resultlength=0;    resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 1., str);    if(status==U_BUFFER_OVERFLOW_ERROR)    {        status=U_ZERO_ERROR;        resultlength=resultLengthOut+1;        result=(UChar*)malloc(sizeof(UChar) * resultlength);        u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 1., str);        if(u_strcmp(result, expected)==0)            log_verbose("PASS: MessagFormat successful on test#8/n");        else{            log_err("FAIL: Error in MessageFormat on test#8/n GOT %s EXPECTED: %s/n", austrdup(result),                 austrdup(expected) );        }        free(result);    }    if(U_FAILURE(status)){        log_data_err("ERROR: failure in message format on test#8 : %s (Are you missing data?)/n", myErrorName(status));    }    free(str);}

/*** Tests the [variable top] tag in rule syntax. Since the default [alternate]* tag has the value shifted, any codepoints before [variable top] should give* a primary ce of 0.*/static void TestVariableTop(void){    const char       *str          = "&z = [variable top]";          int         len          = strlen(str);          UChar      *rules;          UCollator  *myCollation;          UCollator  *enCollation;          UErrorCode  status       = U_ZERO_ERROR;          UChar       source[1];          UChar       ch;          uint8_t     result[20];          uint8_t     expected[20];    rules = (UChar*)malloc(sizeof(UChar*) * (len + 1));    u_uastrcpy(rules, str);    enCollation = ucol_open("en_US", &status);    myCollation = ucol_openRules(rules, len, UCOL_OFF,                                  UCOL_PRIMARY,NULL, &status);    if (U_FAILURE(status)) {        log_err("ERROR: in creation of rule based collator :%s/n",                 myErrorName(status));        return;    }    ucol_setStrength(enCollation, UCOL_PRIMARY);    ucol_setAttribute(enCollation, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED,                      &status);    ucol_setAttribute(myCollation, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED,                      &status);            if (ucol_getAttribute(myCollation, UCOL_ALTERNATE_HANDLING, &status) !=        UCOL_SHIFTED || U_FAILURE(status)) {        log_err("ERROR: ALTERNATE_HANDLING value can not be set to SHIFTED/n");    }    uprv_memset(expected, 0, 20);    /* space is supposed to be a variable */    source[0] = ' ';    len = ucol_getSortKey(enCollation, source, 1, result,                           sizeof(result));    if (uprv_memcmp(expected, result, len) != 0) {        log_err("ERROR: SHIFTED alternate does not return 0 for primary of space/n");    }    ch = 'a';    while (ch < 'z') {        source[0] = ch;        len = ucol_getSortKey(myCollation, source, 1, result,                              sizeof(result));        if (uprv_memcmp(expected, result, len) != 0) {            log_err("ERROR: SHIFTED alternate does not return 0 for primary of %c/n",                     ch);        }        ch ++;    }      free(rules);    ucol_close(enCollation);    ucol_close(myCollation);    enCollation = NULL;    myCollation = NULL;}

static void InitXReplaceable(XReplaceable* rep, const char* cstring) {    rep->text = malloc(sizeof(UChar) * (strlen(cstring)+1));    u_uastrcpy(rep->text, cstring);}

static void _expect(const UTransliterator* trans,                    const char* cfrom,                    const char* cto) {    /* u_uastrcpy has no capacity param for the buffer -- so just     * make all buffers way too big */    enum { CAP = 256 };    UChar from[CAP];    UChar to[CAP];    UChar buf[CAP];    const UChar *ID;    int32_t IDLength;    const char *id;    UErrorCode status = U_ZERO_ERROR;    int32_t limit;    UTransPosition pos;    XReplaceable xrep;    XReplaceable *xrepPtr = &xrep;    UReplaceableCallbacks xrepVtable;    u_uastrcpy(from, cfrom);    u_uastrcpy(to, cto);    ID = utrans_getUnicodeID(trans, &IDLength);    id = aescstrdup(ID, IDLength);    /* utrans_transUChars() */    u_strcpy(buf, from);    limit = u_strlen(buf);    utrans_transUChars(trans, buf, NULL, CAP, 0, &limit, &status);    if (U_FAILURE(status)) {        log_err("FAIL: utrans_transUChars() failed, error=%s/n",                u_errorName(status));        return;    }    if (0 == u_strcmp(buf, to)) {        log_verbose("Ok: utrans_transUChars(%s) x %s -> %s/n",                    id, cfrom, cto);    } else {        char actual[CAP];        u_austrcpy(actual, buf);        log_err("FAIL: utrans_transUChars(%s) x %s -> %s, expected %s/n",                id, cfrom, actual, cto);    }    /* utrans_transIncrementalUChars() */    u_strcpy(buf, from);    pos.start = pos.contextStart = 0;    pos.limit = pos.contextLimit = u_strlen(buf);    utrans_transIncrementalUChars(trans, buf, NULL, CAP, &pos, &status);    utrans_transUChars(trans, buf, NULL, CAP, pos.start, &pos.limit, &status);    if (U_FAILURE(status)) {        log_err("FAIL: utrans_transIncrementalUChars() failed, error=%s/n",                u_errorName(status));        return;    }    if (0 == u_strcmp(buf, to)) {        log_verbose("Ok: utrans_transIncrementalUChars(%s) x %s -> %s/n",                    id, cfrom, cto);    } else {        char actual[CAP];        u_austrcpy(actual, buf);        log_err("FAIL: utrans_transIncrementalUChars(%s) x %s -> %s, expected %s/n",                id, cfrom, actual, cto);    }    /* utrans_trans() */    InitXReplaceableCallbacks(&xrepVtable);    InitXReplaceable(&xrep, cfrom);    limit = u_strlen(from);    utrans_trans(trans, (UReplaceable*)xrepPtr, &xrepVtable, 0, &limit, &status);    if (U_FAILURE(status)) {        log_err("FAIL: utrans_trans() failed, error=%s/n",                u_errorName(status));        FreeXReplaceable(&xrep);        return;    }    if (0 == u_strcmp(xrep.text, to)) {        log_verbose("Ok: utrans_trans(%s) x %s -> %s/n",                    id, cfrom, cto);    } else {        char actual[CAP];        u_austrcpy(actual, xrep.text);        log_err("FAIL: utrans_trans(%s) x %s -> %s, expected %s/n",                id, cfrom, actual, cto);    }    FreeXReplaceable(&xrep);    /* utrans_transIncremental() */    InitXReplaceable(&xrep, cfrom);    pos.start = pos.contextStart = 0;    pos.limit = pos.contextLimit = u_strlen(from);    utrans_transIncremental(trans, (UReplaceable*)xrepPtr, &xrepVtable, &pos, &status);    utrans_trans(trans, (UReplaceable*)xrepPtr, &xrepVtable, pos.start, &pos.limit, &status);    if (U_FAILURE(status)) {        log_err("FAIL: utrans_transIncremental() failed, error=%s/n",                u_errorName(status));//.........这里部分代码省略.........

static void TestBreakIteratorSafeClone(void){    UChar text[51];     /* Keep this odd to test for 64-bit memory alignment */                        /*  NOTE:  This doesn't reliably force mis-alignment of following items. */     uint8_t buffer [CLONETEST_ITERATOR_COUNT] [U_BRK_SAFECLONE_BUFFERSIZE];    int32_t bufferSize = U_BRK_SAFECLONE_BUFFERSIZE;    UBreakIterator * someIterators [CLONETEST_ITERATOR_COUNT];    UBreakIterator * someClonedIterators [CLONETEST_ITERATOR_COUNT];    UBreakIterator * brk;    UErrorCode status = U_ZERO_ERROR;    int32_t start,pos;    int32_t i;    /*Testing ubrk_safeClone */    /* Note:  the adjacent "" are concatenating strings, not adding a /" to the       string, which is probably what whoever wrote this intended.  Don't fix,       because it would throw off the hard coded break positions in the following       tests. */    u_uastrcpy(text, "He's from Africa. ""Mr. Livingston, I presume?"" Yeah");    /* US & Thai - rule-based & dictionary based */    someIterators[0] = ubrk_open(UBRK_WORD, "en_US", text, u_strlen(text), &status);    if(!someIterators[0] || U_FAILURE(status)) {      log_data_err("Couldn't open en_US word break iterator - %s/n", u_errorName(status));      return;    }    someIterators[1] = ubrk_open(UBRK_WORD, "th_TH", text, u_strlen(text), &status);    if(!someIterators[1] || U_FAILURE(status)) {      log_data_err("Couldn't open th_TH word break iterator - %s/n", u_errorName(status));      return;    }    /* test each type of iterator */    for (i = 0; i < CLONETEST_ITERATOR_COUNT; i++)    {        /* Check the various error & informational states */        /* Null status - just returns NULL */        if (0 != ubrk_safeClone(someIterators[i], buffer[i], &bufferSize, 0))        {            log_err("FAIL: Cloned Iterator failed to deal correctly with null status/n");        }        /* error status - should return 0 & keep error the same */        status = U_MEMORY_ALLOCATION_ERROR;        if (0 != ubrk_safeClone(someIterators[i], buffer[i], &bufferSize, &status) || status != U_MEMORY_ALLOCATION_ERROR)        {            log_err("FAIL: Cloned Iterator failed to deal correctly with incoming error status/n");        }        status = U_ZERO_ERROR;        /* Null buffer size pointer - just returns NULL & set error to U_ILLEGAL_ARGUMENT_ERROR*/        if (0 != ubrk_safeClone(someIterators[i], buffer[i], 0, &status) || status != U_ILLEGAL_ARGUMENT_ERROR)        {            log_err("FAIL: Cloned Iterator failed to deal correctly with null bufferSize pointer/n");        }        status = U_ZERO_ERROR;            /* buffer size pointer is 0 - fill in pbufferSize with a size */        bufferSize = 0;        if (0 != ubrk_safeClone(someIterators[i], buffer[i], &bufferSize, &status) || U_FAILURE(status) || bufferSize <= 0)        {            log_err("FAIL: Cloned Iterator failed a sizing request ('preflighting')/n");        }        /* Verify our define is large enough  */        if (U_BRK_SAFECLONE_BUFFERSIZE < bufferSize)        {            log_err("FAIL: Pre-calculated buffer size is too small/n");        }        /* Verify we can use this run-time calculated size */        if (0 == (brk = ubrk_safeClone(someIterators[i], buffer[i], &bufferSize, &status)) || U_FAILURE(status))        {            log_err("FAIL: Iterator can't be cloned with run-time size/n");        }        if (brk)            ubrk_close(brk);        /* size one byte too small - should allocate & let us know */        --bufferSize;        if (0 == (brk = ubrk_safeClone(someIterators[i], 0, &bufferSize, &status)) || status != U_SAFECLONE_ALLOCATED_WARNING)        {            log_err("FAIL: Cloned Iterator failed to deal correctly with too-small buffer size/n");        }        if (brk)            ubrk_close(brk);        status = U_ZERO_ERROR;        bufferSize = U_BRK_SAFECLONE_BUFFERSIZE;        /* Null buffer pointer - return Iterator & set error to U_SAFECLONE_ALLOCATED_ERROR */        if (0 == (brk = ubrk_safeClone(someIterators[i], 0, &bufferSize, &status)) || status != U_SAFECLONE_ALLOCATED_WARNING)        {            log_err("FAIL: Cloned Iterator failed to deal correctly with null buffer pointer/n");        }        if (brk)            ubrk_close(brk);        status = U_ZERO_ERROR;//.........这里部分代码省略.........

static void TestBreakIteratorCAPI(){    UErrorCode status = U_ZERO_ERROR;    UBreakIterator *word, *sentence, *line, *character, *b, *bogus;    int32_t start,pos,end,to;    int32_t i;    int32_t count = 0;    UChar text[50];    /* Note:  the adjacent "" are concatenating strings, not adding a /" to the       string, which is probably what whoever wrote this intended.  Don't fix,       because it would throw off the hard coded break positions in the following       tests. */    u_uastrcpy(text, "He's from Africa. ""Mr. Livingston, I presume?"" Yeah");/*test ubrk_open()*/    log_verbose("/nTesting BreakIterator open functions/n");                                                /* Use french for fun */    word         = ubrk_open(UBRK_WORD, "en_US", text, u_strlen(text), &status);    if(status == U_FILE_ACCESS_ERROR) {        log_data_err("Check your data - it doesn't seem to be around/n");        return;    } else if(U_FAILURE(status)){        log_err_status(status, "FAIL: Error in ubrk_open() for word breakiterator: %s/n", myErrorName(status));    }    else{        log_verbose("PASS: Successfully opened  word breakiterator/n");    }        sentence     = ubrk_open(UBRK_SENTENCE, "en_US", text, u_strlen(text), &status);    if(U_FAILURE(status)){        log_err_status(status, "FAIL: Error in ubrk_open() for sentence breakiterator: %s/n", myErrorName(status));        return;    }    else{        log_verbose("PASS: Successfully opened  sentence breakiterator/n");    }        line         = ubrk_open(UBRK_LINE, "en_US", text, u_strlen(text), &status);    if(U_FAILURE(status)){        log_err("FAIL: Error in ubrk_open() for line breakiterator: %s/n", myErrorName(status));        return;    }    else{        log_verbose("PASS: Successfully opened  line breakiterator/n");    }        character     = ubrk_open(UBRK_CHARACTER, "en_US", text, u_strlen(text), &status);    if(U_FAILURE(status)){        log_err("FAIL: Error in ubrk_open() for character breakiterator: %s/n", myErrorName(status));        return;    }    else{        log_verbose("PASS: Successfully opened  character breakiterator/n");    }    /*trying to open an illegal iterator*/    bogus     = ubrk_open((UBreakIteratorType)5, "en_US", text, u_strlen(text), &status);    if(U_SUCCESS(status)){        log_err("FAIL: Error in ubrk_open() for BOGUS breakiterator. Expected U_ILLEGAL_ARGUMENT_ERROR/n");    }    if(U_FAILURE(status)){        if(status != U_ILLEGAL_ARGUMENT_ERROR){            log_err("FAIL: Error in ubrk_open() for BOGUS breakiterator. Expected U_ILLEGAL_ARGUMENT_ERROR/n Got %s/n", myErrorName(status));        }    }    status=U_ZERO_ERROR;/* ======= Test ubrk_countAvialable() and ubrk_getAvialable() */    log_verbose("/nTesting ubrk_countAvailable() and ubrk_getAvailable()/n");    count=ubrk_countAvailable();    /* use something sensible w/o hardcoding the count */    if(count < 0){        log_err("FAIL: Error in ubrk_countAvialable() returned %d/n", count);    }    else{        log_verbose("PASS: ubrk_countAvialable() successful returned %d/n", count);    }    for(i=0;i<count;i++)    {        log_verbose("%s/n", ubrk_getAvailable(i));         if (ubrk_getAvailable(i) == 0)            log_err("No locale for which breakiterator is applicable/n");        else             log_verbose("A locale %s for which breakiterator is applicable/n",ubrk_getAvailable(i));    }/*========Test ubrk_first(), ubrk_last()...... and other functions*/    log_verbose("/nTesting the functions for word/n");    start = ubrk_first(word);    if(start!=0)        log_err("error ubrk_start(word) did not return 0/n");    log_verbose("first (word = %d/n", (int32_t)start);       pos=ubrk_next(word);    if(pos!=4)//.........这里部分代码省略.........

/** * @bug 4073003 */void Test4073003(){    int32_t pos,i;    UDate d,dd;    UChar *datestr;    UChar temp[15];    UErrorCode status = U_ZERO_ERROR;    UDateFormat *fmt;    UChar *result, *result2;    const char* tests [] = {        "12/25/61",        "12/25/1961",        "4/3/1999",        "4/3/99"    };    fmt= udat_open(UDAT_SHORT,UDAT_SHORT ,NULL, NULL, 0, NULL, 0, &status);    if(U_FAILURE(status))    {        log_data_err("FAIL: error in creating the dateformat using short date and time style: %s (Are you missing data?)/n",                     myErrorName(status));        return;    }    u_uastrcpy(temp, "m/D/yy");    udat_applyPattern(fmt, FALSE, temp, u_strlen(temp));    for(i= 0; i < 4; i+=2) {        status=U_ZERO_ERROR;        datestr=(UChar*)malloc(sizeof(UChar) * (strlen(tests[i])+1));        u_uastrcpy(datestr, tests[i]);        pos=0;        d = udat_parse(fmt, datestr, u_strlen(datestr), &pos, &status);        if(U_FAILURE(status)) {            log_err("ERROR : in test 4073003: %s/n", myErrorName(status));        }        free(datestr);        datestr=(UChar*)malloc(sizeof(UChar) * (strlen(tests[i+1])+1));        u_uastrcpy(datestr, tests[i+1]);        pos=0;        status=U_ZERO_ERROR;        dd = udat_parse(fmt, datestr, u_strlen(datestr), &pos, &status);        if(U_FAILURE(status)) {            log_err("ERROR : in test 4073003: %s/n", myErrorName(status));        }        free(datestr);        result =myFormatit(fmt, d);        result2 =myFormatit(fmt, dd);        if(!result || !result2) {            log_data_err("Fail: could not format - exitting test/n");            return;        }        if (u_strcmp(result, result2)!=0) {            log_err("Fail: %s != %s/n", austrdup(result), austrdup(result2) );        }        else {            log_verbose("Ok: %s == %s/n", austrdup(result), austrdup(result2) );        }    }    udat_close(fmt);}

/* Test u_formatMessage() and u_parseMessage() , format and parse sequence and round trip */static void TestSampleFormatAndParse(void){    UChar *result, *tzID, *str;    UChar pattern[100];    UChar expected[100];    int32_t resultLengthOut, resultlength;    UCalendar *cal;    UDate d1,d;    UDateFormat *def1;    UErrorCode status = U_ZERO_ERROR;    int32_t value = 0;    UChar ret[30];    ctest_setTimeZone(NULL, &status);    log_verbose("Testing format and parse/n");    str=(UChar*)malloc(sizeof(UChar) * 25);    u_uastrcpy(str, "disturbance in force");    tzID=(UChar*)malloc(sizeof(UChar) * 4);    u_uastrcpy(tzID, "PST");    cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);    if(U_FAILURE(status)){        log_data_err("error in ucal_open caldef : %s - (Are you missing data?)/n", myErrorName(status) );    }    ucal_setDateTime(cal, 1999, UCAL_MARCH, 18, 0, 0, 0, &status);    d1=ucal_getMillis(cal, &status);    if(U_FAILURE(status)){            log_data_err("Error: failure in get millis: %s - (Are you missing data?)/n", myErrorName(status) );    }        log_verbose("/nTesting with pattern test#4");    u_uastrcpy(pattern, "On {0, date, long}, there was a {1} on planet {2,number,integer}");    u_uastrcpy(expected, "On March 18, 1999, there was a disturbance in force on planet 7");     resultlength=1;    result=(UChar*)malloc(sizeof(UChar) * resultlength);    resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, d1, str, 7);    if(status==U_BUFFER_OVERFLOW_ERROR)    {        status=U_ZERO_ERROR;        resultlength=resultLengthOut+1;        result=(UChar*)realloc(result, sizeof(UChar) * resultlength);        u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, d1, str, 7);            }    if(U_FAILURE(status)){        log_data_err("ERROR: failure in message format test#4: %s (Are you missing data?)/n", myErrorName(status));    }    else if(u_strcmp(result, expected)==0)        log_verbose("PASS: MessagFormat successful on test#4/n");    else{        log_err("FAIL: Error in MessageFormat on test#4/n GOT: %s EXPECTED: %s/n", austrdup(result),            austrdup(expected) );    }            /*try to parse this and check*/    log_verbose("/nTesting the parse Message test#5/n");    u_parseMessage("en_US", pattern, u_strlen(pattern), result, u_strlen(result), &status, &d, ret, &value);    if(U_FAILURE(status)){        log_data_err("ERROR: error in parsing: test#5: %s (Are you missing data?)/n", myErrorName(status));    }    else if(value!=7 && u_strcmp(str,ret)!=0)        log_err("FAIL: Error in parseMessage on test#5 /n");    else        log_verbose("PASS: parseMessage successful on test#5/n");            def1 = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL, NULL, 0, NULL,0,&status);    if(U_FAILURE(status))    {        log_data_err("error in creating the dateformat using short date and time style: %s (Are you missing data?)/n", myErrorName(status));    }else{        if(u_strcmp(myDateFormat(def1, d), myDateFormat(def1, d1))==0)            log_verbose("PASS: parseMessage successful test#5/n");        else{            log_err("FAIL: parseMessage didn't parse the date successfully/n GOT: %s EXPECTED %s/n",                 austrdup(myDateFormat(def1,d)), austrdup(myDateFormat(def1,d1)) );        }    }    udat_close(def1);    ucal_close(cal);    free(result);    free(str);    free(tzID);        ctest_resetTimeZone();}

//.........这里部分代码省略.........    doAssert(uprv_trunc(12.3456), 12, "uprv_trunc(12.3456) failed.");    doAssert(uprv_trunc(12.234E2), 1223, "uprv_trunc(12.234E2) failed.");    doAssert(uprv_trunc(uprv_getNaN()), uprv_getNaN(), "uprv_trunc(uprv_getNaN()) failed. with parameter=NaN");    doAssert(uprv_trunc(uprv_getInfinity()), uprv_getInfinity(), "uprv_trunc(uprv_getInfinity()) failed. with parameter=Infinity");    log_verbose("Testing the API uprv_pow10()/n");    doAssert(uprv_pow10(4), 10000, "uprv_pow10(4) failed.");    log_verbose("Testing the API uprv_isNegativeInfinity()/n");    isTrue=uprv_isNegativeInfinity(uprv_getInfinity() * -1);    if(isTrue != TRUE){        log_err("ERROR: uprv_isNegativeInfinity failed./n");    }    log_verbose("Testing the API uprv_isPositiveInfinity()/n");    isTrue=uprv_isPositiveInfinity(uprv_getInfinity());    if(isTrue != TRUE){        log_err("ERROR: uprv_isPositiveInfinity failed./n");    }    log_verbose("Testing the API uprv_isInfinite()/n");    isTrue=uprv_isInfinite(uprv_getInfinity());    if(isTrue != TRUE){        log_err("ERROR: uprv_isInfinite failed./n");    }#if 0    log_verbose("Testing the API uprv_digitsAfterDecimal()..../n");    doAssert(uprv_digitsAfterDecimal(value1), 3, "uprv_digitsAfterDecimal() failed.");    doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.2345E2) failed.");    doAssert(uprv_digitsAfterDecimal(1.2345E-2), 6, "uprv_digitsAfterDecimal(1.2345E-2) failed.");    doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.2345E2) failed.");    doAssert(uprv_digitsAfterDecimal(-1.2345E-20), 24, "uprv_digitsAfterDecimal(1.2345E-20) failed.");    doAssert(uprv_digitsAfterDecimal(1.2345E20), 0, "uprv_digitsAfterDecimal(1.2345E20) failed.");    doAssert(uprv_digitsAfterDecimal(-0.021), 3, "uprv_digitsAfterDecimal(-0.021) failed.");    doAssert(uprv_digitsAfterDecimal(23.0), 0, "uprv_digitsAfterDecimal(23.0) failed.");    doAssert(uprv_digitsAfterDecimal(0.022223333321), 9, "uprv_digitsAfterDecimal(0.022223333321) failed.");#endif    log_verbose("Testing the API u_errorName().../n");    str=(char*)u_errorName((UErrorCode)0);    if(strcmp(str, "U_ZERO_ERROR") != 0){        log_err("ERROR: u_getVersion() failed. Expected: U_ZERO_ERROR Got=%s/n",  str);    }    log_verbose("Testing the API u_errorName().../n");    str=(char*)u_errorName((UErrorCode)-127);    if(strcmp(str, "U_USING_DEFAULT_WARNING") != 0){        log_err("ERROR: u_getVersion() failed. Expected: U_USING_DEFAULT_WARNING Got=%s/n",  str);    }    log_verbose("Testing the API u_errorName().. with BOGUS ERRORCODE.../n");    str=(char*)u_errorName((UErrorCode)200);    if(strcmp(str, "[BOGUS UErrorCode]") != 0){        log_err("ERROR: u_getVersion() failed. Expected: [BOGUS UErrorCode] Got=%s/n",  str);    }    {        const char* dataDirectory;        int32_t dataDirectoryLen;        UChar *udataDir=0;        UChar temp[100];        char *charvalue=0;        log_verbose("Testing chars to UChars/n");                 /* This cannot really work on a japanese system. u_uastrcpy will have different results than */        /* u_charsToUChars when there is a backslash in the string! */        /*dataDirectory=u_getDataDirectory();*/        dataDirectory="directory1";  /*no backslashes*/        dataDirectoryLen=(int32_t)strlen(dataDirectory);        udataDir=(UChar*)malloc(sizeof(UChar) * (dataDirectoryLen + 1));        u_charsToUChars(dataDirectory, udataDir, (dataDirectoryLen + 1));        u_uastrcpy(temp, dataDirectory);               if(u_strcmp(temp, udataDir) != 0){            log_err("ERROR: u_charsToUChars failed. Expected %s, Got %s/n", austrdup(temp), austrdup(udataDir));        }        log_verbose("Testing UChars to chars/n");        charvalue=(char*)malloc(sizeof(char) * (u_strlen(udataDir) + 1));        u_UCharsToChars(udataDir, charvalue, (u_strlen(udataDir)+1));        if(strcmp(charvalue, dataDirectory) != 0){            log_err("ERROR: u_UCharsToChars failed. Expected %s, Got %s/n", charvalue, dataDirectory);        }        free(charvalue);        free(udataDir);    }       log_verbose("Testing uprv_timezone()..../n");    {        int32_t tzoffset = uprv_timezone();        log_verbose("Value returned from uprv_timezone = %d/n",  tzoffset);        if (tzoffset != 28800) {            log_verbose("***** WARNING: If testing in the PST timezone, t_timezone should return 28800! *****");        }        if ((tzoffset % 1800 != 0)) {            log_info("Note: t_timezone offset of %ld (for %s : %s) is not a multiple of 30min.", tzoffset, uprv_tzname(0), uprv_tzname(1));        }        /*tzoffset=uprv_getUTCtime();*/    }}

/* Test message format with a Select option */static void TestMsgFormatSelect(void){    UChar* str;    UChar* str1;    UErrorCode status = U_ZERO_ERROR;    UChar *result;    UChar pattern[100];    UChar expected[100];    int32_t resultlength,resultLengthOut;    str=(UChar*)malloc(sizeof(UChar) * 25);    u_uastrcpy(str, "Kirti");    str1=(UChar*)malloc(sizeof(UChar) * 25);    u_uastrcpy(str1, "female");    log_verbose("Testing message format with Select test #1/n:");    u_uastrcpy(pattern, "{0} est {1, select, female {all//u00E9e} other {all//u00E9}} //u00E0 Paris.");    u_uastrcpy(expected, "Kirti est all//u00E9e //u00E0 Paris.");    resultlength=0;    resultLengthOut=u_formatMessage( "fr", pattern, u_strlen(pattern), NULL, resultlength, &status, str , str1);    if(status==U_BUFFER_OVERFLOW_ERROR)    {        status=U_ZERO_ERROR;        resultlength=resultLengthOut+1;        result=(UChar*)malloc(sizeof(UChar) * resultlength);        u_formatMessage( "fr", pattern, u_strlen(pattern), result, resultlength, &status, str , str1);        if(u_strcmp(result, expected)==0)            log_verbose("PASS: MessagFormat successful on Select test#1/n");        else{            log_err("FAIL: Error in MessageFormat on Select test#1/n GOT %s EXPECTED %s/n", austrdup(result),                austrdup(expected) );        }        free(result);    }    if(U_FAILURE(status)){        log_data_err("ERROR: failure in message format on Select test#1 : %s /n", myErrorName(status));    }    free(str);    free(str1);    /*Test a nested pattern*/    str=(UChar*)malloc(sizeof(UChar) * 25);    u_uastrcpy(str, "Noname");    str1=(UChar*)malloc(sizeof(UChar) * 25);    u_uastrcpy(str1, "other");    log_verbose("Testing message format with Select test #2/n:");    u_uastrcpy(pattern, "{0} est {1, select, female {{2,number,integer} all//u00E9e} other {all//u00E9}} //u00E0 Paris.");    u_uastrcpy(expected, "Noname est all//u00E9 //u00E0 Paris.");    resultlength=0;    resultLengthOut=u_formatMessage( "fr", pattern, u_strlen(pattern), NULL, resultlength, &status, str , str1,6);    if(status==U_BUFFER_OVERFLOW_ERROR)    {        status=U_ZERO_ERROR;        resultlength=resultLengthOut+1;        result=(UChar*)malloc(sizeof(UChar) * resultlength);        u_formatMessage( "fr", pattern, u_strlen(pattern), result, resultlength, &status, str , str1);        if(u_strcmp(result, expected)==0)            log_verbose("PASS: MessagFormat successful on Select test#2/n");        else{            log_err("FAIL: Error in MessageFormat on Select test#2/n GOT %s EXPECTED %s/n", austrdup(result),                austrdup(expected) );        }        free(result);    }    if(U_FAILURE(status)){        log_data_err("ERROR: failure in message format on Select test#2 : %s /n", myErrorName(status));    }    free(str);    free(str1);}

/* Test the handling of quotes*/static void TestQuotes(void){    int32_t lneed;    UErrorCode status=U_ZERO_ERROR;    UChar pat[15];    UChar res[15];    UChar *str=NULL;    UNumberFormat *fmt;    char tempBuf[256];    log_verbose("/nTestting the handling of quotes in number format/n");    u_uastrcpy(pat, "a'fo''o'b#");    fmt =unum_open(UNUM_IGNORE,pat, u_strlen(pat), "en_US",NULL, &status);    if(U_FAILURE(status)){        log_err_status(status, "Error in number format costruction using pattern /"a'fo''o'b#/" -> %s/n", u_errorName(status));    }    lneed=0;    lneed=unum_format(fmt, 123, NULL, lneed, NULL, &status);    if(status==U_BUFFER_OVERFLOW_ERROR){        status=U_ZERO_ERROR;        str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );        unum_format(fmt, 123, str, lneed+1,  NULL, &status);    }    if(U_FAILURE(status) || !str) {        log_err_status(status, "Error in formatting using unum_format(.....): %s/n", myErrorName(status) );        return;    }    log_verbose("Pattern /"%s/" /n", u_austrcpy(tempBuf, pat) );    log_verbose("Format 123 -> %s/n", u_austrcpy(tempBuf, 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_open(UNUM_IGNORE,pat, u_strlen(pat), "en_US",NULL, &status);    if(U_FAILURE(status)){        log_err("Error in number format costruction using pattern /"a''b#/"/n");    }    lneed=0;    lneed=unum_format(fmt, 123, NULL, lneed, NULL, &status);    if(status==U_BUFFER_OVERFLOW_ERROR){        status=U_ZERO_ERROR;        str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );        unum_format(fmt, 123, str, lneed+1,  NULL, &status);    }    if(U_FAILURE(status)) {        log_err("Error in formatting using unum_format(.....): %s/n", myErrorName(status) );    }    log_verbose("Pattern /"%s/" /n", u_austrcpy(tempBuf, pat) );    log_verbose("Format 123 -> %s/n", u_austrcpy(tempBuf, 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);}

void TestConstruction1(){    UResourceBundle *test1 = 0, *test2 = 0;    const UChar *result1, *result2;    int32_t resultLen;    UChar temp[7];    UErrorCode   err = U_ZERO_ERROR;    const char* testdatapath ;    const char*      locale="te_IN";    log_verbose("Testing ures_open()....../n");    testdatapath=loadTestData(&err);    if(U_FAILURE(err))    {        log_data_err("Could not load testdata.dat %s /n",myErrorName(err));        return;    }    test1=ures_open(testdatapath, NULL, &err);    if(U_FAILURE(err))    {        log_err("construction of %s did not succeed :  %s /n",NULL, myErrorName(err));        return;    }    test2=ures_open(testdatapath, locale, &err);    if(U_FAILURE(err))    {        log_err("construction of %s did not succeed :  %s /n",locale, myErrorName(err));        return;    }    result1= ures_getStringByKey(test1, "string_in_Root_te_te_IN", &resultLen, &err);    result2= ures_getStringByKey(test2, "string_in_Root_te_te_IN", &resultLen, &err);    if (U_FAILURE(err)) {        log_err("Something threw an error in TestConstruction(): %s/n", myErrorName(err));        return;    }    u_uastrcpy(temp, "TE_IN");    if(u_strcmp(result2, temp)!=0)    {        int n;        log_err("Construction test failed for ures_open();/n");        if(!getTestOption(VERBOSITY_OPTION))            log_info("(run verbose for more information)/n");        log_verbose("/nGot->");        for(n=0;result2[n];n++)        {            log_verbose("%04X ",result2[n]);        }        log_verbose("</n");        log_verbose("/nWant>");        for(n=0;temp[n];n++)        {            log_verbose("%04X ",temp[n]);        }        log_verbose("</n");    }    log_verbose("for string_in_Root_te_te_IN, default.txt had  %s/n", austrdup(result1));    log_verbose("for string_in_Root_te_te_IN, te_IN.txt had %s/n", austrdup(result2));    /* Test getVersionNumber*/    log_verbose("Testing version number/n");    log_verbose("for getVersionNumber :  %s/n", ures_getVersionNumber(test1));    ures_close(test1);    ures_close(test2);}

/** * @bug 4056591 * Verify the function of the [s|g]et2DigitYearStart() API. */void Test4056591(){    int i;    UCalendar *cal;    UDateFormat *def;    UDate start,exp,got;    UChar s[10];    UChar *gotdate, *expdate;    UChar pat[10];    UDate d[4];    UErrorCode status = U_ZERO_ERROR;    const char* strings[] = {        "091225",        "091224",        "611226",        "991227"    };    log_verbose("Testing s[get] 2 digit year start regressively/n");    cal=ucal_open(NULL, 0, "en_US", UCAL_GREGORIAN, &status);    if(U_FAILURE(status)) {        log_data_err("error in ucal_open caldef : %s - (Are you missing data?)/n", myErrorName(status));        return;    }    ucal_setDateTime(cal, 1809, UCAL_DECEMBER, 25, 17, 40, 30, &status);    d[0]=ucal_getMillis(cal, &status);    if(U_FAILURE(status)) {        log_err("Error: failure in get millis: %s/n", myErrorName(status));    }    ucal_setDateTime(cal, 1909, UCAL_DECEMBER, 24, 17, 40, 30, &status);    d[1]=ucal_getMillis(cal, &status);    ucal_setDateTime(cal, 1861, UCAL_DECEMBER, 26, 17, 40, 30, &status);    d[2]=ucal_getMillis(cal, &status);    ucal_setDateTime(cal, 1999, UCAL_DECEMBER, 27, 17, 40, 30, &status);    d[3]=ucal_getMillis(cal, &status);    u_uastrcpy(pat, "yyMMdd");    def = udat_open(UDAT_IGNORE,UDAT_IGNORE,NULL, NULL, 0, pat, u_strlen(pat), &status);    if(U_FAILURE(status))    {        log_err_status(status, "FAIL: error in creating the dateformat using u_openPattern(): %s/n", myErrorName(status));        return;    }    start = 1800;    udat_set2DigitYearStart(def, start, &status);    if(U_FAILURE(status))        log_err("ERROR: in setTwoDigitStartDate: %s/n", myErrorName(status));    if( (udat_get2DigitYearStart(def, &status) != start))        log_err("ERROR: get2DigitYearStart broken/n");    for(i = 0; i < 4; ++i) {        u_uastrcpy(s, strings[i]);        exp = d[i];        got = udat_parse(def, s, u_strlen(s), 0, &status);        gotdate=myFormatit(def, got);        expdate=myFormatit(def, exp);        if (gotdate == NULL || expdate == NULL) {            log_err("myFormatit failed!/n");        }        else if(u_strcmp(gotdate, expdate) !=0) {            log_err("set2DigitYearStart broken for %s /n  got: %s, expected: %s/n", austrdup(s),                    austrdup(gotdate), austrdup(expdate) );        }    }    udat_close(def);    ucal_close(cal);}

int main (void) {    const char *foo = "ＧＧ硬硬der";    puts("converting between char * and UChar * with u_*strcpy");    UChar *dst = (UChar *)malloc(sizeof(UChar) * 10);    u_uastrcpy (dst, foo);    u_printf("cpy C->U %S %d/n", dst, u_strlen(dst));    char *bar = (char *)malloc(sizeof(char) * 50);    u_austrcpy (bar, dst);    printf("cpy U->C %s %lu/n", bar, strlen(bar));    puts("write/read file test");    FILE *f = fopen("gg", "w");    fputs(bar, f);    fclose(f);    free(bar);    bar = NULL;    bar = (char *)malloc(sizeof(char) * 50);    f = fopen("gg", "r");    fgets(bar, 100, f);    puts("char *");    printf("%s %lu/n", bar, strlen(bar));    u_uastrcpy (dst, bar);    puts("UChar *");    u_printf("%S %d/n", dst, u_strlen(dst));    fclose(f);    system("rm gg");    free(dst);    free(bar);    puts("structure file write/read test");    U_STRING_DECL(fmt, "工具人 %d 
C++ uae_sem_post函数代码示例
C++ u_terminateUChars函数代码示例