organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-13 00:43:32 +00:00
Code Issues1 Projects Releases Wiki Activity Actions3

ICU-12012 Replace all sizeof p / U_SIZEOF_... with UPRV_LENGTHOF().

Browse source 
R=markus.icu@gmail.com

Review URL: https://codereview.appspot.com/291740043 .

X-SVN-Rev: 38349
This commit is contained in:
Fredrik Roubert 2016-02-24 22:52:29 +00:00
parent 82801c4b0a
commit f75e591321
10 changed files with 166 additions and 164 deletions

2
icu4c/source/common/ucnv.c
View file

@ -1817,7 +1817,7 @@ ucnv_toUChars(UConverter *cnv,
{
UChar buffer[1024];
destLimit=buffer+sizeof(buffer)/U_SIZEOF_UCHAR;
destLimit=buffer+UPRV_LENGTHOF(buffer);
do {
dest=buffer;
*pErrorCode=U_ZERO_ERROR;

5
icu4c/source/extra/uconv/uwmsg.c
View file

@ -1,6 +1,6 @@
/*
**********************************************************************
* Copyright (C) 1998-2014, International Business Machines Corporation
* Copyright (C) 1998-2016, International Business Machines Corporation
* and others. All Rights Reserved.
**********************************************************************
*
@ -19,6 +19,7 @@
#include "unicode/uwmsg.h"
#include "unicode/ures.h"
#include "unicode/putil.h"
#include "cmemory.h"
#include "cstring.h"
#include <stdlib.h>
@ -143,7 +144,7 @@ U_CFUNC int u_wmsg(FILE *fp, const char *tag, ... )
}
#if UCONFIG_NO_FORMATTING
resultLength = sizeof(gNoFormatting) / U_SIZEOF_UCHAR;
resultLength = UPRV_LENGTHOF(gNoFormatting);
if((msgLen + resultLength) <= UPRV_LENGTHOF(result)) {
memcpy(result, msg, msgLen * U_SIZEOF_UCHAR);
memcpy(result + msgLen, gNoFormatting, resultLength);

5
icu4c/source/samples/ucnv/convsamp.cpp
View file

@ -1,6 +1,6 @@
/**************************************************************************
*
* Copyright (C) 2000-2013, International Business Machines
* Copyright (C) 2000-2016, International Business Machines
* Corporation and others. All Rights Reserved.
*
***************************************************************************
@ -33,6 +33,7 @@
#include <string.h>
#include <stdlib.h> /* malloc */
#include "cmemory.h"
#include "unicode/utypes.h" /* Basic ICU data types */
#include "unicode/ucnv.h" /* C Converter API */
#include "unicode/ustring.h" /* some more string fcns*/
@ -1086,7 +1087,7 @@ void convsample_50() {
conv = ucnv_open(encoding, &err);
// do the conversion
ucnv_toUnicode(conv,
&target, output + sizeof(output)/U_SIZEOF_UCHAR,
&target, output + UPRV_LENGTHOF(output),
&source, input + sizeof(input),
NULL, TRUE, &err);
out = output;

62
icu4c/source/test/cintltst/cnormtst.c
View file

@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-2014, International Business Machines Corporation and
* COPYRIGHT:
* Copyright (c) 1997-2016, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
/********************************************************************************
@ -900,7 +900,7 @@ TestNormCoverage() {
errorCode=U_ZERO_ERROR;
length=unorm_normalize(input, inLength,
UNORM_NFKC, 0,
output, sizeof(output)/U_SIZEOF_UCHAR,
output, UPRV_LENGTHOF(output),
&errorCode);
if(U_FAILURE(errorCode)) {
log_data_err("error unorm_normalize(long input, UNORM_NFKC) failed with %s - (Are you missing data?)\n", u_errorName(errorCode));
@ -940,7 +940,7 @@ TestNormCoverage() {
errorCode=U_ZERO_ERROR;
length=unorm_normalize(input, inLength,
UNORM_FCD, 0,
output, sizeof(output)/U_SIZEOF_UCHAR,
output, UPRV_LENGTHOF(output),
&errorCode);
if(U_FAILURE(errorCode)) {
log_data_err("error unorm_normalize(long input, UNORM_FCD) failed with %s - (Are you missing data?)\n", u_errorName(errorCode));
@ -1055,7 +1055,7 @@ _testIter(const UChar *src, int32_t srcLength,
return;
}
length=unorm_next(iter,
buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
buffer, UPRV_LENGTHOF(buffer),
mode, 0,
(UBool)(out!=NULL), &neededToNormalize,
&errorCode);
@ -1080,7 +1080,7 @@ _testIter(const UChar *src, int32_t srcLength,
return;
}
length=unorm_previous(iter,
buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
buffer, UPRV_LENGTHOF(buffer),
mode, 0,
(UBool)(out!=NULL), &neededToNormalize,
&errorCode);
@ -1185,59 +1185,59 @@ TestNextPrevious() {
UBool neededToNormalize;
UErrorCode errorCode;
uiter_setString(&iter, src, sizeof(src)/U_SIZEOF_UCHAR);
uiter_setString(&iter, src, UPRV_LENGTHOF(src));
/* test iteration with doNormalize */
iter.index=0;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFD, TRUE, nfd, sizeof(nfd)/U_SIZEOF_UCHAR, nfdIndexes, sizeof(nfdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFD, TRUE, nfd, UPRV_LENGTHOF(nfd), nfdIndexes, sizeof(nfdIndexes)/4);
iter.index=0;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKD, TRUE, nfkd, sizeof(nfkd)/U_SIZEOF_UCHAR, nfkdIndexes, sizeof(nfkdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKD, TRUE, nfkd, UPRV_LENGTHOF(nfkd), nfkdIndexes, sizeof(nfkdIndexes)/4);
iter.index=0;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFC, TRUE, nfc, sizeof(nfc)/U_SIZEOF_UCHAR, nfcIndexes, sizeof(nfcIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFC, TRUE, nfc, UPRV_LENGTHOF(nfc), nfcIndexes, sizeof(nfcIndexes)/4);
iter.index=0;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKC, TRUE, nfkc, sizeof(nfkc)/U_SIZEOF_UCHAR, nfkcIndexes, sizeof(nfkcIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKC, TRUE, nfkc, UPRV_LENGTHOF(nfkc), nfkcIndexes, sizeof(nfkcIndexes)/4);
iter.index=0;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_FCD, TRUE, fcd, sizeof(fcd)/U_SIZEOF_UCHAR, fcdIndexes, sizeof(fcdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_FCD, TRUE, fcd, UPRV_LENGTHOF(fcd), fcdIndexes, sizeof(fcdIndexes)/4);
iter.index=iter.length;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFD, FALSE, nfd, sizeof(nfd)/U_SIZEOF_UCHAR, nfdIndexes, sizeof(nfdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFD, FALSE, nfd, UPRV_LENGTHOF(nfd), nfdIndexes, sizeof(nfdIndexes)/4);
iter.index=iter.length;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKD, FALSE, nfkd, sizeof(nfkd)/U_SIZEOF_UCHAR, nfkdIndexes, sizeof(nfkdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKD, FALSE, nfkd, UPRV_LENGTHOF(nfkd), nfkdIndexes, sizeof(nfkdIndexes)/4);
iter.index=iter.length;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFC, FALSE, nfc, sizeof(nfc)/U_SIZEOF_UCHAR, nfcIndexes, sizeof(nfcIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFC, FALSE, nfc, UPRV_LENGTHOF(nfc), nfcIndexes, sizeof(nfcIndexes)/4);
iter.index=iter.length;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKC, FALSE, nfkc, sizeof(nfkc)/U_SIZEOF_UCHAR, nfkcIndexes, sizeof(nfkcIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKC, FALSE, nfkc, UPRV_LENGTHOF(nfkc), nfkcIndexes, sizeof(nfkcIndexes)/4);
iter.index=iter.length;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_FCD, FALSE, fcd, sizeof(fcd)/U_SIZEOF_UCHAR, fcdIndexes, sizeof(fcdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_FCD, FALSE, fcd, UPRV_LENGTHOF(fcd), fcdIndexes, sizeof(fcdIndexes)/4);
/* test iteration without doNormalize */
iter.index=0;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFD, TRUE, NULL, 0, nfdIndexes, sizeof(nfdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFD, TRUE, NULL, 0, nfdIndexes, sizeof(nfdIndexes)/4);
iter.index=0;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKD, TRUE, NULL, 0, nfkdIndexes, sizeof(nfkdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKD, TRUE, NULL, 0, nfkdIndexes, sizeof(nfkdIndexes)/4);
iter.index=0;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFC, TRUE, NULL, 0, nfcIndexes, sizeof(nfcIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFC, TRUE, NULL, 0, nfcIndexes, sizeof(nfcIndexes)/4);
iter.index=0;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKC, TRUE, NULL, 0, nfkcIndexes, sizeof(nfkcIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKC, TRUE, NULL, 0, nfkcIndexes, sizeof(nfkcIndexes)/4);
iter.index=0;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_FCD, TRUE, NULL, 0, fcdIndexes, sizeof(fcdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_FCD, TRUE, NULL, 0, fcdIndexes, sizeof(fcdIndexes)/4);
iter.index=iter.length;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFD, FALSE, NULL, 0, nfdIndexes, sizeof(nfdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFD, FALSE, NULL, 0, nfdIndexes, sizeof(nfdIndexes)/4);
iter.index=iter.length;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKD, FALSE, NULL, 0, nfkdIndexes, sizeof(nfkdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKD, FALSE, NULL, 0, nfkdIndexes, sizeof(nfkdIndexes)/4);
iter.index=iter.length;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFC, FALSE, NULL, 0, nfcIndexes, sizeof(nfcIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFC, FALSE, NULL, 0, nfcIndexes, sizeof(nfcIndexes)/4);
iter.index=iter.length;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_NFKC, FALSE, NULL, 0, nfkcIndexes, sizeof(nfkcIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_NFKC, FALSE, NULL, 0, nfkcIndexes, sizeof(nfkcIndexes)/4);
iter.index=iter.length;
_testIter(src, sizeof(src)/U_SIZEOF_UCHAR, &iter, UNORM_FCD, FALSE, NULL, 0, fcdIndexes, sizeof(fcdIndexes)/4);
_testIter(src, UPRV_LENGTHOF(src), &iter, UNORM_FCD, FALSE, NULL, 0, fcdIndexes, sizeof(fcdIndexes)/4);
/* try without neededToNormalize */
errorCode=U_ZERO_ERROR;
buffer[0]=5;
iter.index=1;
length=unorm_next(&iter, buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
length=unorm_next(&iter, buffer, UPRV_LENGTHOF(buffer),
UNORM_NFD, 0, TRUE, NULL,
&errorCode);
if(U_FAILURE(errorCode) || length!=2 || buffer[0]!=nfd[2] || buffer[1]!=nfd[3]) {
@ -1273,7 +1273,7 @@ TestNextPrevious() {
buffer[0]=buffer[1]=5;
neededToNormalize=9;
iter.index=1;
length=unorm_next(NULL, buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
length=unorm_next(NULL, buffer, UPRV_LENGTHOF(buffer),
UNORM_NFD, 0, TRUE, &neededToNormalize,
&errorCode);
if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
@ -1285,7 +1285,7 @@ TestNextPrevious() {
buffer[0]=buffer[1]=5;
neededToNormalize=9;
iter.index=1;
length=unorm_next(&iter, buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
length=unorm_next(&iter, buffer, UPRV_LENGTHOF(buffer),
(UNormalizationMode)0, 0, TRUE, &neededToNormalize,
&errorCode);
if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
@ -1297,7 +1297,7 @@ TestNextPrevious() {
errorCode=U_MISPLACED_QUANTIFIER;
buffer[0]=5;
iter.index=1;
length=unorm_next(&iter, buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
length=unorm_next(&iter, buffer, UPRV_LENGTHOF(buffer),
UNORM_NFD, 0, TRUE, NULL,
&errorCode);
if(errorCode!=U_MISPLACED_QUANTIFIER) {

4
icu4c/source/test/cintltst/cnumtst.c
View file

@ -617,7 +617,7 @@ free(result);
}
}
for(i = 0; i < UNUM_FORMAT_SYMBOL_COUNT; ++i) {
resultlength = unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, sizeof(symbol)/U_SIZEOF_UCHAR, &status);
resultlength = unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, UPRV_LENGTHOF(symbol), &status);
if(U_FAILURE(status)) {
log_err("Error from unum_getSymbol(%d): %s\n", i, myErrorName(status));
return;
@ -627,7 +627,7 @@ free(result);
}
}
/*try getting from a bogus symbol*/
unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, sizeof(symbol)/U_SIZEOF_UCHAR, &status);
unum_getSymbol(cur_frpattern, (UNumberFormatSymbol)i, symbol, UPRV_LENGTHOF(symbol), &status);
if(U_SUCCESS(status)){
log_err("Error : Expected U_ILLEGAL_ARGUMENT_ERROR for bogus symbol");
}

128
icu4c/source/test/cintltst/cstrcase.c
View file

@ -1,7 +1,7 @@
/*
*******************************************************************************
*
* Copyright (C) 2002-2015, International Business Machines
* Copyright (C) 2002-2016, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
@ -44,12 +44,12 @@ TestCaseLower(void) {
/* lowercase with root locale and separate buffers */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToLower(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
length=u_strToLower(buffer, UPRV_LENGTHOF(buffer),
beforeLower, UPRV_LENGTHOF(beforeLower),
"",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(lowerRoot)) ||
uprv_memcmp(lowerRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -64,14 +64,14 @@ buffer[length]==0 ? "yes" : "no",
/* lowercase with turkish locale and in the same buffer */
uprv_memcpy(buffer, beforeLower, sizeof(beforeLower));
buffer[sizeof(beforeLower)/U_SIZEOF_UCHAR]=0;
buffer[UPRV_LENGTHOF(beforeLower)]=0;
errorCode=U_ZERO_ERROR;
length=u_strToLower(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
length=u_strToLower(buffer, UPRV_LENGTHOF(buffer),
buffer, -1, /* implicit srcLength */
"tr",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(lowerTurkish)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(lowerTurkish)) ||
uprv_memcmp(lowerTurkish, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -85,11 +85,11 @@ buffer[length]==0 ? "yes" : "no",
buffer[0]=buffer[2]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToLower(buffer, 2, /* set destCapacity=2 */
beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
beforeLower, UPRV_LENGTHOF(beforeLower),
"",
&errorCode);
if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
length!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(lowerRoot)) ||
uprv_memcmp(lowerRoot, buffer, 2*U_SIZEOF_UCHAR)!=0 ||
buffer[2]!=0xabcd
) {
@ -101,8 +101,8 @@ buffer[length]==0 ? "yes" : "no",
/* test error handling */
errorCode=U_ZERO_ERROR;
length=u_strToLower(NULL, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
length=u_strToLower(NULL, UPRV_LENGTHOF(buffer),
beforeLower, UPRV_LENGTHOF(beforeLower),
"",
&errorCode);
if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
@ -114,7 +114,7 @@ buffer[length]==0 ? "yes" : "no",
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToLower(buffer, -1,
beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
beforeLower, UPRV_LENGTHOF(beforeLower),
"",
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
@ -142,12 +142,12 @@ TestCaseUpper(void) {
/* uppercase with root locale and in the same buffer */
uprv_memcpy(buffer, beforeUpper, sizeof(beforeUpper));
errorCode=U_ZERO_ERROR;
length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
buffer, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
length=u_strToUpper(buffer, UPRV_LENGTHOF(buffer),
buffer, UPRV_LENGTHOF(beforeUpper),
"",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(upperRoot)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(upperRoot)) ||
uprv_memcmp(upperRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -160,12 +160,12 @@ TestCaseUpper(void) {
/* uppercase with turkish locale and separate buffers */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeUpper, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
length=u_strToUpper(buffer, UPRV_LENGTHOF(buffer),
beforeUpper, UPRV_LENGTHOF(beforeUpper),
"tr",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(upperTurkish)) ||
uprv_memcmp(upperTurkish, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -178,11 +178,11 @@ TestCaseUpper(void) {
/* test preflighting */
errorCode=U_ZERO_ERROR;
length=u_strToUpper(NULL, 0,
beforeUpper, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
beforeUpper, UPRV_LENGTHOF(beforeUpper),
"tr",
&errorCode);
if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
length!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR)
length!=(UPRV_LENGTHOF(upperTurkish))
) {
log_err("error in u_strToUpper(turkish locale pure preflighting)=%ld error=%s\n",
length,
@ -192,8 +192,8 @@ TestCaseUpper(void) {
/* test error handling */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
NULL, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
length=u_strToUpper(buffer, UPRV_LENGTHOF(buffer),
NULL, UPRV_LENGTHOF(beforeUpper),
"tr",
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
@ -207,7 +207,7 @@ TestCaseUpper(void) {
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
length=u_strToUpper(buffer, UPRV_LENGTHOF(buffer),
beforeUpper, -2,
"tr",
&errorCode);
@ -237,7 +237,7 @@ TestCaseTitle(void) {
UErrorCode errorCode;
errorCode=U_ZERO_ERROR;
titleIterChars=ubrk_open(UBRK_CHARACTER, "", beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR, &errorCode);
titleIterChars=ubrk_open(UBRK_CHARACTER, "", beforeTitle, UPRV_LENGTHOF(beforeTitle), &errorCode);
if(U_FAILURE(errorCode)) {
log_err_status(errorCode, "error: ubrk_open(UBRK_CHARACTER)->%s\n", u_errorName(errorCode));
return;
@ -246,12 +246,12 @@ TestCaseTitle(void) {
/* titlecase with standard break iterator and in the same buffer */
uprv_memcpy(buffer, beforeTitle, sizeof(beforeTitle));
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
buffer, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
buffer, UPRV_LENGTHOF(beforeTitle),
NULL, "",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(titleWord)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(titleWord)) ||
uprv_memcmp(titleWord, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -264,12 +264,12 @@ TestCaseTitle(void) {
/* titlecase with UBRK_CHARACTERS and separate buffers */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
beforeTitle, UPRV_LENGTHOF(beforeTitle),
titleIterChars, "",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(titleChar)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(titleChar)) ||
uprv_memcmp(titleChar, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -282,11 +282,11 @@ TestCaseTitle(void) {
/* test preflighting */
errorCode=U_ZERO_ERROR;
length=u_strToTitle(NULL, 0,
beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
beforeTitle, UPRV_LENGTHOF(beforeTitle),
titleIterChars, "",
&errorCode);
if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
length!=(sizeof(titleChar)/U_SIZEOF_UCHAR)
length!=(UPRV_LENGTHOF(titleChar))
) {
log_err("error in u_strToTitle(UBRK_CHARACTERS pure preflighting)=%ld error=%s\n",
length,
@ -296,8 +296,8 @@ TestCaseTitle(void) {
/* test error handling */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
NULL, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
NULL, UPRV_LENGTHOF(beforeTitle),
titleIterChars, "",
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
@ -311,7 +311,7 @@ TestCaseTitle(void) {
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
beforeTitle, -2,
titleIterChars, "",
&errorCode);
@ -341,7 +341,7 @@ TestCaseDutchTitle(void) {
UErrorCode errorCode;
errorCode=U_ZERO_ERROR;
titleIterWord=ubrk_open(UBRK_WORD, "", beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR, &errorCode);
titleIterWord=ubrk_open(UBRK_WORD, "", beforeTitle, UPRV_LENGTHOF(beforeTitle), &errorCode);
if(U_FAILURE(errorCode)) {
log_err_status(errorCode, "error: ubrk_open(UBRK_WORD)->%s\n", u_errorName(errorCode));
return;
@ -350,12 +350,12 @@ TestCaseDutchTitle(void) {
/* titlecase with default locale */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
beforeTitle, UPRV_LENGTHOF(beforeTitle),
titleIterWord, "",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(titleRoot)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(titleRoot)) ||
uprv_memcmp(titleRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -369,12 +369,12 @@ TestCaseDutchTitle(void) {
/* titlecase with Dutch locale */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
length=u_strToTitle(buffer, UPRV_LENGTHOF(buffer),
beforeTitle, UPRV_LENGTHOF(beforeTitle),
titleIterWord, "nl",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(titleDutch)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(titleDutch)) ||
uprv_memcmp(titleDutch, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -456,12 +456,12 @@ TestCaseFolding(void) {
/* test full string case folding with default option and separate buffers */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
mixed, UPRV_LENGTHOF(mixed),
U_FOLD_CASE_DEFAULT,
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(foldedDefault)) ||
uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -475,12 +475,12 @@ TestCaseFolding(void) {
if(isUnicode_3_1) {
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
mixed, UPRV_LENGTHOF(mixed),
U_FOLD_CASE_EXCLUDE_SPECIAL_I,
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(foldedExcludeSpecialI)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(foldedExcludeSpecialI)) ||
uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -493,14 +493,14 @@ TestCaseFolding(void) {
/* test full string case folding with default option and in the same buffer */
uprv_memcpy(buffer, mixed, sizeof(mixed));
buffer[sizeof(mixed)/U_SIZEOF_UCHAR]=0;
buffer[UPRV_LENGTHOF(mixed)]=0;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
buffer, -1, /* implicit srcLength */
U_FOLD_CASE_DEFAULT,
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
length!=(UPRV_LENGTHOF(foldedDefault)) ||
uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -514,12 +514,12 @@ TestCaseFolding(void) {
if(isUnicode_3_1) {
uprv_memcpy(buffer, mixed, sizeof(mixed));
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
buffer, sizeof(mixed)/U_SIZEOF_UCHAR,
length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
buffer, UPRV_LENGTHOF(mixed),
U_FOLD_CASE_EXCLUDE_SPECIAL_I,
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(foldedExcludeSpecialI)/U_SIZEOF_UCHAR) ||
length!=UPRV_LENGTHOF(foldedExcludeSpecialI) ||
uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
@ -534,11 +534,11 @@ TestCaseFolding(void) {
buffer[0]=buffer[2]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, 2, /* set destCapacity=2 */
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
mixed, UPRV_LENGTHOF(mixed),
U_FOLD_CASE_DEFAULT,
&errorCode);
if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
length!=UPRV_LENGTHOF(foldedDefault) ||
uprv_memcmp(foldedDefault, buffer, 2*U_SIZEOF_UCHAR)!=0 ||
buffer[2]!=0xabcd
) {
@ -550,11 +550,11 @@ TestCaseFolding(void) {
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(NULL, 0,
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
mixed, UPRV_LENGTHOF(mixed),
U_FOLD_CASE_DEFAULT,
&errorCode);
if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR)
length!=UPRV_LENGTHOF(foldedDefault)
) {
log_err("error in u_strFoldCase(default pure preflighting)=%ld error=%s\n",
length,
@ -563,8 +563,8 @@ TestCaseFolding(void) {
/* test error handling */
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(NULL, sizeof(buffer)/U_SIZEOF_UCHAR,
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
length=u_strFoldCase(NULL, UPRV_LENGTHOF(buffer),
mixed, UPRV_LENGTHOF(mixed),
U_FOLD_CASE_DEFAULT,
&errorCode);
if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
@ -576,7 +576,7 @@ TestCaseFolding(void) {
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, -1,
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
mixed, UPRV_LENGTHOF(mixed),
U_FOLD_CASE_DEFAULT,
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
@ -590,8 +590,8 @@ TestCaseFolding(void) {
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
NULL, sizeof(mixed)/U_SIZEOF_UCHAR,
length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
NULL, UPRV_LENGTHOF(mixed),
U_FOLD_CASE_EXCLUDE_SPECIAL_I,
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
@ -605,7 +605,7 @@ TestCaseFolding(void) {
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
length=u_strFoldCase(buffer, UPRV_LENGTHOF(buffer),
mixed, -2,
U_FOLD_CASE_EXCLUDE_SPECIAL_I,
&errorCode);

18
icu4c/source/test/cintltst/nccbtst.c
View file

@ -199,7 +199,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
static const int32_t fromUOffsets[] = { 0, 2, 3, 3, 3, 5, 5, 6, 6, 8, 8, 8, 8 };
/* test ibm-930 (EBCDIC_STATEFUL) with fallbacks that are not taken to check correct state transitions */
if(!testConvertFromUnicode(fromU, sizeof(fromU)/U_SIZEOF_UCHAR,
if(!testConvertFromUnicode(fromU, UPRV_LENGTHOF(fromU),
fromUBytes, sizeof(fromUBytes),
"ibm-930",
UCNV_FROM_U_CALLBACK_SKIP, fromUOffsets,
@ -220,7 +220,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
static const int32_t latin1FromUOffsets[] = { 0, 1, 3, 6 };
/* US-ASCII */
if(!testConvertFromUnicode(usasciiFromU, sizeof(usasciiFromU)/U_SIZEOF_UCHAR,
if(!testConvertFromUnicode(usasciiFromU, UPRV_LENGTHOF(usasciiFromU),
usasciiFromUBytes, sizeof(usasciiFromUBytes),
"US-ASCII",
UCNV_FROM_U_CALLBACK_SKIP, usasciiFromUOffsets,
@ -231,7 +231,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
#if !UCONFIG_NO_LEGACY_CONVERSION
/* SBCS NLTC codepage 367 for US-ASCII */
if(!testConvertFromUnicode(usasciiFromU, sizeof(usasciiFromU)/U_SIZEOF_UCHAR,
if(!testConvertFromUnicode(usasciiFromU, UPRV_LENGTHOF(usasciiFromU),
usasciiFromUBytes, sizeof(usasciiFromUBytes),
"ibm-367",
UCNV_FROM_U_CALLBACK_SKIP, usasciiFromUOffsets,
@ -242,7 +242,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
#endif
/* ISO-Latin-1 */
if(!testConvertFromUnicode(latin1FromU, sizeof(latin1FromU)/U_SIZEOF_UCHAR,
if(!testConvertFromUnicode(latin1FromU, UPRV_LENGTHOF(latin1FromU),
latin1FromUBytes, sizeof(latin1FromUBytes),
"LATIN_1",
UCNV_FROM_U_CALLBACK_SKIP, latin1FromUOffsets,
@ -253,7 +253,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
#if !UCONFIG_NO_LEGACY_CONVERSION
/* windows-1252 */
if(!testConvertFromUnicode(latin1FromU, sizeof(latin1FromU)/U_SIZEOF_UCHAR,
if(!testConvertFromUnicode(latin1FromU, UPRV_LENGTHOF(latin1FromU),
latin1FromUBytes, sizeof(latin1FromUBytes),
"windows-1252",
UCNV_FROM_U_CALLBACK_SKIP, latin1FromUOffsets,
@ -694,7 +694,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
/* US-ASCII */
if(!testConvertToUnicode(usasciiToUBytes, sizeof(usasciiToUBytes),
usasciiToU, sizeof(usasciiToU)/U_SIZEOF_UCHAR,
usasciiToU, UPRV_LENGTHOF(usasciiToU),
"US-ASCII",
UCNV_TO_U_CALLBACK_SKIP, usasciiToUOffsets,
NULL, 0)
@ -705,7 +705,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
#if !UCONFIG_NO_LEGACY_CONVERSION
/* SBCS NLTC codepage 367 for US-ASCII */
if(!testConvertToUnicode(usasciiToUBytes, sizeof(usasciiToUBytes),
usasciiToU, sizeof(usasciiToU)/U_SIZEOF_UCHAR,
usasciiToU, UPRV_LENGTHOF(usasciiToU),
"ibm-367",
UCNV_TO_U_CALLBACK_SKIP, usasciiToUOffsets,
NULL, 0)
@ -716,7 +716,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
/* ISO-Latin-1 */
if(!testConvertToUnicode(latin1ToUBytes, sizeof(latin1ToUBytes),
latin1ToU, sizeof(latin1ToU)/U_SIZEOF_UCHAR,
latin1ToU, UPRV_LENGTHOF(latin1ToU),
"LATIN_1",
UCNV_TO_U_CALLBACK_SKIP, latin1ToUOffsets,
NULL, 0)
@ -727,7 +727,7 @@ static void TestSkip(int32_t inputsize, int32_t outputsize)
#if !UCONFIG_NO_LEGACY_CONVERSION
/* windows-1252 */
if(!testConvertToUnicode(latin1ToUBytes, sizeof(latin1ToUBytes),
latin1ToU, sizeof(latin1ToU)/U_SIZEOF_UCHAR,
latin1ToU, UPRV_LENGTHOF(latin1ToU),
"windows-1252",
UCNV_TO_U_CALLBACK_SKIP, latin1ToUOffsets,
NULL, 0)

18
icu4c/source/test/cintltst/nucnvtst.c
View file

@ -1014,13 +1014,13 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
16, 16, 16, 17, 17, 17, 18, 18, 18, 18
};
testConvertFromU(unicode, sizeof(unicode)/U_SIZEOF_UCHAR, utf7, sizeof(utf7), "UTF-7", fromUnicodeOffsets,FALSE);
testConvertFromU(unicode, UPRV_LENGTHOF(unicode), utf7, sizeof(utf7), "UTF-7", fromUnicodeOffsets,FALSE);
testConvertToU(utf7, sizeof(utf7), unicode, sizeof(unicode)/U_SIZEOF_UCHAR, "UTF-7", toUnicodeOffsets,FALSE);
testConvertToU(utf7, sizeof(utf7), unicode, UPRV_LENGTHOF(unicode), "UTF-7", toUnicodeOffsets,FALSE);
testConvertFromU(unicode, sizeof(unicode)/U_SIZEOF_UCHAR, utf7Restricted, sizeof(utf7Restricted), "UTF-7,version=1", fromUnicodeOffsetsR,FALSE);
testConvertFromU(unicode, UPRV_LENGTHOF(unicode), utf7Restricted, sizeof(utf7Restricted), "UTF-7,version=1", fromUnicodeOffsetsR,FALSE);
testConvertToU(utf7Restricted, sizeof(utf7Restricted), unicode, sizeof(unicode)/U_SIZEOF_UCHAR, "UTF-7,version=1", toUnicodeOffsetsR,FALSE);
testConvertToU(utf7Restricted, sizeof(utf7Restricted), unicode, UPRV_LENGTHOF(unicode), "UTF-7,version=1", toUnicodeOffsetsR,FALSE);
}
/*
@ -1094,9 +1094,9 @@ static void TestNewConvertWithBufferSizes(int32_t outsize, int32_t insize )
35, 36, 36, 36, 37, 37, 37, 37, 37
};
testConvertFromU(unicode, sizeof(unicode)/U_SIZEOF_UCHAR, imap, sizeof(imap), "IMAP-mailbox-name", fromUnicodeOffsets,FALSE);
testConvertFromU(unicode, UPRV_LENGTHOF(unicode), imap, sizeof(imap), "IMAP-mailbox-name", fromUnicodeOffsets,FALSE);
testConvertToU(imap, sizeof(imap), unicode, sizeof(unicode)/U_SIZEOF_UCHAR, "IMAP-mailbox-name", toUnicodeOffsets,FALSE);
testConvertToU(imap, sizeof(imap), unicode, UPRV_LENGTHOF(unicode), "IMAP-mailbox-name", toUnicodeOffsets,FALSE);
}
/* Test UTF-8 bad data handling*/
@ -1546,7 +1546,7 @@ static void TestAmbiguous()
return;
}
/* convert target from SJIS to Unicode */
sjisLength = ucnv_toUChars(sjis_cnv, sjisResult, sizeof(sjisResult)/U_SIZEOF_UCHAR, target, (int32_t)strlen(target), &status);
sjisLength = ucnv_toUChars(sjis_cnv, sjisResult, UPRV_LENGTHOF(sjisResult), target, (int32_t)strlen(target), &status);
if (U_FAILURE(status))
{
log_err("Failed to convert the SJIS string.\n");
@ -1555,7 +1555,7 @@ static void TestAmbiguous()
return;
}
/* convert target from Latin-1 to Unicode */
/*asciiLength =*/ ucnv_toUChars(ascii_cnv, asciiResult, sizeof(asciiResult)/U_SIZEOF_UCHAR, target, (int32_t)strlen(target), &status);
/*asciiLength =*/ ucnv_toUChars(ascii_cnv, asciiResult, UPRV_LENGTHOF(asciiResult), target, (int32_t)strlen(target), &status);
if (U_FAILURE(status))
{
log_err("Failed to convert the Latin-1 string.\n");
@ -3276,7 +3276,7 @@ TestISCII(){
0xEF, 0x30,
};
testConvertToU(byteArr,(sizeof(byteArr)),in,(sizeof(in)/U_SIZEOF_UCHAR),"x-iscii-de",NULL,TRUE);
testConvertToU(byteArr,(sizeof(byteArr)),in,UPRV_LENGTHOF(in),"x-iscii-de",NULL,TRUE);
TestConv(in,(sizeof(in)/2),"ISCII,version=0","hindi", (char *)byteArr,sizeof(byteArr));
}

56
icu4c/source/test/cintltst/utf16tst.c
View file

@ -147,8 +147,8 @@ static void TestGetChar()
uint16_t i=0;
UChar32 c;
uint16_t offset=0;
for(offset=0; offset<sizeof(input)/U_SIZEOF_UCHAR; offset++) {
if(0<offset && offset<sizeof(input)/U_SIZEOF_UCHAR-1){
for(offset=0; offset<UPRV_LENGTHOF(input); offset++) {
if(0<offset && offset<UPRV_LENGTHOF(input)-1){
UTF16_GET_CHAR_UNSAFE(input, offset, c);
if(c != result[i]){
log_err("ERROR: UTF16_GET_CHAR_UNSAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i], c);
@ -160,17 +160,17 @@ static void TestGetChar()
}
}
UTF16_GET_CHAR_SAFE(input, 0, offset, sizeof(input)/U_SIZEOF_UCHAR, c, FALSE);
UTF16_GET_CHAR_SAFE(input, 0, offset, UPRV_LENGTHOF(input), c, FALSE);
if(c != result[i+1]){
log_err("ERROR: UTF16_GET_CHAR_SAFE failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+1], c);
}
U16_GET(input, 0, offset, sizeof(input)/U_SIZEOF_UCHAR, c);
U16_GET(input, 0, offset, UPRV_LENGTHOF(input), c);
if(c != result[i+1]){
log_err("ERROR: U16_GET failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+1], c);
}
UTF16_GET_CHAR_SAFE(input, 0, offset, sizeof(input)/U_SIZEOF_UCHAR, c, TRUE);
UTF16_GET_CHAR_SAFE(input, 0, offset, UPRV_LENGTHOF(input), c, TRUE);
if(c != result[i+2]){
log_err("ERROR: UTF16_GET_CHAR_SAFE(strict) failed for offset=%ld. Expected:%lx Got:%lx\n", offset, result[i+2], c);
}
@ -217,7 +217,7 @@ static void TestNextPrevChar(){
UChar32 c=0x0000;
uint16_t i=0;
uint16_t offset=0, setOffset=0;
for(offset=0; offset<sizeof(input)/U_SIZEOF_UCHAR; offset++){
for(offset=0; offset<UPRV_LENGTHOF(input); offset++){
setOffset=offset;
UTF16_NEXT_CHAR_UNSAFE(input, setOffset, c);
if(setOffset != movedOffset[i]){
@ -239,7 +239,7 @@ static void TestNextPrevChar(){
}
setOffset=offset;
UTF16_NEXT_CHAR_SAFE(input, setOffset, sizeof(input)/U_SIZEOF_UCHAR, c, FALSE);
UTF16_NEXT_CHAR_SAFE(input, setOffset, UPRV_LENGTHOF(input), c, FALSE);
if(setOffset != movedOffset[i+1]){
log_err("ERROR: UTF16_NEXT_CHAR_SAFE failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
offset, movedOffset[i+1], setOffset);
@ -249,7 +249,7 @@ static void TestNextPrevChar(){
}
setOffset=offset;
U16_NEXT(input, setOffset, sizeof(input)/U_SIZEOF_UCHAR, c);
U16_NEXT(input, setOffset, UPRV_LENGTHOF(input), c);
if(setOffset != movedOffset[i+1]){
log_err("ERROR: U16_NEXT failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
offset, movedOffset[i+1], setOffset);
@ -259,7 +259,7 @@ static void TestNextPrevChar(){
}
setOffset=offset;
UTF16_NEXT_CHAR_SAFE(input, setOffset, sizeof(input)/U_SIZEOF_UCHAR, c, TRUE);
UTF16_NEXT_CHAR_SAFE(input, setOffset, UPRV_LENGTHOF(input), c, TRUE);
if(setOffset != movedOffset[i+1]){
log_err("ERROR: UTF16_NEXT_CHAR_SAFE(strict) failed to move the offset correctly at %d\n ExpectedOffset:%d Got %d\n",
offset, movedOffset[i+2], setOffset);
@ -271,7 +271,7 @@ static void TestNextPrevChar(){
i=(uint16_t)(i+6);
}
i=0;
for(offset=(uint16_t)sizeof(input)/U_SIZEOF_UCHAR; offset > 0; --offset){
for(offset=(uint16_t)UPRV_LENGTHOF(input); offset > 0; --offset){
setOffset=offset;
UTF16_PREV_CHAR_UNSAFE(input, setOffset, c);
if(setOffset != movedOffset[i+3]){
@ -408,7 +408,7 @@ static void TestFwdBack(){
uint16_t offunsafe=0, offsafe=0;
uint16_t i=0;
while(offunsafe < sizeof(input)/U_SIZEOF_UCHAR){
while(offunsafe < UPRV_LENGTHOF(input)){
UTF16_FWD_1_UNSAFE(input, offunsafe);
if(offunsafe != fwd_unsafe[i]){
log_err("ERROR: Forward_unsafe offset expected:%d, Got:%d\n", fwd_unsafe[i], offunsafe);
@ -418,7 +418,7 @@ static void TestFwdBack(){
offunsafe=0, offsafe=0;
i=0;
while(offunsafe < sizeof(input)/U_SIZEOF_UCHAR){
while(offunsafe < UPRV_LENGTHOF(input)){
U16_FWD_1_UNSAFE(input, offunsafe);
if(offunsafe != fwd_unsafe[i]){
log_err("ERROR: U16_FWD_1_UNSAFE offset expected:%d, Got:%d\n", fwd_unsafe[i], offunsafe);
@ -427,8 +427,8 @@ static void TestFwdBack(){
}
i=0;
while(offsafe < sizeof(input)/U_SIZEOF_UCHAR){
UTF16_FWD_1_SAFE(input, offsafe, sizeof(input)/U_SIZEOF_UCHAR);
while(offsafe < UPRV_LENGTHOF(input)){
UTF16_FWD_1_SAFE(input, offsafe, UPRV_LENGTHOF(input));
if(offsafe != fwd_safe[i]){
log_err("ERROR: Forward_safe offset expected:%d, Got:%d\n", fwd_safe[i], offsafe);
}
@ -436,16 +436,16 @@ static void TestFwdBack(){
}
i=0;
while(offsafe < sizeof(input)/U_SIZEOF_UCHAR){
U16_FWD_1(input, offsafe, sizeof(input)/U_SIZEOF_UCHAR);
while(offsafe < UPRV_LENGTHOF(input)){
U16_FWD_1(input, offsafe, UPRV_LENGTHOF(input));
if(offsafe != fwd_safe[i]){
log_err("ERROR: U16_FWD_1 offset expected:%d, Got:%d\n", fwd_safe[i], offsafe);
}
i++;
}
offunsafe=sizeof(input)/U_SIZEOF_UCHAR;
offsafe=sizeof(input)/U_SIZEOF_UCHAR;
offunsafe=UPRV_LENGTHOF(input);
offsafe=UPRV_LENGTHOF(input);
i=0;
while(offunsafe > 0){
UTF16_BACK_1_UNSAFE(input, offunsafe);
@ -455,8 +455,8 @@ static void TestFwdBack(){
i++;
}
offunsafe=sizeof(input)/U_SIZEOF_UCHAR;
offsafe=sizeof(input)/U_SIZEOF_UCHAR;
offunsafe=UPRV_LENGTHOF(input);
offsafe=UPRV_LENGTHOF(input);
i=0;
while(offunsafe > 0){
U16_BACK_1_UNSAFE(input, offunsafe);
@ -503,7 +503,7 @@ static void TestFwdBack(){
offsafe=0;
for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
UTF16_FWD_N_SAFE(input, offsafe, sizeof(input)/U_SIZEOF_UCHAR, Nvalue[i]);
UTF16_FWD_N_SAFE(input, offsafe, UPRV_LENGTHOF(input), Nvalue[i]);
if(offsafe != fwd_N_safe[i]){
log_err("ERROR: Forward_N_safe offset expected:%d, Got:%d\n", fwd_N_safe[i], offsafe);
}
@ -512,14 +512,14 @@ static void TestFwdBack(){
offsafe=0;
for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
U16_FWD_N(input, offsafe, sizeof(input)/U_SIZEOF_UCHAR, Nvalue[i]);
U16_FWD_N(input, offsafe, UPRV_LENGTHOF(input), Nvalue[i]);
if(offsafe != fwd_N_safe[i]){
log_err("ERROR: U16_FWD_N offset expected:%d, Got:%d\n", fwd_N_safe[i], offsafe);
}
}
offunsafe=sizeof(input)/U_SIZEOF_UCHAR;
offunsafe=UPRV_LENGTHOF(input);
for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){
UTF16_BACK_N_UNSAFE(input, offunsafe, Nvalue[i]);
if(offunsafe != back_N_unsafe[i]){
@ -527,7 +527,7 @@ static void TestFwdBack(){
}
}
offunsafe=sizeof(input)/U_SIZEOF_UCHAR;
offunsafe=UPRV_LENGTHOF(input);
for(i=0; i<UPRV_LENGTHOF(Nvalue)-2; i++){
U16_BACK_N_UNSAFE(input, offunsafe, Nvalue[i]);
if(offunsafe != back_N_unsafe[i]){
@ -535,7 +535,7 @@ static void TestFwdBack(){
}
}
offsafe=sizeof(input)/U_SIZEOF_UCHAR;
offsafe=UPRV_LENGTHOF(input);
for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
UTF16_BACK_N_SAFE(input, 0, offsafe, Nvalue[i]);
if(offsafe != back_N_safe[i]){
@ -543,7 +543,7 @@ static void TestFwdBack(){
}
}
offsafe=sizeof(input)/U_SIZEOF_UCHAR;
offsafe=UPRV_LENGTHOF(input);
for(i=0; i<UPRV_LENGTHOF(Nvalue); i++){
U16_BACK_N(input, 0, offsafe, Nvalue[i]);
if(offsafe != back_N_safe[i]){
@ -561,7 +561,7 @@ static void TestSetChar(){
uint16_t i=0;
uint16_t offset=0, setOffset=0;
for(offset=0; offset<sizeof(input)/U_SIZEOF_UCHAR; offset++){
for(offset=0; offset<UPRV_LENGTHOF(input); offset++){
setOffset=offset;
UTF16_SET_CHAR_START_UNSAFE(input, setOffset);
if(setOffset != start_unsafe[i]){
@ -601,7 +601,7 @@ static void TestSetChar(){
}
setOffset=offset;
U16_SET_CP_LIMIT(input,0, setOffset, sizeof(input)/U_SIZEOF_UCHAR);
U16_SET_CP_LIMIT(input,0, setOffset, UPRV_LENGTHOF(input));
if(setOffset != limit_safe[i]){
log_err("ERROR: U16_SET_CHAR_LIMIT failed for offset=%ld. Expected:%lx Got:%lx\n", offset, limit_safe[i], setOffset);
}

32
icu4c/source/test/intltest/strcase.cpp
View file

@ -1,7 +1,7 @@
/*
*******************************************************************************
*
* Copyright (C) 2002-2014, International Business Machines
* Copyright (C) 2002-2016, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
@ -138,48 +138,48 @@ StringCaseTest::TestCaseConversion()
UnicodeString s;
/* lowercase with root locale */
s=UnicodeString(FALSE, beforeLower, (int32_t)(sizeof(beforeLower)/U_SIZEOF_UCHAR));
s=UnicodeString(FALSE, beforeLower, UPRV_LENGTHOF(beforeLower));
s.toLower("");
if( s.length()!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) ||
if( s.length()!=UPRV_LENGTHOF(lowerRoot) ||
s!=UnicodeString(FALSE, lowerRoot, s.length())
) {
errln("error in toLower(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerRoot, (int32_t)(sizeof(lowerRoot)/U_SIZEOF_UCHAR)) + "\"");
errln("error in toLower(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerRoot, UPRV_LENGTHOF(lowerRoot)) + "\"");
}
/* lowercase with turkish locale */
s=UnicodeString(FALSE, beforeLower, (int32_t)(sizeof(beforeLower)/U_SIZEOF_UCHAR));
s=UnicodeString(FALSE, beforeLower, UPRV_LENGTHOF(beforeLower));
s.setCharAt(0, beforeLower[0]).toLower(Locale("tr"));
if( s.length()!=(sizeof(lowerTurkish)/U_SIZEOF_UCHAR) ||
if( s.length()!=UPRV_LENGTHOF(lowerTurkish) ||
s!=UnicodeString(FALSE, lowerTurkish, s.length())
) {
errln("error in toLower(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerTurkish, (int32_t)(sizeof(lowerTurkish)/U_SIZEOF_UCHAR)) + "\"");
errln("error in toLower(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerTurkish, UPRV_LENGTHOF(lowerTurkish)) + "\"");
}
/* uppercase with root locale */
s=UnicodeString(FALSE, beforeUpper, (int32_t)(sizeof(beforeUpper)/U_SIZEOF_UCHAR));
s=UnicodeString(FALSE, beforeUpper, UPRV_LENGTHOF(beforeUpper));
s.setCharAt(0, beforeUpper[0]).toUpper(Locale(""));
if( s.length()!=(sizeof(upperRoot)/U_SIZEOF_UCHAR) ||
if( s.length()!=UPRV_LENGTHOF(upperRoot) ||
s!=UnicodeString(FALSE, upperRoot, s.length())
) {
errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperRoot, (int32_t)(sizeof(upperRoot)/U_SIZEOF_UCHAR)) + "\"");
errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperRoot, UPRV_LENGTHOF(upperRoot)) + "\"");
}
/* uppercase with turkish locale */
s=UnicodeString(FALSE, beforeUpper, (int32_t)(sizeof(beforeUpper)/U_SIZEOF_UCHAR));
s=UnicodeString(FALSE, beforeUpper, UPRV_LENGTHOF(beforeUpper));
s.toUpper(Locale("tr"));
if( s.length()!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR) ||
if( s.length()!=UPRV_LENGTHOF(upperTurkish) ||
s!=UnicodeString(FALSE, upperTurkish, s.length())
) {
errln("error in toUpper(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperTurkish, (int32_t)(sizeof(upperTurkish)/U_SIZEOF_UCHAR)) + "\"");
errln("error in toUpper(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperTurkish, UPRV_LENGTHOF(upperTurkish)) + "\"");
}
/* uppercase a short string with root locale */
s=UnicodeString(FALSE, beforeMiniUpper, (int32_t)(sizeof(beforeMiniUpper)/U_SIZEOF_UCHAR));
s=UnicodeString(FALSE, beforeMiniUpper, UPRV_LENGTHOF(beforeMiniUpper));
s.setCharAt(0, beforeMiniUpper[0]).toUpper("");
if( s.length()!=(sizeof(miniUpper)/U_SIZEOF_UCHAR) ||
if( s.length()!=UPRV_LENGTHOF(miniUpper) ||
s!=UnicodeString(FALSE, miniUpper, s.length())
) {
errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, miniUpper, (int32_t)(sizeof(miniUpper)/U_SIZEOF_UCHAR)) + "\"");
errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, miniUpper, UPRV_LENGTHOF(miniUpper)) + "\"");
}
}