AuroraMiddleware/scuffed-code
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
83d22bc5dc
scuffed-code/icu4c/source/test/intltest/ucdtest.cpp

582 lines
21 KiB
C++
Raw Normal View History

ICU-161 updated the copyright notices. X-SVN-Rev: 596
2000-01-15 02:00:06 +00:00
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-1999, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
#include "ucdtest.h"
ICU-12 all public include files are now in unicode dir, all private icu_ functions renamed to uprv_ X-SVN-Rev: 473
1999-12-28 23:57:50 +00:00
#include "unicode/unicode.h"
ICU-315 S/390 and EBCDIC updates X-SVN-Rev: 977
2000-03-22 23:17:42 +00:00
#include "unicode/ustring.h"
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
#include <stdio.h>
#include <string.h>
#include <assert.h>
UnicodeTest::UnicodeTest()
{
}
UnicodeTest::~UnicodeTest()
{
}
ICU-351 Define UBool to be used in the APIs. X-SVN-Rev: 1410
2000-05-18 22:08:39 +00:00
void UnicodeTest::runIndexedTest( int32_t index, UBool exec, char* &name, char* par )
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
{
if (exec) logln("TestSuite UnicodeTest: ");
switch (index) {
case 0: name = "TestUpperLower"; if (exec) TestUpperLower(); break;
case 1: name = "TestLetterNumber"; if (exec) TestLetterNumber(); break;
case 2: name = "TestMisc"; if (exec) TestMisc(); break;
case 3: name = "TestUnicodeData"; if (exec) TestUnicodeData(); break;
ICU-176 Addional tests for UTF-16 support X-SVN-Rev: 1329
2000-05-04 17:27:16 +00:00
case 4: name = "TestCodeUnit"; if(exec) TestCodeUnit(); break;
case 5: name = "TestCodePoint"; if(exec) TestCodePoint(); break;
case 6: name = "TestCharLength"; if(exec) TestCharLength(); break;
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
default: name = ""; break; //needed to end loop
}
}
//====================================================
// private data used by the tests
//====================================================
const UChar LAST_CHAR_CODE_IN_FILE = 0xFFFD;
const char tagStrings[] = "MnMcMeNdNlNoZsZlZpCcCfCsCoCnLuLlLtLmLoPcPdPsPePoSmScSkSoPiPf";
const int32_t tagValues[] =
{
/* Mn */ Unicode::NON_SPACING_MARK,
/* Mc */ Unicode::COMBINING_SPACING_MARK,
/* Me */ Unicode::ENCLOSING_MARK,
/* Nd */ Unicode::DECIMAL_DIGIT_NUMBER,
/* Nl */ Unicode::LETTER_NUMBER,
/* No */ Unicode::OTHER_NUMBER,
/* Zs */ Unicode::SPACE_SEPARATOR,
/* Zl */ Unicode::LINE_SEPARATOR,
/* Zp */ Unicode::PARAGRAPH_SEPARATOR,
/* Cc */ Unicode::CONTROL,
/* Cf */ Unicode::FORMAT,
/* Cs */ Unicode::SURROGATE,
/* Co */ Unicode::PRIVATE_USE,
/* Cn */ Unicode::UNASSIGNED,
/* Lu */ Unicode::UPPERCASE_LETTER,
/* Ll */ Unicode::LOWERCASE_LETTER,
/* Lt */ Unicode::TITLECASE_LETTER,
/* Lm */ Unicode::MODIFIER_LETTER,
/* Lo */ Unicode::OTHER_LETTER,
/* Pc */ Unicode::CONNECTOR_PUNCTUATION,
/* Pd */ Unicode::DASH_PUNCTUATION,
/* Ps */ Unicode::START_PUNCTUATION,
/* Pe */ Unicode::END_PUNCTUATION,
/* Po */ Unicode::OTHER_PUNCTUATION,
/* Sm */ Unicode::MATH_SYMBOL,
/* Sc */ Unicode::CURRENCY_SYMBOL,
/* Sk */ Unicode::MODIFIER_SYMBOL,
/* So */ Unicode::OTHER_SYMBOL,
/* Pi */ Unicode::INITIAL_PUNCTUATION,
/* Pf */ Unicode::FINAL_PUNCTUATION
};
const char dirStrings[][5] = {
"L",
"R",
"EN",
"ES",
"ET",
"AN",
"CS",
"B",
"S",
"WS",
"ON",
"LRE",
"LRO",
"AL",
"RLE",
"RLO",
"PDF",
"NSM",
"BN"
};
//====================================================
// test toUpperCase() and toLowerCase()
//====================================================
void UnicodeTest::TestUpperLower()
{
ICU-315 S/390 and EBCDIC updates X-SVN-Rev: 977
2000-03-22 23:17:42 +00:00
U_STRING_DECL(upperTest, "abcdefg123hij.?:klmno", 21);
U_STRING_DECL(lowerTest, "ABCDEFG123HIJ.?:KLMNO", 21);
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
uint16_t i;
ICU-315 S/390 and EBCDIC updates X-SVN-Rev: 977
2000-03-22 23:17:42 +00:00
U_STRING_INIT(upperTest, "abcdefg123hij.?:klmno", 21);
U_STRING_INIT(lowerTest, "ABCDEFG123HIJ.?:KLMNO", 21);
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
//Checks LetterLike Symbols which were previously a source of confusion
//[Bertrand A. D. 02/04/98]
for (i=0x2100;i<0x2138;i++)
{
if(i!=0x2126 && i!=0x212a && i!=0x212b)
{
if (i != Unicode::toLowerCase(i)) // itself
errln("Failed case conversion with itself: " + UCharToUnicodeString(i));
if (i != Unicode::toUpperCase(i))
errln("Failed case conversion with itself: " + UCharToUnicodeString(i));
}
}
for (i = 0; i < 21; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (Unicode::isLetter(upperTest[i]) && !Unicode::isLowerCase(upperTest[i]))
errln("Failed isLowerCase test at " + UCharToUnicodeString(upperTest[i]));
else if (Unicode::isLetter(lowerTest[i]) && !Unicode::isUpperCase(lowerTest[i]))
errln("Failed isUpperCase test at " + UCharToUnicodeString(lowerTest[i]));
else if (upperTest[i] != Unicode::toLowerCase(lowerTest[i]))
errln("Failed case conversion : " + UCharToUnicodeString(upperTest[i]) +
" to " + UCharToUnicodeString(lowerTest[i]));
else if (lowerTest[i] != Unicode::toUpperCase(upperTest[i]))
errln("Failed case conversion : " + UCharToUnicodeString(upperTest[i]) +
" to " + UCharToUnicodeString(lowerTest[i]));
else if (upperTest[i] != Unicode::toLowerCase(upperTest[i])) // itself
errln("Failed case conversion with itself: " + UCharToUnicodeString(upperTest[i]));
else if (lowerTest[i] != Unicode::toUpperCase(lowerTest[i]))
errln("Failed case conversion with itself: " + UCharToUnicodeString(lowerTest[i]));
}
}
/* test isLetter() and isDigit() */
void UnicodeTest::TestLetterNumber()
{
UChar i;
for (i = 0x0041; i < 0x005B; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (!Unicode::isLetter(i))
errln("Failed isLetter test at " + UCharToUnicodeString(i));
}
for (i = 0x0660; i < 0x066A; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (Unicode::isLetter(i))
errln("Failed isLetter test with numbers at " + i);
}
for (i = 0x0660; i < 0x066A; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (!Unicode::isDigit(i))
errln("Failed isNumber test at " + i);
}
}
/* Tests for isDefined(), isBaseForm(), isSpaceChar() and getCellWidth() */
void UnicodeTest::TestMisc()
{
const UChar sampleSpaces[] = {0x0020, 0x00a0, 0x2000, 0x2001, 0x2005};
ICU-315 S/390 and EBCDIC updates X-SVN-Rev: 977
2000-03-22 23:17:42 +00:00
const UChar sampleNonSpaces[] = {0x61, 0x62, 0x63, 0x64, 0x74};
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
const UChar sampleUndefined[] = {0xfff1, 0xfff7, 0xfa30};
const UChar sampleDefined[] = {0x523E, 0x4f88, 0xfffd};
const UChar sampleBase[] = {0x0061, 0x0031, 0x03d2};
const UChar sampleNonBase[] = {0x002B, 0x0020, 0x203B};
const UChar sampleChars[] = {0x000a, 0x0045, 0x4e00, 0xDC00};
const UChar sampleDigits[]= {0x0030, 0x0662, 0x0F23, 0x0ED5};
const UChar sampleNonDigits[] = {0x0010, 0x0041, 0x0122, 0x68FE};
const int32_t sampleDigitValues[] = {0, 2, 3, 5};
const uint16_t sampleCellWidth[] = {Unicode::ZERO_WIDTH,
Unicode::HALF_WIDTH,
Unicode::FULL_WIDTH,
Unicode::NEUTRAL};
int32_t i;
for (i = 0; i < 5; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (!(Unicode::isSpaceChar(sampleSpaces[i])) ||
(Unicode::isSpaceChar(sampleNonSpaces[i])))
errln((UnicodeString)"Space char test error : " + (int32_t)sampleSpaces[i] +
" or " + (int32_t)sampleNonSpaces[i]);
}
for (i = 0; i < 3; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if ((Unicode::isDefined(sampleUndefined[i])) ||
!(Unicode::isDefined(sampleDefined[i])))
errln((UnicodeString)"Undefined char test error : " +
(int32_t)sampleUndefined[i] + " or " + (int32_t)sampleDefined[i]);
}
for (i = 0; i < 3; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if ((Unicode::isBaseForm(sampleNonBase[i])) ||
!(Unicode::isBaseForm(sampleBase[i])))
errln((UnicodeString)"Non-baseform char test error : " +
(int32_t)sampleNonBase[i] + " or " + (int32_t)sampleBase[i]);
}
for (i = 0; i < 4; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (Unicode::getCellWidth(sampleChars[i]) != sampleCellWidth[i])
errln((UnicodeString)"Cell width char test error : " +
(int32_t)sampleChars[i]);
}
for (i = 0; i < 4; i++) {
if ((Unicode::isDigit(sampleDigits[i]) &&
(Unicode::digitValue(sampleDigits[i])!= sampleDigitValues[i])) ||
(Unicode::isDigit(sampleNonDigits[i]))) {
errln((UnicodeString)"Digit char test error : " +
(int32_t)sampleDigits[i] + " or " + (int32_t)sampleNonDigits[i]);
}
}
}
/* Tests for isControl() and isPrintable() */
void UnicodeTest::TestControlPrint()
{
const UChar sampleControl[] = {0x001b, 0x0097, 0x0082};
ICU-315 S/390 and EBCDIC updates X-SVN-Rev: 977
2000-03-22 23:17:42 +00:00
const UChar sampleNonControl[] = {0x61, 0x0031, 0x00e2};
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
const UChar samplePrintable[] = {0x0042, 0x005f, 0x2014};
ICU-130 account for some control codes now having Zs Zl Zp Unicode properties X-SVN-Rev: 1388
2000-05-18 17:49:51 +00:00
const UChar sampleNonPrintable[] = {0x200c, 0x009f, 0x001b};
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
int32_t i;
for (i = 0; i < 3; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (!(Unicode::isControl(sampleControl[i])) ||
(Unicode::isControl(sampleNonControl[i])))
errln((UnicodeString)"Control char test error : " + (int32_t)sampleControl[i] +
" or " + (int32_t)sampleNonControl[i]);
}
for (i = 0; i < 3; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if ((Unicode::isPrintable(samplePrintable[i])) ||
!(Unicode::isPrintable(samplePrintable[i])))
errln((UnicodeString)"Printable char test error : " +
(int32_t)samplePrintable[i] + " or " + (int32_t)sampleNonPrintable[i]);
}
}
/* Tests for isJavaIdentifierStart(), isJavaIdentifierPart(),
* isUnicodeIdentifierStart() and isUnicodeIdentifierPart() */
void UnicodeTest::TestIdentifier()
{
const UChar sampleJavaIDStart[] = {0x0071, 0x00e4, 0x005f};
const UChar sampleNonJavaIDStart[] = {0x0020, 0x2030, 0x0082};
const UChar sampleUnicodeIDStart[] = {0x0250, 0x00e2, 0x0061};
const UChar sampleNonUnicodeIDStart[] = {0x2000, 0x000a, 0x2019};
const UChar sampleJavaIDPart[] = {0x005f, 0x0032, 0x0045};
const UChar sampleNonJavaIDPart[] = {0x007f, 0x2020, 0x0020};
const UChar sampleUnicodeIDPart[] = {0x005f, 0x0032, 0x0045};
const UChar sampleNonUnicodeIDPart[] = {0x007f, 0x00a3, 0x0020};
const UChar sampleIDIgnore[] = {0x0006, 0x0010, 0x206b};
const UChar sampleNonIDIgnore[] = {0x0075, 0x00a3, 0x0061};
int32_t i;
for (i = 0; i < 3; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (!(Unicode::isJavaIdentifierStart(sampleJavaIDStart[i])) ||
(Unicode::isJavaIdentifierStart(sampleNonJavaIDStart[i])))
errln((UnicodeString)"Java ID Start char test error : " + (int32_t)sampleJavaIDStart[i] +
" or " + (int32_t)sampleNonJavaIDStart[i]);
}
for (i = 0; i < 3; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (!(Unicode::isJavaIdentifierPart(sampleJavaIDPart[i])) ||
(Unicode::isJavaIdentifierPart(sampleNonJavaIDPart[i])))
errln((UnicodeString)"Java ID Part char test error : " + (int32_t)sampleJavaIDPart[i] +
" or " + (int32_t)sampleNonJavaIDPart[i]);
}
for (i = 0; i < 3; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (!(Unicode::isUnicodeIdentifierStart(sampleUnicodeIDStart[i])) ||
(Unicode::isUnicodeIdentifierStart(sampleNonUnicodeIDStart[i])))
errln((UnicodeString)"Unicode ID Start char test error : " + (int32_t)sampleUnicodeIDStart[i] +
" or " + (int32_t)sampleNonUnicodeIDStart[i]);
}
for (i = 0; i < 3; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (!(Unicode::isUnicodeIdentifierPart(sampleUnicodeIDPart[i])) ||
(Unicode::isUnicodeIdentifierPart(sampleNonUnicodeIDPart[i])))
errln((UnicodeString)"Unicode ID Part char test error : " + (int32_t)sampleUnicodeIDPart[i] +
" or " + (int32_t)sampleNonUnicodeIDPart[i]);
}
for (i = 0; i < 3; i++) {
// logln((UnicodeString)"testing " + (int32_t)i + "...");
if (!(Unicode::isIdentifierIgnorable(sampleIDIgnore[i])) ||
(Unicode::isIdentifierIgnorable(sampleNonIDIgnore[i])))
errln((UnicodeString)"ID ignorable char test error : " + (int32_t)sampleIDIgnore[i] +
" or " + (int32_t)sampleNonIDIgnore[i]);
}
}
/* tests for getType(), isTitleCase(), and toTitleCase() as well as characterDirection()*/
void UnicodeTest::TestUnicodeData()
{
FILE* input;
char buffer[1000];
char* bufferPtr, *dirPtr;
char path[256];
ICU-8 jitterbug 10: Added better diagnostic on datafile open X-SVN-Rev: 34
1999-10-11 15:43:59 +00:00
const char* datafile = "UnicodeData-3.0.0.txt";
ICU-87 rename icu_getDefaultDataDirectory() to u_[get|set]DataDirectory() X-SVN-Rev: 184
1999-11-18 22:50:13 +00:00
strcpy(path, u_getDataDirectory());
ICU-8 jitterbug 10: Added better diagnostic on datafile open X-SVN-Rev: 34
1999-10-11 15:43:59 +00:00
strcat(path, datafile);
input = fopen( path, "r");
if (input == 0)
{
errln("Failed to open: " + UnicodeString(datafile));
return;
}
ICU-158 add test for Unicode::getCharName() X-SVN-Rev: 289
1999-12-03 19:53:37 +00:00
int32_t unicode;
ICU-130 account for some control codes now having Zs Zl Zp Unicode properties X-SVN-Rev: 1388
2000-05-18 17:49:51 +00:00
int8_t type;
ICU-158 add test for Unicode::getCharName() X-SVN-Rev: 289
1999-12-03 19:53:37 +00:00
for(;;) {
bufferPtr = fgets(buffer, 999, input);
if (bufferPtr == NULL) break;
if (bufferPtr[0] == '#' || bufferPtr[0] == '\n' || bufferPtr[0] == 0) continue;
sscanf(bufferPtr, "%X", &unicode);
assert(0 <= unicode && unicode < 65536);
if (unicode == LAST_CHAR_CODE_IN_FILE)
break;
bufferPtr = strchr(bufferPtr, ';');
assert(bufferPtr != NULL);
bufferPtr = strchr(bufferPtr + 1, ';'); // go to start of third field
assert(bufferPtr != NULL);
dirPtr = bufferPtr;
dirPtr = strchr(dirPtr + 1, ';');
assert(dirPtr != NULL);
dirPtr = strchr(dirPtr + 1, ';');
assert(dirPtr != NULL);
bufferPtr++;
bufferPtr[2] = 0;
// logln((UnicodeString)"testing " + (int32_t)unicode + "...");
ICU-130 account for some control codes now having Zs Zl Zp Unicode properties X-SVN-Rev: 1388
2000-05-18 17:49:51 +00:00
/* we override the general category of some control characters */
switch(unicode) {
case 9:
case 0xb:
case 0x1f:
type = U_SPACE_SEPARATOR;
break;
case 0xc:
type = U_LINE_SEPARATOR;
break;
case 0xa:
case 0xd:
case 0x1c:
case 0x1d:
case 0x1e:
case 0x85:
type = U_PARAGRAPH_SEPARATOR;
break;
default:
type = (int8_t)tagValues[MakeProp(bufferPtr)];
break;
}
if (Unicode::getType((UChar)unicode) != type)
ICU-158 add test for Unicode::getCharName() X-SVN-Rev: 289
1999-12-03 19:53:37 +00:00
errln("Unicode character type failed at " + unicode);
// test title case
if ((Unicode::toTitleCase((UChar)unicode) != Unicode::toUpperCase((UChar)unicode)) &&
!(Unicode::isTitleCase(Unicode::toTitleCase((UChar)unicode))))
errln("Title case test failed at " + unicode);
bufferPtr = strchr(dirPtr + 1, ';');
dirPtr++;
bufferPtr[0] = 0;
if (Unicode::characterDirection((UChar)unicode) != MakeDir(dirPtr))
errln("Unicode character directionality failed at\n " + unicode);
}
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
ICU-158 add test for Unicode::getCharName() X-SVN-Rev: 289
1999-12-03 19:53:37 +00:00
if (input) fclose(input);
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
ICU-158 add test for Unicode::getCharName() X-SVN-Rev: 289
1999-12-03 19:53:37 +00:00
// test Unicode::getCharName()
// a more thorough test of u_charName() is in cintltst/cucdtst.c
UTextOffset length=Unicode::getCharName(0x284, buffer, sizeof(buffer));
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
ICU-158 add test for Unicode::getCharName() X-SVN-Rev: 289
1999-12-03 19:53:37 +00:00
// use invariant-character conversion to Unicode
UnicodeString name(buffer, length, "");
if(name!=UNICODE_STRING("LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK", 49)) {
errln("Unicode character name lookup failed\n");
}
ICU-298 jitterbug 130: add support for u_isMirrored() and u_charMirror() X-SVN-Rev: 1240
2000-04-24 22:44:06 +00:00
// test Unicode::isMirrored() and charMirror()
// see also cintltst/cucdtest.c
if(!(Unicode::isMirrored(0x28) && Unicode::isMirrored(0xbb) && Unicode::isMirrored(0x2045) && Unicode::isMirrored(0x232a) &&
!Unicode::isMirrored(0x27) && !Unicode::isMirrored(0x61) && !Unicode::isMirrored(0x284) && !Unicode::isMirrored(0x3400)
)
) {
errln("Unicode::isMirrored() does not work correctly\n");
}
if(!(Unicode::charMirror(0x3c)==0x3e && Unicode::charMirror(0x5d)==0x5b && Unicode::charMirror(0x208d)==0x208e && Unicode::charMirror(0x3017)==0x3016 &&
Unicode::charMirror(0x2e)==0x2e && Unicode::charMirror(0x6f3)==0x6f3 && Unicode::charMirror(0x301c)==0x301c && Unicode::charMirror(0xa4ab)==0xa4ab
)
) {
errln("Unicode::charMirror() does not work correctly\n");
}
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
}
int32_t UnicodeTest::MakeProp(char* str)
{
int32_t result = 0;
ICU version 1.3 merge from CMVS. X-SVN-Rev: 9
1999-09-30 23:47:52 +00:00
const char* matchPosition;
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
matchPosition = strstr(tagStrings, str);
if (matchPosition == 0) errln((UnicodeString)"unrecognized type letter " + str);
else result = ((matchPosition - tagStrings) / 2);
return result;
}
int32_t UnicodeTest::MakeDir(char* str)
{
int32_t pos = 0;
for (pos = 0; pos < 19; pos++) {
if (strcmp(str, dirStrings[pos]) == 0) {
return pos;
}
}
return -1;
}
ICU-176 Addional tests for UTF-16 support X-SVN-Rev: 1329
2000-05-04 17:27:16 +00:00
/*Tests added by Madhu*/
Initial revision X-SVN-Rev: 2
1999-08-16 21:50:52 +00:00
ICU-176 Addional tests for UTF-16 support X-SVN-Rev: 1329
2000-05-04 17:27:16 +00:00
/* Tests for isSingle(), isLead(), isTrial(), isSurrogate */
void UnicodeTest::TestCodeUnit(){
const UChar codeunit[]={0x0000,0xe065,0x20ac,0xd7ff,0xd800,0xd841,0xd905,0xdbff,0xdc00,0xdc02,0xddee,0xdfff,0};
int16_t i;
for(i=0; i<sizeof(codeunit)/sizeof(codeunit[0]); i++){
UChar c=codeunit[i];
UnicodeString msg;
msg.append((UChar32)c);
logln((UnicodeString)"Testing code unit value of " + prettify(msg));
if(i<4){
if(!(Unicode::isSingle(c)) || (Unicode::isLead(c)) || (Unicode::isTrail(c)) ||(Unicode::isSurrogate(c))){
errln((UnicodeString)"ERROR:" + prettify(msg) + " is a single");
}
}
if(i >= 4 && i< 8){
if(!(Unicode::isLead(c)) || Unicode::isSingle(c) || Unicode::isTrail(c) || !(Unicode::isSurrogate(c))){
errln((UnicodeString)"ERROR:" + prettify(msg) + " is a first surrogate");
}
}
if(i >= 8 && i< 12){
if(!(Unicode::isTrail(c)) || Unicode::isSingle(c) || Unicode::isLead(c) || !(Unicode::isSurrogate(c))){
errln((UnicodeString)"ERROR:" + prettify(msg) + " is a second surrogate");
}
}
}
}
/* Tests for isSurrogate(), isUnicodeChar(), isError(), isValid() */
void UnicodeTest::TestCodePoint(){
const UChar32 codePoint[]={
//surrogate, notvalid(codepoint), not a UnicodeChar, not Error
0xd800,
0xdbff,
0xdc00,
0xdfff,
0xdc04,
0xd821,
//not a surrogate, valid, isUnicodeChar , not Error
0x20ac,
0xd7ff,
0xe000,
0xe123,
0x0061,
0xe065,
0x20402,
0x24506,
0x23456,
0x20402,
0x10402,
0x23456,
//not a surrogate, not valid, isUnicodeChar, isError
0x0015,
0x009f,
//not a surrogate, not valid, not isUnicodeChar, isError
0xffff,
0xfffe,
};
int16_t i;
for(i=0; i<sizeof(codePoint)/sizeof(codePoint[0]); i++){
UChar32 c=codePoint[i];
UnicodeString msg;
msg.append(c);
logln((UnicodeString)"Testing code Point value of " + prettify(msg));
if(i<6){
if(!Unicode::isSurrogate(c)){
errln((UnicodeString)"ERROR: isSurrogate() failed for" + prettify(msg));
}
if(Unicode::isValid(c)){
errln((UnicodeString)"ERROR: isValid() failed for "+ prettify(msg));
}
if(Unicode::isUnicodeChar(c)){
errln((UnicodeString)"ERROR: isUnicodeChar() failed for "+ prettify(msg));
}
if(Unicode::isError(c)){
errln((UnicodeString)"ERROR: isError() failed for "+ prettify(msg));
}
}else if(i >=6 && i<18){
if(Unicode::isSurrogate(c)){
errln((UnicodeString)"ERROR: isSurrogate() failed for" + prettify(msg));
}
if(!Unicode::isValid(c)){
errln((UnicodeString)"ERROR: isValid() failed for "+ prettify(msg));
}
if(!Unicode::isUnicodeChar(c)){
errln((UnicodeString)"ERROR: isUnicodeChar() failed for "+ prettify(msg));
}
if(Unicode::isError(c)){
errln((UnicodeString)"ERROR: isError() failed for "+ prettify(msg));
}
}else if(i >=18 && i<20){
if(Unicode::isSurrogate(c)){
errln((UnicodeString)"ERROR: isSurrogate() failed for" + prettify(msg));
}
if(Unicode::isValid(c)){
errln((UnicodeString)"ERROR: isValid() failed for "+ prettify(msg));
}
if(!Unicode::isUnicodeChar(c)){
errln((UnicodeString)"ERROR: isUnicodeChar() failed for "+ prettify(msg));
}
if(!Unicode::isError(c)){
errln((UnicodeString)"ERROR: isError() failed for "+ prettify(msg));
}
}
else if(i >=18 && i<sizeof(codePoint)/sizeof(codePoint[0])){
if(Unicode::isSurrogate(c)){
errln((UnicodeString)"ERROR: isSurrogate() failed for" + prettify(msg));
}
if(Unicode::isValid(c)){
errln((UnicodeString)"ERROR: isValid() failed for "+ prettify(msg));
}
if(Unicode::isUnicodeChar(c)){
errln((UnicodeString)"ERROR: isUnicodeChar() failed for "+ prettify(msg));
}
if(!Unicode::isError(c)){
errln((UnicodeString)"ERROR: isError() failed for "+ prettify(msg));
}
}
}
}
void UnicodeTest::TestCharLength()
{
const int32_t codepoint[]={
1, 0x0061,
1, 0xe065,
1, 0x20ac,
2, 0x20402,
2, 0x23456,
2, 0x24506,
2, 0x20402,
2, 0x10402,
1, 0xd7ff,
1, 0xe000
};
int16_t i;
ICU-351 Define UBool to be used in the APIs. X-SVN-Rev: 1410
2000-05-18 22:08:39 +00:00
UBool multiple;
ICU-176 Addional tests for UTF-16 support X-SVN-Rev: 1329
2000-05-04 17:27:16 +00:00
for(i=0; i<sizeof(codepoint)/sizeof(codepoint[0]); i=i+2){
UChar32 c=codepoint[i+1];
UnicodeString msg;
msg.append(c);
if(Unicode::charLength(c) != codepoint[i]){
errln((UnicodeString)"The no: of code units for" + prettify(msg)+
":- Expected: " + (int32_t)codepoint[i] + " Got: " + Unicode::charLength(c));
}else{
logln((UnicodeString)"The no: of code units for" + prettify(msg) + " is " + Unicode::charLength(c));
}
multiple=codepoint[i] == 1 ? FALSE : TRUE;
if(Unicode::needMultipleUChar(c) != multiple){
errln("ERROR: Unicode::needMultipleUChar() failed for" + prettify(msg));
}
}
}
Reference in New Issue Copy Permalink