mirror of
https://github.com/unicode-org/icu.git
synced 2025-04-05 21:45:37 +00:00
ICU-2449 data-driven conversion tests
X-SVN-Rev: 12647
This commit is contained in:
Markus Scherer
parent
ad268ad5e2
commit
53de0aef70
7 changed files with 1111 additions and 43 deletions
|
|
@ -27,7 +27,7 @@ DEFS += -D'U_TOPSRCDIR="$(top_srcdir)/"' -D'U_TOPBUILDDIR="$(BUILDDIR)"'
|
|||
LIBS = $(LIBICUI18N) $(LIBICUUC) $(LIBICUTOOLUTIL) $(DEFAULT_LIBS) $(LIB_M)
|
||||
|
||||
OBJECTS = allcoll.o apicoll.o callimts.o calregts.o caltest.o \
|
||||
caltztst.o canittst.o citrtest.o cntabcol.o cputilst.o currcoll.o dacoll.o \
|
||||
caltztst.o canittst.o citrtest.o cntabcol.o convtest.o cputilst.o currcoll.o dacoll.o \
|
||||
dadrcoll.o dcfmapts.o decoll.o dtfmapts.o dtfmrgts.o dtfmtrtts.o dtfmttst.o \
|
||||
encoll.o escoll.o ficoll.o frcoll.o g7coll.o intltest.o \
|
||||
itercoll.o itformat.o itmajor.o itutil.o jacoll.o lcukocol.o \
|
||||
|
|
|
|||
899
icu4c/source/test/intltest/convtest.cpp
Normal file
899
icu4c/source/test/intltest/convtest.cpp
Normal file
|
|
@ -0,0 +1,899 @@
|
|||
/*
|
||||
*******************************************************************************
|
||||
*
|
||||
* Copyright (C) 2003, International Business Machines
|
||||
* Corporation and others. All Rights Reserved.
|
||||
*
|
||||
*******************************************************************************
|
||||
* file name: convtest.cpp
|
||||
* encoding: US-ASCII
|
||||
* tab size: 8 (not used)
|
||||
* indentation:4
|
||||
*
|
||||
* created on: 2003jul15
|
||||
* created by: Markus W. Scherer
|
||||
*
|
||||
* Test file for data-driven conversion tests.
|
||||
*/
|
||||
|
||||
#include "unicode/utypes.h"
|
||||
#include "unicode/ucnv.h"
|
||||
#include "unicode/unistr.h"
|
||||
#include "unicode/ustring.h"
|
||||
#include "unicode/ures.h"
|
||||
#include "convtest.h"
|
||||
#include "tstdtmod.h"
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
|
||||
|
||||
enum {
|
||||
// characters used in test data for callbacks
|
||||
SUB_CB='?',
|
||||
SKIP_CB='0',
|
||||
STOP_CB='.',
|
||||
ESC_CB='&'
|
||||
};
|
||||
|
||||
void
|
||||
ConversionTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
|
||||
if (exec) logln("TestSuite StringCaseTest: ");
|
||||
switch (index) {
|
||||
case 0: name="TestToUnicode"; if (exec) TestToUnicode(); break;
|
||||
case 1: name="TestFromUnicode"; if (exec) TestFromUnicode(); break;
|
||||
default: name=""; break; //needed to end loop
|
||||
}
|
||||
}
|
||||
|
||||
// test data interface ----------------------------------------------------- ***
|
||||
|
||||
void
|
||||
ConversionTest::TestToUnicode() {
|
||||
ConversionCase cc;
|
||||
char charset[100], cbopt[4];
|
||||
const char *option;
|
||||
UnicodeString s, unicode;
|
||||
int32_t offsetsLength;
|
||||
UConverterToUCallback callback;
|
||||
|
||||
TestLog testLog;
|
||||
TestDataModule *dataModule;
|
||||
TestData *testData;
|
||||
const DataMap *testCase;
|
||||
UErrorCode errorCode;
|
||||
int32_t i;
|
||||
|
||||
errorCode=U_ZERO_ERROR;
|
||||
dataModule=TestDataModule::getTestDataModule("conversion", testLog, errorCode);
|
||||
if(U_SUCCESS(errorCode)) {
|
||||
testData=dataModule->createTestData("toUnicode", errorCode);
|
||||
if(U_SUCCESS(errorCode)) {
|
||||
for(i=0; testData->nextCase(testCase, errorCode); ++i) {
|
||||
cc.caseNr=i;
|
||||
|
||||
s=testCase->getString("charset", errorCode);
|
||||
s.extract(0, 0x7fffffff, charset, sizeof(charset), "");
|
||||
cc.charset=charset;
|
||||
|
||||
cc.bytes=testCase->getBinary(cc.bytesLength, "bytes", errorCode);
|
||||
unicode=testCase->getString("unicode", errorCode);
|
||||
cc.unicode=unicode.getBuffer();
|
||||
cc.unicodeLength=unicode.length();
|
||||
|
||||
offsetsLength=0;
|
||||
cc.offsets=testCase->getIntVector(offsetsLength, "offsets", errorCode);
|
||||
if(offsetsLength==0) {
|
||||
cc.offsets=NULL;
|
||||
} else if(offsetsLength!=unicode.length()) {
|
||||
errln("toUnicode[%d] unicode[%d] and offsets[%d] must have the same length",
|
||||
i, unicode.length(), offsetsLength);
|
||||
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
||||
}
|
||||
|
||||
cc.finalFlush= 0!=testCase->getInt28("flush", errorCode);
|
||||
cc.fallbacks= 0!=testCase->getInt28("fallbacks", errorCode);
|
||||
|
||||
s=testCase->getString("errorCode", errorCode);
|
||||
if(s==UNICODE_STRING("invalid", 7)) {
|
||||
cc.outErrorCode=U_INVALID_CHAR_FOUND;
|
||||
} else if(s==UNICODE_STRING("illegal", 7)) {
|
||||
cc.outErrorCode=U_ILLEGAL_CHAR_FOUND;
|
||||
} else if(s==UNICODE_STRING("truncated", 9)) {
|
||||
cc.outErrorCode=U_TRUNCATED_CHAR_FOUND;
|
||||
} else {
|
||||
cc.outErrorCode=U_ZERO_ERROR;
|
||||
}
|
||||
|
||||
s=testCase->getString("callback", errorCode);
|
||||
s.extract(0, 0x7fffffff, cbopt, sizeof(cbopt), "");
|
||||
cc.cbopt=cbopt;
|
||||
switch(cbopt[0]) {
|
||||
case SUB_CB:
|
||||
callback=UCNV_TO_U_CALLBACK_SUBSTITUTE;
|
||||
break;
|
||||
case SKIP_CB:
|
||||
callback=UCNV_TO_U_CALLBACK_SKIP;
|
||||
break;
|
||||
case STOP_CB:
|
||||
callback=UCNV_TO_U_CALLBACK_STOP;
|
||||
break;
|
||||
case ESC_CB:
|
||||
callback=UCNV_TO_U_CALLBACK_ESCAPE;
|
||||
break;
|
||||
default:
|
||||
callback=NULL;
|
||||
break;
|
||||
}
|
||||
option=callback==NULL ? cbopt : cbopt+1;
|
||||
if(*option==0) {
|
||||
option=NULL;
|
||||
}
|
||||
|
||||
cc.invalidChars=testCase->getBinary(cc.invalidLength, "invalidChars", errorCode);
|
||||
|
||||
if(U_FAILURE(errorCode)) {
|
||||
errln("error parsing conversion/toUnicode test case %d - %s",
|
||||
i, u_errorName(errorCode));
|
||||
errorCode=U_ZERO_ERROR;
|
||||
} else {
|
||||
ToUnicodeCase(cc, callback, option);
|
||||
}
|
||||
}
|
||||
delete testData;
|
||||
}
|
||||
delete dataModule;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ConversionTest::TestFromUnicode() {
|
||||
ConversionCase cc;
|
||||
char charset[100], cbopt[4];
|
||||
const char *option;
|
||||
UnicodeString s, unicode, invalidUChars;
|
||||
int32_t offsetsLength;
|
||||
UConverterFromUCallback callback;
|
||||
|
||||
TestLog testLog;
|
||||
TestDataModule *dataModule;
|
||||
TestData *testData;
|
||||
const DataMap *testCase;
|
||||
UErrorCode errorCode;
|
||||
int32_t i;
|
||||
|
||||
errorCode=U_ZERO_ERROR;
|
||||
dataModule=TestDataModule::getTestDataModule("conversion", testLog, errorCode);
|
||||
if(U_SUCCESS(errorCode)) {
|
||||
testData=dataModule->createTestData("fromUnicode", errorCode);
|
||||
if(U_SUCCESS(errorCode)) {
|
||||
for(i=0; testData->nextCase(testCase, errorCode); ++i) {
|
||||
cc.caseNr=i;
|
||||
|
||||
s=testCase->getString("charset", errorCode);
|
||||
s.extract(0, 0x7fffffff, charset, sizeof(charset), "");
|
||||
cc.charset=charset;
|
||||
|
||||
unicode=testCase->getString("unicode", errorCode);
|
||||
cc.unicode=unicode.getBuffer();
|
||||
cc.unicodeLength=unicode.length();
|
||||
cc.bytes=testCase->getBinary(cc.bytesLength, "bytes", errorCode);
|
||||
|
||||
offsetsLength=0;
|
||||
cc.offsets=testCase->getIntVector(offsetsLength, "offsets", errorCode);
|
||||
if(offsetsLength==0) {
|
||||
cc.offsets=NULL;
|
||||
} else if(offsetsLength!=cc.bytesLength) {
|
||||
errln("fromUnicode[%d] bytes[%d] and offsets[%d] must have the same length",
|
||||
i, cc.bytesLength, offsetsLength);
|
||||
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
||||
}
|
||||
|
||||
cc.finalFlush= 0!=testCase->getInt28("flush", errorCode);
|
||||
cc.fallbacks= 0!=testCase->getInt28("fallbacks", errorCode);
|
||||
|
||||
s=testCase->getString("errorCode", errorCode);
|
||||
if(s==UNICODE_STRING("invalid", 7)) {
|
||||
cc.outErrorCode=U_INVALID_CHAR_FOUND;
|
||||
} else if(s==UNICODE_STRING("illegal", 7)) {
|
||||
cc.outErrorCode=U_ILLEGAL_CHAR_FOUND;
|
||||
} else if(s==UNICODE_STRING("truncated", 9)) {
|
||||
cc.outErrorCode=U_TRUNCATED_CHAR_FOUND;
|
||||
} else {
|
||||
cc.outErrorCode=U_ZERO_ERROR;
|
||||
}
|
||||
|
||||
s=testCase->getString("callback", errorCode);
|
||||
s.extract(0, 0x7fffffff, cbopt, sizeof(cbopt), "");
|
||||
cc.cbopt=cbopt;
|
||||
switch(cbopt[0]) {
|
||||
case SUB_CB:
|
||||
callback=UCNV_FROM_U_CALLBACK_SUBSTITUTE;
|
||||
break;
|
||||
case SKIP_CB:
|
||||
callback=UCNV_FROM_U_CALLBACK_SKIP;
|
||||
break;
|
||||
case STOP_CB:
|
||||
callback=UCNV_FROM_U_CALLBACK_STOP;
|
||||
break;
|
||||
case ESC_CB:
|
||||
callback=UCNV_FROM_U_CALLBACK_ESCAPE;
|
||||
break;
|
||||
default:
|
||||
callback=NULL;
|
||||
break;
|
||||
}
|
||||
option=callback==NULL ? cbopt : cbopt+1;
|
||||
if(*option==0) {
|
||||
option=NULL;
|
||||
}
|
||||
|
||||
invalidUChars=testCase->getString("invalidUChars", errorCode);
|
||||
cc.invalidUChars=invalidUChars.getBuffer();
|
||||
cc.invalidLength=invalidUChars.length();
|
||||
|
||||
if(U_FAILURE(errorCode)) {
|
||||
errln("error parsing conversion/fromUnicode test case %d - %s",
|
||||
i, u_errorName(errorCode));
|
||||
errorCode=U_ZERO_ERROR;
|
||||
} else {
|
||||
FromUnicodeCase(cc, callback, option);
|
||||
}
|
||||
}
|
||||
delete testData;
|
||||
}
|
||||
delete dataModule;
|
||||
}
|
||||
}
|
||||
|
||||
// output helpers ---------------------------------------------------------- ***
|
||||
|
||||
static U_INLINE char
|
||||
hexDigit(uint8_t digit) {
|
||||
return digit<=9 ? (char)('0'+digit) : (char)('a'-10+digit);
|
||||
}
|
||||
|
||||
static char *
|
||||
printBytes(const uint8_t *bytes, int32_t length, char *out) {
|
||||
uint8_t b;
|
||||
|
||||
if(length>0) {
|
||||
b=*bytes++;
|
||||
--length;
|
||||
*out++=hexDigit((uint8_t)(b>>4));
|
||||
*out++=hexDigit((uint8_t)(b&0xf));
|
||||
}
|
||||
|
||||
while(length>0) {
|
||||
b=*bytes++;
|
||||
--length;
|
||||
*out++=' ';
|
||||
*out++=hexDigit((uint8_t)(b>>4));
|
||||
*out++=hexDigit((uint8_t)(b&0xf));
|
||||
}
|
||||
*out++=0;
|
||||
return out;
|
||||
}
|
||||
|
||||
static char *
|
||||
printUnicode(const UChar *unicode, int32_t length, char *out) {
|
||||
UChar32 c;
|
||||
int32_t i;
|
||||
|
||||
for(i=0; i<length;) {
|
||||
if(i>0) {
|
||||
*out++=' ';
|
||||
}
|
||||
U16_NEXT(unicode, i, length, c);
|
||||
// write 4..6 digits
|
||||
if(c>=0x100000) {
|
||||
*out++='1';
|
||||
}
|
||||
if(c>=0x10000) {
|
||||
*out++=hexDigit((uint8_t)((c>>16)&0xf));
|
||||
}
|
||||
*out++=hexDigit((uint8_t)((c>>12)&0xf));
|
||||
*out++=hexDigit((uint8_t)((c>>8)&0xf));
|
||||
*out++=hexDigit((uint8_t)((c>>4)&0xf));
|
||||
*out++=hexDigit((uint8_t)(c&0xf));
|
||||
}
|
||||
*out++=0;
|
||||
return out;
|
||||
}
|
||||
|
||||
static char *
|
||||
printOffsets(const int32_t *offsets, int32_t length, char *out) {
|
||||
int32_t i, o, d;
|
||||
|
||||
if(offsets==NULL) {
|
||||
length=0;
|
||||
}
|
||||
|
||||
for(i=0; i<length; ++i) {
|
||||
if(i>0) {
|
||||
*out++=' ';
|
||||
}
|
||||
o=offsets[i];
|
||||
|
||||
// print all offsets with 2 characters each (-x, -9..99, xx)
|
||||
if(o<-9) {
|
||||
*out++='-';
|
||||
*out++='x';
|
||||
} else if(o<0) {
|
||||
*out++='-';
|
||||
*out++=(char)('0'-o);
|
||||
} else if(o<=99) {
|
||||
*out++=(d=o/10)==0 ? ' ' : (char)('0'+d);
|
||||
*out++=(char)('0'+o%10);
|
||||
} else /* o>99 */ {
|
||||
*out++='x';
|
||||
*out++='x';
|
||||
}
|
||||
}
|
||||
*out++=0;
|
||||
return out;
|
||||
}
|
||||
|
||||
// toUnicode test worker functions ----------------------------------------- ***
|
||||
|
||||
static int32_t
|
||||
stepToUnicode(ConversionCase &cc, UConverter *cnv,
|
||||
UChar *result, int32_t resultCapacity,
|
||||
int32_t *resultOffsets, /* also resultCapacity */
|
||||
int32_t step,
|
||||
UErrorCode *pErrorCode) {
|
||||
const char *source, *sourceLimit, *bytesLimit;
|
||||
UChar *target, *targetLimit, *resultLimit;
|
||||
UBool flush;
|
||||
|
||||
source=(const char *)cc.bytes;
|
||||
target=result;
|
||||
bytesLimit=source+cc.bytesLength;
|
||||
resultLimit=result+resultCapacity;
|
||||
|
||||
if(step>=0) {
|
||||
// call ucnv_toUnicode() with in/out buffers no larger than (step) at a time
|
||||
// move only one buffer (in vs. out) at a time to be extra mean
|
||||
// step==0 performs bulk conversion and generates offsets
|
||||
|
||||
// initialize the partial limits for the loop
|
||||
if(step==0) {
|
||||
// use the entire buffers
|
||||
sourceLimit=bytesLimit;
|
||||
targetLimit=resultLimit;
|
||||
flush=cc.finalFlush;
|
||||
} else {
|
||||
// start with empty partial buffers
|
||||
sourceLimit=source;
|
||||
targetLimit=target;
|
||||
flush=FALSE;
|
||||
|
||||
// output offsets only for bulk conversion
|
||||
resultOffsets=NULL;
|
||||
}
|
||||
|
||||
for(;;) {
|
||||
// resetting the opposite conversion direction must not affect this one
|
||||
ucnv_resetFromUnicode(cnv);
|
||||
|
||||
// convert
|
||||
ucnv_toUnicode(cnv,
|
||||
&target, targetLimit,
|
||||
&source, sourceLimit,
|
||||
resultOffsets,
|
||||
flush, pErrorCode);
|
||||
|
||||
// check pointers and errors
|
||||
if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
|
||||
if(target!=targetLimit) {
|
||||
// buffer overflow must only be set when the target is filled
|
||||
*pErrorCode=U_INTERNAL_PROGRAM_ERROR;
|
||||
break;
|
||||
} else if(targetLimit==resultLimit) {
|
||||
// not just a partial overflow
|
||||
break;
|
||||
}
|
||||
|
||||
// the partial target is filled, set a new limit, reset the error and continue
|
||||
targetLimit=(resultLimit-target)>=step ? target+step : resultLimit;
|
||||
*pErrorCode=U_ZERO_ERROR;
|
||||
} else if(U_FAILURE(*pErrorCode)) {
|
||||
// some other error occurred, done
|
||||
break;
|
||||
} else {
|
||||
if(source!=sourceLimit) {
|
||||
// when no error occurs, then the input must be consumed
|
||||
*pErrorCode=U_INTERNAL_PROGRAM_ERROR;
|
||||
break;
|
||||
}
|
||||
|
||||
if(sourceLimit==bytesLimit) {
|
||||
// we are done
|
||||
break;
|
||||
}
|
||||
|
||||
// the partial conversion succeeded, set a new limit and continue
|
||||
sourceLimit=(bytesLimit-source)>=step ? source+step : bytesLimit;
|
||||
flush=(UBool)(cc.finalFlush && sourceLimit==bytesLimit);
|
||||
}
|
||||
}
|
||||
} else /* step<0 */ {
|
||||
// step==-1 or -2: call ucnv_toUnicode() and ucnv_getNextUChar() alternatingly
|
||||
// step==-3: call only ucnv_getNextUChar()
|
||||
UChar32 c;
|
||||
|
||||
// end the loop by getting an index out of bounds error
|
||||
for(;;) {
|
||||
// resetting the opposite conversion direction must not affect this one
|
||||
ucnv_resetFromUnicode(cnv);
|
||||
|
||||
// convert
|
||||
if((step&1)!=0 /* odd: -1 or -3 */) {
|
||||
sourceLimit=source; // use sourceLimit not as a real limit
|
||||
// but to remember the pre-getNextUChar source pointer
|
||||
c=ucnv_getNextUChar(cnv, &source, bytesLimit, pErrorCode);
|
||||
|
||||
// check pointers and errors
|
||||
if(*pErrorCode==U_INDEX_OUTOFBOUNDS_ERROR) {
|
||||
if(source!=bytesLimit) {
|
||||
*pErrorCode=U_INTERNAL_PROGRAM_ERROR;
|
||||
} else {
|
||||
*pErrorCode=U_ZERO_ERROR;
|
||||
}
|
||||
break;
|
||||
} else if(U_FAILURE(*pErrorCode)) {
|
||||
break;
|
||||
}
|
||||
// source may not move if c is from previous overflow
|
||||
|
||||
if(target==resultLimit) {
|
||||
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
|
||||
break;
|
||||
}
|
||||
if(c<=0xffff) {
|
||||
*target++=(UChar)c;
|
||||
} else {
|
||||
*target++=U16_LEAD(c);
|
||||
if(target==resultLimit) {
|
||||
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
|
||||
break;
|
||||
}
|
||||
*target++=U16_TRAIL(c);
|
||||
}
|
||||
|
||||
// alternate between -1 and -2 but leave -3 alone
|
||||
if(step==-1) {
|
||||
step=-2;
|
||||
}
|
||||
} else /* step==-2 */ {
|
||||
// allow only one UChar output
|
||||
targetLimit=target<resultLimit ? target+1 : resultLimit;
|
||||
|
||||
// as with ucnv_getNextUChar(), we always flush and never output offsets
|
||||
ucnv_toUnicode(cnv,
|
||||
&target, targetLimit,
|
||||
&source, bytesLimit,
|
||||
NULL, TRUE, pErrorCode);
|
||||
|
||||
// check pointers and errors
|
||||
if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
|
||||
if(target!=targetLimit) {
|
||||
// buffer overflow must only be set when the target is filled
|
||||
*pErrorCode=U_INTERNAL_PROGRAM_ERROR;
|
||||
break;
|
||||
} else if(targetLimit==resultLimit) {
|
||||
// not just a partial overflow
|
||||
break;
|
||||
}
|
||||
|
||||
// the partial target is filled, set a new limit and continue
|
||||
*pErrorCode=U_ZERO_ERROR;
|
||||
} else if(U_FAILURE(*pErrorCode)) {
|
||||
// some other error occurred, done
|
||||
break;
|
||||
} else {
|
||||
if(source!=bytesLimit) {
|
||||
// when no error occurs, then the input must be consumed
|
||||
*pErrorCode=U_INTERNAL_PROGRAM_ERROR;
|
||||
break;
|
||||
}
|
||||
|
||||
// we are done (flush==TRUE) but we continue, to get the index out of bounds error above
|
||||
}
|
||||
|
||||
step=-1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (int32_t)(target-result);
|
||||
}
|
||||
|
||||
UBool
|
||||
ConversionTest::ToUnicodeCase(ConversionCase &cc, UConverterToUCallback callback, const char *option) {
|
||||
UConverter *cnv;
|
||||
UErrorCode errorCode;
|
||||
|
||||
// open the converter
|
||||
errorCode=U_ZERO_ERROR;
|
||||
cnv=ucnv_open(cc.charset, &errorCode);
|
||||
if(U_FAILURE(errorCode)) {
|
||||
errln("toUnicode[%d](%s cb=\"%s\" fb=%d flush=%d) ucnv_open() failed - %s",
|
||||
cc.caseNr, cc.charset, cc.cbopt, cc.fallbacks, cc.finalFlush, u_errorName(errorCode));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// set the callback
|
||||
if(callback!=NULL) {
|
||||
ucnv_setToUCallBack(cnv, callback, option, NULL, NULL, &errorCode);
|
||||
if(U_FAILURE(errorCode)) {
|
||||
errln("toUnicode[%d](%s cb=\"%s\" fb=%d flush=%d) ucnv_setToUCallBack() failed - %s",
|
||||
cc.caseNr, cc.charset, cc.cbopt, cc.fallbacks, cc.finalFlush, u_errorName(errorCode));
|
||||
ucnv_close(cnv);
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t resultOffsets[200];
|
||||
UChar result[200];
|
||||
int32_t resultLength;
|
||||
|
||||
static const struct {
|
||||
int32_t step;
|
||||
const char *name;
|
||||
} steps[]={
|
||||
{ 0, "bulk" }, // must be first for offsets to be checked
|
||||
{ 1, "step=1" },
|
||||
{ 3, "step=3" },
|
||||
{ 7, "step=7" },
|
||||
{ -3, "getNext" },
|
||||
{ -1, "getNext+toU" },
|
||||
{ -2, "toU+getNext" }
|
||||
};
|
||||
int32_t i, step;
|
||||
|
||||
for(i=0; i<LENGTHOF(steps); ++i) {
|
||||
step=steps[i].step;
|
||||
if(step!=0) {
|
||||
// bulk test is first, then offsets are not checked any more
|
||||
cc.offsets=NULL;
|
||||
}
|
||||
errorCode=U_ZERO_ERROR;
|
||||
resultLength=stepToUnicode(cc, cnv,
|
||||
result, LENGTHOF(result),
|
||||
step==0 ? resultOffsets : NULL,
|
||||
step, &errorCode);
|
||||
if(!checkToUnicode(
|
||||
cc, cnv, steps[i].name,
|
||||
result, resultLength,
|
||||
cc.offsets!=NULL ? resultOffsets : NULL,
|
||||
errorCode)
|
||||
) {
|
||||
return FALSE;
|
||||
}
|
||||
ucnv_resetToUnicode(cnv);
|
||||
}
|
||||
|
||||
ucnv_close(cnv);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
UBool
|
||||
ConversionTest::checkToUnicode(ConversionCase &cc, UConverter *cnv, const char *name,
|
||||
const UChar *result, int32_t resultLength,
|
||||
const int32_t *resultOffsets,
|
||||
UErrorCode resultErrorCode) {
|
||||
char resultInvalidChars[8];
|
||||
int8_t resultInvalidLength;
|
||||
UErrorCode errorCode;
|
||||
|
||||
const char *msg;
|
||||
|
||||
// reset the message; NULL will mean "ok"
|
||||
msg=NULL;
|
||||
|
||||
errorCode=U_ZERO_ERROR;
|
||||
resultInvalidLength=sizeof(resultInvalidChars);
|
||||
ucnv_getInvalidChars(cnv, resultInvalidChars, &resultInvalidLength, &errorCode);
|
||||
if(U_FAILURE(errorCode)) {
|
||||
errln("toUnicode[%d](%s cb=\"%s\" fb=%d flush=%d %s) ucnv_getInvalidChars() failed - %s",
|
||||
cc.caseNr, cc.charset, cc.cbopt, cc.fallbacks, cc.finalFlush, name, u_errorName(errorCode));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// check everything that might have gone wrong
|
||||
if(cc.unicodeLength!=resultLength) {
|
||||
msg="wrong result length";
|
||||
} else if(0!=u_memcmp(cc.unicode, result, cc.unicodeLength)) {
|
||||
msg="wrong result string";
|
||||
} else if(cc.offsets!=NULL && 0!=memcmp(cc.offsets, resultOffsets, cc.unicodeLength*sizeof(*cc.offsets))) {
|
||||
msg="wrong offsets";
|
||||
} else if(cc.outErrorCode!=resultErrorCode) {
|
||||
msg="wrong error code";
|
||||
} else if(cc.invalidLength!=resultInvalidLength) {
|
||||
msg="wrong length of last invalid input";
|
||||
} else if(0!=memcmp(cc.invalidChars, resultInvalidChars, cc.invalidLength)) {
|
||||
msg="wrong last invalid input";
|
||||
}
|
||||
|
||||
if(msg==NULL) {
|
||||
return TRUE;
|
||||
} else {
|
||||
char buffer[2000]; // one buffer for all strings
|
||||
char *s, *bytesString, *unicodeString, *resultString,
|
||||
*offsetsString, *resultOffsetsString,
|
||||
*invalidCharsString, *resultInvalidCharsString;
|
||||
|
||||
bytesString=s=buffer;
|
||||
s=printBytes(cc.bytes, cc.bytesLength, bytesString);
|
||||
s=printUnicode(cc.unicode, cc.unicodeLength, unicodeString=s);
|
||||
s=printUnicode(result, resultLength, resultString=s);
|
||||
s=printOffsets(cc.offsets, cc.unicodeLength, offsetsString=s);
|
||||
s=printOffsets(resultOffsets, resultLength, resultOffsetsString=s);
|
||||
s=printBytes(cc.invalidChars, cc.invalidLength, invalidCharsString=s);
|
||||
s=printBytes((uint8_t *)resultInvalidChars, resultInvalidLength, resultInvalidCharsString=s);
|
||||
|
||||
if((s-buffer)>sizeof(buffer)) {
|
||||
errln("toUnicode[%d](%s cb=\"%s\" fb=%d flush=%d %s) fatal error: checkToUnicode() test output buffer overflow writing %d chars\n",
|
||||
cc.caseNr, cc.charset, cc.cbopt, cc.fallbacks, cc.finalFlush, name, (int)(s-buffer));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
errln("toUnicode[%d](%s cb=\"%s\" fb=%d flush=%d %s) failed: %s\n"
|
||||
" bytes <%s>[%d]\n"
|
||||
" expected <%s>[%d]\n"
|
||||
" result <%s>[%d]\n"
|
||||
" offsets <%s>\n"
|
||||
" result offsets <%s>\n"
|
||||
" error code expected %s got %s\n"
|
||||
" invalidChars expected <%s> got <%s>\n",
|
||||
cc.caseNr, cc.charset, cc.cbopt, cc.fallbacks, cc.finalFlush, name, msg,
|
||||
bytesString, cc.bytesLength,
|
||||
unicodeString, cc.unicodeLength,
|
||||
resultString, resultLength,
|
||||
offsetsString,
|
||||
resultOffsetsString,
|
||||
u_errorName(cc.outErrorCode), u_errorName(resultErrorCode),
|
||||
invalidCharsString, resultInvalidCharsString);
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
// fromUnicode test worker functions --------------------------------------- ***
|
||||
|
||||
static int32_t
|
||||
stepFromUnicode(ConversionCase &cc, UConverter *cnv,
|
||||
char *result, int32_t resultCapacity,
|
||||
int32_t *resultOffsets, /* also resultCapacity */
|
||||
int32_t step,
|
||||
UErrorCode *pErrorCode) {
|
||||
const UChar *source, *sourceLimit, *unicodeLimit;
|
||||
char *target, *targetLimit, *resultLimit;
|
||||
UBool flush;
|
||||
|
||||
source=cc.unicode;
|
||||
target=result;
|
||||
unicodeLimit=source+cc.unicodeLength;
|
||||
resultLimit=result+resultCapacity;
|
||||
|
||||
// call ucnv_fromUnicode() with in/out buffers no larger than (step) at a time
|
||||
// move only one buffer (in vs. out) at a time to be extra mean
|
||||
// step==0 performs bulk conversion and generates offsets
|
||||
|
||||
// initialize the partial limits for the loop
|
||||
if(step==0) {
|
||||
// use the entire buffers
|
||||
sourceLimit=unicodeLimit;
|
||||
targetLimit=resultLimit;
|
||||
flush=cc.finalFlush;
|
||||
} else {
|
||||
// start with empty partial buffers
|
||||
sourceLimit=source;
|
||||
targetLimit=target;
|
||||
flush=FALSE;
|
||||
|
||||
// output offsets only for bulk conversion
|
||||
resultOffsets=NULL;
|
||||
}
|
||||
|
||||
for(;;) {
|
||||
// resetting the opposite conversion direction must not affect this one
|
||||
ucnv_resetToUnicode(cnv);
|
||||
|
||||
// convert
|
||||
ucnv_fromUnicode(cnv,
|
||||
&target, targetLimit,
|
||||
&source, sourceLimit,
|
||||
resultOffsets,
|
||||
flush, pErrorCode);
|
||||
|
||||
// check pointers and errors
|
||||
if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR) {
|
||||
if(target!=targetLimit) {
|
||||
// buffer overflow must only be set when the target is filled
|
||||
*pErrorCode=U_INTERNAL_PROGRAM_ERROR;
|
||||
break;
|
||||
} else if(targetLimit==resultLimit) {
|
||||
// not just a partial overflow
|
||||
break;
|
||||
}
|
||||
|
||||
// the partial target is filled, set a new limit, reset the error and continue
|
||||
targetLimit=(resultLimit-target)>=step ? target+step : resultLimit;
|
||||
*pErrorCode=U_ZERO_ERROR;
|
||||
} else if(U_FAILURE(*pErrorCode)) {
|
||||
// some other error occurred, done
|
||||
break;
|
||||
} else {
|
||||
if(source!=sourceLimit) {
|
||||
// when no error occurs, then the input must be consumed
|
||||
*pErrorCode=U_INTERNAL_PROGRAM_ERROR;
|
||||
break;
|
||||
}
|
||||
|
||||
if(sourceLimit==unicodeLimit) {
|
||||
// we are done
|
||||
break;
|
||||
}
|
||||
|
||||
// the partial conversion succeeded, set a new limit and continue
|
||||
sourceLimit=(unicodeLimit-source)>=step ? source+step : unicodeLimit;
|
||||
flush=(UBool)(cc.finalFlush && sourceLimit==unicodeLimit);
|
||||
}
|
||||
}
|
||||
|
||||
return (int32_t)(target-result);
|
||||
}
|
||||
|
||||
UBool
|
||||
ConversionTest::FromUnicodeCase(ConversionCase &cc, UConverterFromUCallback callback, const char *option) {
|
||||
UConverter *cnv;
|
||||
UErrorCode errorCode;
|
||||
|
||||
// open the converter
|
||||
errorCode=U_ZERO_ERROR;
|
||||
cnv=ucnv_open(cc.charset, &errorCode);
|
||||
if(U_FAILURE(errorCode)) {
|
||||
errln("fromUnicode[%d](%s cb=\"%s\" fb=%d flush=%d) ucnv_open() failed - %s",
|
||||
cc.caseNr, cc.charset, cc.cbopt, cc.fallbacks, cc.finalFlush, u_errorName(errorCode));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// set the callback
|
||||
if(callback!=NULL) {
|
||||
ucnv_setFromUCallBack(cnv, callback, option, NULL, NULL, &errorCode);
|
||||
if(U_FAILURE(errorCode)) {
|
||||
errln("fromUnicode[%d](%s cb=\"%s\" fb=%d flush=%d) ucnv_setFromUCallBack() failed - %s",
|
||||
cc.caseNr, cc.charset, cc.cbopt, cc.fallbacks, cc.finalFlush, u_errorName(errorCode));
|
||||
ucnv_close(cnv);
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
// set the fallbacks flag
|
||||
// TODO change with Jitterbug 2401, then add a similar call for toUnicode too
|
||||
ucnv_setFallback(cnv, cc.fallbacks);
|
||||
|
||||
int32_t resultOffsets[200];
|
||||
char result[200];
|
||||
int32_t resultLength;
|
||||
|
||||
static const struct {
|
||||
int32_t step;
|
||||
const char *name;
|
||||
} steps[]={
|
||||
{ 0, "bulk" }, // must be first for offsets to be checked
|
||||
{ 1, "step=1" },
|
||||
{ 3, "step=3" },
|
||||
{ 7, "step=7" }
|
||||
};
|
||||
int32_t i, step;
|
||||
|
||||
for(i=0; i<LENGTHOF(steps); ++i) {
|
||||
step=steps[i].step;
|
||||
if(step!=0) {
|
||||
// bulk test is first, then offsets are not checked any more
|
||||
cc.offsets=NULL;
|
||||
}
|
||||
errorCode=U_ZERO_ERROR;
|
||||
resultLength=stepFromUnicode(cc, cnv,
|
||||
result, LENGTHOF(result),
|
||||
step==0 ? resultOffsets : NULL,
|
||||
step, &errorCode);
|
||||
if(!checkFromUnicode(
|
||||
cc, cnv, steps[i].name,
|
||||
(uint8_t *)result, resultLength,
|
||||
cc.offsets!=NULL ? resultOffsets : NULL,
|
||||
errorCode)
|
||||
) {
|
||||
return FALSE;
|
||||
}
|
||||
ucnv_resetFromUnicode(cnv);
|
||||
}
|
||||
|
||||
ucnv_close(cnv);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
UBool
|
||||
ConversionTest::checkFromUnicode(ConversionCase &cc, UConverter *cnv, const char *name,
|
||||
const uint8_t *result, int32_t resultLength,
|
||||
const int32_t *resultOffsets,
|
||||
UErrorCode resultErrorCode) {
|
||||
UChar resultInvalidUChars[8];
|
||||
int8_t resultInvalidLength;
|
||||
UErrorCode errorCode;
|
||||
|
||||
const char *msg;
|
||||
|
||||
// reset the message; NULL will mean "ok"
|
||||
msg=NULL;
|
||||
|
||||
errorCode=U_ZERO_ERROR;
|
||||
resultInvalidLength=LENGTHOF(resultInvalidUChars);
|
||||
ucnv_getInvalidUChars(cnv, resultInvalidUChars, &resultInvalidLength, &errorCode);
|
||||
if(U_FAILURE(errorCode)) {
|
||||
errln("fromUnicode[%d](%s cb=\"%s\" fb=%d flush=%d %s) ucnv_getInvalidUChars() failed - %s",
|
||||
cc.caseNr, cc.charset, cc.cbopt, cc.fallbacks, cc.finalFlush, name, u_errorName(errorCode));
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// check everything that might have gone wrong
|
||||
if(cc.bytesLength!=resultLength) {
|
||||
msg="wrong result length";
|
||||
} else if(0!=memcmp(cc.bytes, result, cc.bytesLength)) {
|
||||
msg="wrong result string";
|
||||
} else if(cc.offsets!=NULL && 0!=memcmp(cc.offsets, resultOffsets, cc.bytesLength*sizeof(*cc.offsets))) {
|
||||
msg="wrong offsets";
|
||||
} else if(cc.outErrorCode!=resultErrorCode) {
|
||||
msg="wrong error code";
|
||||
} else if(cc.invalidLength!=resultInvalidLength) {
|
||||
msg="wrong length of last invalid input";
|
||||
} else if(0!=u_memcmp(cc.invalidUChars, resultInvalidUChars, cc.invalidLength)) {
|
||||
msg="wrong last invalid input";
|
||||
}
|
||||
|
||||
if(msg==NULL) {
|
||||
return TRUE;
|
||||
} else {
|
||||
char buffer[2000]; // one buffer for all strings
|
||||
char *s, *unicodeString, *bytesString, *resultString,
|
||||
*offsetsString, *resultOffsetsString,
|
||||
*invalidCharsString, *resultInvalidUCharsString;
|
||||
|
||||
unicodeString=s=buffer;
|
||||
s=printUnicode(cc.unicode, cc.unicodeLength, unicodeString);
|
||||
s=printBytes(cc.bytes, cc.bytesLength, bytesString=s);
|
||||
s=printBytes(result, resultLength, resultString=s);
|
||||
s=printOffsets(cc.offsets, cc.bytesLength, offsetsString=s);
|
||||
s=printOffsets(resultOffsets, resultLength, resultOffsetsString=s);
|
||||
s=printUnicode(cc.invalidUChars, cc.invalidLength, invalidCharsString=s);
|
||||
s=printUnicode(resultInvalidUChars, resultInvalidLength, resultInvalidUCharsString=s);
|
||||
|
||||
if((s-buffer)>sizeof(buffer)) {
|
||||
errln("fromUnicode[%d](%s cb=\"%s\" fb=%d flush=%d %s) fatal error: checkFromUnicode() test output buffer overflow writing %d chars\n",
|
||||
cc.caseNr, cc.charset, cc.cbopt, cc.fallbacks, cc.finalFlush, name, (int)(s-buffer));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
errln("fromUnicode[%d](%s cb=\"%s\" fb=%d flush=%d %s) failed: %s\n"
|
||||
" unicode <%s>[%d]\n"
|
||||
" expected <%s>[%d]\n"
|
||||
" result <%s>[%d]\n"
|
||||
" offsets <%s>\n"
|
||||
" result offsets <%s>\n"
|
||||
" error code expected %s got %s\n"
|
||||
" invalidChars expected <%s> got <%s>\n",
|
||||
cc.caseNr, cc.charset, cc.cbopt, cc.fallbacks, cc.finalFlush, name, msg,
|
||||
unicodeString, cc.unicodeLength,
|
||||
bytesString, cc.bytesLength,
|
||||
resultString, resultLength,
|
||||
offsetsString,
|
||||
resultOffsetsString,
|
||||
u_errorName(cc.outErrorCode), u_errorName(resultErrorCode),
|
||||
invalidCharsString, resultInvalidUCharsString);
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
}
|
||||
81
icu4c/source/test/intltest/convtest.h
Normal file
81
icu4c/source/test/intltest/convtest.h
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
/*
|
||||
*******************************************************************************
|
||||
*
|
||||
* Copyright (C) 2003, International Business Machines
|
||||
* Corporation and others. All Rights Reserved.
|
||||
*
|
||||
*******************************************************************************
|
||||
* file name: convtest.h
|
||||
* encoding: US-ASCII
|
||||
* tab size: 8 (not used)
|
||||
* indentation:4
|
||||
*
|
||||
* created on: 2003jul15
|
||||
* created by: Markus W. Scherer
|
||||
*
|
||||
* Test file for data-driven conversion tests.
|
||||
*/
|
||||
|
||||
#ifndef __CONVTEST_H__
|
||||
#define __CONVTEST_H__
|
||||
|
||||
#include "unicode/utypes.h"
|
||||
#include "unicode/ucnv.h"
|
||||
#include "intltest.h"
|
||||
|
||||
struct ConversionCase {
|
||||
int32_t caseNr;
|
||||
const char *charset, *cbopt, *name;
|
||||
|
||||
const uint8_t *bytes;
|
||||
int32_t bytesLength;
|
||||
const UChar *unicode;
|
||||
int32_t unicodeLength;
|
||||
const int32_t *offsets;
|
||||
|
||||
UBool finalFlush;
|
||||
UBool fallbacks;
|
||||
UErrorCode outErrorCode;
|
||||
const uint8_t *invalidChars;
|
||||
const UChar *invalidUChars;
|
||||
int32_t invalidLength;
|
||||
|
||||
uint8_t resultBytes[200];
|
||||
UChar resultUnicode[200];
|
||||
int32_t resultOffsets[200];
|
||||
int32_t resultLength;
|
||||
|
||||
UErrorCode resultErrorCode;
|
||||
};
|
||||
|
||||
class ConversionTest : public IntlTest {
|
||||
public:
|
||||
ConversionTest() {}
|
||||
virtual ~ConversionTest() {}
|
||||
|
||||
void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
|
||||
|
||||
void TestToUnicode();
|
||||
void TestFromUnicode();
|
||||
|
||||
private:
|
||||
UBool
|
||||
ToUnicodeCase(ConversionCase &cc, UConverterToUCallback callback, const char *option);
|
||||
|
||||
UBool
|
||||
FromUnicodeCase(ConversionCase &cc, UConverterFromUCallback callback, const char *option);
|
||||
|
||||
UBool
|
||||
checkToUnicode(ConversionCase &cc, UConverter *cnv, const char *name,
|
||||
const UChar *result, int32_t resultLength,
|
||||
const int32_t *resultOffsets,
|
||||
UErrorCode resultErrorCode);
|
||||
|
||||
UBool
|
||||
checkFromUnicode(ConversionCase &cc, UConverter *cnv, const char *name,
|
||||
const uint8_t *result, int32_t resultLength,
|
||||
const int32_t *resultOffsets,
|
||||
UErrorCode resultErrorCode);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -411,6 +411,18 @@ SOURCE=.\tsputil.cpp
|
|||
SOURCE=.\tsputil.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "conversion"
|
||||
|
||||
# PROP Default_Filter ""
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\convtest.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\convtest.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "data & memory"
|
||||
|
||||
# PROP Default_Filter ""
|
||||
|
|
@ -703,6 +715,46 @@ SOURCE=.\restsnew.cpp
|
|||
SOURCE=.\restsnew.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "idna"
|
||||
|
||||
# PROP Default_Filter "*.c,*.h"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\idnaref.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\idnaref.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\nptrans.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\nptrans.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\punyref.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\punyref.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\testidn.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\testidna.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\testidna.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "misc"
|
||||
|
||||
# PROP Default_Filter ""
|
||||
|
|
@ -963,45 +1015,5 @@ SOURCE=.\unhxtrts.cpp
|
|||
SOURCE=.\unhxtrts.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# Begin Group "idna"
|
||||
|
||||
# PROP Default_Filter "*.c,*.h"
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\idnaref.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\idnaref.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\nptrans.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\nptrans.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\punyref.c
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\punyref.h
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\testidn.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\testidna.cpp
|
||||
# End Source File
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\testidna.h
|
||||
# End Source File
|
||||
# End Group
|
||||
# End Target
|
||||
# End Project
|
||||
|
|
|
|||
|
|
@ -20,7 +20,6 @@
|
|||
#include "itutil.h"
|
||||
#include "tscoll.h"
|
||||
#include "itformat.h"
|
||||
//%#include "itconv.h"
|
||||
#include "ittrans.h"
|
||||
#include "itrbbi.h"
|
||||
#include "itrbnf.h"
|
||||
|
|
@ -31,6 +30,8 @@
|
|||
#include "canittst.h"
|
||||
#include "icusvtst.h"
|
||||
#include "testidna.h"
|
||||
#include "convtest.h"
|
||||
|
||||
#define CASE_SUITE(id, suite) case id: \
|
||||
name = #suite; \
|
||||
if(exec) { \
|
||||
|
|
@ -147,6 +148,14 @@ void MajorTestLevel::runIndexedTest( int32_t index, UBool exec, const char* &nam
|
|||
}
|
||||
#endif
|
||||
break;
|
||||
case 11: name = "conversion";
|
||||
if (exec) {
|
||||
logln("TestSuite Conversion---"); logln();
|
||||
ConversionTest test;
|
||||
callTest( test, par );
|
||||
}
|
||||
break;
|
||||
|
||||
default: name = ""; break;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
66
icu4c/source/test/testdata/conversion.txt
vendored
Normal file
66
icu4c/source/test/testdata/conversion.txt
vendored
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
//*******************************************************************************
|
||||
//
|
||||
// Copyright (C) 2003, International Business Machines
|
||||
// Corporation and others. All Rights Reserved.
|
||||
//
|
||||
//*******************************************************************************
|
||||
|
||||
conversion {
|
||||
Info {
|
||||
Description { "Test data for conversion" }
|
||||
LongDescription {
|
||||
"Test data for data-driven conversion tests in icu/source/test/intltest/convtest.cpp\n"
|
||||
"Run intltest conversion\n"
|
||||
|
||||
"ICU callbacks are specified as strings with pairs of characters, each optional.\n"
|
||||
"Callback function - '?'=Sub '0'=Skip '.'=Stop '&'=Escape\n"
|
||||
"Callback option - a letter is passed in directly as const char * see ucnv_err.h\n"
|
||||
"Empty string: Sub callback with NULL option\n"
|
||||
|
||||
"fallbacks: per-direction boolean, currently only for fromUnicode; see Jitterbug 2401\n"
|
||||
|
||||
"errorCode: (empty)==zero | invalid | illegal | truncated\n"
|
||||
}
|
||||
}
|
||||
TestData {
|
||||
toUnicode {
|
||||
Headers { "charset", "bytes", "unicode", "offsets", "flush", "fallbacks", "errorCode", "callback", "invalidChars" }
|
||||
Cases {
|
||||
// surrogates in CESU-8
|
||||
{ "CESU-8", :bin{ eda080eda081edb081 }, "\ud800\U00010401", :intvector{ 0, 3, 6 }, :int{1}, :int{0}, "", "", :bin{""} }
|
||||
// e080 is a partial sequence
|
||||
{ "UTF-8", :bin{ 31ffe4ba8ce08061 }, "1\ufffd\u4e8c\ufffda", :intvector{ 0, 1, 2, 5, 7 }, :int{1}, :int{0}, "", "", :bin{ e080 } }
|
||||
// fbbfbfbfbf exceedes U+10ffff
|
||||
{ "UTF-8", :bin{ 31fbbfbfbfbf61 }, "1\ufffda", :intvector{ 0, 1, 6 }, :int{1}, :int{0}, "", "", :bin{ fbbfbfbfbf } }
|
||||
|
||||
// lead byte a2 without trail byte
|
||||
{ "ibm-1363", :bin{ a2aea2 }, "\u00a1", :intvector{ 0 }, :int{1}, :int{0}, "truncated", ".", :bin{ a2 } }
|
||||
{ "ibm-1363", :bin{ a2aea2 }, "\u00a1\u001a", :intvector{ 0, 2 }, :int{1}, :int{0}, "", "?", :bin{ a2 } }
|
||||
|
||||
// e4b8 is a partial sequence
|
||||
{ "UTF-8", :bin{ 31e4ba8ce4b8 }, "1\u4e8c", :intvector{ 0, 1 }, :int{1}, :int{0}, "truncated", ".", :bin{ e4b8 } }
|
||||
{ "UTF-8", :bin{ 31e4ba8ce4b8 }, "1\u4e8c\ufffd", :intvector{ 0, 1, 4 }, :int{1}, :int{0}, "", "?", :bin{ e4b8 } }
|
||||
|
||||
// simple sample, no error handling
|
||||
{ "UTF-8", :bin{ 61F48FBFBF }, "a\U0010FFFF", :intvector{ 0, 1, 1 }, :int{1}, :int{0}, "", "", :bin{""} }
|
||||
}
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------- ***
|
||||
|
||||
fromUnicode {
|
||||
Headers { "charset", "unicode", "bytes", "offsets", "flush", "fallbacks", "errorCode", "callback", "invalidUChars" }
|
||||
Cases {
|
||||
// sub callback for supplementary code point
|
||||
{ "LATIN1", "1\U000104012", :bin{ 311a32 }, :intvector{ 0, 1, 3 }, :int{1}, :int{0}, "", "", "" }
|
||||
{ "ibm-920", "1\U000104012", :bin{ 311a32 }, :intvector{ 0, 1, 3 }, :int{1}, :int{0}, "", "", "" }
|
||||
// same but not flushing
|
||||
{ "LATIN1", "1\U000104012", :bin{ 311a32 }, :intvector{ 0, 1, 3 }, :int{0}, :int{0}, "", "", "\U00010401" }
|
||||
{ "ibm-920", "1\U000104012", :bin{ 311a32 }, :intvector{ 0, 1, 3 }, :int{0}, :int{0}, "", "", "\U00010401" }
|
||||
|
||||
// simple sample, no error handling
|
||||
{ "UTF-8", "a\U0010FFFF", :bin{ 61F48FBFBF }, :intvector{ 0, 1, 1, 1, 1 }, :int{1}, :int{0}, "", "", "" }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
3
icu4c/source/test/testdata/testdata.mk
vendored
3
icu4c/source/test/testdata/testdata.mk
vendored
|
|
@ -14,11 +14,12 @@ TESTDT=$(TESTPKG)_
|
|||
ALL : "$(TESTDATAOUT)\testdata.dat"
|
||||
@echo Test data is built.
|
||||
|
||||
"$(TESTDATAOUT)\testdata.dat" : "$(TESTDATABLD)\casing.res" "$(TESTDATABLD)\mc.res" "$(TESTDATABLD)\root.res" "$(TESTDATABLD)\te.res" "$(TESTDATABLD)\te_IN.res" "$(TESTDATABLD)\testaliases.res" "$(TESTDATABLD)\testtypes.res" "$(TESTDATABLD)\testempty.res" "$(TESTDATABLD)\$(TESTDT)iscii.res" "$(TESTDATABLD)\$(TESTDT)idna_rules.res" "$(TESTDATABLD)\DataDrivenCollationTest.res" $(TESTDATABLD)\$(TESTDT)test.icu "$(TESTDATABLD)\$(TESTDT)test1.cnv" "$(TESTDATABLD)\$(TESTDT)test3.cnv" "$(TESTDATABLD)\$(TESTDT)test4.cnv" "$(TESTDATABLD)\$(TESTDT)ibm9027.cnv"
|
||||
"$(TESTDATAOUT)\testdata.dat" : "$(TESTDATABLD)\casing.res" "$(TESTDATABLD)\conversion.res" "$(TESTDATABLD)\mc.res" "$(TESTDATABLD)\root.res" "$(TESTDATABLD)\te.res" "$(TESTDATABLD)\te_IN.res" "$(TESTDATABLD)\testaliases.res" "$(TESTDATABLD)\testtypes.res" "$(TESTDATABLD)\testempty.res" "$(TESTDATABLD)\$(TESTDT)iscii.res" "$(TESTDATABLD)\$(TESTDT)idna_rules.res" "$(TESTDATABLD)\DataDrivenCollationTest.res" $(TESTDATABLD)\$(TESTDT)test.icu "$(TESTDATABLD)\$(TESTDT)test1.cnv" "$(TESTDATABLD)\$(TESTDT)test3.cnv" "$(TESTDATABLD)\$(TESTDT)test4.cnv" "$(TESTDATABLD)\$(TESTDT)ibm9027.cnv"
|
||||
@echo Building test data
|
||||
@copy "$(TESTDATABLD)\$(TESTDT)te.res" "$(TESTDATAOUT)\$(TESTDT)nam.typ"
|
||||
@"$(ICUTOOLS)\pkgdata\$(CFG)\pkgdata" -f -v -m common -c -p"$(TESTPKG)" -O "$(PKGOPT)" -d "$(TESTDATAOUT)" -T "$(TESTDATABLD)" -s "$(TESTDATABLD)" <<
|
||||
$(TESTDT)casing.res
|
||||
$(TESTDT)conversion.res
|
||||
$(TESTDT)mc.res
|
||||
$(TESTDT)root.res
|
||||
$(TESTDT)te.res
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue