mirror of
https://github.com/unicode-org/icu.git
synced 2025-04-06 05:55:35 +00:00
ICU-315 S/390 and EBCDIC updates
X-SVN-Rev: 977
This commit is contained in:
Markus Scherer
parent
46d8dce364
commit
9f363ccb70
32 changed files with 900 additions and 1213 deletions
|
|
@ -12,11 +12,24 @@
|
|||
* Madhu Katragadda Ported for C API
|
||||
*********************************************************************************
|
||||
*/
|
||||
|
||||
/*
|
||||
* Important: This file is included into intltest/allcoll.cpp so that the
|
||||
* test data is shared. This makes it easier to maintain the test data,
|
||||
* especially since the Unicode data must be portable and quoted character
|
||||
* literals will not work.
|
||||
* If it is included, then there will be a #define INCLUDE_CALLCOLL_C
|
||||
* that must prevent the actual code in here from being part of the
|
||||
* allcoll.cpp compilation.
|
||||
*/
|
||||
|
||||
/**
|
||||
* CollationDummyTest is a third level test class. This tests creation of
|
||||
* a customized collator object. For example, number 1 to be sorted
|
||||
* equlivalent to word 'one'.
|
||||
*/
|
||||
#ifndef INCLUDE_CALLCOLL_C
|
||||
|
||||
#include "unicode/utypes.h"
|
||||
#include "unicode/ucol.h"
|
||||
#include "unicode/uloc.h"
|
||||
|
|
@ -27,6 +40,9 @@
|
|||
#include <string.h>
|
||||
|
||||
static UCollator *myCollation;
|
||||
|
||||
#endif
|
||||
|
||||
static const UChar DEFAULTRULEARRAY[] =
|
||||
{
|
||||
0x3d, 0x27, (UChar)0x200B, 0x27, 0x3d, (UChar)0x200C, 0x3d, (UChar)0x200D, 0x3d, (UChar)0x200E, 0x3d, (UChar)0x200F
|
||||
|
|
@ -237,7 +253,7 @@ static const UChar DEFAULTRULEARRAY[] =
|
|||
, (UChar)0x0000
|
||||
};
|
||||
|
||||
const UChar testSourceCases[][MAX_TOKEN_LEN] = {
|
||||
const UChar testSourceCases[][16] = {
|
||||
{0x61, 0x62, 0x27, 0x63, 0},
|
||||
{0x63, 0x6f, 0x2d, 0x6f, 0x70, 0},
|
||||
{0x61, 0x62, 0},
|
||||
|
|
@ -277,7 +293,7 @@ const UChar testSourceCases[][MAX_TOKEN_LEN] = {
|
|||
{0x70, 0x00EA,0x30} /* 37 */
|
||||
};
|
||||
|
||||
const UChar testTargetCases[][MAX_TOKEN_LEN] = {
|
||||
const UChar testTargetCases[][16] = {
|
||||
{0x61, 0x62, 0x63, 0x27, 0},
|
||||
{0x43, 0x4f, 0x4f, 0x50, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
|
|
@ -317,6 +333,8 @@ const UChar testTargetCases[][MAX_TOKEN_LEN] = {
|
|||
{0x70, (UChar)0x00EB,0x30} /* 37 */
|
||||
};
|
||||
|
||||
#ifndef INCLUDE_CALLCOLL_C
|
||||
|
||||
const UCollationResult results[] = {
|
||||
UCOL_LESS,
|
||||
UCOL_GREATER,
|
||||
|
|
@ -359,10 +377,14 @@ const UCollationResult results[] = {
|
|||
UCOL_LESS /* 37 */
|
||||
};
|
||||
|
||||
const UChar testCases[][MAX_TOKEN_LEN] =
|
||||
#endif
|
||||
|
||||
const UChar testCases[][4] =
|
||||
{
|
||||
{0x61, 0},
|
||||
{0x41, 0},
|
||||
{0x00e4, 0},
|
||||
{0x00c4, 0},
|
||||
{0x61, 0x65, 0},
|
||||
{0x61, 0x45, 0},
|
||||
{0x41, 0x65, 0},
|
||||
|
|
@ -374,6 +396,9 @@ const UChar testCases[][MAX_TOKEN_LEN] =
|
|||
{0x7a, 0}
|
||||
};
|
||||
|
||||
#define COUNT_TEST_CASES 13
|
||||
|
||||
#ifndef INCLUDE_CALLCOLL_C
|
||||
|
||||
void addAllCollTest(TestNode** root)
|
||||
{
|
||||
|
|
@ -554,9 +579,9 @@ void TestExtra()
|
|||
}
|
||||
ucol_setNormalization(myCollation, UCOL_DEFAULT_NORMALIZATION);
|
||||
ucol_setStrength(myCollation, UCOL_TERTIARY);
|
||||
for (i = 0; i < 10 ; i++)
|
||||
for (i = 0; i < COUNT_TEST_CASES-1 ; i++)
|
||||
{
|
||||
for (j = i + 1; j < 11; j += 1)
|
||||
for (j = i + 1; j < COUNT_TEST_CASES; j += 1)
|
||||
{
|
||||
|
||||
doTest(myCollation, testCases[i], testCases[j], UCOL_LESS);
|
||||
|
|
@ -567,3 +592,5 @@ void TestExtra()
|
|||
ucol_close(myCollation);
|
||||
myCollation = 0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -119,92 +119,47 @@ UChar* appendCompareResult(UCollationResult result, UChar* target)
|
|||
return target;
|
||||
}
|
||||
|
||||
#if U_CHARSET_FAMILY==U_EBCDIC_FAMILY
|
||||
/*
|
||||
* These maps for ASCII to/from EBCDIC are copied from putil.c.
|
||||
* For more information, see there.
|
||||
*/
|
||||
|
||||
static uint8_t asciiFromEbcdic[256]={
|
||||
0x00, 0x01, 0x02, 0x03, 0x00, 0x09, 0x00, 0x7F, 0x00, 0x00, 0x00, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x10, 0x11, 0x12, 0x13, 0x00, 0x00, 0x08, 0x00, 0x18, 0x19, 0x00, 0x00, 0x1C, 0x1D, 0x1E, 0x1F,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x17, 0x1B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x07,
|
||||
0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x00, 0x1A,
|
||||
0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2E, 0x3C, 0x28, 0x2B, 0x7C,
|
||||
0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
|
||||
0x2D, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22,
|
||||
0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x00, 0x00,
|
||||
0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x5C, 0x00, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
|
||||
static uint8_t ebcdicFromAscii[256]={
|
||||
0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, 0x16, 0x05, 0x25, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
||||
0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F,
|
||||
0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61,
|
||||
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F,
|
||||
0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
|
||||
0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xAD, 0xE0, 0xBD, 0x5F, 0x6D,
|
||||
0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
|
||||
0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
#endif
|
||||
|
||||
UChar* CharsToUChars(const char* chars)
|
||||
{
|
||||
int unicode;
|
||||
int i;
|
||||
UChar *buffer;
|
||||
UChar *alias;
|
||||
int len = strlen(chars);
|
||||
int count = 0;
|
||||
|
||||
/* preflight */
|
||||
for (i = 0; i < len;) {
|
||||
if ((chars[i] == '\\') && (i+1 < len) && (chars[i+1] == 'u')) {
|
||||
++count;
|
||||
for (i = 0; chars[i] != 0;) {
|
||||
if ((chars[i] == '\\') && (chars[i+1] == 'u')) {
|
||||
i += 6;
|
||||
} else {
|
||||
++count;
|
||||
i++;
|
||||
}
|
||||
++count;
|
||||
}
|
||||
|
||||
buffer = (UChar*) malloc(sizeof(UChar) * (count + 1));
|
||||
alias = buffer;
|
||||
alias = buffer = (UChar*) malloc(sizeof(UChar) * (count + 1));
|
||||
|
||||
for (i = 0; i < len;) {
|
||||
if ((chars[i] == '\\') && (i+1 < len) && (chars[i+1] == 'u')) {
|
||||
|
||||
sscanf(&(chars[i+2]), "%4X", &unicode);
|
||||
*alias = (UChar)unicode;
|
||||
i += 6;
|
||||
++alias;
|
||||
} else {
|
||||
#if U_CHARSET_FAMILY==U_ASCII_FAMILY
|
||||
*alias = (UChar)(uint8_t)chars[i];
|
||||
#elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY
|
||||
*alias = asciiFromEbcdic[(uint8_t)chars[i]];
|
||||
#else
|
||||
# error U_CHARSET_FAMILY is not valid
|
||||
#endif
|
||||
++alias;
|
||||
++i;
|
||||
}
|
||||
for (;;) {
|
||||
/* search for \u or the end */
|
||||
for(i = 0; chars[i] != 0 && !(chars[i] == '\\' && chars[i+1] == 'u'); ++i) {}
|
||||
|
||||
/* convert characters between escape sequences */
|
||||
if(i > 0) {
|
||||
u_charsToUChars(chars, alias, i);
|
||||
chars += i;
|
||||
alias += i;
|
||||
}
|
||||
|
||||
/* did we reach the end or an escape sequence? */
|
||||
if(*chars == 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
/* unescape one character: we know that there is a \u sequence at chars[limit] */
|
||||
chars += 2;
|
||||
sscanf(chars, "%4X", &unicode);
|
||||
*alias++ = (UChar)unicode;
|
||||
chars += 4;
|
||||
}
|
||||
*alias = 0x0000;
|
||||
return buffer;
|
||||
|
|
|
|||
|
|
@ -24,217 +24,12 @@
|
|||
#include "allcoll.h"
|
||||
#endif
|
||||
|
||||
static const UChar DEFAULTRULEARRAY[] =
|
||||
{
|
||||
'=', '\'', (UChar)0x200B, '\'', '=', (UChar)0x200C, '=', (UChar)0x200D, '=', (UChar)0x200E, '=', (UChar)0x200F
|
||||
, '=', (UChar)0x0001, '=', (UChar)0x0002, '=', (UChar)0x0003, '=', (UChar)0x0004
|
||||
, '=', (UChar)0x0005, '=', (UChar)0x0006, '=', (UChar)0x0007, '=', (UChar)0x0008, '=', '\'', (UChar)0x0009, '\''
|
||||
, '=', '\'', (UChar)0x000b, '\'', '=', (UChar)0x000e //vt,, so
|
||||
, '=', (UChar)0x000f, '=', '\'', (UChar)0x0010, '\'', '=', (UChar)0x0011, '=', (UChar)0x0012, '=', (UChar)0x0013 //si, dle, dc1, dc2, dc3
|
||||
, '=', (UChar)0x0014, '=', (UChar)0x0015, '=', (UChar)0x0016, '=', (UChar)0x0017, '=', (UChar)0x0018 //dc4, nak, syn, etb, can
|
||||
, '=', (UChar)0x0019, '=', (UChar)0x001a, '=', (UChar)0x001b, '=', (UChar)0x001c, '=', (UChar)0x001d //em, sub, esc, fs, gs
|
||||
, '=', (UChar)0x001e, '=', (UChar)0x001f, '=', (UChar)0x007f //rs, us, del
|
||||
//....then the C1 Latin 1 reserved control codes
|
||||
, '=', (UChar)0x0080, '=', (UChar)0x0081, '=', (UChar)0x0082, '=', (UChar)0x0083, '=', (UChar)0x0084, '=', (UChar)0x0085
|
||||
, '=', (UChar)0x0086, '=', (UChar)0x0087, '=', (UChar)0x0088, '=', (UChar)0x0089, '=', (UChar)0x008a, '=', (UChar)0x008b
|
||||
, '=', (UChar)0x008c, '=', (UChar)0x008d, '=', (UChar)0x008e, '=', (UChar)0x008f, '=', (UChar)0x0090, '=', (UChar)0x0091
|
||||
, '=', (UChar)0x0092, '=', (UChar)0x0093, '=', (UChar)0x0094, '=', (UChar)0x0095, '=', (UChar)0x0096, '=', (UChar)0x0097
|
||||
, '=', (UChar)0x0098, '=', (UChar)0x0099, '=', (UChar)0x009a, '=', (UChar)0x009b, '=', (UChar)0x009c, '=', (UChar)0x009d
|
||||
, '=', (UChar)0x009e, '=', (UChar)0x009f
|
||||
// IGNORE except for secondary, tertiary difference
|
||||
// Spaces
|
||||
, ';', '\'', (UChar)0x0020, '\'', ';', '\'', (UChar)0x00A0, '\'' // spaces
|
||||
, ';', '\'', (UChar)0x2000, '\'', ';', '\'', (UChar)0x2001, '\'', ';', '\'', (UChar)0x2002, '\'', ';', '\'', (UChar)0x2003, '\'', ';', '\'', (UChar)0x2004, '\'' // spaces
|
||||
, ';', '\'', (UChar)0x2005, '\'', ';', '\'', (UChar)0x2006, '\'', ';', '\'', (UChar)0x2007, '\'', ';', '\'', (UChar)0x2008, '\'', ';', '\'', (UChar)0x2009, '\'' // spaces
|
||||
, ';', '\'', (UChar)0x200A, '\'', ';', '\'', (UChar)0x3000, '\'', ';', '\'', (UChar)0xFEFF, '\'' // spaces
|
||||
, ';', '\'', '\r', '\'', ';', '\'', '\t', '\'', ';', '\'', '\n', '\'', ';', '\'', '\f', '\'', ';', '\'', (UChar)0x000b, '\'' // whitespace
|
||||
|
||||
// Non-spacing accents
|
||||
|
||||
, ';', (UChar)0x0301 // non-spacing acute accent
|
||||
, ';', (UChar)0x0300 // non-spacing grave accent
|
||||
, ';', (UChar)0x0306 // non-spacing breve accent
|
||||
, ';', (UChar)0x0302 // non-spacing circumflex accent
|
||||
, ';', (UChar)0x030c // non-spacing caron/hacek accent
|
||||
, ';', (UChar)0x030a // non-spacing ring above accent
|
||||
, ';', (UChar)0x030d // non-spacing vertical line above
|
||||
, ';', (UChar)0x0308 // non-spacing diaeresis accent
|
||||
, ';', (UChar)0x030b // non-spacing double acute accent
|
||||
, ';', (UChar)0x0303 // non-spacing tilde accent
|
||||
, ';', (UChar)0x0307 // non-spacing dot above/overdot accent
|
||||
, ';', (UChar)0x0304 // non-spacing macron accent
|
||||
, ';', (UChar)0x0337 // non-spacing short slash overlay (overstruck diacritic)
|
||||
, ';', (UChar)0x0327 // non-spacing cedilla accent
|
||||
, ';', (UChar)0x0328 // non-spacing ogonek accent
|
||||
, ';', (UChar)0x0323 // non-spacing dot-below/underdot accent
|
||||
, ';', (UChar)0x0332 // non-spacing underscore/underline accent
|
||||
// with the rest of the general diacritical marks in binary order
|
||||
, ';', (UChar)0x0305 // non-spacing overscore/overline
|
||||
, ';', (UChar)0x0309 // non-spacing hook above
|
||||
, ';', (UChar)0x030e // non-spacing double vertical line above
|
||||
, ';', (UChar)0x030f // non-spacing double grave
|
||||
, ';', (UChar)0x0310 // non-spacing chandrabindu
|
||||
, ';', (UChar)0x0311 // non-spacing inverted breve
|
||||
, ';', (UChar)0x0312 // non-spacing turned comma above/cedilla above
|
||||
, ';', (UChar)0x0313 // non-spacing comma above
|
||||
, ';', (UChar)0x0314 // non-spacing reversed comma above
|
||||
, ';', (UChar)0x0315 // non-spacing comma above right
|
||||
, ';', (UChar)0x0316 // non-spacing grave below
|
||||
, ';', (UChar)0x0317 // non-spacing acute below
|
||||
, ';', (UChar)0x0318 // non-spacing left tack below
|
||||
, ';', (UChar)0x0319 // non-spacing tack below
|
||||
, ';', (UChar)0x031a // non-spacing left angle above
|
||||
, ';', (UChar)0x031b // non-spacing horn
|
||||
, ';', (UChar)0x031c // non-spacing left half ring below
|
||||
, ';', (UChar)0x031d // non-spacing up tack below
|
||||
, ';', (UChar)0x031e // non-spacing down tack below
|
||||
, ';', (UChar)0x031f // non-spacing plus sign below
|
||||
, ';', (UChar)0x0320 // non-spacing minus sign below
|
||||
, ';', (UChar)0x0321 // non-spacing palatalized hook below
|
||||
, ';', (UChar)0x0322 // non-spacing retroflex hook below
|
||||
, ';', (UChar)0x0324 // non-spacing double dot below
|
||||
, ';', (UChar)0x0325 // non-spacing ring below
|
||||
, ';', (UChar)0x0326 // non-spacing comma below
|
||||
, ';', (UChar)0x0329 // non-spacing vertical line below
|
||||
, ';', (UChar)0x032a // non-spacing bridge below
|
||||
, ';', (UChar)0x032b // non-spacing inverted double arch below
|
||||
, ';', (UChar)0x032c // non-spacing hacek below
|
||||
, ';', (UChar)0x032d // non-spacing circumflex below
|
||||
, ';', (UChar)0x032e // non-spacing breve below
|
||||
, ';', (UChar)0x032f // non-spacing inverted breve below
|
||||
, ';', (UChar)0x0330 // non-spacing tilde below
|
||||
, ';', (UChar)0x0331 // non-spacing macron below
|
||||
, ';', (UChar)0x0333 // non-spacing double underscore
|
||||
, ';', (UChar)0x0334 // non-spacing tilde overlay
|
||||
, ';', (UChar)0x0335 // non-spacing short bar overlay
|
||||
, ';', (UChar)0x0336 // non-spacing long bar overlay
|
||||
, ';', (UChar)0x0338 // non-spacing long slash overlay
|
||||
, ';', (UChar)0x0339 // non-spacing right half ring below
|
||||
, ';', (UChar)0x033a // non-spacing inverted bridge below
|
||||
, ';', (UChar)0x033b // non-spacing square below
|
||||
, ';', (UChar)0x033c // non-spacing seagull below
|
||||
, ';', (UChar)0x033d // non-spacing x above
|
||||
, ';', (UChar)0x033e // non-spacing vertical tilde
|
||||
, ';', (UChar)0x033f // non-spacing double overscore
|
||||
, ';', (UChar)0x0340 // non-spacing grave tone mark
|
||||
, ';', (UChar)0x0341 // non-spacing acute tone mark
|
||||
, ';', (UChar)0x0342, ';', (UChar)0x0343, ';', (UChar)0x0344, ';', (UChar)0x0345, ';', (UChar)0x0360, ';', (UChar)0x0361 // newer
|
||||
, ';', (UChar)0x0483, ';', (UChar)0x0484, ';', (UChar)0x0485, ';', (UChar)0x0486 // Cyrillic accents
|
||||
|
||||
, ';', (UChar)0x20D0, ';', (UChar)0x20D1, ';', (UChar)0x20D2 // symbol accents
|
||||
, ';', (UChar)0x20D3, ';', (UChar)0x20D4, ';', (UChar)0x20D5 // symbol accents
|
||||
, ';', (UChar)0x20D6, ';', (UChar)0x20D7, ';', (UChar)0x20D8 // symbol accents
|
||||
, ';', (UChar)0x20D9, ';', (UChar)0x20DA, ';', (UChar)0x20DB // symbol accents
|
||||
, ';', (UChar)0x20DC, ';', (UChar)0x20DD, ';', (UChar)0x20DE // symbol accents
|
||||
, ';', (UChar)0x20DF, ';', (UChar)0x20E0, ';', (UChar)0x20E1 // symbol accents
|
||||
|
||||
, ',', '\'', (UChar)0x002D, '\'', ';', (UChar)0x00AD // dashes
|
||||
, ';', (UChar)0x2010, ';', (UChar)0x2011, ';', (UChar)0x2012 // dashes
|
||||
, ';', (UChar)0x2013, ';', (UChar)0x2014, ';', (UChar)0x2015 // dashes
|
||||
, ';', (UChar)0x2212 // dashes
|
||||
|
||||
// other punctuation
|
||||
|
||||
, '<', '\'', (UChar)0x005f, '\'' // underline/underscore (spacing)
|
||||
, '<', (UChar)0x00af // overline or macron (spacing)
|
||||
// , '<', (UChar)0x00ad // syllable hyphen (SHY) or soft hyphen
|
||||
, '<', '\'', (UChar)0x002c, '\'' // comma (spacing)
|
||||
, '<', '\'', (UChar)0x003b, '\'' // semicolon
|
||||
, '<', '\'', (UChar)0x003a, '\'' // colon
|
||||
, '<', '\'', (UChar)0x0021, '\'' // exclamation point
|
||||
, '<', (UChar)0x00a1 // inverted exclamation point
|
||||
, '<', '\'', (UChar)0x003f, '\'' // question mark
|
||||
, '<', (UChar)0x00bf // inverted question mark
|
||||
, '<', '\'', (UChar)0x002f, '\'' // slash
|
||||
, '<', '\'', (UChar)0x002e, '\'' // period/full stop
|
||||
, '<', (UChar)0x00b4 // acute accent (spacing)
|
||||
, '<', '\'', (UChar)0x0060, '\'' // grave accent (spacing)
|
||||
, '<', '\'', (UChar)0x005e, '\'' // circumflex accent (spacing)
|
||||
, '<', (UChar)0x00a8 // diaresis/umlaut accent (spacing)
|
||||
, '<', '\'', (UChar)0x007e, '\'' // tilde accent (spacing)
|
||||
, '<', (UChar)0x00b7 // middle dot (spacing)
|
||||
, '<', (UChar)0x00b8 // cedilla accent (spacing)
|
||||
, '<', '\'', (UChar)0x0027, '\'' // apostrophe
|
||||
, '<', '\'', '"', '\'' // quotation marks
|
||||
, '<', (UChar)0x00ab // left angle quotes
|
||||
, '<', (UChar)0x00bb // right angle quotes
|
||||
, '<', '\'', (UChar)0x0028, '\'' // left parenthesis
|
||||
, '<', '\'', (UChar)0x0029, '\'' // right parenthesis
|
||||
, '<', '\'', (UChar)0x005b, '\'' // left bracket
|
||||
, '<', '\'', (UChar)0x005d, '\'' // right bracket
|
||||
, '<', '\'', (UChar)0x007b, '\'' // left brace
|
||||
, '<', '\'', (UChar)0x007d, '\'' // right brace
|
||||
, '<', (UChar)0x00a7 // section symbol
|
||||
, '<', (UChar)0x00b6 // paragraph symbol
|
||||
, '<', (UChar)0x00a9 // copyright symbol
|
||||
, '<', (UChar)0x00ae // registered trademark symbol
|
||||
, '<', '\'', (UChar)0x0040, '\'' // at sign
|
||||
, '<', (UChar)0x00a4 // international currency symbol
|
||||
, '<', (UChar)0x00a2 // cent sign
|
||||
, '<', '\'', (UChar)0x0024, '\'' // dollar sign
|
||||
, '<', (UChar)0x00a3 // pound-sterling sign
|
||||
, '<', (UChar)0x00a5 // yen sign
|
||||
, '<', '\'', (UChar)0x002a, '\'' // asterisk
|
||||
, '<', '\'', (UChar)0x005c, '\'' // backslash
|
||||
, '<', '\'', (UChar)0x0026, '\'' // ampersand
|
||||
, '<', '\'', (UChar)0x0023, '\'' // number sign
|
||||
, '<', '\'', (UChar)0x0025, '\'' // percent sign
|
||||
, '<', '\'', (UChar)0x002b, '\'' // plus sign
|
||||
// , '<', (UChar)0x002d // hyphen or minus sign
|
||||
, '<', (UChar)0x00b1 // plus-or-minus sign
|
||||
, '<', (UChar)0x00f7 // divide sign
|
||||
, '<', (UChar)0x00d7 // multiply sign
|
||||
, '<', '\'', (UChar)0x003c, '\'' // less-than sign
|
||||
, '<', '\'', (UChar)0x003d, '\'' // equal sign
|
||||
, '<', '\'', (UChar)0x003e, '\'' // greater-than sign
|
||||
, '<', (UChar)0x00ac // end of line symbol/logical NOT symbol
|
||||
, '<', '\'', (UChar)0x007c, '\'' // vertical line/logical OR symbol
|
||||
, '<', (UChar)0x00a6 // broken vertical line
|
||||
, '<', (UChar)0x00b0 // degree symbol
|
||||
, '<', (UChar)0x00b5 // micro symbol
|
||||
|
||||
// NUMERICS
|
||||
|
||||
, '<', '0', '<', '1', '<', '2', '<', '3', '<', '4', '<', '5', '<', '6', '<', '7', '<', '8', '<', '9'
|
||||
, '<', (UChar)0x00bc, '<', (UChar)0x00bd, '<', (UChar)0x00be // 1/4,1/2,3/4 fractions
|
||||
|
||||
// NON-IGNORABLES
|
||||
, '<', 'a', ',', 'A'
|
||||
, '<', 'b', ',', 'B'
|
||||
, '<', 'c', ',', 'C'
|
||||
, '<', 'd', ',', 'D'
|
||||
, '<', (UChar)0x00F0, ',', (UChar)0x00D0 // eth
|
||||
, '<', 'e', ',', 'E'
|
||||
, '<', 'f', ',', 'F'
|
||||
, '<', 'g', ',', 'G'
|
||||
, '<', 'h', ',', 'H'
|
||||
, '<', 'i', ',', 'I'
|
||||
, '<', 'j', ',', 'J'
|
||||
, '<', 'k', ',', 'K'
|
||||
, '<', 'l', ',', 'L'
|
||||
, '<', 'm', ',', 'M'
|
||||
, '<', 'n', ',', 'N'
|
||||
, '<', 'o', ',', 'O'
|
||||
, '<', 'p', ',', 'P'
|
||||
, '<', 'q', ',', 'Q'
|
||||
, '<', 'r', ',', 'R'
|
||||
, '<', 's', ',', 'S', '&', 'S', 'S', ',', (UChar)0x00DF // s-zet
|
||||
, '<', 't', ',', 'T'
|
||||
, '&', 'T', 'H', ',', 0x00FE, '&', 'T', 'H', ',', (UChar)0x00DE // thorn
|
||||
, '<', 'u', ',', 'U'
|
||||
, '<', 'v', ',', 'V'
|
||||
, '<', 'w', ',', 'W'
|
||||
, '<', 'x', ',', 'X'
|
||||
, '<', 'y', ',', 'Y'
|
||||
, '<', 'z', ',', 'Z'
|
||||
, '&', 'A', 'E', ',', (UChar)0x00C6 // ae & AE ligature
|
||||
, '&', 'A', 'E', ',', (UChar)0x00E6
|
||||
, '&', 'O', 'E', ',', (UChar)0x0152 // oe & OE ligature
|
||||
, '&', 'O', 'E', ',', (UChar)0x0153
|
||||
, (UChar)0x0000
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Include callcoll.c to get the test data.
|
||||
* This helps maintain a single copy of the data.
|
||||
*/
|
||||
#define INCLUDE_CALLCOLL_C
|
||||
#include "../cintltst/callcoll.c"
|
||||
|
||||
CollationDummyTest::CollationDummyTest()
|
||||
: myCollation(0)
|
||||
|
|
@ -252,80 +47,6 @@ CollationDummyTest::~CollationDummyTest()
|
|||
delete myCollation;
|
||||
}
|
||||
|
||||
const UChar CollationDummyTest::testSourceCases[][CollationDummyTest::MAX_TOKEN_LEN] = {
|
||||
{'a', 'b', '\'', 'c', 0},
|
||||
{'c', 'o', '-', 'o', 'p', 0},
|
||||
{'a', 'b', 0},
|
||||
{'a', 'm', 'p', 'e', 'r', 's', 'a', 'd', 0},
|
||||
{'a', 'l', 'l', 0},
|
||||
{'f', 'o', 'u', 'r', 0},
|
||||
{'f', 'i', 'v', 'e', 0},
|
||||
{'1', 0},
|
||||
{'1', 0},
|
||||
{'1', 0}, // 10
|
||||
{'2', 0},
|
||||
{'2', 0},
|
||||
{'H', 'e', 'l', 'l', 'o', 0},
|
||||
{'a', '<', 'b', 0},
|
||||
{'a', '<', 'b', 0},
|
||||
{'a', 'c', 'c', 0},
|
||||
{'a', 'c', 'H', 'c', 0}, // simple test
|
||||
{'p', 0x00EA, 'c', 'h', 'e', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0}, // 20
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 0x00E6, 'c', 0},
|
||||
{'a', 'c', 'H', 'c', 0}, // primary test
|
||||
{'b', 'l', 'a', 'c', 'k', 0},
|
||||
{'f', 'o', 'u', 'r', 0},
|
||||
{'f', 'i', 'v', 'e', 0},
|
||||
{'1', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0}, // 30
|
||||
{'a', 'b', 'c', 'H', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'c', 'H', 'c', 0} // 33
|
||||
};
|
||||
|
||||
const UChar CollationDummyTest::testTargetCases[][CollationDummyTest::MAX_TOKEN_LEN] = {
|
||||
{'a', 'b', 'c', '\'', 0},
|
||||
{'C', 'O', 'O', 'P', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'&', 0},
|
||||
{'&', 0},
|
||||
{'4', 0},
|
||||
{'5', 0},
|
||||
{'o', 'n', 'e', 0},
|
||||
{'n', 'n', 'e', 0},
|
||||
{'p', 'n', 'e', 0}, // 10
|
||||
{'t', 'w', 'o', 0},
|
||||
{'u', 'w', 'o', 0},
|
||||
{'h', 'e', 'l', 'l', 'O', 0},
|
||||
{'a', '<', '=', 'b', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'C', 'H', 'c', 0},
|
||||
{'a', 'C', 'H', 'c', 0}, // simple test
|
||||
{'p', 0x00E9, 'c', 'h', 0x00E9, 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'B', 'C', 0}, // 20
|
||||
{'a', 'b', 'c', 'h', 0},
|
||||
{'a', 'b', 'd', 0},
|
||||
{0x00E4, 'b', 'c', 0},
|
||||
{'a', 0x00C6, 'c', 0},
|
||||
{'a', 'C', 'H', 'c', 0}, // primary test
|
||||
{'b', 'l', 'a', 'c', 'k', '-', 'b', 'i', 'r', 'd', 0},
|
||||
{'4', 0},
|
||||
{'5', 0},
|
||||
{'o', 'n', 'e', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'B', 'c', 0}, // 30
|
||||
{'a', 'b', 'c', 'h', 0},
|
||||
{'a', 'b', 'd', 0},
|
||||
{'a', 'C', 'H', 'c', 0} // 34
|
||||
};
|
||||
|
||||
const Collator::EComparisonResult CollationDummyTest::results[] = {
|
||||
Collator::LESS,
|
||||
Collator::GREATER,
|
||||
|
|
@ -362,24 +83,10 @@ const Collator::EComparisonResult CollationDummyTest::results[] = {
|
|||
Collator::EQUAL, // 30
|
||||
Collator::EQUAL,
|
||||
Collator::LESS,
|
||||
Collator::EQUAL // 34
|
||||
};
|
||||
|
||||
const UChar CollationDummyTest::testCases[][CollationDummyTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'a', 0},
|
||||
{'A', 0},
|
||||
{0x00e4, 0},
|
||||
{0x00c4, 0},
|
||||
{'a', 'e', 0},
|
||||
{'a', 'E', 0},
|
||||
{'A', 'e', 0},
|
||||
{'A', 'E', 0},
|
||||
{0x00e6, 0},
|
||||
{0x00c6, 0},
|
||||
{'b', 0},
|
||||
{'c', 0},
|
||||
{'z', 0}
|
||||
Collator::EQUAL, // 34
|
||||
Collator::EQUAL,
|
||||
Collator::EQUAL,
|
||||
Collator::LESS /* 37 */
|
||||
};
|
||||
|
||||
void CollationDummyTest::doTest( UnicodeString source, UnicodeString target, Collator::EComparisonResult result)
|
||||
|
|
@ -432,9 +139,9 @@ void CollationDummyTest::TestExtra( char* par )
|
|||
{
|
||||
int32_t i, j;
|
||||
myCollation->setStrength(Collator::TERTIARY);
|
||||
for (i = 0; i < 12; i++)
|
||||
for (i = 0; i < COUNT_TEST_CASES-1; i++)
|
||||
{
|
||||
for (j = i + 1; j < 13; j += 1)
|
||||
for (j = i + 1; j < COUNT_TEST_CASES; j += 1)
|
||||
{
|
||||
doTest(testCases[i], testCases[j], Collator::LESS);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,9 +55,6 @@ public:
|
|||
void TestExtra( char* par );
|
||||
|
||||
private:
|
||||
static const UChar testCases[][MAX_TOKEN_LEN];
|
||||
static const UChar testSourceCases[][MAX_TOKEN_LEN];
|
||||
static const UChar testTargetCases[][MAX_TOKEN_LEN];
|
||||
static const Collator::EComparisonResult results[];
|
||||
|
||||
RuleBasedCollator *myCollation;
|
||||
|
|
|
|||
|
|
@ -19,6 +19,18 @@
|
|||
#define MAX_FILE_LEN 1024*20
|
||||
#define UCS_FILE_NAME_SIZE 100
|
||||
|
||||
/* default codepage name, keep synchronized with ccapitst.c */
|
||||
#ifdef WIN32
|
||||
/* this assumes a Western European Windows */
|
||||
# define DEFAULT_CODEPAGE "IBM-1252"
|
||||
#elif defined(OS390)
|
||||
# define DEFAULT_CODEPAGE "ibm-37-s390"
|
||||
#elif defined(OS400)
|
||||
# define DEFAULT_CODEPAGE "ibm-37"
|
||||
#else
|
||||
# define DEFAULT_CODEPAGE "LATIN_1"
|
||||
#endif
|
||||
|
||||
/*writes and entire UnicodeString along with a BOM to a file*/
|
||||
void WriteToFile(const UnicodeString *a, FILE *myfile);
|
||||
/*Case insensitive compare*/
|
||||
|
|
@ -218,19 +230,13 @@ void ConvertTest::TestConvert()
|
|||
someConverters[1] = new UnicodeConverterCPP;
|
||||
someConverters[2] = new UnicodeConverterCPP("utf8", err);
|
||||
if (U_FAILURE(err)) errln ((UnicodeString)"FAILURE! " + err);
|
||||
#ifdef WIN32
|
||||
if ((strcmp(someConverters[1]->getName(err),"IBM-1252")==0)&&
|
||||
(strcmp(someConverters[0]->getName(err),"IBM-1252")==0))
|
||||
|
||||
if ((stricmp(someConverters[1]->getName(err),DEFAULT_CODEPAGE)==0)&&
|
||||
(stricmp(someConverters[0]->getName(err),DEFAULT_CODEPAGE)==0))
|
||||
logln("getName ok");
|
||||
else errln("getName failed");
|
||||
logln(someConverters[1]->getName(err));
|
||||
#else
|
||||
if ((strcmp(someConverters[1]->getName(err),"LATIN_1")==0)&&
|
||||
(strcmp(someConverters[0]->getName(err),"LATIN_1")==0))
|
||||
logln("getName ok");
|
||||
else errln("getName failed");
|
||||
logln(someConverters[1]->getName(err));
|
||||
#endif
|
||||
|
||||
logln("\n---Testing UnicodeConverterCPP::operator==...");
|
||||
if (((*someConverters[1] == *someConverters[0])==TRUE)&&
|
||||
(*someConverters[1] == *someConverters[2])==FALSE)
|
||||
|
|
@ -562,7 +568,15 @@ void ConvertTest::TestAmbiguous()
|
|||
{
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
UnicodeConverterCPP *ascii_cnv = 0, *sjis_cnv = 0;
|
||||
const char *target = "\\usr\\local\\share\\data\\icutest.txt";
|
||||
const char target[] = {
|
||||
/* "\\usr\\local\\share\\data\\icutest.txt" */
|
||||
0x5c, 0x75, 0x73, 0x72,
|
||||
0x5c, 0x6c, 0x6f, 0x63, 0x61, 0x6c,
|
||||
0x5c, 0x73, 0x68, 0x61, 0x72, 0x65,
|
||||
0x5c, 0x64, 0x61, 0x74, 0x61,
|
||||
0x5c, 0x69, 0x63, 0x75, 0x74, 0x65, 0x73, 0x74, 0x2e, 0x74, 0x78, 0x74,
|
||||
0
|
||||
};
|
||||
UnicodeString asciiResult, sjisResult;
|
||||
|
||||
sjis_cnv = new UnicodeConverterCPP("SJIS", status);
|
||||
|
|
|
|||
|
|
@ -37,25 +37,25 @@ CollationDanishTest::~CollationDanishTest()
|
|||
}
|
||||
|
||||
const UChar CollationDanishTest::testSourceCases[][CollationDanishTest::MAX_TOKEN_LEN] = {
|
||||
{'L', 'u', 'c', 0},
|
||||
{'l', 'u', 'c', 'k', 0},
|
||||
{'L', 0x00FC, 'b', 'e', 'c', 'k', 0},
|
||||
{'L', 0x00E4, 'v', 'i', 0},
|
||||
{'L', 0x00F6, 'w', 'w', 0},
|
||||
{'L', 'v', 'i', 0},
|
||||
{'L', 0x00E4, 'v', 'i', 0},
|
||||
{'L', 0x00FC, 'b', 'e', 'c', 'k', 0}
|
||||
{0x4c, 0x75, 0x63, 0},
|
||||
{0x6c, 0x75, 0x63, 0x6b, 0},
|
||||
{0x4c, 0x00FC, 0x62, 0x65, 0x63, 0x6b, 0},
|
||||
{0x4c, 0x00E4, 0x76, 0x69, 0},
|
||||
{0x4c, 0x00F6, 0x77, 0x77, 0},
|
||||
{0x4c, 0x76, 0x69, 0},
|
||||
{0x4c, 0x00E4, 0x76, 0x69, 0},
|
||||
{0x4c, 0x00FC, 0x62, 0x65, 0x63, 0x6b, 0}
|
||||
};
|
||||
|
||||
const UChar CollationDanishTest::testTargetCases[][CollationDanishTest::MAX_TOKEN_LEN] = {
|
||||
{'l', 'u', 'c', 'k', 0},
|
||||
{'L', 0x00FC, 'b', 'e', 'c', 'k', 0},
|
||||
{'l', 'y', 'b', 'e', 'c', 'k', 0},
|
||||
{'L', 0x00F6, 'w', 'e', 0},
|
||||
{'m', 'a', 's', 't', 0},
|
||||
{'L', 'w', 'i', 0},
|
||||
{'L', 0x00F6, 'w', 'i', 0},
|
||||
{'L', 'y', 'b', 'e', 'c', 'k', 0}
|
||||
{0x6c, 0x75, 0x63, 0x6b, 0},
|
||||
{0x4c, 0x00FC, 0x62, 0x65, 0x63, 0x6b, 0},
|
||||
{0x6c, 0x79, 0x62, 0x65, 0x63, 0x6b, 0},
|
||||
{0x4c, 0x00F6, 0x77, 0x65, 0},
|
||||
{0x6d, 0x61, 0x73, 0x74, 0},
|
||||
{0x4c, 0x77, 0x69, 0},
|
||||
{0x4c, 0x00F6, 0x77, 0x69, 0},
|
||||
{0x4c, 0x79, 0x62, 0x65, 0x63, 0x6b, 0}
|
||||
};
|
||||
|
||||
const Collator::EComparisonResult CollationDanishTest::results[] = {
|
||||
|
|
@ -71,117 +71,117 @@ const Collator::EComparisonResult CollationDanishTest::results[] = {
|
|||
};
|
||||
|
||||
const UChar CollationDanishTest::testBugs[][CollationDanishTest::MAX_TOKEN_LEN] = {
|
||||
{'A', '/', 'S', 0},
|
||||
{'A', 'N', 'D', 'R', 'E', 0},
|
||||
{'A', 'N', 'D', 'R', 0x00C9, 0},
|
||||
{'A', 'N', 'D', 'R', 'E', 'A', 'S', 0},
|
||||
{'A', 'S', 0},
|
||||
{'C', 'A', 0},
|
||||
{0x00C7, 'A', 0},
|
||||
{'C', 'B', 0},
|
||||
{0x00C7, 'C', 0},
|
||||
{'D', '.', 'S', '.', 'B', '.', 0},
|
||||
{'D', 'A', 0}, // 10
|
||||
{'D', 'B', 0},
|
||||
{'D', 'S', 'B', 0},
|
||||
{'D', 'S', 'C', 0},
|
||||
{'E', 'K', 'S', 'T', 'R', 'A', '_', 'A', 'R', 'B', 'E', 'J', 'D', 'E', 0},
|
||||
{'E', 'K', 'S', 'T', 'R', 'A', 'B', 'U', 'D', 0},
|
||||
{'H', 0x00D8, 'S', 'T', 0}, // could the 0x00D8 be 0x2205?
|
||||
{'H', 'A', 'A', 'G', 0}, // 20
|
||||
{'H', 0x00C5, 'N', 'D', 'B', 'O', 'G', 0},
|
||||
{'H', 'A', 'A', 'N', 'D', 'V', 0x00C6, 'R', 'K', 'S', 'B', 'A', 'N', 'K', 'E', 'N', 0},
|
||||
{'k', 'a', 'r', 'l', 0},
|
||||
{'K', 'a', 'r', 'l', 0},
|
||||
{'N', 'I', 'E', 'L', 'S', 'E', 'N', 0},
|
||||
{'N', 'I', 'E', 'L', 'S', ' ', 'J', 0x00D8, 'R', 'G', 'E', 'N', 0},
|
||||
{'N', 'I', 'E', 'L', 'S', '-', 'J', 0x00D8, 'R', 'G', 'E', 'N', 0},
|
||||
{'R', 0x00C9, 'E', ',', ' ', 'A', 0},
|
||||
{'R', 'E', 'E', ',', ' ', 'B', 0},
|
||||
{'R', 0x00C9, 'E', ',', ' ', 'L', 0}, // 30
|
||||
{'R', 'E', 'E', ',', ' ', 'V', 0},
|
||||
{'S', 'C', 'H', 'Y', 'T', 'T', ',', ' ', 'B', 0},
|
||||
{'S', 'C', 'H', 'Y', 'T', 'T', ',', ' ', 'H', 0},
|
||||
{'S', 'C', 'H', 0x00DC, 'T', 'T', ',', ' ', 'H', 0},
|
||||
{'S', 'C', 'H', 'Y', 'T', 'T', ',', ' ', 'L', 0},
|
||||
{'S', 'C', 'H', 0x00DC, 'T', 'T', ',', ' ', 'M', 0},
|
||||
{'S', 'S', 0},
|
||||
{0x41, 0x2f, 0x53, 0},
|
||||
{0x41, 0x4e, 0x44, 0x52, 0x45, 0},
|
||||
{0x41, 0x4e, 0x44, 0x52, 0x00C9, 0},
|
||||
{0x41, 0x4e, 0x44, 0x52, 0x45, 0x41, 0x53, 0},
|
||||
{0x41, 0x53, 0},
|
||||
{0x43, 0x41, 0},
|
||||
{0x00C7, 0x41, 0},
|
||||
{0x43, 0x42, 0},
|
||||
{0x00C7, 0x43, 0},
|
||||
{0x44, 0x2e, 0x53, 0x2e, 0x42, 0x2e, 0},
|
||||
{0x44, 0x41, 0}, // 10
|
||||
{0x44, 0x42, 0},
|
||||
{0x44, 0x53, 0x42, 0},
|
||||
{0x44, 0x53, 0x43, 0},
|
||||
{0x45, 0x4b, 0x53, 0x54, 0x52, 0x41, 0x5f, 0x41, 0x52, 0x42, 0x45, 0x4a, 0x44, 0x45, 0},
|
||||
{0x45, 0x4b, 0x53, 0x54, 0x52, 0x41, 0x42, 0x55, 0x44, 0},
|
||||
{0x48, 0x00D8, 0x53, 0x54, 0}, // could the 0x00D8 be 0x2205?
|
||||
{0x48, 0x41, 0x41, 0x47, 0}, // 20
|
||||
{0x48, 0x00C5, 0x4e, 0x44, 0x42, 0x4f, 0x47, 0},
|
||||
{0x48, 0x41, 0x41, 0x4e, 0x44, 0x56, 0x00C6, 0x52, 0x4b, 0x53, 0x42, 0x41, 0x4e, 0x4b, 0x45, 0x4e, 0},
|
||||
{0x6b, 0x61, 0x72, 0x6c, 0},
|
||||
{0x4b, 0x61, 0x72, 0x6c, 0},
|
||||
{0x4e, 0x49, 0x45, 0x4c, 0x53, 0x45, 0x4e, 0},
|
||||
{0x4e, 0x49, 0x45, 0x4c, 0x53, 0x20, 0x4a, 0x00D8, 0x52, 0x47, 0x45, 0x4e, 0},
|
||||
{0x4e, 0x49, 0x45, 0x4c, 0x53, 0x2d, 0x4a, 0x00D8, 0x52, 0x47, 0x45, 0x4e, 0},
|
||||
{0x52, 0x00C9, 0x45, 0x2c, 0x20, 0x41, 0},
|
||||
{0x52, 0x45, 0x45, 0x2c, 0x20, 0x42, 0},
|
||||
{0x52, 0x00C9, 0x45, 0x2c, 0x20, 0x4c, 0}, // 30
|
||||
{0x52, 0x45, 0x45, 0x2c, 0x20, 0x56, 0},
|
||||
{0x53, 0x43, 0x48, 0x59, 0x54, 0x54, 0x2c, 0x20, 0x42, 0},
|
||||
{0x53, 0x43, 0x48, 0x59, 0x54, 0x54, 0x2c, 0x20, 0x48, 0},
|
||||
{0x53, 0x43, 0x48, 0x00DC, 0x54, 0x54, 0x2c, 0x20, 0x48, 0},
|
||||
{0x53, 0x43, 0x48, 0x59, 0x54, 0x54, 0x2c, 0x20, 0x4c, 0},
|
||||
{0x53, 0x43, 0x48, 0x00DC, 0x54, 0x54, 0x2c, 0x20, 0x4d, 0},
|
||||
{0x53, 0x53, 0},
|
||||
{0x00DF, 0},
|
||||
{'S', 'S', 'A', 0},
|
||||
{'S', 'T', 'O', 'R', 'E', 'K', 0x00C6, 'R', 0},
|
||||
{'S', 'T', 'O', 'R', 'E', ' ', 'V', 'I', 'L', 'D', 'M', 'O', 'S', 'E', 0}, // 40
|
||||
{'S', 'T', 'O', 'R', 'M', 'L', 'Y', 0},
|
||||
{'S', 'T', 'O', 'R', 'M', ' ', 'P', 'E', 'T', 'E', 'R', 'S', 'E', 'N', 0},
|
||||
{'T', 'H', 'O', 'R', 'V', 'A', 'L', 'D', 0},
|
||||
{'T', 'H', 'O', 'R', 'V', 'A', 'R', 'D', 'U', 'R', 0},
|
||||
{0x00FE, 'O', 'R', 'V', 'A', 'R', 0x0110, 'U', 'R', 0},
|
||||
{'T', 'H', 'Y', 'G', 'E', 'S', 'E', 'N', 0},
|
||||
{'V', 'E', 'S', 'T', 'E', 'R', 'G', 0x00C5, 'R', 'D', ',', ' ', 'A', 0},
|
||||
{'V', 'E', 'S', 'T', 'E', 'R', 'G', 'A', 'A', 'R', 'D', ',', ' ', 'A', 0},
|
||||
{'V', 'E', 'S', 'T', 'E', 'R', 'G', 0x00C5, 'R', 'D', ',', ' ', 'B', 0}, // 50
|
||||
{0x00C6, 'B', 'L', 'E', 0},
|
||||
{0x00C4, 'B', 'L', 'E', 0},
|
||||
{0x00D8, 'B', 'E', 'R', 'G', 0},
|
||||
{0x00D6, 'B', 'E', 'R', 'G', 0},
|
||||
{0x0110, 'A', 0},
|
||||
{0x0110, 'C', 0} // 54
|
||||
{0x53, 0x53, 0x41, 0},
|
||||
{0x53, 0x54, 0x4f, 0x52, 0x45, 0x4b, 0x00C6, 0x52, 0},
|
||||
{0x53, 0x54, 0x4f, 0x52, 0x45, 0x20, 0x56, 0x49, 0x4c, 0x44, 0x4d, 0x4f, 0x53, 0x45, 0}, // 40
|
||||
{0x53, 0x54, 0x4f, 0x52, 0x4d, 0x4c, 0x59, 0},
|
||||
{0x53, 0x54, 0x4f, 0x52, 0x4d, 0x20, 0x50, 0x45, 0x54, 0x45, 0x52, 0x53, 0x45, 0x4e, 0},
|
||||
{0x54, 0x48, 0x4f, 0x52, 0x56, 0x41, 0x4c, 0x44, 0},
|
||||
{0x54, 0x48, 0x4f, 0x52, 0x56, 0x41, 0x52, 0x44, 0x55, 0x52, 0},
|
||||
{0x00FE, 0x4f, 0x52, 0x56, 0x41, 0x52, 0x0110, 0x55, 0x52, 0},
|
||||
{0x54, 0x48, 0x59, 0x47, 0x45, 0x53, 0x45, 0x4e, 0},
|
||||
{0x56, 0x45, 0x53, 0x54, 0x45, 0x52, 0x47, 0x00C5, 0x52, 0x44, 0x2c, 0x20, 0x41, 0},
|
||||
{0x56, 0x45, 0x53, 0x54, 0x45, 0x52, 0x47, 0x41, 0x41, 0x52, 0x44, 0x2c, 0x20, 0x41, 0},
|
||||
{0x56, 0x45, 0x53, 0x54, 0x45, 0x52, 0x47, 0x00C5, 0x52, 0x44, 0x2c, 0x20, 0x42, 0}, // 50
|
||||
{0x00C6, 0x42, 0x4c, 0x45, 0},
|
||||
{0x00C4, 0x42, 0x4c, 0x45, 0},
|
||||
{0x00D8, 0x42, 0x45, 0x52, 0x47, 0},
|
||||
{0x00D6, 0x42, 0x45, 0x52, 0x47, 0},
|
||||
{0x0110, 0x41, 0},
|
||||
{0x0110, 0x43, 0} // 54
|
||||
};
|
||||
|
||||
const UChar CollationDanishTest::testNTList[][CollationDanishTest::MAX_TOKEN_LEN] = {
|
||||
{'a', 'n', 'd', 'e', 'r', 'e', 0},
|
||||
{'c', 'h', 'a', 'q', 'u', 'e', 0},
|
||||
{'c', 'h', 'e', 'm', 'i', 'n', 0},
|
||||
{'c', 'o', 't', 'e', 0},
|
||||
{'c', 'o', 't', 0x00e9, 0},
|
||||
{'c', 0x00f4, 't', 'e', 0},
|
||||
{'c', 0x00f4, 't', 0x00e9, 0},
|
||||
{0x010d, 'u', 0x010d, 0x0113, 't', 0},
|
||||
{'C', 'z', 'e', 'c', 'h', 0},
|
||||
{'h', 'i', 0x0161, 'a', 0},
|
||||
{'i', 'r', 'd', 'i', 's', 'c', 'h', 0},
|
||||
{'l', 'i', 'e', 0},
|
||||
{'l', 'i', 'r', 'e', 0},
|
||||
{'l', 'l', 'a', 'm', 'a', 0},
|
||||
{'l', 0x00f5, 'u', 'g', 0},
|
||||
{'l', 0x00f2, 'z', 'a', 0},
|
||||
{'l', 'u', 0x010d, 0},
|
||||
{'l', 'u', 'c', 'k', 0},
|
||||
{'L', 0x00fc, 'b', 'e', 'c', 'k', 0},
|
||||
{'l', 'y', 'e', 0}, /* 20 */
|
||||
{'l', 0x00e4, 'v', 'i', 0},
|
||||
{'L', 0x00f6, 'w', 'e', 'n', 0},
|
||||
{'m', 0x00e0, 0x0161, 't', 'a', 0},
|
||||
{'m', 0x00ee, 'r', 0},
|
||||
{'m', 'y', 'n', 'd', 'i', 'g', 0},
|
||||
{'M', 0x00e4, 'n', 'n', 'e', 'r', 0},
|
||||
{'m', 0x00f6, 'c', 'h', 't', 'e', 'n', 0},
|
||||
{'p', 'i', 0x00f1, 'a', 0},
|
||||
{'p', 'i', 'n', 't', 0},
|
||||
{'p', 'y', 'l', 'o', 'n', 0},
|
||||
{0x0161, 0x00e0, 'r', 'a', 'n', 0},
|
||||
{'s', 'a', 'v', 'o', 'i', 'r', 0},
|
||||
{0x0160, 'e', 'r', 'b', 0x016b, 'r', 'a', 0},
|
||||
{'S', 'i', 'e', 't', 'l', 'a', 0},
|
||||
{0x015b, 'l', 'u', 'b', 0},
|
||||
{'s', 'u', 'b', 't', 'l', 'e', 0},
|
||||
{'s', 'y', 'm', 'b', 'o', 'l', 0},
|
||||
{'s', 0x00e4, 'm', 't', 'l', 'i', 'c', 'h', 0},
|
||||
{'w', 'a', 'f', 'f', 'l', 'e', 0},
|
||||
{'v', 'e', 'r', 'k', 'e', 'h', 'r', 't', 0},
|
||||
{'w', 'o', 'o', 'd', 0},
|
||||
{'v', 'o', 'x', 0}, /* 40 */
|
||||
{'v', 0x00e4, 'g', 'a', 0},
|
||||
{'y', 'e', 'n', 0},
|
||||
{'y', 'u', 'a', 'n', 0},
|
||||
{'y', 'u', 'c', 'c', 'a', 0},
|
||||
{0x017e, 'a', 'l', 0},
|
||||
{0x017e, 'e', 'n', 'a', 0},
|
||||
{0x017d, 'e', 'n', 0x0113, 'v', 'a', 0},
|
||||
{'z', 'o', 'o', 0},
|
||||
{'Z', 'v', 'i', 'e', 'd', 'r', 'i', 'j', 'a', 0},
|
||||
{'Z', 0x00fc, 'r', 'i', 'c', 'h', 0},
|
||||
{'z', 'y', 's', 'k', 0},
|
||||
{0x00e4, 'n', 'd', 'e', 'r', 'e', 0} /* 53 */
|
||||
{0x61, 0x6e, 0x64, 0x65, 0x72, 0x65, 0},
|
||||
{0x63, 0x68, 0x61, 0x71, 0x75, 0x65, 0},
|
||||
{0x63, 0x68, 0x65, 0x6d, 0x69, 0x6e, 0},
|
||||
{0x63, 0x6f, 0x74, 0x65, 0},
|
||||
{0x63, 0x6f, 0x74, 0x00e9, 0},
|
||||
{0x63, 0x00f4, 0x74, 0x65, 0},
|
||||
{0x63, 0x00f4, 0x74, 0x00e9, 0},
|
||||
{0x010d, 0x75, 0x010d, 0x0113, 0x74, 0},
|
||||
{0x43, 0x7a, 0x65, 0x63, 0x68, 0},
|
||||
{0x68, 0x69, 0x0161, 0x61, 0},
|
||||
{0x69, 0x72, 0x64, 0x69, 0x73, 0x63, 0x68, 0},
|
||||
{0x6c, 0x69, 0x65, 0},
|
||||
{0x6c, 0x69, 0x72, 0x65, 0},
|
||||
{0x6c, 0x6c, 0x61, 0x6d, 0x61, 0},
|
||||
{0x6c, 0x00f5, 0x75, 0x67, 0},
|
||||
{0x6c, 0x00f2, 0x7a, 0x61, 0},
|
||||
{0x6c, 0x75, 0x010d, 0},
|
||||
{0x6c, 0x75, 0x63, 0x6b, 0},
|
||||
{0x4c, 0x00fc, 0x62, 0x65, 0x63, 0x6b, 0},
|
||||
{0x6c, 0x79, 0x65, 0}, /* 20 */
|
||||
{0x6c, 0x00e4, 0x76, 0x69, 0},
|
||||
{0x4c, 0x00f6, 0x77, 0x65, 0x6e, 0},
|
||||
{0x6d, 0x00e0, 0x0161, 0x74, 0x61, 0},
|
||||
{0x6d, 0x00ee, 0x72, 0},
|
||||
{0x6d, 0x79, 0x6e, 0x64, 0x69, 0x67, 0},
|
||||
{0x4d, 0x00e4, 0x6e, 0x6e, 0x65, 0x72, 0},
|
||||
{0x6d, 0x00f6, 0x63, 0x68, 0x74, 0x65, 0x6e, 0},
|
||||
{0x70, 0x69, 0x00f1, 0x61, 0},
|
||||
{0x70, 0x69, 0x6e, 0x74, 0},
|
||||
{0x70, 0x79, 0x6c, 0x6f, 0x6e, 0},
|
||||
{0x0161, 0x00e0, 0x72, 0x61, 0x6e, 0},
|
||||
{0x73, 0x61, 0x76, 0x6f, 0x69, 0x72, 0},
|
||||
{0x0160, 0x65, 0x72, 0x62, 0x016b, 0x72, 0x61, 0},
|
||||
{0x53, 0x69, 0x65, 0x74, 0x6c, 0x61, 0},
|
||||
{0x015b, 0x6c, 0x75, 0x62, 0},
|
||||
{0x73, 0x75, 0x62, 0x74, 0x6c, 0x65, 0},
|
||||
{0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0},
|
||||
{0x73, 0x00e4, 0x6d, 0x74, 0x6c, 0x69, 0x63, 0x68, 0},
|
||||
{0x77, 0x61, 0x66, 0x66, 0x6c, 0x65, 0},
|
||||
{0x76, 0x65, 0x72, 0x6b, 0x65, 0x68, 0x72, 0x74, 0},
|
||||
{0x77, 0x6f, 0x6f, 0x64, 0},
|
||||
{0x76, 0x6f, 0x78, 0}, /* 40 */
|
||||
{0x76, 0x00e4, 0x67, 0x61, 0},
|
||||
{0x79, 0x65, 0x6e, 0},
|
||||
{0x79, 0x75, 0x61, 0x6e, 0},
|
||||
{0x79, 0x75, 0x63, 0x63, 0x61, 0},
|
||||
{0x017e, 0x61, 0x6c, 0},
|
||||
{0x017e, 0x65, 0x6e, 0x61, 0},
|
||||
{0x017d, 0x65, 0x6e, 0x0113, 0x76, 0x61, 0},
|
||||
{0x7a, 0x6f, 0x6f, 0},
|
||||
{0x5a, 0x76, 0x69, 0x65, 0x64, 0x72, 0x69, 0x6a, 0x61, 0},
|
||||
{0x5a, 0x00fc, 0x72, 0x69, 0x63, 0x68, 0},
|
||||
{0x7a, 0x79, 0x73, 0x6b, 0},
|
||||
{0x00e4, 0x6e, 0x64, 0x65, 0x72, 0x65, 0} /* 53 */
|
||||
};
|
||||
void CollationDanishTest::doTest( UnicodeString source, UnicodeString target, Collator::EComparisonResult result)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -39,34 +39,34 @@ CollationGermanTest::~CollationGermanTest()
|
|||
|
||||
const UChar CollationGermanTest::testSourceCases[][CollationGermanTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'G', 'r', 0x00F6, 0x00DF, 'e', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'T', 0x00F6, 'n', 'e', 0},
|
||||
{'T', 0x00F6, 'n', 'e', 0},
|
||||
{'T', 0x00F6, 'n', 'e', 0},
|
||||
{'a', 0x0308, 'b', 'c', 0},
|
||||
{0x00E4, 'b', 'c', 0},
|
||||
{0x00E4, 'b', 'c', 0},
|
||||
{'S', 't', 'r', 'a', 0x00DF, 'e', 0},
|
||||
{'e', 'f', 'g', 0},
|
||||
{0x00E4, 'b', 'c', 0},
|
||||
{'S', 't', 'r', 'a', 0x00DF, 'e', 0}
|
||||
{0x47, 0x72, 0x00F6, 0x00DF, 0x65, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x54, 0x00F6, 0x6e, 0x65, 0},
|
||||
{0x54, 0x00F6, 0x6e, 0x65, 0},
|
||||
{0x54, 0x00F6, 0x6e, 0x65, 0},
|
||||
{0x61, 0x0308, 0x62, 0x63, 0},
|
||||
{0x00E4, 0x62, 0x63, 0},
|
||||
{0x00E4, 0x62, 0x63, 0},
|
||||
{0x53, 0x74, 0x72, 0x61, 0x00DF, 0x65, 0},
|
||||
{0x65, 0x66, 0x67, 0},
|
||||
{0x00E4, 0x62, 0x63, 0},
|
||||
{0x53, 0x74, 0x72, 0x61, 0x00DF, 0x65, 0}
|
||||
};
|
||||
|
||||
const UChar CollationGermanTest::testTargetCases[][CollationGermanTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'G', 'r', 'o', 's', 's', 'i', 's', 't', 0},
|
||||
{'a', 0x0308, 'b', 'c', 0},
|
||||
{'T', 'o', 'n', 0},
|
||||
{'T', 'o', 'd', 0},
|
||||
{'T', 'o', 'f', 'u', 0},
|
||||
{'A', 0x0308, 'b', 'c', 0},
|
||||
{'a', 0x0308, 'b', 'c', 0},
|
||||
{'a', 'e', 'b', 'c', 0},
|
||||
{'S', 't', 'r', 'a', 's', 's', 'e', 0},
|
||||
{'e', 'f', 'g', 0},
|
||||
{'a', 'e', 'b', 'c', 0},
|
||||
{'S', 't', 'r', 'a', 's', 's', 'e', 0}
|
||||
{0x47, 0x72, 0x6f, 0x73, 0x73, 0x69, 0x73, 0x74, 0},
|
||||
{0x61, 0x0308, 0x62, 0x63, 0},
|
||||
{0x54, 0x6f, 0x6e, 0},
|
||||
{0x54, 0x6f, 0x64, 0},
|
||||
{0x54, 0x6f, 0x66, 0x75, 0},
|
||||
{0x41, 0x0308, 0x62, 0x63, 0},
|
||||
{0x61, 0x0308, 0x62, 0x63, 0},
|
||||
{0x61, 0x65, 0x62, 0x63, 0},
|
||||
{0x53, 0x74, 0x72, 0x61, 0x73, 0x73, 0x65, 0},
|
||||
{0x65, 0x66, 0x67, 0},
|
||||
{0x61, 0x65, 0x62, 0x63, 0},
|
||||
{0x53, 0x74, 0x72, 0x61, 0x73, 0x73, 0x65, 0}
|
||||
};
|
||||
|
||||
const Collator::EComparisonResult CollationGermanTest::results[][2] =
|
||||
|
|
|
|||
|
|
@ -257,7 +257,7 @@ DateFormatTest::TestFieldPosition(void)
|
|||
"", "1997", "August", "", "", "13", "", "Wednesday", "", "PM", "2", "",
|
||||
"34", "12", "", "PDT", "",
|
||||
/* Following two added by weiv for two new fields */ "", "",
|
||||
"", "1997", "ao\373t",/* 373 = 0xFB */ "", "", "13", "", "mercredi",
|
||||
"", "1997", "#",/* # is a marker for "ao\xfbt" == "aou^t" */ "", "", "13", "", "mercredi",
|
||||
"", "", "", "14", "34", "", "", "GMT-07:00", "",
|
||||
/* Following two added by weiv for two new fields */ "", "",
|
||||
"AD", "97", "8", "33", "3", "13", "225", "Wed", "2", "PM", "2",
|
||||
|
|
@ -287,7 +287,14 @@ DateFormatTest::TestFieldPosition(void)
|
|||
for (int32_t i = 0; i < Calendar::FIELD_COUNT;++i) {
|
||||
UnicodeString field;
|
||||
getFieldText(df, i, someDate, field);
|
||||
UnicodeString expStr(expected[exp]);
|
||||
UnicodeString expStr;
|
||||
if(expected[exp][0]!='#') {
|
||||
expStr=UnicodeString(expected[exp]);
|
||||
} else {
|
||||
/* we cannot have latin-1 characters in source code, therefore we fix up the string for "aou^t" */
|
||||
expStr.append(0x61).append(0x6f).append(0xfb).append(0x74);
|
||||
}
|
||||
|
||||
if (!(field == expStr)) errln(UnicodeString("FAIL: field #") + i + " " +
|
||||
fieldNames[i] + " = \"" + escape(field) + "\", expected \"" + escape(expStr) + "\"");
|
||||
++exp;
|
||||
|
|
|
|||
|
|
@ -38,107 +38,107 @@ CollationEnglishTest::~CollationEnglishTest()
|
|||
}
|
||||
|
||||
const UChar CollationEnglishTest::testSourceCases[][CollationEnglishTest::MAX_TOKEN_LEN] = {
|
||||
{'a', 'b', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', '-', 'b', 'i', 'r', 'd', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', ' ', 'b', 'i', 'r', 'd', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', '-', 'b', 'i', 'r', 'd', 0},
|
||||
{'H', 'e', 'l', 'l', 'o', 0},
|
||||
{'A', 'B', 'C', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', 'b', 'i', 'r', 'd', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', '-', 'b', 'i', 'r', 'd', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', '-', 'b', 'i', 'r', 'd', 0},
|
||||
{'p', 0x00EA, 'c', 'h', 'e', 0}, // 10
|
||||
{'p', 0x00E9, 'c', 'h', 0x00E9, 0},
|
||||
{0x00C4, 'B', 0x0308, 'C', 0x0308, 0},
|
||||
{'a', 0x0308, 'b', 'c', 0},
|
||||
{'p', 0x00E9, 'c', 'h', 'e', 'r', 0},
|
||||
{'r', 'o', 'l', 'e', 's', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'A', 0},
|
||||
{'A', 0},
|
||||
{'a', 'b', 0}, // 20
|
||||
{'t', 'c', 'o', 'm', 'p', 'a', 'r', 'e', 'p', 'l', 'a', 'i', 'n', 0},
|
||||
{'a', 'b', 0},
|
||||
{'a', '#', 'b', 0},
|
||||
{'a', '#', 'b', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'A', 'b', 'c', 'd', 'a', 0},
|
||||
{'a', 'b', 'c', 'd', 'a', 0},
|
||||
{'a', 'b', 'c', 'd', 'a', 0},
|
||||
{0x00E6, 'b', 'c', 'd', 'a', 0},
|
||||
{0x00E4, 'b', 'c', 'd', 'a', 0}, // 30
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'c', 'H', 'c', 0},
|
||||
{'a', 0x0308, 'b', 'c', 0},
|
||||
{'t', 'h', 'i', 0x0302, 's', 0},
|
||||
{'p', 0x00EA, 'c', 'h', 'e'},
|
||||
{'a', 'b', 'c', 0}, // 40
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 0x00E6, 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 0x00E6, 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'p', 0x00E9, 'c', 'h', 0x00E9, 0} // 49
|
||||
{0x61, 0x62, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x2d, 0x62, 0x69, 0x72, 0x64, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x20, 0x62, 0x69, 0x72, 0x64, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x2d, 0x62, 0x69, 0x72, 0x64, 0},
|
||||
{0x48, 0x65, 0x6c, 0x6c, 0x6f, 0},
|
||||
{0x41, 0x42, 0x43, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x62, 0x69, 0x72, 0x64, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x2d, 0x62, 0x69, 0x72, 0x64, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x2d, 0x62, 0x69, 0x72, 0x64, 0},
|
||||
{0x70, 0x00EA, 0x63, 0x68, 0x65, 0}, // 10
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x00E9, 0},
|
||||
{0x00C4, 0x42, 0x0308, 0x43, 0x0308, 0},
|
||||
{0x61, 0x0308, 0x62, 0x63, 0},
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x65, 0x72, 0},
|
||||
{0x72, 0x6f, 0x6c, 0x65, 0x73, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x41, 0},
|
||||
{0x41, 0},
|
||||
{0x61, 0x62, 0}, // 20
|
||||
{0x74, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0},
|
||||
{0x61, 0x62, 0},
|
||||
{0x61, 0x23, 0x62, 0},
|
||||
{0x61, 0x23, 0x62, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x41, 0x62, 0x63, 0x64, 0x61, 0},
|
||||
{0x61, 0x62, 0x63, 0x64, 0x61, 0},
|
||||
{0x61, 0x62, 0x63, 0x64, 0x61, 0},
|
||||
{0x00E6, 0x62, 0x63, 0x64, 0x61, 0},
|
||||
{0x00E4, 0x62, 0x63, 0x64, 0x61, 0}, // 30
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x63, 0x48, 0x63, 0},
|
||||
{0x61, 0x0308, 0x62, 0x63, 0},
|
||||
{0x74, 0x68, 0x69, 0x0302, 0x73, 0},
|
||||
{0x70, 0x00EA, 0x63, 0x68, 0x65},
|
||||
{0x61, 0x62, 0x63, 0}, // 40
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x00E6, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x00E6, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x00E9, 0} // 49
|
||||
};
|
||||
|
||||
const UChar CollationEnglishTest::testTargetCases[][CollationEnglishTest::MAX_TOKEN_LEN] = {
|
||||
{'a', 'b', 'c', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', 'b', 'i', 'r', 'd', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', '-', 'b', 'i', 'r', 'd', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', 0},
|
||||
{'h', 'e', 'l', 'l', 'o', 0},
|
||||
{'A', 'B', 'C', 0},
|
||||
{'A', 'B', 'C', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', 'b', 'i', 'r', 'd', 's', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', 'b', 'i', 'r', 'd', 's', 0},
|
||||
{'b', 'l', 'a', 'c', 'k', 'b', 'i', 'r', 'd', 0}, // 10
|
||||
{'p', 0x00E9, 'c', 'h', 0x00E9, 0},
|
||||
{'p', 0x00E9, 'c', 'h', 'e', 'r', 0},
|
||||
{0x00C4, 'B', 0x0308, 'C', 0x0308, 0},
|
||||
{'A', 0x0308, 'b', 'c', 0},
|
||||
{'p', 0x00E9, 'c', 'h', 'e', 0},
|
||||
{'r', 'o', 0x0302, 'l', 'e', 0},
|
||||
{'A', 0x00E1, 'c', 'd', 0},
|
||||
{'A', 0x00E1, 'c', 'd', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', 'c', 0}, // 20
|
||||
{'T', 'C', 'o', 'm', 'p', 'a', 'r', 'e', 'P', 'l', 'a', 'i', 'n', 0},
|
||||
{'a', 'B', 'c', 0},
|
||||
{'a', '#', 'B', 0},
|
||||
{'a', '&', 'b', 0},
|
||||
{'a', '#', 'c', 0},
|
||||
{'a', 'b', 'c', 'd', 'a', 0},
|
||||
{0x00C4, 'b', 'c', 'd', 'a', 0},
|
||||
{0x00E4, 'b', 'c', 'd', 'a', 0},
|
||||
{0x00C4, 'b', 'c', 'd', 'a', 0},
|
||||
{0x00C4, 'b', 'c', 'd', 'a', 0}, // 30
|
||||
{'a', 'b', '#', 'c', 0},
|
||||
{'a', 'b', 'c', 0},
|
||||
{'a', 'b', '=', 'c', 0},
|
||||
{'a', 'b', 'd', 0},
|
||||
{0x00E4, 'b', 'c', 0},
|
||||
{'a', 'C', 'H', 'c', 0},
|
||||
{0x00E4, 'b', 'c', 0},
|
||||
{'t', 'h', 0x00EE, 's', 0},
|
||||
{'p', 0x00E9, 'c', 'h', 0x00E9, 0},
|
||||
{'a', 'B', 'C', 0}, // 40
|
||||
{'a', 'b', 'd', 0},
|
||||
{0x00E4, 'b', 'c', 0},
|
||||
{'a', 0x00C6, 'c', 0},
|
||||
{'a', 'B', 'd', 0},
|
||||
{0x00E4, 'b', 'c', 0},
|
||||
{'a', 0x00C6, 'c', 0},
|
||||
{'a', 'B', 'd', 0},
|
||||
{0x00E4, 'b', 'c', 0},
|
||||
{'p', 0x00EA, 'c', 'h', 'e', 0} // 49
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x62, 0x69, 0x72, 0x64, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x2d, 0x62, 0x69, 0x72, 0x64, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0},
|
||||
{0x68, 0x65, 0x6c, 0x6c, 0x6f, 0},
|
||||
{0x41, 0x42, 0x43, 0},
|
||||
{0x41, 0x42, 0x43, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x62, 0x69, 0x72, 0x64, 0x73, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x62, 0x69, 0x72, 0x64, 0x73, 0},
|
||||
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x62, 0x69, 0x72, 0x64, 0}, // 10
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x00E9, 0},
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x65, 0x72, 0},
|
||||
{0x00C4, 0x42, 0x0308, 0x43, 0x0308, 0},
|
||||
{0x41, 0x0308, 0x62, 0x63, 0},
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x65, 0},
|
||||
{0x72, 0x6f, 0x0302, 0x6c, 0x65, 0},
|
||||
{0x41, 0x00E1, 0x63, 0x64, 0},
|
||||
{0x41, 0x00E1, 0x63, 0x64, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0}, // 20
|
||||
{0x54, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x65, 0x50, 0x6c, 0x61, 0x69, 0x6e, 0},
|
||||
{0x61, 0x42, 0x63, 0},
|
||||
{0x61, 0x23, 0x42, 0},
|
||||
{0x61, 0x26, 0x62, 0},
|
||||
{0x61, 0x23, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0x64, 0x61, 0},
|
||||
{0x00C4, 0x62, 0x63, 0x64, 0x61, 0},
|
||||
{0x00E4, 0x62, 0x63, 0x64, 0x61, 0},
|
||||
{0x00C4, 0x62, 0x63, 0x64, 0x61, 0},
|
||||
{0x00C4, 0x62, 0x63, 0x64, 0x61, 0}, // 30
|
||||
{0x61, 0x62, 0x23, 0x63, 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x61, 0x62, 0x3d, 0x63, 0},
|
||||
{0x61, 0x62, 0x64, 0},
|
||||
{0x00E4, 0x62, 0x63, 0},
|
||||
{0x61, 0x43, 0x48, 0x63, 0},
|
||||
{0x00E4, 0x62, 0x63, 0},
|
||||
{0x74, 0x68, 0x00EE, 0x73, 0},
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x00E9, 0},
|
||||
{0x61, 0x42, 0x43, 0}, // 40
|
||||
{0x61, 0x62, 0x64, 0},
|
||||
{0x00E4, 0x62, 0x63, 0},
|
||||
{0x61, 0x00C6, 0x63, 0},
|
||||
{0x61, 0x42, 0x64, 0},
|
||||
{0x00E4, 0x62, 0x63, 0},
|
||||
{0x61, 0x00C6, 0x63, 0},
|
||||
{0x61, 0x42, 0x64, 0},
|
||||
{0x00E4, 0x62, 0x63, 0},
|
||||
{0x70, 0x00EA, 0x63, 0x68, 0x65, 0} // 49
|
||||
};
|
||||
|
||||
const Collator::EComparisonResult CollationEnglishTest::results[] = {
|
||||
|
|
@ -198,57 +198,57 @@ const Collator::EComparisonResult CollationEnglishTest::results[] = {
|
|||
};
|
||||
|
||||
const UChar CollationEnglishTest::testBugs[][CollationEnglishTest::MAX_TOKEN_LEN] = {
|
||||
{'a', 0},
|
||||
{'A', 0},
|
||||
{'e', 0},
|
||||
{'E', 0},
|
||||
{0x61, 0},
|
||||
{0x41, 0},
|
||||
{0x65, 0},
|
||||
{0x45, 0},
|
||||
{0x00e9, 0},
|
||||
{0x00e8, 0},
|
||||
{0x00ea, 0},
|
||||
{0x00eb, 0},
|
||||
{'e', 'a', 0},
|
||||
{'x', 0}
|
||||
{0x65, 0x61, 0},
|
||||
{0x78, 0}
|
||||
};
|
||||
|
||||
// 0x0300 is grave, 0x0301 is acute
|
||||
// the order of elements in this array must be different than the order in CollationFrenchTest
|
||||
const UChar CollationEnglishTest::testAcute[][CollationEnglishTest::MAX_TOKEN_LEN] = {
|
||||
{'e', 'e', 0},
|
||||
{'e', 'e', 0x0301, 0},
|
||||
{'e', 'e', 0x0301, 0x0300, 0},
|
||||
{'e', 'e', 0x0300, 0},
|
||||
{'e', 'e', 0x0300, 0x0301, 0},
|
||||
{'e', 0x0301, 'e', 0},
|
||||
{'e', 0x0301, 'e', 0x0301, 0},
|
||||
{'e', 0x0301, 'e', 0x0301, 0x0300, 0},
|
||||
{'e', 0x0301, 'e', 0x0300, 0},
|
||||
{'e', 0x0301, 'e', 0x0300, 0x0301, 0},
|
||||
{'e', 0x0301, 0x0300, 'e', 0},
|
||||
{'e', 0x0301, 0x0300, 'e', 0x0301, 0},
|
||||
{'e', 0x0301, 0x0300, 'e', 0x0301, 0x0300, 0},
|
||||
{'e', 0x0301, 0x0300, 'e', 0x0300, 0},
|
||||
{'e', 0x0301, 0x0300, 'e', 0x0300, 0x0301, 0},
|
||||
{'e', 0x0300, 'e', 0},
|
||||
{'e', 0x0300, 'e', 0x0301, 0},
|
||||
{'e', 0x0300, 'e', 0x0301, 0x0300, 0},
|
||||
{'e', 0x0300, 'e', 0x0300, 0},
|
||||
{'e', 0x0300, 'e', 0x0300, 0x0301, 0},
|
||||
{'e', 0x0300, 0x0301, 'e', 0},
|
||||
{'e', 0x0300, 0x0301, 'e', 0x0301, 0},
|
||||
{'e', 0x0300, 0x0301, 'e', 0x0301, 0x0300, 0},
|
||||
{'e', 0x0300, 0x0301, 'e', 0x0300, 0},
|
||||
{'e', 0x0300, 0x0301, 'e', 0x0300, 0x0301, 0}
|
||||
{0x65, 0x65, 0},
|
||||
{0x65, 0x65, 0x0301, 0},
|
||||
{0x65, 0x65, 0x0301, 0x0300, 0},
|
||||
{0x65, 0x65, 0x0300, 0},
|
||||
{0x65, 0x65, 0x0300, 0x0301, 0},
|
||||
{0x65, 0x0301, 0x65, 0},
|
||||
{0x65, 0x0301, 0x65, 0x0301, 0},
|
||||
{0x65, 0x0301, 0x65, 0x0301, 0x0300, 0},
|
||||
{0x65, 0x0301, 0x65, 0x0300, 0},
|
||||
{0x65, 0x0301, 0x65, 0x0300, 0x0301, 0},
|
||||
{0x65, 0x0301, 0x0300, 0x65, 0},
|
||||
{0x65, 0x0301, 0x0300, 0x65, 0x0301, 0},
|
||||
{0x65, 0x0301, 0x0300, 0x65, 0x0301, 0x0300, 0},
|
||||
{0x65, 0x0301, 0x0300, 0x65, 0x0300, 0},
|
||||
{0x65, 0x0301, 0x0300, 0x65, 0x0300, 0x0301, 0},
|
||||
{0x65, 0x0300, 0x65, 0},
|
||||
{0x65, 0x0300, 0x65, 0x0301, 0},
|
||||
{0x65, 0x0300, 0x65, 0x0301, 0x0300, 0},
|
||||
{0x65, 0x0300, 0x65, 0x0300, 0},
|
||||
{0x65, 0x0300, 0x65, 0x0300, 0x0301, 0},
|
||||
{0x65, 0x0300, 0x0301, 0x65, 0},
|
||||
{0x65, 0x0300, 0x0301, 0x65, 0x0301, 0},
|
||||
{0x65, 0x0300, 0x0301, 0x65, 0x0301, 0x0300, 0},
|
||||
{0x65, 0x0300, 0x0301, 0x65, 0x0300, 0},
|
||||
{0x65, 0x0300, 0x0301, 0x65, 0x0300, 0x0301, 0}
|
||||
};
|
||||
|
||||
static const UChar testMore[][CollationEnglishTest::MAX_TOKEN_LEN] = {
|
||||
{'a', 'e', 0},
|
||||
{0x61, 0x65, 0},
|
||||
{ 0x00E6, 0},
|
||||
{ 0x00C6, 0},
|
||||
{'a', 'f', 0},
|
||||
{'o', 'e', 0},
|
||||
{0x61, 0x66, 0},
|
||||
{0x6f, 0x65, 0},
|
||||
{ 0x0153, 0},
|
||||
{ 0x0152, 0},
|
||||
{'o', 'f', 0},
|
||||
{0x6f, 0x66, 0},
|
||||
};
|
||||
|
||||
void CollationEnglishTest::doTest( UnicodeString source, UnicodeString target, Collator::EComparisonResult result)
|
||||
|
|
|
|||
|
|
@ -38,27 +38,27 @@ CollationSpanishTest::~CollationSpanishTest()
|
|||
}
|
||||
|
||||
const UChar CollationSpanishTest::testSourceCases[][CollationSpanishTest::MAX_TOKEN_LEN] = {
|
||||
{'a', 'l', 'i', 'a', 's', 0},
|
||||
{'E', 'l', 'l', 'i', 'o', 't', 0},
|
||||
{'H', 'e', 'l', 'l', 'o', 0},
|
||||
{'a', 'c', 'H', 'c', 0},
|
||||
{'a', 'c', 'c', 0},
|
||||
{'a', 'l', 'i', 'a', 's', 0},
|
||||
{'a', 'c', 'H', 'c', 0},
|
||||
{'a', 'c', 'c', 0},
|
||||
{'H', 'e', 'l', 'l', 'o', 0},
|
||||
{0x61, 0x6c, 0x69, 0x61, 0x73, 0},
|
||||
{0x45, 0x6c, 0x6c, 0x69, 0x6f, 0x74, 0},
|
||||
{0x48, 0x65, 0x6c, 0x6c, 0x6f, 0},
|
||||
{0x61, 0x63, 0x48, 0x63, 0},
|
||||
{0x61, 0x63, 0x63, 0},
|
||||
{0x61, 0x6c, 0x69, 0x61, 0x73, 0},
|
||||
{0x61, 0x63, 0x48, 0x63, 0},
|
||||
{0x61, 0x63, 0x63, 0},
|
||||
{0x48, 0x65, 0x6c, 0x6c, 0x6f, 0},
|
||||
};
|
||||
|
||||
const UChar CollationSpanishTest::testTargetCases[][CollationSpanishTest::MAX_TOKEN_LEN] = {
|
||||
{'a', 'l', 'l', 'i', 'a', 's', 0},
|
||||
{'E', 'm', 'i', 'o', 't', 0},
|
||||
{'h', 'e', 'l', 'l', 'O', 0},
|
||||
{'a', 'C', 'H', 'c', 0},
|
||||
{'a', 'C', 'H', 'c', 0},
|
||||
{'a', 'l', 'l', 'i', 'a', 's', 0},
|
||||
{'a', 'C', 'H', 'c', 0},
|
||||
{'a', 'C', 'H', 'c', 0},
|
||||
{'h', 'e', 'l', 'l', 'O', 0},
|
||||
{0x61, 0x6c, 0x6c, 0x69, 0x61, 0x73, 0},
|
||||
{0x45, 0x6d, 0x69, 0x6f, 0x74, 0},
|
||||
{0x68, 0x65, 0x6c, 0x6c, 0x4f, 0},
|
||||
{0x61, 0x43, 0x48, 0x63, 0},
|
||||
{0x61, 0x43, 0x48, 0x63, 0},
|
||||
{0x61, 0x6c, 0x6c, 0x69, 0x61, 0x73, 0},
|
||||
{0x61, 0x43, 0x48, 0x63, 0},
|
||||
{0x61, 0x43, 0x48, 0x63, 0},
|
||||
{0x68, 0x65, 0x6c, 0x6c, 0x4f, 0},
|
||||
};
|
||||
|
||||
const Collator::EComparisonResult CollationSpanishTest::results[] = {
|
||||
|
|
|
|||
|
|
@ -37,19 +37,19 @@ CollationFinnishTest::~CollationFinnishTest()
|
|||
}
|
||||
|
||||
const UChar CollationFinnishTest::testSourceCases[][CollationFinnishTest::MAX_TOKEN_LEN] = {
|
||||
{'w', 'a', 't', 0},
|
||||
{'v', 'a', 't', 0},
|
||||
{'a', 0x00FC, 'b', 'e', 'c', 'k', 0},
|
||||
{'L', 0x00E5, 'v', 'i', 0},
|
||||
{'w', 'a', 't', 0}
|
||||
{0x77, 0x61, 0x74, 0},
|
||||
{0x76, 0x61, 0x74, 0},
|
||||
{0x61, 0x00FC, 0x62, 0x65, 0x63, 0x6b, 0},
|
||||
{0x4c, 0x00E5, 0x76, 0x69, 0},
|
||||
{0x77, 0x61, 0x74, 0}
|
||||
};
|
||||
|
||||
const UChar CollationFinnishTest::testTargetCases[][CollationFinnishTest::MAX_TOKEN_LEN] = {
|
||||
{'v', 'a', 't', 0},
|
||||
{'w', 'a', 'y', 0},
|
||||
{'a', 'x', 'b', 'e', 'c', 'k', 0},
|
||||
{'L', 0x00E4, 'w', 'e', 0},
|
||||
{'v', 'a', 't', 0}
|
||||
{0x76, 0x61, 0x74, 0},
|
||||
{0x77, 0x61, 0x79, 0},
|
||||
{0x61, 0x78, 0x62, 0x65, 0x63, 0x6b, 0},
|
||||
{0x4c, 0x00E4, 0x77, 0x65, 0},
|
||||
{0x76, 0x61, 0x74, 0}
|
||||
};
|
||||
|
||||
const Collator::EComparisonResult CollationFinnishTest::results[] = {
|
||||
|
|
|
|||
|
|
@ -38,14 +38,14 @@ CollationFrenchTest::~CollationFrenchTest()
|
|||
|
||||
const UChar CollationFrenchTest::testSourceCases[][CollationFrenchTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'a', 'b', 'c', 0},
|
||||
{'C', 'O', 'T', 'E', 0},
|
||||
{'c', 'o', '-', 'o', 'p', 0},
|
||||
{'p', 0x00EA, 'c', 'h', 'e', 0},
|
||||
{'p', 0x00EA, 'c', 'h', 'e', 'r', 0},
|
||||
{'p', 0x00E9, 'c', 'h', 'e', 'r', 0},
|
||||
{'p', 0x00E9, 'c', 'h', 'e', 'r', 0},
|
||||
{'H', 'e', 'l', 'l', 'o', 0},
|
||||
{0x61, 0x62, 0x63, 0},
|
||||
{0x43, 0x4f, 0x54, 0x45, 0},
|
||||
{0x63, 0x6f, 0x2d, 0x6f, 0x70, 0},
|
||||
{0x70, 0x00EA, 0x63, 0x68, 0x65, 0},
|
||||
{0x70, 0x00EA, 0x63, 0x68, 0x65, 0x72, 0},
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x65, 0x72, 0},
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x65, 0x72, 0},
|
||||
{0x48, 0x65, 0x6c, 0x6c, 0x6f, 0},
|
||||
{0x01f1, 0},
|
||||
{0xfb00, 0},
|
||||
{0x01fa, 0},
|
||||
|
|
@ -54,14 +54,14 @@ const UChar CollationFrenchTest::testSourceCases[][CollationFrenchTest::MAX_TOKE
|
|||
|
||||
const UChar CollationFrenchTest::testTargetCases[][CollationFrenchTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'A', 'B', 'C', 0},
|
||||
{'c', 0x00f4, 't', 'e', 0},
|
||||
{'C', 'O', 'O', 'P', 0},
|
||||
{'p', 0x00E9, 'c', 'h', 0x00E9, 0},
|
||||
{'p', 0x00E9, 'c', 'h', 0x00E9, 0},
|
||||
{'p', 0x00EA, 'c', 'h', 'e', 0},
|
||||
{'p', 0x00EA, 'c', 'h', 'e', 'r', 0},
|
||||
{'h', 'e', 'l', 'l', 'O', 0},
|
||||
{0x41, 0x42, 0x43, 0},
|
||||
{0x63, 0x00f4, 0x74, 0x65, 0},
|
||||
{0x43, 0x4f, 0x4f, 0x50, 0},
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x00E9, 0},
|
||||
{0x70, 0x00E9, 0x63, 0x68, 0x00E9, 0},
|
||||
{0x70, 0x00EA, 0x63, 0x68, 0x65, 0},
|
||||
{0x70, 0x00EA, 0x63, 0x68, 0x65, 0x72, 0},
|
||||
{0x68, 0x65, 0x6c, 0x6c, 0x4f, 0},
|
||||
{0x01ee, 0},
|
||||
{0x25ca, 0},
|
||||
{0x00e0, 0},
|
||||
|
|
@ -88,45 +88,45 @@ const Collator::EComparisonResult CollationFrenchTest::results[] =
|
|||
// the order of elements in this array must be different than the order in CollationEnglishTest
|
||||
const UChar CollationFrenchTest::testAcute[][CollationFrenchTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'e', 'e', 0},
|
||||
{'e', 0x0301, 'e', 0},
|
||||
{'e', 0x0301, 0x0300, 'e', 0},
|
||||
{'e', 0x0300, 'e', 0},
|
||||
{'e', 0x0300, 0x0301, 'e', 0},
|
||||
{'e', 'e', 0x0301, 0},
|
||||
{'e', 0x0301, 'e', 0x0301, 0},
|
||||
{'e', 0x0301, 0x0300, 'e', 0x0301, 0},
|
||||
{'e', 0x0300, 'e', 0x0301, 0},
|
||||
{'e', 0x0300, 0x0301, 'e', 0x0301, 0},
|
||||
{'e', 'e', 0x0301, 0x0300, 0},
|
||||
{'e', 0x0301, 'e', 0x0301, 0x0300, 0},
|
||||
{'e', 0x0301, 0x0300, 'e', 0x0301, 0x0300, 0},
|
||||
{'e', 0x0300, 'e', 0x0301, 0x0300, 0},
|
||||
{'e', 0x0300, 0x0301, 'e', 0x0301, 0x0300, 0},
|
||||
{'e', 'e', 0x0300, 0},
|
||||
{'e', 0x0301, 'e', 0x0300, 0},
|
||||
{'e', 0x0301, 0x0300, 'e', 0x0300, 0},
|
||||
{'e', 0x0300, 'e', 0x0300, 0},
|
||||
{'e', 0x0300, 0x0301, 'e', 0x0300, 0},
|
||||
{'e', 'e', 0x0300, 0x0301, 0},
|
||||
{'e', 0x0301, 'e', 0x0300, 0x0301, 0},
|
||||
{'e', 0x0301, 0x0300, 'e', 0x0300, 0x0301, 0},
|
||||
{'e', 0x0300, 'e', 0x0300, 0x0301, 0},
|
||||
{'e', 0x0300, 0x0301, 'e', 0x0300, 0x0301, 0}
|
||||
{0x65, 0x65, 0},
|
||||
{0x65, 0x0301, 0x65, 0},
|
||||
{0x65, 0x0301, 0x0300, 0x65, 0},
|
||||
{0x65, 0x0300, 0x65, 0},
|
||||
{0x65, 0x0300, 0x0301, 0x65, 0},
|
||||
{0x65, 0x65, 0x0301, 0},
|
||||
{0x65, 0x0301, 0x65, 0x0301, 0},
|
||||
{0x65, 0x0301, 0x0300, 0x65, 0x0301, 0},
|
||||
{0x65, 0x0300, 0x65, 0x0301, 0},
|
||||
{0x65, 0x0300, 0x0301, 0x65, 0x0301, 0},
|
||||
{0x65, 0x65, 0x0301, 0x0300, 0},
|
||||
{0x65, 0x0301, 0x65, 0x0301, 0x0300, 0},
|
||||
{0x65, 0x0301, 0x0300, 0x65, 0x0301, 0x0300, 0},
|
||||
{0x65, 0x0300, 0x65, 0x0301, 0x0300, 0},
|
||||
{0x65, 0x0300, 0x0301, 0x65, 0x0301, 0x0300, 0},
|
||||
{0x65, 0x65, 0x0300, 0},
|
||||
{0x65, 0x0301, 0x65, 0x0300, 0},
|
||||
{0x65, 0x0301, 0x0300, 0x65, 0x0300, 0},
|
||||
{0x65, 0x0300, 0x65, 0x0300, 0},
|
||||
{0x65, 0x0300, 0x0301, 0x65, 0x0300, 0},
|
||||
{0x65, 0x65, 0x0300, 0x0301, 0},
|
||||
{0x65, 0x0301, 0x65, 0x0300, 0x0301, 0},
|
||||
{0x65, 0x0301, 0x0300, 0x65, 0x0300, 0x0301, 0},
|
||||
{0x65, 0x0300, 0x65, 0x0300, 0x0301, 0},
|
||||
{0x65, 0x0300, 0x0301, 0x65, 0x0300, 0x0301, 0}
|
||||
};
|
||||
|
||||
const UChar CollationFrenchTest::testBugs[][CollationFrenchTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'a', 0},
|
||||
{'A', 0},
|
||||
{'e', 0},
|
||||
{'E', 0},
|
||||
{0x61, 0},
|
||||
{0x41, 0},
|
||||
{0x65, 0},
|
||||
{0x45, 0},
|
||||
{0x00e9, 0},
|
||||
{0x00e8, 0},
|
||||
{0x00ea, 0},
|
||||
{0x00eb, 0},
|
||||
{'e', 'a', 0},
|
||||
{'x', 0}
|
||||
{0x65, 0x61, 0},
|
||||
{0x78, 0}
|
||||
};
|
||||
|
||||
void CollationFrenchTest::doTest( UnicodeString source, UnicodeString target, Collator::EComparisonResult result)
|
||||
|
|
|
|||
|
|
@ -36,37 +36,37 @@ const Locale G7CollationTest::locales[8] = {
|
|||
};
|
||||
|
||||
const UChar G7CollationTest::testCases[][G7CollationTest::MAX_TOKEN_LEN] = {
|
||||
{ 'b', 'l', 'a', 'c', 'k', '-', 'b', 'i', 'r', 'd', 's', 0}, // 0
|
||||
{ 'P', 'a', 't', 0}, // 1
|
||||
{ 'p', 0x00E9, 'c', 'h', 0x00E9, 0}, // 2
|
||||
{ 'p', 0x00EA, 'c', 'h', 'e', 0}, // 3
|
||||
{ 'p', 0x00E9, 'c', 'h', 'e', 'r', 0}, // 4
|
||||
{ 'p', 0x00EA, 'c', 'h', 'e', 'r', 0}, // 5
|
||||
{ 'T', 'o', 'd', 0}, // 6
|
||||
{ 'T', 0x00F6, 'n', 'e', 0}, // 7
|
||||
{ 'T', 'o', 'f', 'u', 0}, // 8
|
||||
{ 'b', 'l', 'a', 'c', 'k', 'b', 'i', 'r', 'd', 's', 0}, // 9
|
||||
{ 'T', 'o', 'n', 0}, // 10
|
||||
{ 'P', 'A', 'T', 0}, // 11
|
||||
{ 'b', 'l', 'a', 'c', 'k', 'b', 'i', 'r', 'd', 0}, // 12
|
||||
{ 'b', 'l', 'a', 'c', 'k', '-', 'b', 'i', 'r', 'd', 0}, // 13
|
||||
{ 'p', 'a', 't', 0}, // 14
|
||||
{ 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x2d, 0x62, 0x69, 0x72, 0x64, 0x73, 0}, // 0
|
||||
{ 0x50, 0x61, 0x74, 0}, // 1
|
||||
{ 0x70, 0x00E9, 0x63, 0x68, 0x00E9, 0}, // 2
|
||||
{ 0x70, 0x00EA, 0x63, 0x68, 0x65, 0}, // 3
|
||||
{ 0x70, 0x00E9, 0x63, 0x68, 0x65, 0x72, 0}, // 4
|
||||
{ 0x70, 0x00EA, 0x63, 0x68, 0x65, 0x72, 0}, // 5
|
||||
{ 0x54, 0x6f, 0x64, 0}, // 6
|
||||
{ 0x54, 0x00F6, 0x6e, 0x65, 0}, // 7
|
||||
{ 0x54, 0x6f, 0x66, 0x75, 0}, // 8
|
||||
{ 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x62, 0x69, 0x72, 0x64, 0x73, 0}, // 9
|
||||
{ 0x54, 0x6f, 0x6e, 0}, // 10
|
||||
{ 0x50, 0x41, 0x54, 0}, // 11
|
||||
{ 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x62, 0x69, 0x72, 0x64, 0}, // 12
|
||||
{ 0x62, 0x6c, 0x61, 0x63, 0x6b, 0x2d, 0x62, 0x69, 0x72, 0x64, 0}, // 13
|
||||
{ 0x70, 0x61, 0x74, 0}, // 14
|
||||
// Additional tests
|
||||
{ 'c', 'z', 'a', 'r', 0 }, // 15
|
||||
{ 'c', 'h', 'u', 'r', 'o', 0 }, // 16
|
||||
{ 'c', 'a', 't', 0 }, // 17
|
||||
{ 'd', 'a', 'r', 'n', 0 }, // 18
|
||||
{ '?', 0 }, // 19
|
||||
{ 'q', 'u', 'i', 'c', 'k', 0 }, // 20
|
||||
{ '#', 0 }, // 21
|
||||
{ '&', 0 }, // 22
|
||||
{ 'a', 'a', 'r', 'd', 'v', 'a', 'r', 'k', 0}, // 23
|
||||
{ 'a', '-', 'r', 'd', 'v', 'a', 'r', 'k', 0}, // 24
|
||||
{ 'a', 'b', 'b', 'o', 't', 0}, // 25
|
||||
{ 'c', 'o', 'o', 'p', 0}, // 26
|
||||
{ 'c', 'o', '-', 'p', 0}, // 27
|
||||
{ 'c', 'o', 'p', 0}, // 28
|
||||
{ 'z', 'e', 'b', 'r', 'a', 0} // 29
|
||||
{ 0x63, 0x7a, 0x61, 0x72, 0 }, // 15
|
||||
{ 0x63, 0x68, 0x75, 0x72, 0x6f, 0 }, // 16
|
||||
{ 0x63, 0x61, 0x74, 0 }, // 17
|
||||
{ 0x64, 0x61, 0x72, 0x6e, 0 }, // 18
|
||||
{ 0x3f, 0 }, // 19
|
||||
{ 0x71, 0x75, 0x69, 0x63, 0x6b, 0 }, // 20
|
||||
{ 0x23, 0 }, // 21
|
||||
{ 0x26, 0 }, // 22
|
||||
{ 0x61, 0x61, 0x72, 0x64, 0x76, 0x61, 0x72, 0x6b, 0}, // 23
|
||||
{ 0x61, 0x2d, 0x72, 0x64, 0x76, 0x61, 0x72, 0x6b, 0}, // 24
|
||||
{ 0x61, 0x62, 0x62, 0x6f, 0x74, 0}, // 25
|
||||
{ 0x63, 0x6f, 0x6f, 0x70, 0}, // 26
|
||||
{ 0x63, 0x6f, 0x2d, 0x70, 0}, // 27
|
||||
{ 0x63, 0x6f, 0x70, 0}, // 28
|
||||
{ 0x7a, 0x65, 0x62, 0x72, 0x61, 0} // 29
|
||||
};
|
||||
|
||||
const int32_t G7CollationTest::results[G7CollationTest::TESTLOCALES][G7CollationTest::TOTALTESTSET] = {
|
||||
|
|
|
|||
|
|
@ -965,3 +965,43 @@ main(int argc, char* argv[])
|
|||
|
||||
return major.getErrors();
|
||||
}
|
||||
|
||||
/*
|
||||
* This is a variant of cintltst/ccolltst.c:CharsToUChars().
|
||||
* It converts a character string into a UnicodeString, with
|
||||
* unescaping \u sequences.
|
||||
*/
|
||||
UnicodeString CharsToUnicodeString(const char* chars)
|
||||
{
|
||||
int unicode;
|
||||
int i;
|
||||
UnicodeString result;
|
||||
UChar buffer[400];
|
||||
|
||||
for (;;) {
|
||||
/* repeat the following according to the length of the buffer */
|
||||
do {
|
||||
/* search for \u or the end */
|
||||
for(i = 0; i < 400 && chars[i] != 0 && !(chars[i] == '\\' && chars[i+1] == 'u'); ++i) {}
|
||||
|
||||
/* convert characters between escape sequences */
|
||||
if(i > 0) {
|
||||
u_charsToUChars(chars, buffer, i);
|
||||
result.append(buffer, i);
|
||||
chars += i;
|
||||
}
|
||||
} while(i == 400);
|
||||
|
||||
/* did we reach the end or an escape sequence? */
|
||||
if(*chars == 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
/* unescape one character: we know that there is a \u sequence at chars[limit] */
|
||||
chars += 2;
|
||||
sscanf(chars, "%4X", &unicode);
|
||||
result.append((UChar)unicode);
|
||||
chars += 4;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -167,5 +167,11 @@ IntlTest& operator<<(IntlTest& test, const int32_t num);
|
|||
IntlTest& endl( IntlTest& test );
|
||||
IntlTest& operator<<(IntlTest& test, IntlTest& ( * _f)(IntlTest&));
|
||||
|
||||
/**
|
||||
* This is a variant of cintltst/ccolltst.c:CharsToUChars().
|
||||
* It converts a character string into a UnicodeString, with
|
||||
* unescaping \u sequences.
|
||||
*/
|
||||
extern UnicodeString CharsToUnicodeString(const char* chars);
|
||||
|
||||
#endif // _INTLTEST
|
||||
|
|
|
|||
|
|
@ -206,9 +206,9 @@ void CollationIteratorTest::TestMaxExpansion(char *par)
|
|||
rule1 += " < b < e";
|
||||
ExpansionRecord test1[] =
|
||||
{
|
||||
{'a', 1},
|
||||
{'b', 1},
|
||||
{'e', 2}
|
||||
{0x61, 1},
|
||||
{0x62, 1},
|
||||
{0x65, 2}
|
||||
};
|
||||
verifyExpansion(rule1, test1, ARRAY_LENGTH(test1));
|
||||
|
||||
|
|
@ -219,10 +219,10 @@ void CollationIteratorTest::TestMaxExpansion(char *par)
|
|||
UnicodeString rule2("< a & ae = a1 & aeef = z < b < e < f");
|
||||
ExpansionRecord test2[] =
|
||||
{
|
||||
{'a', 1},
|
||||
{'b', 1},
|
||||
{'e', 2},
|
||||
{'f', 4}
|
||||
{0x61, 1},
|
||||
{0x62, 1},
|
||||
{0x65, 2},
|
||||
{0x66, 4}
|
||||
};
|
||||
verifyExpansion(rule2, test2, ARRAY_LENGTH(test2));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -109,26 +109,6 @@ public:
|
|||
#include <string.h>
|
||||
#include "unicode/schriter.h"
|
||||
|
||||
// [HSYS] Just to make it easier to use with UChar array.
|
||||
UnicodeString CharsToUnicodeString2(const char* chars)
|
||||
{
|
||||
int len = strlen(chars);
|
||||
int i;
|
||||
UnicodeString buffer;
|
||||
for (i = 0; i < len;) {
|
||||
if ((chars[i] == '\\') && (i+1 < len) && (chars[i+1] == 'u')) {
|
||||
int unicode;
|
||||
sscanf(&(chars[i+2]), "%4X", &unicode);
|
||||
buffer += (UChar)unicode;
|
||||
i += 6;
|
||||
} else {
|
||||
buffer += (UChar)chars[i++];
|
||||
}
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
||||
|
||||
const UChar IntlTestTextBoundary::cannedTestArray[] = {
|
||||
0x0001, 0x0002, 0x0003, 0x0004, ' ', '!', '\\', '"', '#', '$', '%', '&', '(', ')', '+', '-', '0', '1',
|
||||
'2', '3', '4', '<', '=', '>', 'A', 'B', 'C', 'D', 'E', '[', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', '{',
|
||||
|
|
@ -251,7 +231,7 @@ void IntlTestTextBoundary::addTestWordData()
|
|||
wordSelectionData->addElement(" ");
|
||||
|
||||
// to test for bug #4097779
|
||||
wordSelectionData->addElement(CharsToUnicodeString2("aa\\u0300a"));
|
||||
wordSelectionData->addElement(CharsToUnicodeString("aa\\u0300a"));
|
||||
wordSelectionData->addElement(" ");
|
||||
|
||||
// to test for bug #4098467
|
||||
|
|
@ -260,28 +240,28 @@ void IntlTestTextBoundary::addTestWordData()
|
|||
// it correctly), first as precomposed syllables, and then as conjoining jamo.
|
||||
// Both sequences should be semantically identical and break the same way.
|
||||
// precomposed syllables...
|
||||
wordSelectionData->addElement(CharsToUnicodeString2("\\uc0c1\\ud56d"));
|
||||
wordSelectionData->addElement(CharsToUnicodeString("\\uc0c1\\ud56d"));
|
||||
wordSelectionData->addElement(" ");
|
||||
wordSelectionData->addElement(CharsToUnicodeString2("\\ud55c\\uc778"));
|
||||
wordSelectionData->addElement(CharsToUnicodeString("\\ud55c\\uc778"));
|
||||
wordSelectionData->addElement(" ");
|
||||
wordSelectionData->addElement(CharsToUnicodeString2("\\uc5f0\\ud569"));
|
||||
wordSelectionData->addElement(CharsToUnicodeString("\\uc5f0\\ud569"));
|
||||
wordSelectionData->addElement(" ");
|
||||
wordSelectionData->addElement(CharsToUnicodeString2("\\uc7a5\\ub85c\\uad50\\ud68c"));
|
||||
wordSelectionData->addElement(CharsToUnicodeString("\\uc7a5\\ub85c\\uad50\\ud68c"));
|
||||
wordSelectionData->addElement(" ");
|
||||
// conjoining jamo...
|
||||
wordSelectionData->addElement(CharsToUnicodeString2("\\u1109\\u1161\\u11bc\\u1112\\u1161\\u11bc"));
|
||||
wordSelectionData->addElement(CharsToUnicodeString("\\u1109\\u1161\\u11bc\\u1112\\u1161\\u11bc"));
|
||||
wordSelectionData->addElement(" ");
|
||||
wordSelectionData->addElement(CharsToUnicodeString2("\\u1112\\u1161\\u11ab\\u110b\\u1175\\u11ab"));
|
||||
wordSelectionData->addElement(CharsToUnicodeString("\\u1112\\u1161\\u11ab\\u110b\\u1175\\u11ab"));
|
||||
wordSelectionData->addElement(" ");
|
||||
wordSelectionData->addElement(CharsToUnicodeString2("\\u110b\\u1167\\u11ab\\u1112\\u1161\\u11b8"));
|
||||
wordSelectionData->addElement(CharsToUnicodeString("\\u110b\\u1167\\u11ab\\u1112\\u1161\\u11b8"));
|
||||
wordSelectionData->addElement(" ");
|
||||
wordSelectionData->addElement(CharsToUnicodeString2("\\u110c\\u1161\\u11bc\\u1105\\u1169\\u1100\\u116d\\u1112\\u116c"));
|
||||
wordSelectionData->addElement(CharsToUnicodeString("\\u110c\\u1161\\u11bc\\u1105\\u1169\\u1100\\u116d\\u1112\\u116c"));
|
||||
wordSelectionData->addElement(" ");
|
||||
|
||||
// this is a test for bug #4117554: the ideographic iteration mark (U+3005) should
|
||||
// count as a Kanji character for the purposes of word breaking
|
||||
wordSelectionData->addElement("abc");
|
||||
wordSelectionData->addElement(CharsToUnicodeString2("\\u4e01\\u4e02\\u3005\\u4e03\\u4e03"));
|
||||
wordSelectionData->addElement(CharsToUnicodeString("\\u4e01\\u4e02\\u3005\\u4e03\\u4e03"));
|
||||
wordSelectionData->addElement("abc");
|
||||
|
||||
|
||||
|
|
@ -326,64 +306,64 @@ void IntlTestTextBoundary::addTestSentenceData()
|
|||
sentenceSelectionData->addElement("Yes, I am definatelly 12\" tall!!");
|
||||
|
||||
// test for bug #4113835: \n and \r count as spaces, not as paragraph breaks
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString2("Now\ris\nthe\r\ntime\n\rfor\r\rall\\u2029"));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString("Now\ris\nthe\r\ntime\n\rfor\r\rall\\u2029"));
|
||||
|
||||
// test for bug #4111338: Don't break sentences at the boundary between CJK
|
||||
// and other letters
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString2("\\u5487\\u67ff\\ue591\\u5017\\u61b3\\u60a1\\u9510\\u8165:\"JAVA\\u821c")
|
||||
+ CharsToUnicodeString2("\\u8165\\u7fc8\\u51ce\\u306d,\\u2494\\u56d8\\u4ec0\\u60b1\\u8560\\u51ba")
|
||||
+ CharsToUnicodeString2("\\u611d\\u57b6\\u2510\\u5d46\".\\u2029"));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString2("\\u5487\\u67ff\\ue591\\u5017\\u61b3\\u60a1\\u9510\\u8165\\u9de8")
|
||||
+ CharsToUnicodeString2("\\u97e4JAVA\\u821c\\u8165\\u7fc8\\u51ce\\u306d\\ue30b\\u2494\\u56d8\\u4ec0")
|
||||
+ CharsToUnicodeString2("\\u60b1\\u8560\\u51ba\\u611d\\u57b6\\u2510\\u5d46\\u97e5\\u7751\\u2029"));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString2("\\u5487\\u67ff\\ue591\\u5017\\u61b3\\u60a1\\u9510\\u8165\\u9de8\\u97e4")
|
||||
+ CharsToUnicodeString2("\\u6470\\u8790JAVA\\u821c\\u8165\\u7fc8\\u51ce\\u306d\\ue30b\\u2494\\u56d8")
|
||||
+ CharsToUnicodeString2("\\u4ec0\\u60b1\\u8560\\u51ba\\u611d\\u57b6\\u2510\\u5d46\\u97e5\\u7751\\u2029"));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString2("He said, \"I can go there.\"\\u2029"));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString("\\u5487\\u67ff\\ue591\\u5017\\u61b3\\u60a1\\u9510\\u8165:\"JAVA\\u821c")
|
||||
+ CharsToUnicodeString("\\u8165\\u7fc8\\u51ce\\u306d,\\u2494\\u56d8\\u4ec0\\u60b1\\u8560\\u51ba")
|
||||
+ CharsToUnicodeString("\\u611d\\u57b6\\u2510\\u5d46\".\\u2029"));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString("\\u5487\\u67ff\\ue591\\u5017\\u61b3\\u60a1\\u9510\\u8165\\u9de8")
|
||||
+ CharsToUnicodeString("\\u97e4JAVA\\u821c\\u8165\\u7fc8\\u51ce\\u306d\\ue30b\\u2494\\u56d8\\u4ec0")
|
||||
+ CharsToUnicodeString("\\u60b1\\u8560\\u51ba\\u611d\\u57b6\\u2510\\u5d46\\u97e5\\u7751\\u2029"));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString("\\u5487\\u67ff\\ue591\\u5017\\u61b3\\u60a1\\u9510\\u8165\\u9de8\\u97e4")
|
||||
+ CharsToUnicodeString("\\u6470\\u8790JAVA\\u821c\\u8165\\u7fc8\\u51ce\\u306d\\ue30b\\u2494\\u56d8")
|
||||
+ CharsToUnicodeString("\\u4ec0\\u60b1\\u8560\\u51ba\\u611d\\u57b6\\u2510\\u5d46\\u97e5\\u7751\\u2029"));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString("He said, \"I can go there.\"\\u2029"));
|
||||
|
||||
// test for bug #4117554: Treat fullwidth variants of .!? the same as their
|
||||
// normal counterparts
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString2("I know I'm right\\uff0e "));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString2("Right\\uff1f "));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString2("Right\\uff01 "));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString("I know I'm right\\uff0e "));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString("Right\\uff1f "));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString("Right\\uff01 "));
|
||||
|
||||
// test for bug #4117554: Don't break sentences at boundary between CJK and digits
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString2("\\u5487\\u67ff\\ue591\\u5017\\u61b3\\u60a1\\u9510\\u8165\\u9de8")
|
||||
+ CharsToUnicodeString2("\\u97e48888\\u821c\\u8165\\u7fc8\\u51ce\\u306d\\ue30b\\u2494\\u56d8\\u4ec0")
|
||||
+ CharsToUnicodeString2("\\u60b1\\u8560\\u51ba\\u611d\\u57b6\\u2510\\u5d46\\u97e5\\u7751\\u2029"));
|
||||
sentenceSelectionData->addElement(CharsToUnicodeString("\\u5487\\u67ff\\ue591\\u5017\\u61b3\\u60a1\\u9510\\u8165\\u9de8")
|
||||
+ CharsToUnicodeString("\\u97e48888\\u821c\\u8165\\u7fc8\\u51ce\\u306d\\ue30b\\u2494\\u56d8\\u4ec0")
|
||||
+ CharsToUnicodeString("\\u60b1\\u8560\\u51ba\\u611d\\u57b6\\u2510\\u5d46\\u97e5\\u7751\\u2029"));
|
||||
|
||||
// test for bug #4117554: Break sentence between a sentence terminator and
|
||||
// opening punctuation
|
||||
sentenceSelectionData->addElement("no?");
|
||||
sentenceSelectionData->addElement("(yes)" + CharsToUnicodeString2("\\u2029"));
|
||||
sentenceSelectionData->addElement("(yes)" + CharsToUnicodeString("\\u2029"));
|
||||
|
||||
// test for bug #4158381: Don't break sentence after period if it isn't
|
||||
// followed by a space
|
||||
sentenceSelectionData->addElement("Test <code>Flags.Flag</code> class. ");
|
||||
sentenceSelectionData->addElement("Another test." + CharsToUnicodeString2("\\u2029"));
|
||||
sentenceSelectionData->addElement("Another test." + CharsToUnicodeString("\\u2029"));
|
||||
|
||||
// test for bug #4158381: No breaks when there are no terminators around
|
||||
sentenceSelectionData->addElement("<P>Provides a set of "lightweight" (all-java<FONT SIZE=\"-2\"><SUP>TM</SUP></FONT> language) components that, to the maximum degree possible, work the same on all platforms. ");
|
||||
sentenceSelectionData->addElement("Another test." + CharsToUnicodeString2("\\u2029"));
|
||||
sentenceSelectionData->addElement("Another test." + CharsToUnicodeString("\\u2029"));
|
||||
|
||||
// test for bug #4143071: Make sure sentences that end with digits
|
||||
// work right
|
||||
sentenceSelectionData->addElement("Today is the 27th of May, 1998. ");
|
||||
sentenceSelectionData->addElement("Tomorrow with be 28 May 1998. ");
|
||||
sentenceSelectionData->addElement("The day after will be the 30th."
|
||||
+ CharsToUnicodeString2("\\u2029"));
|
||||
+ CharsToUnicodeString("\\u2029"));
|
||||
|
||||
// test for bug #4152416: Make sure sentences ending with a capital
|
||||
// letter are treated correctly
|
||||
sentenceSelectionData->addElement("The type of all primitive <code>boolean</code> values accessed in the target VM. ");
|
||||
sentenceSelectionData->addElement("Calls to xxx will return an implementor of this interface." + CharsToUnicodeString2("\\u2029"));
|
||||
sentenceSelectionData->addElement("Calls to xxx will return an implementor of this interface." + CharsToUnicodeString("\\u2029"));
|
||||
|
||||
// test for bug #4152117: Make sure sentence breaking is handling
|
||||
// punctuation correctly [COULD NOT REPRODUCE THIS BUG, BUT TEST IS
|
||||
// HERE TO MAKE SURE IT DOESN'T CROP UP]
|
||||
sentenceSelectionData->addElement("Constructs a randomly generated BigInteger, uniformly distributed over the range <tt>0</tt> to <tt>(2<sup>numBits</sup> - 1)</tt>, inclusive. ");
|
||||
sentenceSelectionData->addElement("The uniformity of the distribution assumes that a fair source of random bits is provided in <tt>rnd</tt>. ");
|
||||
sentenceSelectionData->addElement("Note that this constructor always constructs a non-negative BigInteger." + CharsToUnicodeString2("\\u2029"));
|
||||
sentenceSelectionData->addElement("Note that this constructor always constructs a non-negative BigInteger." + CharsToUnicodeString("\\u2029"));
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -424,18 +404,18 @@ void IntlTestTextBoundary::addTestLineData()
|
|||
lineSelectionData->addElement("all");
|
||||
|
||||
// to test for bug #4068133
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u96f6"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u4e00\\u3002"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u4e8c\\u3001"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u4e09\\u3002\\u3001"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u56db\\u3001\\u3002\\u3001"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u4e94,"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u516d."));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u4e03.\\u3001,\\u3002"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u516b"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u96f6"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u4e00\\u3002"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u4e8c\\u3001"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u4e09\\u3002\\u3001"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u56db\\u3001\\u3002\\u3001"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u4e94,"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u516d."));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u4e03.\\u3001,\\u3002"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u516b"));
|
||||
|
||||
// to test for bug #4086052
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("foo\\u00a0bar "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("foo\\u00a0bar "));
|
||||
// lineSelectionData->addElement("foo\\ufeffbar");
|
||||
|
||||
// to test for bug #4097920
|
||||
|
|
@ -459,20 +439,20 @@ void IntlTestTextBoundary::addTestLineData()
|
|||
// it correctly), first as precomposed syllables, and then as conjoining jamo.
|
||||
// Both sequences should be semantically identical and break the same way.
|
||||
// precomposed syllables...
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\uc0c1\\ud56d "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\ud55c\\uc778 "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\uc5f0\\ud569 "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\uc7a5\\ub85c\\uad50\\ud68c "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\uc0c1\\ud56d "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\ud55c\\uc778 "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\uc5f0\\ud569 "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\uc7a5\\ub85c\\uad50\\ud68c "));
|
||||
// conjoining jamo...
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u1109\\u1161\\u11bc\\u1112\\u1161\\u11bc "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u1112\\u1161\\u11ab\\u110b\\u1175\\u11ab "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u110b\\u1167\\u11ab\\u1112\\u1161\\u11b8 "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u110c\\u1161\\u11bc\\u1105\\u1169\\u1100\\u116d\\u1112\\u116c"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u1109\\u1161\\u11bc\\u1112\\u1161\\u11bc "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u1112\\u1161\\u11ab\\u110b\\u1175\\u11ab "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u110b\\u1167\\u11ab\\u1112\\u1161\\u11b8 "));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u110c\\u1161\\u11bc\\u1105\\u1169\\u1100\\u116d\\u1112\\u116c"));
|
||||
|
||||
// to test for bug #4117554: Fullwidth .!? should be treated as postJwrd
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u4e01\\uff0e"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u4e02\\uff01"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString2("\\u4e03\\uff1f"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u4e01\\uff0e"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u4e02\\uff01"));
|
||||
lineSelectionData->addElement(CharsToUnicodeString("\\u4e03\\uff1f"));
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -521,34 +501,34 @@ void IntlTestTextBoundary::addTestCharacterData()
|
|||
// it correctly), first as precomposed syllables, and then as conjoining jamo.
|
||||
// Both sequences should be semantically identical and break the same way.
|
||||
// precomposed syllables...
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\uc0c1"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\ud56d"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\uc0c1"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\ud56d"));
|
||||
characterSelectionData->addElement(" ");
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\ud55c"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\uc778"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\ud55c"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\uc778"));
|
||||
characterSelectionData->addElement(" ");
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\uc5f0"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\ud569"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\uc5f0"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\ud569"));
|
||||
characterSelectionData->addElement(" ");
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\uc7a5"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\ub85c"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\uad50"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\ud68c"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\uc7a5"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\ub85c"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\uad50"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\ud68c"));
|
||||
characterSelectionData->addElement(" ");
|
||||
// conjoining jamo...
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\u1109\\u1161\\u11bc"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\u1112\\u1161\\u11bc"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\u1109\\u1161\\u11bc"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\u1112\\u1161\\u11bc"));
|
||||
characterSelectionData->addElement(" ");
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\u1112\\u1161\\u11ab"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\u110b\\u1175\\u11ab"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\u1112\\u1161\\u11ab"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\u110b\\u1175\\u11ab"));
|
||||
characterSelectionData->addElement(" ");
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\u110b\\u1167\\u11ab"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\u1112\\u1161\\u11b8"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\u110b\\u1167\\u11ab"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\u1112\\u1161\\u11b8"));
|
||||
characterSelectionData->addElement(" ");
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\u110c\\u1161\\u11bc"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\u1105\\u1169"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\u1100\\u116d"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString2("\\u1112\\u116c"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\u110c\\u1161\\u11bc"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\u1105\\u1169"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\u1100\\u116d"));
|
||||
characterSelectionData->addElement(CharsToUnicodeString("\\u1112\\u116c"));
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -588,7 +568,7 @@ void IntlTestTextBoundary::TestSentenceInvariants()
|
|||
errln("Failed to create the BreakIterator for default locale in TestSentenceInvariant.\n");
|
||||
return;
|
||||
}
|
||||
UnicodeString s = *cannedTestChars + CharsToUnicodeString2(".,\\u3001\\u3002\\u3041\\u3042\\u3043\\ufeff");
|
||||
UnicodeString s = *cannedTestChars + CharsToUnicodeString(".,\\u3001\\u3002\\u3041\\u3042\\u3043\\ufeff");
|
||||
doOtherInvariantTest(*e, s);
|
||||
delete e;
|
||||
}
|
||||
|
|
@ -616,9 +596,9 @@ void IntlTestTextBoundary::TestWordInvariants()
|
|||
errln("Failed to create the BreakIterator for default locale in TestWordInvariants.\n");
|
||||
return;
|
||||
}
|
||||
UnicodeString s = *cannedTestChars + CharsToUnicodeString2("\',.\\u3041\\u3042\\u3043\\u309b\\u309c\\u30a1\\u30a2\\u30a3\\u4e00\\u4e01\\u4e02");
|
||||
UnicodeString s = *cannedTestChars + CharsToUnicodeString("\',.\\u3041\\u3042\\u3043\\u309b\\u309c\\u30a1\\u30a2\\u30a3\\u4e00\\u4e01\\u4e02");
|
||||
doBreakInvariantTest(*e, s);
|
||||
s = *cannedTestChars + CharsToUnicodeString2("\',.\\u3041\\u3042\\u3043\\u309b\\u309c\\u30a1\\u30a2\\u30a3\\u4e00\\u4e01\\u4e02");
|
||||
s = *cannedTestChars + CharsToUnicodeString("\',.\\u3041\\u3042\\u3043\\u309b\\u309c\\u30a1\\u30a2\\u30a3\\u4e00\\u4e01\\u4e02");
|
||||
doOtherInvariantTest(*e, s);
|
||||
delete e;
|
||||
}
|
||||
|
|
@ -647,9 +627,9 @@ void IntlTestTextBoundary::TestCharacterInvariants()
|
|||
errln("Failed to create the BreakIterator for default locale in TestCharacterInvariants.\n");
|
||||
return;
|
||||
}
|
||||
UnicodeString s = *cannedTestChars + CharsToUnicodeString2("\\u1100\\u1101\\u1102\\u1160\\u1161\\u1162\\u11a8\\u11a9\\u11aa");
|
||||
UnicodeString s = *cannedTestChars + CharsToUnicodeString("\\u1100\\u1101\\u1102\\u1160\\u1161\\u1162\\u11a8\\u11a9\\u11aa");
|
||||
doBreakInvariantTest(*e, s);
|
||||
s = *cannedTestChars + CharsToUnicodeString2("\\u1100\\u1101\\u1102\\u1160\\u1161\\u1162\\u11a8\\u11a9\\u11aa");
|
||||
s = *cannedTestChars + CharsToUnicodeString("\\u1100\\u1101\\u1102\\u1160\\u1161\\u1162\\u11a8\\u11a9\\u11aa");
|
||||
doOtherInvariantTest(*e, s);
|
||||
delete e;
|
||||
}
|
||||
|
|
@ -677,7 +657,7 @@ void IntlTestTextBoundary::TestLineInvariants()
|
|||
errln("Failed to create the BreakIterator for default locale in TestLineInvariants.\n");
|
||||
return;
|
||||
}
|
||||
UnicodeString s = CharsToUnicodeString2(".,;:\\u3001\\u3002\\u3041\\u3042\\u3043\\u3044\\u3045\\u30a3\\u4e00\\u4e01\\u4e02");
|
||||
UnicodeString s = CharsToUnicodeString(".,;:\\u3001\\u3002\\u3041\\u3042\\u3043\\u3044\\u3045\\u30a3\\u4e00\\u4e01\\u4e02");
|
||||
UnicodeString testChars = *cannedTestChars + s;
|
||||
doBreakInvariantTest(*e, testChars);
|
||||
doOtherInvariantTest(*e, testChars);
|
||||
|
|
@ -687,7 +667,7 @@ void IntlTestTextBoundary::TestLineInvariants()
|
|||
|
||||
// in addition to the other invariants, a line-break iterator should make sure that:
|
||||
// it doesn't break around the non-breaking characters
|
||||
UnicodeString noBreak = CharsToUnicodeString2("\\u00a0\\u2007\\u2011\\ufeff");
|
||||
UnicodeString noBreak = CharsToUnicodeString("\\u00a0\\u2007\\u2011\\ufeff");
|
||||
UnicodeString work("aaa");
|
||||
for (i = 0; i < testChars.length(); i++) {
|
||||
UChar c = testChars[i];
|
||||
|
|
@ -713,7 +693,7 @@ void IntlTestTextBoundary::TestLineInvariants()
|
|||
|
||||
// it does break after hyphens (unless they're followed by a digit, a non-spacing mark,
|
||||
// a currency symbol, a non-breaking space, or a line or paragraph separator)
|
||||
UnicodeString dashes = CharsToUnicodeString2("-\\u00ad\\u2010\\u2012\\u2013\\u2014");
|
||||
UnicodeString dashes = CharsToUnicodeString("-\\u00ad\\u2010\\u2012\\u2013\\u2014");
|
||||
for (i = 0; i < testChars.length(); i++) {
|
||||
work[0] = testChars[i];
|
||||
for (j = 0; j < dashes.length(); j++) {
|
||||
|
|
@ -761,27 +741,27 @@ void IntlTestTextBoundary::TestThaiLineBreak() {
|
|||
// the end of the word and not treated as an independent punctuation mark.
|
||||
|
||||
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e2a\\u0e16\\u0e32\\u0e19\\u0e35\\u0e2f"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e08\\u0e30"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e23\\u0e30\\u0e14\\u0e21"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e40\\u0e08\\u0e49\\u0e32"));
|
||||
// thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e2b\\u0e19\\u0e49\\u0e32"));
|
||||
// thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e17\\u0e35\\u0e48"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e2b\\u0e19\\u0e49\\u0e32\\u0e17\\u0e35\\u0e48"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e2a\\u0e16\\u0e32\\u0e19\\u0e35\\u0e2f"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e08\\u0e30"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e23\\u0e30\\u0e14\\u0e21"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e40\\u0e08\\u0e49\\u0e32"));
|
||||
// thaiLineSelection->addElement(CharsToUnicodeString("\\u0e2b\\u0e19\\u0e49\\u0e32"));
|
||||
// thaiLineSelection->addElement(CharsToUnicodeString("\\u0e17\\u0e35\\u0e48"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e2b\\u0e19\\u0e49\\u0e32\\u0e17\\u0e35\\u0e48"));
|
||||
// the commented-out lines (I think) are the preferred result; this line is what our current dictionary is giving us
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e2d\\u0e2d\\u0e01"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e21\\u0e32"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e40\\u0e23\\u0e48\\u0e07"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e23\\u0e30\\u0e1a\\u0e32\\u0e22"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e2d\\u0e22\\u0e48\\u0e32\\u0e07"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e40\\u0e15\\u0e47\\u0e21"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e2d\\u0e2d\\u0e01"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e21\\u0e32"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e40\\u0e23\\u0e48\\u0e07"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e23\\u0e30\\u0e1a\\u0e32\\u0e22"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e2d\\u0e22\\u0e48\\u0e32\\u0e07"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e40\\u0e15\\u0e47\\u0e21"));
|
||||
|
||||
// the one time where the paiyannoi occurs somewhere other than at the end
|
||||
// of a word is in the Thai abbrevation for "etc.", which both begins and
|
||||
// ends with a paiyannoi
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e2f\\u0e25\\u0e2f"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e17\\u0e35\\u0e48"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e19\\u0e31\\u0e49\\u0e19"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e2f\\u0e25\\u0e2f"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e17\\u0e35\\u0e48"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e19\\u0e31\\u0e49\\u0e19"));
|
||||
|
||||
BreakIterator* e = BreakIterator::createLineInstance(
|
||||
Locale(UnicodeString("th", (char*)0)), status);
|
||||
|
|
@ -803,52 +783,52 @@ void IntlTestTextBoundary::TestMixedThaiLineBreak()
|
|||
|
||||
// Arabic numerals should always be separated from surrounding Thai text
|
||||
/*
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e04\\u0e48\\u0e32"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e40\\u0e07\\u0e34\\u0e19"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e1a\\u0e32\\u0e17"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e41\\u0e15\\u0e30"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e23\\u0e30\\u0e14\\u0e31\\u0e1a"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e04\\u0e48\\u0e32"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e40\\u0e07\\u0e34\\u0e19"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e1a\\u0e32\\u0e17"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e41\\u0e15\\u0e30"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e23\\u0e30\\u0e14\\u0e31\\u0e1a"));
|
||||
thaiLineSelection->addElement("39");
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e1a\\u0e32\\u0e17 "));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e1a\\u0e32\\u0e17 "));
|
||||
|
||||
// words in non-Thai scripts should always be separated from surrounding Thai text
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e17\\u0e14"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e2a\\u0e2d\\u0e1a"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e17\\u0e14"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e2a\\u0e2d\\u0e1a"));
|
||||
thaiLineSelection->addElement("Java");
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e1a\\u0e19"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e40\\u0e04\\u0e23\\u0e37\\u0e48\\u0e2d\\u0e07"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e44\\u0e2d\\u0e1a\\u0e35\\u0e40\\u0e2d\\u0e47\\u0e21 "));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e1a\\u0e19"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e40\\u0e04\\u0e23\\u0e37\\u0e48\\u0e2d\\u0e07"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e44\\u0e2d\\u0e1a\\u0e35\\u0e40\\u0e2d\\u0e47\\u0e21 "));
|
||||
|
||||
// Thai numerals should always be separated from the text surrounding them
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e04\\u0e48\\u0e32"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e40\\u0e07\\u0e34\\u0e19"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e1a\\u0e32\\u0e17"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e41\\u0e15\\u0e30"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e23\\u0e30\\u0e14\\u0e31\\u0e1a"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e53\\u0e59"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e1a\\u0e32\\u0e17 "));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e04\\u0e48\\u0e32"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e40\\u0e07\\u0e34\\u0e19"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e1a\\u0e32\\u0e17"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e41\\u0e15\\u0e30"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e23\\u0e30\\u0e14\\u0e31\\u0e1a"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e53\\u0e59"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e1a\\u0e32\\u0e17 "));
|
||||
|
||||
// Thai text should interact correctly with punctuation and symbols
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e44\\u0e2d\\u0e1a\\u0e35\\u0e40\\u0e2d\\u0e47\\u0e21"));
|
||||
// thaiLineSelection->addElement(CharsToUnicodeString2("(\\u0e1b\\u0e23\\u0e30\\u0e40\\u0e17\\u0e28"));
|
||||
// thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e44\\u0e17\\u0e22)"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("(\\u0e1b\\u0e23\\u0e30\\u0e40\\u0e17\\u0e28\\u0e44\\u0e17\\u0e22)"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e44\\u0e2d\\u0e1a\\u0e35\\u0e40\\u0e2d\\u0e47\\u0e21"));
|
||||
// thaiLineSelection->addElement(CharsToUnicodeString("(\\u0e1b\\u0e23\\u0e30\\u0e40\\u0e17\\u0e28"));
|
||||
// thaiLineSelection->addElement(CharsToUnicodeString("\\u0e44\\u0e17\\u0e22)"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("(\\u0e1b\\u0e23\\u0e30\\u0e40\\u0e17\\u0e28\\u0e44\\u0e17\\u0e22)"));
|
||||
// I believe the commented-out reading above to be the correct one, but this is what passes with our current dictionary
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e08\\u0e33\\u0e01\\u0e31\\u0e14"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e40\\u0e1b\\u0e34\\u0e14"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e15\\u0e31\\u0e27\""));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e08\\u0e33\\u0e01\\u0e31\\u0e14"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e40\\u0e1b\\u0e34\\u0e14"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e15\\u0e31\\u0e27\""));
|
||||
*/
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e2e\\u0e32\\u0e23\\u0e4c\\u0e14\\u0e14\\u0e34\\u0e2a\\u0e01\\u0e4c\""));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e23\\u0e38\\u0e48\\u0e19"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e43\\u0e2b\\u0e21\\u0e48"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e40\\u0e14\\u0e37\\u0e2d\\u0e19\\u0e21\\u0e34."));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e22."));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e19\\u0e35\\u0e49"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e23\\u0e32\\u0e04\\u0e32"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e2e\\u0e32\\u0e23\\u0e4c\\u0e14\\u0e14\\u0e34\\u0e2a\\u0e01\\u0e4c\""));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e23\\u0e38\\u0e48\\u0e19"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e43\\u0e2b\\u0e21\\u0e48"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e40\\u0e14\\u0e37\\u0e2d\\u0e19\\u0e21\\u0e34."));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e22."));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e19\\u0e35\\u0e49"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e23\\u0e32\\u0e04\\u0e32"));
|
||||
thaiLineSelection->addElement("$200");
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e40\\u0e17\\u0e48\\u0e32"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e19\\u0e31\\u0e49\\u0e19 "));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("(\"\\u0e2e\\u0e32\\u0e23\\u0e4c\\u0e14\\u0e14\\u0e34\\u0e2a\\u0e01\\u0e4c\")."));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e40\\u0e17\\u0e48\\u0e32"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e19\\u0e31\\u0e49\\u0e19 "));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("(\"\\u0e2e\\u0e32\\u0e23\\u0e4c\\u0e14\\u0e14\\u0e34\\u0e2a\\u0e01\\u0e4c\")."));
|
||||
|
||||
BreakIterator* e = BreakIterator::createLineInstance(
|
||||
Locale(UnicodeString("th", (char*)0)), status);
|
||||
|
|
@ -872,13 +852,13 @@ void IntlTestTextBoundary::TestMaiyamok()
|
|||
// the Thai maiyamok character is a shorthand symbol that means "repeat the previous
|
||||
// word". Instead of appearing as a word unto itself, however, it's kept together
|
||||
// with the word before it
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e44\\u0e1b\\u0e46"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e21\\u0e32\\u0e46"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e23\\u0e30\\u0e2b\\u0e27\\u0e48\\u0e32\\u0e07"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e01\\u0e23\\u0e38\\u0e07\\u0e40\\u0e17\\u0e1e"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e41\\u0e25\\u0e30"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e40\\u0e03\\u0e35\\u0e22\\u0e07"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString2("\\u0e43\\u0e2b\\u0e21\\u0e48"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e44\\u0e1b\\u0e46"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e21\\u0e32\\u0e46"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e23\\u0e30\\u0e2b\\u0e27\\u0e48\\u0e32\\u0e07"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e01\\u0e23\\u0e38\\u0e07\\u0e40\\u0e17\\u0e1e"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e41\\u0e25\\u0e30"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e40\\u0e03\\u0e35\\u0e22\\u0e07"));
|
||||
thaiLineSelection->addElement(CharsToUnicodeString("\\u0e43\\u0e2b\\u0e21\\u0e48"));
|
||||
|
||||
BreakIterator* e = BreakIterator::createLineInstance(
|
||||
Locale(UnicodeString("th", (char*)0)), status);
|
||||
|
|
@ -900,9 +880,9 @@ void IntlTestTextBoundary::TestMaiyamok()
|
|||
void IntlTestTextBoundary::TestJapaneseLineBreak()
|
||||
{
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
UnicodeString testString = CharsToUnicodeString2("\\u4e00x\\u4e8c");
|
||||
UnicodeString precedingChars = CharsToUnicodeString2("([{\\u00ab$\\u00a5\\u00a3\\u00a4\\u2018\\u201a\\u201c\\u201e\\u201b\\u201f");
|
||||
UnicodeString followingChars = CharsToUnicodeString2(")]}\\u00bb!%,.\\u3001\\u3002\\u3063\\u3083\\u3085\\u3087\\u30c3\\u30e3\\u30e5\\u30e7\\u30fc:;\\u309b\\u309c\\u3005\\u309d\\u309e\\u30fd\\u30fe\\u2019\\u201d\\u00b0\\u2032\\u2033\\u2034\\u2030\\u2031\\u2103\\u2109\\u00a2\\u0300\\u0301\\u0302");
|
||||
UnicodeString testString = CharsToUnicodeString("\\u4e00x\\u4e8c");
|
||||
UnicodeString precedingChars = CharsToUnicodeString("([{\\u00ab$\\u00a5\\u00a3\\u00a4\\u2018\\u201a\\u201c\\u201e\\u201b\\u201f");
|
||||
UnicodeString followingChars = CharsToUnicodeString(")]}\\u00bb!%,.\\u3001\\u3002\\u3063\\u3083\\u3085\\u3087\\u30c3\\u30e3\\u30e5\\u30e7\\u30fc:;\\u309b\\u309c\\u3005\\u309d\\u309e\\u30fd\\u30fe\\u2019\\u201d\\u00b0\\u2032\\u2033\\u2034\\u2030\\u2031\\u2103\\u2109\\u00a2\\u0300\\u0301\\u0302");
|
||||
BreakIterator *iter = BreakIterator::createLineInstance(Locale::JAPAN, status);
|
||||
|
||||
UTextOffset i;
|
||||
|
|
@ -1376,7 +1356,7 @@ void IntlTestTextBoundary::doBreakInvariantTest(BreakIterator& tb, UnicodeString
|
|||
int errorCount = 0;
|
||||
|
||||
// a break should always occur after CR (unless followed by LF), LF, PS, and LS
|
||||
UnicodeString breaks = CharsToUnicodeString2("\r\n\\u2029\\u2028");
|
||||
UnicodeString breaks = CharsToUnicodeString("\r\n\\u2029\\u2028");
|
||||
UTextOffset i, j;
|
||||
|
||||
for (i = 0; i < breaks.length(); i++) {
|
||||
|
|
|
|||
|
|
@ -37,9 +37,9 @@ CollationKanaTest::~CollationKanaTest()
|
|||
}
|
||||
|
||||
const UChar CollationKanaTest::testSourceCases[][CollationKanaTest::MAX_TOKEN_LEN] = {
|
||||
{'A', 0x0300, 0x0301, 0},
|
||||
{'A', 0x0300, 0x0316, 0},
|
||||
{'A', 0x0300, 0},
|
||||
{0x41, 0x0300, 0x0301, 0},
|
||||
{0x41, 0x0300, 0x0316, 0},
|
||||
{0x41, 0x0300, 0},
|
||||
{0x00C0, 0x0301, 0},
|
||||
{0x00C0, 0x0316, 0},
|
||||
{0xff9E, 0},
|
||||
|
|
@ -51,11 +51,11 @@ const UChar CollationKanaTest::testSourceCases[][CollationKanaTest::MAX_TOKEN_LE
|
|||
};
|
||||
|
||||
const UChar CollationKanaTest::testTargetCases[][CollationKanaTest::MAX_TOKEN_LEN] = {
|
||||
{'A', 0x0301, 0x0300, 0},
|
||||
{'A', 0x0316, 0x0300, 0},
|
||||
{0x41, 0x0301, 0x0300, 0},
|
||||
{0x41, 0x0316, 0x0300, 0},
|
||||
{0x00C0, 0},
|
||||
{'A', 0x0301, 0x0300, 0},
|
||||
{'A', 0x0316, 0x0300, 0},
|
||||
{0x41, 0x0301, 0x0300, 0},
|
||||
{0x41, 0x0316, 0x0300, 0},
|
||||
{0xFF9F, 0},
|
||||
{0x30A2, 0},
|
||||
{0x3042, 0x3042, 0},
|
||||
|
|
|
|||
|
|
@ -559,14 +559,14 @@ char* rawData[27][7] = {
|
|||
//{ "English (United States)", "French (France)", "Croatian (Croatia)", "Greek (Greece)", "Norwegian (Norway,NY)", "Italian", "xx (YY)" },
|
||||
|
||||
// display langage (French)
|
||||
{ "anglais", "français", "", "grec", "norvégien", "italien", "xx" },
|
||||
{ "anglais", "fran\\u00E7ais", "", "grec", "norv\\u00E9gien", "italien", "xx" },
|
||||
// display country (French)
|
||||
{ "États-Unis", "France", "", "Grèce", "Norvège", "", "YY" },
|
||||
{ "\\u00C9tats-Unis", "France", "", "Gr\\u00E8ce", "Norv\\u00E8ge", "", "YY" },
|
||||
// display variant (French)
|
||||
{ "", "", "", "", "Nynorsk", "", "" },
|
||||
// display name (French)
|
||||
//{ "anglais (États-Unis)", "français (France)", "", "grec (Grèce)", "norvégien (Norvège,Nynorsk)", "italien", "xx (YY)" },
|
||||
{ "anglais (États-Unis)", "français (France)", "", "grec (Grèce)", "norvégien (Norvège, Nynorsk)", "italien", "xx (YY)" },
|
||||
{ "anglais (\\u00C9tats-Unis)", "fran\\u00E7ais (France)", "", "grec (Gr\\u00E8ce)", "norv\\u00E9gien (Norv\\u00E8ge, Nynorsk)", "italien", "xx (YY)" },
|
||||
|
||||
// display langage (Croatian)
|
||||
{ "", "", "hrvatski", "", "", "", "xx" },
|
||||
|
|
@ -600,7 +600,7 @@ char* rawData[27][7] = {
|
|||
UChar greekDisplayLanguage[] = { 0x03b5, 0x03bb, 0x03bb, 0x03b7, 0x03bd, 0x03b9, 0x03ba, 0x03ac, 0 };
|
||||
UChar greekDisplayCountry[] = { 0x0395, 0x03bb, 0x03bb, 0x03ac, 0x03b4, 0x03b1, 0 };
|
||||
UChar greekDisplayName[] = { 0x03b5, 0x03bb, 0x03bb, 0x03b7, 0x03bd, 0x03b9, 0x03ba,
|
||||
0x03ac, ' ', '(', 0x0395, 0x03bb, 0x03bb, 0x03ac, 0x03b4, 0x03b1, ')', 0 };
|
||||
0x03ac, 0x20, 0x28, 0x0395, 0x03bb, 0x03bb, 0x03ac, 0x03b4, 0x03b1, 0x29, 0 };
|
||||
|
||||
void LocaleTest::setUpDataTable()
|
||||
{
|
||||
|
|
@ -609,8 +609,9 @@ void LocaleTest::setUpDataTable()
|
|||
|
||||
for (int32_t i = 0; i < 27; i++) {
|
||||
dataTable[i] = new UnicodeString[7];
|
||||
for (int32_t j = 0; j < 7; j++)
|
||||
dataTable[i][j] = rawData[i][j];
|
||||
for (int32_t j = 0; j < 7; j++) {
|
||||
dataTable[i][j] = CharsToUnicodeString(rawData[i][j]);
|
||||
}
|
||||
}
|
||||
dataTable[DLANG_EL][GREEK] = greekDisplayLanguage;
|
||||
dataTable[DCTRY_EL][GREEK] = greekDisplayCountry;
|
||||
|
|
@ -618,7 +619,6 @@ void LocaleTest::setUpDataTable()
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
// ====================
|
||||
|
||||
|
||||
|
|
@ -937,7 +937,7 @@ LocaleTest::TestAtypicalLocales()
|
|||
"anglais (France)",
|
||||
"espagnol (Allemagne)",
|
||||
"Croatia",
|
||||
"Suède",
|
||||
CharsToUnicodeString("Su\\u00E8de"),
|
||||
"Dominican Republic",
|
||||
"Belgique" };
|
||||
UnicodeString rus("Russian (M");
|
||||
|
|
|
|||
|
|
@ -110,9 +110,11 @@ NumberFormatRoundTripTest::test(NumberFormat *fmt)
|
|||
{
|
||||
if (TRUE)
|
||||
{
|
||||
#if !defined(OS390) || defined(IEEE_ON)
|
||||
test(fmt, uprv_getNaN());
|
||||
test(fmt, uprv_getInfinity());
|
||||
test(fmt, -uprv_getInfinity());
|
||||
#endif
|
||||
|
||||
test(fmt, (int32_t)500);
|
||||
test(fmt, (int32_t)0);
|
||||
|
|
@ -129,7 +131,11 @@ NumberFormatRoundTripTest::test(NumberFormat *fmt)
|
|||
test(fmt, uprv_floor((randomDouble(10000))));
|
||||
test(fmt, randomDouble(1e50));
|
||||
test(fmt, randomDouble(1e-50));
|
||||
#ifndef OS390
|
||||
test(fmt, randomDouble(1e100));
|
||||
#elif defined(IEEE_ON)
|
||||
test(fmt, randomDouble(1e75)); /*OS390*/
|
||||
#endif
|
||||
// {sfb} When formatting with a percent instance, numbers very close to
|
||||
// DBL_MAX will fail the round trip. This is because:
|
||||
// 1) Format the double into a string --> INF% (since 100 * double > DBL_MAX)
|
||||
|
|
@ -141,16 +147,32 @@ NumberFormatRoundTripTest::test(NumberFormat *fmt)
|
|||
// the double will stay in range.
|
||||
//if(fmt->getMultipler() == 1)
|
||||
if(fmt->getDynamicClassID() == DecimalFormat::getStaticClassID())
|
||||
#ifndef OS390
|
||||
test(fmt, randomDouble(1e308) / ((DecimalFormat*)fmt)->getMultiplier());
|
||||
|
||||
#ifndef XP_MAC
|
||||
test(fmt, randomDouble(1e-323));
|
||||
#else
|
||||
# ifdef IEEE_ON
|
||||
test(fmt, randomDouble(1e75) / ((DecimalFormat*)fmt)->getMultiplier());
|
||||
# else
|
||||
test(fmt, randomDouble(1e65) / ((DecimalFormat*)fmt)->getMultiplier()); /*OS390*/
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef XP_MAC
|
||||
// PowerPC doesn't support denormalized doubles, so the low-end range
|
||||
// doesn't match NT
|
||||
test(fmt, randomDouble(1e-290));
|
||||
#elif defined(OS390)
|
||||
# ifdef IEEE_ON
|
||||
test(fmt, randomDouble(1e-78)); /*OS390*/
|
||||
# endif
|
||||
#else
|
||||
test(fmt, randomDouble(1e-323));
|
||||
#endif
|
||||
#ifndef OS390
|
||||
test(fmt, randomDouble(1e-100));
|
||||
#elif defined(IEEE_ON)
|
||||
test(fmt, randomDouble(1e-78)); /*OS390*/
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -230,7 +230,7 @@ void NumberFormatRegressionTest::Test4087245 (void)
|
|||
FieldPosition pos(FieldPosition::DONT_CARE);
|
||||
logln(UnicodeString("format(") + n + ") = " +
|
||||
df->format(n, buf1, pos));
|
||||
symbols->setDecimalSeparator(UChar('p')); // change value of field
|
||||
symbols->setDecimalSeparator(0x70); // change value of field
|
||||
logln(UnicodeString("format(") + n + ") = " +
|
||||
df->format(n, buf2, pos));
|
||||
if(buf1 != buf2)
|
||||
|
|
@ -421,11 +421,11 @@ void NumberFormatRegressionTest::Test4086575(void)
|
|||
// Space as group separator
|
||||
|
||||
logln("...applyLocalizedPattern # ###,00;(# ###,00) ");
|
||||
// nbsp = \u00a0 = ' '
|
||||
// nbsp = \u00a0
|
||||
//nf->applyLocalizedPattern("#\u00a0###,00;(#\u00a0###,00)");
|
||||
UChar patChars[] = {
|
||||
'#', 0x00a0, '#', '#', '#', ',', '0', '0', ';',
|
||||
'(', '#', 0x00a0, '#', '#', '#', ',', '0', '0', ')'
|
||||
0x23, 0x00a0, 0x23, 0x23, 0x23, 0x2c, 0x30, 0x30, 0x3b,
|
||||
0x28, 0x23, 0x00a0, 0x23, 0x23, 0x23, 0x2c, 0x30, 0x30, 0x29
|
||||
};
|
||||
UnicodeString pat(patChars, 19, 19);
|
||||
nf->applyLocalizedPattern(pat, status);
|
||||
|
|
@ -436,7 +436,7 @@ void NumberFormatRegressionTest::Test4086575(void)
|
|||
buffer = nf->format((int32_t)1234, buffer, pos);
|
||||
//if (buffer != UnicodeString("1\u00a0234,00"))
|
||||
UChar c[] = {
|
||||
'1', 0x00a0, '2', '3', '4', ',', '0', '0'
|
||||
0x31, 0x00a0, 0x32, 0x33, 0x34, 0x2c, 0x30, 0x30
|
||||
};
|
||||
UnicodeString cc(c, 8, 8);
|
||||
if (buffer != cc)
|
||||
|
|
@ -445,7 +445,7 @@ void NumberFormatRegressionTest::Test4086575(void)
|
|||
buffer.remove();
|
||||
buffer = nf->format((int32_t)-1234, buffer, pos);
|
||||
UChar c1[] = {
|
||||
'(', '1', 0x00a0, '2', '3', '4', ',', '0', '0', ')'
|
||||
0x28, 0x31, 0x00a0, 0x32, 0x33, 0x34, 0x2c, 0x30, 0x30, 0x29
|
||||
};
|
||||
UnicodeString cc1(c1, 10, 10);
|
||||
if (buffer != cc1)
|
||||
|
|
@ -740,13 +740,13 @@ void NumberFormatRegressionTest::Test4070798 (void)
|
|||
String expectedPercent = "-578\u00a0998%";
|
||||
*/
|
||||
UChar chars1 [] = {
|
||||
'-', '5', 0x00a0, '7', '8', '9', ',', '9', '8', '8'
|
||||
0x2d, 0x35, 0x00a0, 0x37, 0x38, 0x39, 0x2c, 0x39, 0x38, 0x38
|
||||
};
|
||||
UChar chars2 [] = {
|
||||
'5', 0x00a0, '7', '8', '9', ',', '9', '9', ' ', 'F'
|
||||
0x35, 0x00a0, 0x37, 0x38, 0x39, 0x2c, 0x39, 0x39, 0x20, 0x46
|
||||
};
|
||||
UChar chars3 [] = {
|
||||
'-', '5', '7', '8', 0x00a0, '9', '9', '9', '%'
|
||||
0x2d, 0x35, 0x37, 0x38, 0x00a0, 0x39, 0x39, 0x39, 0x25
|
||||
};
|
||||
UnicodeString expectedDefault(chars1, 10, 10);
|
||||
UnicodeString expectedCurrency(chars2, 10, 10);
|
||||
|
|
@ -808,13 +808,13 @@ void NumberFormatRegressionTest::Test4071005 (void)
|
|||
String expectedPercent = "-578\u00a0998%";
|
||||
*/
|
||||
UChar chars1 [] = {
|
||||
'-', '5', 0x00a0, '7', '8', '9', ',', '9', '8', '8'
|
||||
0x2d, 0x35, 0x00a0, 0x37, 0x38, 0x39, 0x2c, 0x39, 0x38, 0x38
|
||||
};
|
||||
UChar chars2 [] = {
|
||||
'5', 0x00a0, '7', '8', '9', ',', '9', '9', ' ', '$'
|
||||
0x35, 0x00a0, 0x37, 0x38, 0x39, 0x2c, 0x39, 0x39, 0x20, 0x24
|
||||
};
|
||||
UChar chars3 [] = {
|
||||
'-', '5', '7', '8', 0x00a0, '9', '9', '9', '%'
|
||||
0x2d, 0x35, 0x37, 0x38, 0x00a0, 0x39, 0x39, 0x39, 0x25
|
||||
};
|
||||
UnicodeString expectedDefault(chars1, 10, 10);
|
||||
UnicodeString expectedCurrency(chars2, 10, 10);
|
||||
|
|
@ -1363,14 +1363,20 @@ void NumberFormatRegressionTest::Test4106667(void)
|
|||
/* @bug 4110936
|
||||
* DecimalFormat.setMaximumIntegerDigits() works incorrectly.
|
||||
*/
|
||||
#ifdef OS390
|
||||
# define MAX_INT_DIGITS 70
|
||||
#else
|
||||
# define MAX_INT_DIGITS 128
|
||||
#endif
|
||||
|
||||
void NumberFormatRegressionTest::Test4110936(void)
|
||||
{
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
NumberFormat *nf = NumberFormat::createInstance(status);
|
||||
failure(status, "NumberFormat::createInstance");
|
||||
nf->setMaximumIntegerDigits(128);
|
||||
logln("setMaximumIntegerDigits(128)");
|
||||
if (nf->getMaximumIntegerDigits() != 128)
|
||||
nf->setMaximumIntegerDigits(MAX_INT_DIGITS);
|
||||
logln("setMaximumIntegerDigits(MAX_INT_DIGITS)");
|
||||
if (nf->getMaximumIntegerDigits() != MAX_INT_DIGITS)
|
||||
errln("getMaximumIntegerDigits() returns " +
|
||||
nf->getMaximumIntegerDigits());
|
||||
|
||||
|
|
@ -1840,7 +1846,11 @@ NumberFormatRegressionTest::Test4162852(void)
|
|||
logln(UnicodeString("") +
|
||||
d + " -> " +
|
||||
'"' + s + '"' + " -> " + e);
|
||||
#if !defined(OS390) || defined(IEEE_ON)
|
||||
if (e != 0.0 || 1.0/e > 0.0) {
|
||||
#else
|
||||
if (e != 0.0) {
|
||||
#endif
|
||||
logln("Failed to parse negative zero");
|
||||
}
|
||||
delete f;
|
||||
|
|
@ -1995,7 +2005,7 @@ void NumberFormatRegressionTest::Test4212072(void) {
|
|||
UnicodeString s;
|
||||
FieldPosition pos;
|
||||
|
||||
sym.setMinusSign('^');
|
||||
sym.setMinusSign(0x5e);
|
||||
fmt.setDecimalFormatSymbols(sym);
|
||||
s.remove();
|
||||
if (fmt.format((int32_t)-1, s, pos) != UnicodeString("^1")) {
|
||||
|
|
@ -2007,11 +2017,11 @@ void NumberFormatRegressionTest::Test4212072(void) {
|
|||
errln(UnicodeString("FAIL: (minus=^).getNegativePrefix -> ") +
|
||||
s + ", exp ^");
|
||||
}
|
||||
sym.setMinusSign('-');
|
||||
sym.setMinusSign(0x2d);
|
||||
|
||||
fmt.applyPattern(UnicodeString("#%"), status);
|
||||
failure(status, "applyPattern percent");
|
||||
sym.setPercent('^');
|
||||
sym.setPercent(0x5e);
|
||||
fmt.setDecimalFormatSymbols(sym);
|
||||
s.remove();
|
||||
if (fmt.format(0.25, s, pos) != UnicodeString("25^")) {
|
||||
|
|
@ -2023,11 +2033,11 @@ void NumberFormatRegressionTest::Test4212072(void) {
|
|||
errln(UnicodeString("FAIL: (percent=^).getPositiveSuffix -> ") +
|
||||
s + ", exp ^");
|
||||
}
|
||||
sym.setPercent('%');
|
||||
sym.setPercent(0x25);
|
||||
|
||||
fmt.applyPattern(str("#\\u2030"), status);
|
||||
failure(status, "applyPattern permill");
|
||||
sym.setPerMill('^');
|
||||
sym.setPerMill(0x5e);
|
||||
fmt.setDecimalFormatSymbols(sym);
|
||||
s.remove();
|
||||
if (fmt.format(0.25, s, pos) != UnicodeString("250^")) {
|
||||
|
|
|
|||
|
|
@ -18,26 +18,6 @@
|
|||
#include "rbbiapts.h"
|
||||
#include "string.h"
|
||||
#include "stdio.h"
|
||||
//Just to make it easier to use with UChar array.
|
||||
UnicodeString CharsToUnicodeString(const char* chars)
|
||||
{
|
||||
int i;
|
||||
int unicode;
|
||||
int len = strlen(chars);
|
||||
|
||||
UnicodeString buffer;
|
||||
for (i = 0; i < len;) {
|
||||
if ((chars[i] == '\\') && (i+1 < len) && (chars[i+1] == 'u')) {
|
||||
|
||||
sscanf(&(chars[i+2]), "%4X", &unicode);
|
||||
buffer += (UChar)unicode;
|
||||
i += 6;
|
||||
} else {
|
||||
buffer += (UChar)chars[i++];
|
||||
}
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/**
|
||||
* API Test the RuleBasedBreakIterator class
|
||||
|
|
|
|||
|
|
@ -113,28 +113,6 @@ public:
|
|||
* RBBITest is medium top level test class RuleBasedBreakIterator
|
||||
*/
|
||||
|
||||
|
||||
// [HSYS] Just to make it easier to use with UChar array.
|
||||
static UnicodeString CharsToUnicodeString(const char* chars)
|
||||
{
|
||||
int len = strlen(chars);
|
||||
int i;
|
||||
UnicodeString buffer;
|
||||
for (i = 0; i < len;) {
|
||||
if ((chars[i] == '\\') && (i+1 < len) && (chars[i+1] == 'u')) {
|
||||
int unicode;
|
||||
sscanf(&(chars[i+2]), "%4X", &unicode);
|
||||
buffer += (UChar)unicode;
|
||||
i += 6;
|
||||
} else {
|
||||
buffer += (UChar)chars[i++];
|
||||
}
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
||||
|
||||
|
||||
const UnicodeString halfNA = CharsToUnicodeString("\\u0928\\u094d\\u200d"); //halfform NA = devanigiri NA + virama(supresses inherent vowel)+ zero width joiner
|
||||
const UnicodeString halfSA = CharsToUnicodeString("\\u0938\\u094d\\u200d");
|
||||
const UnicodeString halfCHA = CharsToUnicodeString("\\u091a\\u094d\\u200d");
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ static UErrorCode status = U_ZERO_ERROR;
|
|||
|
||||
const UnicodeString CollationRegressionTest::test1 = "XFILE What subset of all possible test cases has the highest probability of detecting the most errors?";
|
||||
const UnicodeString CollationRegressionTest::test2 = "Xf ile What subset of all possible test cases has the lowest probability of detecting the least errors?";
|
||||
const UChar chars3[] = {'a', 0x00FC, 'b', 'e', 'c', 'k', ' ', 'G', 'r', 0x00F6, 0x00DF, 'e', ' ', 'L', 0x00FC, 'b', 'c', 'k', 0};
|
||||
const UChar chars3[] = {0x61, 0x00FC, 0x62, 0x65, 0x63, 0x6b, 0x20, 0x47, 0x72, 0x00F6, 0x00DF, 0x65, 0x20, 0x4c, 0x00FC, 0x62, 0x63, 0x6b, 0};
|
||||
const UnicodeString CollationRegressionTest::test3(chars3);
|
||||
|
||||
CollationRegressionTest::CollationRegressionTest()
|
||||
|
|
@ -189,15 +189,15 @@ void CollationRegressionTest::Test4054734(char *par)
|
|||
|
||||
static const UChar decomp[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{0x0001, 0}, {'<', 0}, {0x0002, 0},
|
||||
{0x0001, 0}, {'=', 0}, {0x0001, 0},
|
||||
{'A', 0x0001, 0}, {'>', 0}, {'~', 0x0002, 0},
|
||||
{0x00c0, 0}, {'=', 0}, {'A', 0x0300, 0}
|
||||
{0x0001, 0}, {0x3c, 0}, {0x0002, 0},
|
||||
{0x0001, 0}, {0x3d, 0}, {0x0001, 0},
|
||||
{0x41, 0x0001, 0}, {0x3e, 0}, {0x7e, 0x0002, 0},
|
||||
{0x00c0, 0}, {0x3d, 0}, {0x41, 0x0300, 0}
|
||||
};
|
||||
|
||||
static const UChar nodecomp[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{0x00C0, 0}, {'>', 0}, {'A', 0x0300, 0}
|
||||
{0x00C0, 0}, {0x3e, 0}, {0x41, 0x0300, 0}
|
||||
};
|
||||
|
||||
RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
|
||||
|
|
@ -225,7 +225,7 @@ void CollationRegressionTest::Test4054736(char *par)
|
|||
|
||||
static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{0xFB4F, 0}, {'=', 0}, {0x05D0, 0x05DC} // Alef-Lamed vs. Alef, Lamed
|
||||
{0xFB4F, 0}, {0x3d, 0}, {0x05D0, 0x05DC} // Alef-Lamed vs. Alef, Lamed
|
||||
};
|
||||
|
||||
compareArray(*c, tests, ARRAY_LENGTH(tests));
|
||||
|
|
@ -348,12 +348,12 @@ void CollationRegressionTest::Test4060154(char *par)
|
|||
|
||||
static const UChar tertiary[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'A', 0}, {'<', 0}, {'B', 0},
|
||||
{'H', 0}, {'<', 0}, {0x0131, 0},
|
||||
{'H', 0}, {'<', 0}, {'I', 0},
|
||||
{0x0131, 0}, {'<', 0}, {0x0130, 0},
|
||||
{0x0130, 0}, {'<', 0}, {'i', 0},
|
||||
{0x0130, 0}, {'>', 0}, {'H', 0}
|
||||
{0x41, 0}, {0x3c, 0}, {0x42, 0},
|
||||
{0x48, 0}, {0x3c, 0}, {0x0131, 0},
|
||||
{0x48, 0}, {0x3c, 0}, {0x49, 0},
|
||||
{0x0131, 0}, {0x3c, 0}, {0x0130, 0},
|
||||
{0x0130, 0}, {0x3c, 0}, {0x69, 0},
|
||||
{0x0130, 0}, {0x3e, 0}, {0x48, 0}
|
||||
};
|
||||
|
||||
c->setStrength(Collator::TERTIARY);
|
||||
|
|
@ -367,8 +367,8 @@ void CollationRegressionTest::Test4060154(char *par)
|
|||
*/
|
||||
static const UChar secondary[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'H', 0}, {'<', 0}, {'I', 0},
|
||||
{0x0131, 0}, {'=', 0}, {0x0130, 0}
|
||||
{0x48, 0}, {0x3c, 0}, {0x49, 0},
|
||||
{0x0131, 0}, {0x3d, 0}, {0x0130, 0}
|
||||
};
|
||||
|
||||
c->setStrength(Collator::PRIMARY);
|
||||
|
|
@ -405,7 +405,7 @@ void CollationRegressionTest::Test4062418(char *par)
|
|||
*/
|
||||
static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'p', 0x00EA, 'c', 'h', 'e', 0}, {'<', 0}, {'p', 0x00E9, 'c', 'h', 0x00E9, 0}
|
||||
{0x70, 0x00EA, 0x63, 0x68, 0x65, 0}, {0x3c, 0}, {0x70, 0x00E9, 0x63, 0x68, 0x00E9, 0}
|
||||
};
|
||||
|
||||
compareArray(*c, tests, ARRAY_LENGTH(tests));
|
||||
|
|
@ -434,7 +434,7 @@ void CollationRegressionTest::Test4065540(char *par)
|
|||
void CollationRegressionTest::Test4066189(char *par)
|
||||
{
|
||||
static const UChar chars1[] = {0x1EB1, 0};
|
||||
static const UChar chars2[] = {'a', 0x0306, 0x0300, 0};
|
||||
static const UChar chars2[] = {0x61, 0x0306, 0x0300, 0};
|
||||
const UnicodeString test1(chars1);
|
||||
const UnicodeString test2(chars2);
|
||||
|
||||
|
|
@ -485,7 +485,7 @@ void CollationRegressionTest::Test4066696(char *par)
|
|||
|
||||
static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{0x00E0, 0}, {'<', 0}, {0x01FA, 0}
|
||||
{0x00E0, 0}, {0x3c, 0}, {0x01FA, 0}
|
||||
};
|
||||
|
||||
compareArray(*c, tests, ARRAY_LENGTH(tests));
|
||||
|
|
@ -501,8 +501,8 @@ void CollationRegressionTest::Test4076676(char *par)
|
|||
{
|
||||
// These combining characters are all in the same class, so they should not
|
||||
// be reordered, and they should compare as unequal.
|
||||
static const UChar s1[] = {'A', 0x0301, 0x0302, 0x0300, 0};
|
||||
static const UChar s2[] = {'A', 0x0302, 0x0300, 0x0301, 0};
|
||||
static const UChar s1[] = {0x41, 0x0301, 0x0302, 0x0300, 0};
|
||||
static const UChar s2[] = {0x41, 0x0302, 0x0300, 0x0301, 0};
|
||||
|
||||
RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
|
||||
c->setStrength(Collator::TERTIARY);
|
||||
|
|
@ -582,8 +582,8 @@ void CollationRegressionTest::Test4081866(char *par)
|
|||
{
|
||||
// These combining characters are all in different classes,
|
||||
// so they should be reordered and the strings should compare as equal.
|
||||
static const UChar s1[] = {'A', 0x0300, 0x0316, 0x0327, 0x0315, 0};
|
||||
static const UChar s2[] = {'A', 0x0327, 0x0316, 0x0315, 0x0300, 0};
|
||||
static const UChar s1[] = {0x41, 0x0300, 0x0316, 0x0327, 0x0315, 0};
|
||||
static const UChar s2[] = {0x41, 0x0327, 0x0316, 0x0315, 0x0300, 0};
|
||||
|
||||
RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
|
||||
c->setStrength(Collator::TERTIARY);
|
||||
|
|
@ -624,9 +624,9 @@ void CollationRegressionTest::Test4087241(char *par)
|
|||
|
||||
static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'z', 0}, {'<', 0}, {0x00E6, 0}, // z < ae
|
||||
{'a', 0x0308, 0}, {'<', 0}, {'a', 0x030A, 0}, // a-unlaut < a-ring
|
||||
{'Y', 0}, {'<', 0}, {'u', 0x0308, 0}, // Y < u-umlaut
|
||||
{0x7a, 0}, {0x3c, 0}, {0x00E6, 0}, // z < ae
|
||||
{0x61, 0x0308, 0}, {0x3c, 0}, {0x61, 0x030A, 0}, // a-unlaut < a-ring
|
||||
{0x59, 0}, {0x3c, 0}, {0x75, 0x0308, 0}, // Y < u-umlaut
|
||||
};
|
||||
|
||||
compareArray(*c, tests, ARRAY_LENGTH(tests));
|
||||
|
|
@ -645,7 +645,7 @@ void CollationRegressionTest::Test4087243(char *par)
|
|||
|
||||
static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'1', '2', '3', 0}, {'=', 0}, {'1', '2', '3', 0x0001, 0} // 1 2 3 = 1 2 3 ctrl-A
|
||||
{0x31, 0x32, 0x33, 0}, {0x3d, 0}, {0x31, 0x32, 0x33, 0x0001, 0} // 1 2 3 = 1 2 3 ctrl-A
|
||||
};
|
||||
|
||||
compareArray(*c, tests, ARRAY_LENGTH(tests));
|
||||
|
|
@ -675,7 +675,7 @@ void CollationRegressionTest::Test4092260(char *par)
|
|||
|
||||
static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{0x00B5, 0}, {'=', 0}, {0x03BC, 0}
|
||||
{0x00B5, 0}, {0x3d, 0}, {0x03BC, 0}
|
||||
};
|
||||
|
||||
compareArray(*c, tests, ARRAY_LENGTH(tests));
|
||||
|
|
@ -702,7 +702,7 @@ void CollationRegressionTest::Test4095316(char *par)
|
|||
|
||||
static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{0x03D4, 0}, {'=', 0}, {0x03AB, 0}
|
||||
{0x03D4, 0}, {0x3d, 0}, {0x03AB, 0}
|
||||
};
|
||||
|
||||
compareArray(*c, tests, ARRAY_LENGTH(tests));
|
||||
|
|
@ -751,8 +751,8 @@ void CollationRegressionTest::Test4103436(char *par)
|
|||
|
||||
static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'f', 'i', 'l', 'e', 0}, {'<', 0}, {'f', 'i', 'l', 'e', ' ', 'a', 'c', 'c', 'e', 's', 's', 0},
|
||||
{'f', 'i', 'l', 'e', 0}, {'<', 0}, {'f', 'i', 'l', 'e', 'a', 'c', 'c', 'e', 's', 's', 0}
|
||||
{0x66, 0x69, 0x6c, 0x65, 0}, {0x3c, 0}, {0x66, 0x69, 0x6c, 0x65, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0},
|
||||
{0x66, 0x69, 0x6c, 0x65, 0}, {0x3c, 0}, {0x66, 0x69, 0x6c, 0x65, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0}
|
||||
};
|
||||
|
||||
compareArray(*c, tests, ARRAY_LENGTH(tests));
|
||||
|
|
@ -776,7 +776,7 @@ void CollationRegressionTest::Test4114076(char *par)
|
|||
//
|
||||
static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{0xd4db, 0}, {'=', 0}, {0x1111, 0x1171, 0x11b6, 0}
|
||||
{0xd4db, 0}, {0x3d, 0}, {0x1111, 0x1171, 0x11b6, 0}
|
||||
};
|
||||
|
||||
c->setDecomposition(Normalizer::DECOMP);
|
||||
|
|
@ -788,7 +788,7 @@ void CollationRegressionTest::Test4114076(char *par)
|
|||
//
|
||||
static const UChar test2[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{0xd4db, 0}, {'=', 0}, {0x1111, 0x116e, 0x1175, 0x11af, 0x11c2, 0}
|
||||
{0xd4db, 0}, {0x3d, 0}, {0x1111, 0x116e, 0x1175, 0x11af, 0x11c2, 0}
|
||||
};
|
||||
|
||||
c->setDecomposition(Normalizer::DECOMP_COMPAT);
|
||||
|
|
@ -815,7 +815,7 @@ void CollationRegressionTest::Test4124632(char *par)
|
|||
delete coll;
|
||||
}
|
||||
|
||||
static const UChar test[] = {'A', 0x0308, 'b', 'c', 0};
|
||||
static const UChar test[] = {0x41, 0x0308, 0x62, 0x63, 0};
|
||||
CollationKey key;
|
||||
|
||||
coll->getCollationKey(test, key, status);
|
||||
|
|
@ -848,8 +848,8 @@ void CollationRegressionTest::Test4132736(char *par)
|
|||
|
||||
static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'e', 0x0300, 'e', 0x0301, 0}, {'<', 0}, {'e', 0x0301, 'e', 0x0300, 0},
|
||||
{'e', 0x0300, 0x0301, 0}, {'>', 0}, {'e', 0x0301, 0x0300, 0}
|
||||
{0x65, 0x0300, 0x65, 0x0301, 0}, {0x3c, 0}, {0x65, 0x0301, 0x65, 0x0300, 0},
|
||||
{0x65, 0x0300, 0x0301, 0}, {0x3e, 0}, {0x65, 0x0301, 0x0300, 0}
|
||||
};
|
||||
|
||||
compareArray(*c, test1, ARRAY_LENGTH(test1));
|
||||
|
|
@ -865,9 +865,9 @@ void CollationRegressionTest::Test4133509(char *par)
|
|||
{
|
||||
static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n', 0}, {'<', 0}, {'E', 'x', 'c', 'e', 'p', 't', 'i', 'o', 'n', 'I', 'n', 'I', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'r', 'E', 'r', 'r', 'o', 'r', 0},
|
||||
{'G', 'r', 'a', 'p', 'h', 'i', 'c', 's', 0}, {'<', 0}, {'G', 'r', 'a', 'p', 'h', 'i', 'c', 's', 'E', 'n', 'v', 'i', 'r', 'o', 'n', 'm', 'e', 'n', 't', 0},
|
||||
{'S', 't', 'r', 'i', 'n', 'g', 0}, {'<', 0}, {'S', 't', 'r', 'i', 'n', 'g', 'B', 'u', 'f', 'f', 'e', 'r', 0}
|
||||
{0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0}, {0x3c, 0}, {0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0},
|
||||
{0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0}, {0x3c, 0}, {0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0},
|
||||
{0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0}, {0x3c, 0}, {0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0}
|
||||
};
|
||||
|
||||
compareArray(*en_us, test1, ARRAY_LENGTH(test1));
|
||||
|
|
@ -887,12 +887,12 @@ void CollationRegressionTest::Test4114077(char *par)
|
|||
|
||||
static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{0x00C0, 0}, {'=', 0}, {'A', 0x0300, 0}, // Should be equivalent
|
||||
{'p', 0x00ea, 'c', 'h', 'e', 0}, {'>', 0}, {'p', 0x00e9, 'c', 'h', 0x00e9, 0},
|
||||
{0x0204, 0}, {'=', 0}, {'E', 0x030F, 0},
|
||||
{0x01fa, 0}, {'=', 0}, {'A', 0x030a, 0x0301, 0}, // a-ring-acute -> a-ring, acute
|
||||
{0x00C0, 0}, {0x3d, 0}, {0x41, 0x0300, 0}, // Should be equivalent
|
||||
{0x70, 0x00ea, 0x63, 0x68, 0x65, 0}, {0x3e, 0}, {0x70, 0x00e9, 0x63, 0x68, 0x00e9, 0},
|
||||
{0x0204, 0}, {0x3d, 0}, {0x45, 0x030F, 0},
|
||||
{0x01fa, 0}, {0x3d, 0}, {0x41, 0x030a, 0x0301, 0}, // a-ring-acute -> a-ring, acute
|
||||
// -> a, ring, acute
|
||||
{'A', 0x0300, 0x0316, 0}, {'<', 0}, {'A', 0x0316, 0x0300, 0} // No reordering --> unequal
|
||||
{0x41, 0x0300, 0x0316, 0}, {0x3c, 0}, {0x41, 0x0316, 0x0300, 0} // No reordering --> unequal
|
||||
};
|
||||
|
||||
c->setDecomposition(Normalizer::NO_OP);
|
||||
|
|
@ -900,7 +900,7 @@ void CollationRegressionTest::Test4114077(char *par)
|
|||
|
||||
static const UChar test2[][CollationRegressionTest::MAX_TOKEN_LEN] =
|
||||
{
|
||||
{'A', 0x0300, 0x0316, 0}, {'=', 0}, {'A', 0x0316, 0x0300, 0} // Reordering --> equal
|
||||
{0x41, 0x0300, 0x0316, 0}, {0x3d, 0}, {0x41, 0x0316, 0x0300, 0} // Reordering --> equal
|
||||
};
|
||||
|
||||
c->setDecomposition(Normalizer::DECOMP);
|
||||
|
|
|
|||
|
|
@ -94,7 +94,7 @@ void CollationThaiTest::TestDictionary(void) {
|
|||
UnicodeString word(buffer, TEST_FILE_ENCODING);
|
||||
line++;
|
||||
|
||||
if (word.charAt(0) == '#') {
|
||||
if (word.charAt(0) == 0x23) {
|
||||
// Skip comments
|
||||
continue;
|
||||
}
|
||||
|
|
@ -289,32 +289,5 @@ int8_t CollationThaiTest::sign(int32_t i) {
|
|||
*/
|
||||
UnicodeString& CollationThaiTest::parseChars(UnicodeString& result,
|
||||
const char* chars) {
|
||||
result.remove();
|
||||
int32_t len = uprv_strlen(chars);
|
||||
for (int32_t i=0; i<len; ) {
|
||||
if ((i+5)<len && chars[i] == '\\' &&
|
||||
(chars[i+1] == 'u' || chars[i+1] == 'U')) {
|
||||
UChar c = 0;
|
||||
i += 2;
|
||||
for (int32_t d=0; d<4; ++d) {
|
||||
int8_t digit = chars[i++];
|
||||
if (digit >= '0' && digit <= '9') {
|
||||
digit -= '0';
|
||||
} else if (digit >= 'A' && digit <= 'F') {
|
||||
digit -= 'A' - 10;
|
||||
} else if (digit >= 'a' && digit <= 'f') {
|
||||
digit -= 'a' - 10;
|
||||
} else {
|
||||
digit = 0; // illegal hex digit
|
||||
}
|
||||
c = (c << 4) | digit;
|
||||
}
|
||||
result += c;
|
||||
} else {
|
||||
char buf[] = { chars[i], 0 };
|
||||
result += buf;
|
||||
++i;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
return result = CharsToUnicodeString(chars);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,24 +19,6 @@
|
|||
#include <stdio.h>
|
||||
#include "unicode/rep.h"
|
||||
|
||||
//Just to make it easier to use with UChar array.
|
||||
static UnicodeString CharsToUnicodeString(const char* chars)
|
||||
{
|
||||
int len = strlen(chars);
|
||||
int i;
|
||||
UnicodeString buffer;
|
||||
for (i = 0; i < len;) {
|
||||
if ((chars[i] == '\\') && (i+1 < len) && (chars[i+1] == 'u')) {
|
||||
int unicode;
|
||||
sscanf(&(chars[i+2]), "%4X", &unicode);
|
||||
buffer += (UChar)unicode;
|
||||
i += 6;
|
||||
} else {
|
||||
buffer += (UChar)chars[i++];
|
||||
}
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
int32_t getInt(UnicodeString str)
|
||||
{
|
||||
int len=str.length();
|
||||
|
|
|
|||
|
|
@ -36,31 +36,31 @@ CollationTurkishTest::~CollationTurkishTest()
|
|||
}
|
||||
|
||||
const UChar CollationTurkishTest::testSourceCases[][CollationTurkishTest::MAX_TOKEN_LEN] = {
|
||||
{'s', 0x0327, 0},
|
||||
{'v', 0x00E4, 't', 0},
|
||||
{'o', 'l', 'd', 0},
|
||||
{0x00FC, 'o', 'i', 'd', 0},
|
||||
{'h', 0x011E, 'a', 'l', 't', 0},
|
||||
{'s', 't', 'r', 'e', 's', 0x015E, 0},
|
||||
{'v', 'o', 0x0131, 'd', 0},
|
||||
{'i', 'd', 'e', 'a', 0},
|
||||
{0x00FC, 'o', 'i', 'd', 0},
|
||||
{'v', 'o', 0x0131, 'd', 0},
|
||||
{'i', 'd', 'e', 'a', 0}
|
||||
{0x73, 0x0327, 0},
|
||||
{0x76, 0x00E4, 0x74, 0},
|
||||
{0x6f, 0x6c, 0x64, 0},
|
||||
{0x00FC, 0x6f, 0x69, 0x64, 0},
|
||||
{0x68, 0x011E, 0x61, 0x6c, 0x74, 0},
|
||||
{0x73, 0x74, 0x72, 0x65, 0x73, 0x015E, 0},
|
||||
{0x76, 0x6f, 0x0131, 0x64, 0},
|
||||
{0x69, 0x64, 0x65, 0x61, 0},
|
||||
{0x00FC, 0x6f, 0x69, 0x64, 0},
|
||||
{0x76, 0x6f, 0x0131, 0x64, 0},
|
||||
{0x69, 0x64, 0x65, 0x61, 0}
|
||||
};
|
||||
|
||||
const UChar CollationTurkishTest::testTargetCases[][CollationTurkishTest::MAX_TOKEN_LEN] = {
|
||||
{'u', 0x0308, 0},
|
||||
{'v', 'b', 't', 0},
|
||||
{0x00D6, 'a', 'y', 0},
|
||||
{'v', 'o', 'i', 'd', 0},
|
||||
{'h', 'a', 'l', 't', 0},
|
||||
{0x015E, 't', 'r', 'e', 0x015E, 's', 0},
|
||||
{'v', 'o', 'i', 'd', 0},
|
||||
{'I', 'd', 'e', 'a', 0},
|
||||
{'v', 'o', 'i', 'd', 0},
|
||||
{'v', 'o', 'i', 'd', 0},
|
||||
{'I', 'd', 'e', 'a', 0}
|
||||
{0x75, 0x0308, 0},
|
||||
{0x76, 0x62, 0x74, 0},
|
||||
{0x00D6, 0x61, 0x79, 0},
|
||||
{0x76, 0x6f, 0x69, 0x64, 0},
|
||||
{0x68, 0x61, 0x6c, 0x74, 0},
|
||||
{0x015E, 0x74, 0x72, 0x65, 0x015E, 0x73, 0},
|
||||
{0x76, 0x6f, 0x69, 0x64, 0},
|
||||
{0x49, 0x64, 0x65, 0x61, 0},
|
||||
{0x76, 0x6f, 0x69, 0x64, 0},
|
||||
{0x76, 0x6f, 0x69, 0x64, 0},
|
||||
{0x49, 0x64, 0x65, 0x61, 0}
|
||||
};
|
||||
|
||||
const Collator::EComparisonResult CollationTurkishTest::results[] = {
|
||||
|
|
|
|||
|
|
@ -211,6 +211,13 @@ void SimpleThread::sleep(int32_t millis)
|
|||
useconds_t m = millis * 1000;
|
||||
if (m > 1000000) m = 1000000;
|
||||
usleep(m);
|
||||
#elif defined(OS390)
|
||||
millis *= 1000;
|
||||
while(millis > 1000000) {
|
||||
usleep(999999);
|
||||
millis -= 1000000;
|
||||
}
|
||||
usleep(millis);
|
||||
#else
|
||||
usleep(millis * 1000);
|
||||
#endif
|
||||
|
|
@ -441,26 +448,6 @@ void MultithreadTest::TestMutex()
|
|||
|
||||
#include <string.h>
|
||||
|
||||
// [HSYS] Just to make it easier to use with UChar array.
|
||||
// ripped off from ittxtbd.cpp::CharsToUnicodeString
|
||||
UnicodeString UEscapeString(const char* chars)
|
||||
{
|
||||
int len = strlen(chars);
|
||||
int i;
|
||||
UnicodeString buffer;
|
||||
for (i = 0; i < len;) {
|
||||
if ((chars[i] == '\\') && (i+1 < len) && (chars[i+1] == 'u')) {
|
||||
int unicode;
|
||||
sscanf(&(chars[i+2]), "%4X", &unicode);
|
||||
buffer += (UChar)unicode;
|
||||
i += 6;
|
||||
} else {
|
||||
buffer += (UChar)chars[i++];
|
||||
}
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
||||
// * Show exactly where the string's differences lie.
|
||||
UnicodeString showDifference(const UnicodeString& expected, const UnicodeString& result)
|
||||
{
|
||||
|
|
@ -543,8 +530,8 @@ FormatThreadTestData kPercentFormatTestData[] =
|
|||
FormatThreadTestData((double)5., UnicodeString("500%")),
|
||||
FormatThreadTestData( 1, "100%" ),
|
||||
FormatThreadTestData( 0.26, "26%" ),
|
||||
FormatThreadTestData( 16384.99, UEscapeString("1\\u00a0638\\u00a0499%") ), // U+00a0 = NBSP
|
||||
FormatThreadTestData( 81890.23, UEscapeString("8\\u00a0189\\u00a0023%" )),
|
||||
FormatThreadTestData( 16384.99, CharsToUnicodeString("1\\u00a0638\\u00a0499%") ), // U+00a0 = NBSP
|
||||
FormatThreadTestData( 81890.23, CharsToUnicodeString("8\\u00a0189\\u00a0023%" )),
|
||||
};
|
||||
int32_t kPercentFormatTestDataLength = sizeof(kPercentFormatTestData) / sizeof(kPercentFormatTestData[0]);
|
||||
|
||||
|
|
@ -685,7 +672,7 @@ public:
|
|||
messageLocale= Locale("de","AT"); // Austrian German
|
||||
countryToCheck= Locale("","US"); // hmm
|
||||
currencyToCheck= 40193.12;
|
||||
expected= UEscapeString("2:user in Vereinigte Staaten is receiving a #7 error - U_MEMORY_ALLOCATION_ERROR. They insist they just spent \\u00f6S 40.193,12 on memory.");
|
||||
expected= CharsToUnicodeString("2:user in Vereinigte Staaten is receiving a #7 error - U_MEMORY_ALLOCATION_ERROR. They insist they just spent \\u00f6S 40.193,12 on memory.");
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -104,10 +104,17 @@ IntlTestNumberFormat::testFormat(char *par)
|
|||
|
||||
if (1)
|
||||
{
|
||||
#ifdef OS390
|
||||
tryIt(-2.02147304840132e-68);
|
||||
tryIt(3.88057859588817e-68); // Test rounding when only some digits are shown because exponent is close to -maxfrac
|
||||
tryIt(-2.64651110485945e+65); // Overflows to +INF when shown as a percent
|
||||
tryIt(9.29526819488338e+64); // Ok -- used to fail?
|
||||
#else
|
||||
tryIt(-2.02147304840132e-100);
|
||||
tryIt(3.88057859588817e-096); // Test rounding when only some digits are shown because exponent is close to -maxfrac
|
||||
tryIt(-2.64651110485945e+306); // Overflows to +INF when shown as a percent
|
||||
tryIt(9.29526819488338e+250); // Ok -- used to fail?
|
||||
#endif
|
||||
}
|
||||
|
||||
if (1)
|
||||
|
|
@ -117,22 +124,31 @@ IntlTestNumberFormat::testFormat(char *par)
|
|||
// These fail due to round-off
|
||||
// The least significant digit drops by one during each format-parse cycle.
|
||||
// Both numbers DON'T have a round-off problem when multiplied by 100! (shown as %)
|
||||
#ifdef OS390
|
||||
tryIt(-9.18228054496402e+64);
|
||||
tryIt(-9.69413034454191e+64);
|
||||
#else
|
||||
tryIt(-9.18228054496402e+255);
|
||||
tryIt(-9.69413034454191e+273);
|
||||
#endif
|
||||
}
|
||||
|
||||
if (1)
|
||||
{
|
||||
tryIt(T_INT32(251887531));
|
||||
tryIt((int32_t)251887531);
|
||||
#ifndef OS390
|
||||
tryIt(-2.3e-168);
|
||||
|
||||
tryIt(uprv_getNaN());
|
||||
tryIt(uprv_getInfinity());
|
||||
tryIt(-uprv_getInfinity());
|
||||
#endif
|
||||
|
||||
tryIt(5e-20 / 9);
|
||||
tryIt(5e20 / 9);
|
||||
#ifndef OS390
|
||||
tryIt(1.234e-200);
|
||||
#endif
|
||||
tryIt(1.234e-50);
|
||||
tryIt(9.99999999999996);
|
||||
tryIt(9.999999999999996);
|
||||
|
|
@ -150,7 +166,7 @@ IntlTestNumberFormat::testFormat(char *par)
|
|||
tryIt(4.0 / 9.0 * 1e+20);
|
||||
|
||||
tryIt(2147483647.);
|
||||
tryIt(T_INT32(0));
|
||||
tryIt((int32_t)0);
|
||||
tryIt(0.0);
|
||||
tryIt((int32_t)1);
|
||||
tryIt((int32_t)10);
|
||||
|
|
@ -171,18 +187,20 @@ IntlTestNumberFormat::testFormat(char *par)
|
|||
double it = randDouble() * 10000;
|
||||
tryIt(0.0);
|
||||
tryIt(it);
|
||||
tryIt(T_INT32(0));
|
||||
tryIt(T_INT32(uprv_floor(it)));
|
||||
tryIt((int32_t)0);
|
||||
tryIt((int32_t)uprv_floor(it));
|
||||
|
||||
// try again
|
||||
it = randDouble() * 10;
|
||||
tryIt(it);
|
||||
tryIt(T_INT32(uprv_floor(it)));
|
||||
tryIt((int32_t)uprv_floor(it));
|
||||
|
||||
#ifndef OS390
|
||||
// try again with very larget numbers
|
||||
it = randDouble() * 10000000000.0;
|
||||
tryIt(it);
|
||||
tryIt(T_INT32(uprv_floor(it)));
|
||||
tryIt((int32_t)uprv_floor(it));
|
||||
#endif
|
||||
}
|
||||
|
||||
delete fFormat;
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@
|
|||
|
||||
#include "ucdtest.h"
|
||||
#include "unicode/unicode.h"
|
||||
#include "unicode/ustring.h"
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
|
@ -98,10 +99,13 @@ const char dirStrings[][5] = {
|
|||
//====================================================
|
||||
void UnicodeTest::TestUpperLower()
|
||||
{
|
||||
static char* upperTest = "abcdefg123hij.?:klmno";
|
||||
static char* lowerTest = "ABCDEFG123HIJ.?:KLMNO";
|
||||
U_STRING_DECL(upperTest, "abcdefg123hij.?:klmno", 21);
|
||||
U_STRING_DECL(lowerTest, "ABCDEFG123HIJ.?:KLMNO", 21);
|
||||
uint16_t i;
|
||||
|
||||
U_STRING_INIT(upperTest, "abcdefg123hij.?:klmno", 21);
|
||||
U_STRING_INIT(lowerTest, "ABCDEFG123HIJ.?:KLMNO", 21);
|
||||
|
||||
//Checks LetterLike Symbols which were previously a source of confusion
|
||||
//[Bertrand A. D. 02/04/98]
|
||||
for (i=0x2100;i<0x2138;i++)
|
||||
|
|
@ -160,7 +164,7 @@ void UnicodeTest::TestLetterNumber()
|
|||
void UnicodeTest::TestMisc()
|
||||
{
|
||||
const UChar sampleSpaces[] = {0x0020, 0x00a0, 0x2000, 0x2001, 0x2005};
|
||||
const UChar sampleNonSpaces[] = {'a', 'b', 'c', 'd', 't'};
|
||||
const UChar sampleNonSpaces[] = {0x61, 0x62, 0x63, 0x64, 0x74};
|
||||
const UChar sampleUndefined[] = {0xfff1, 0xfff7, 0xfa30};
|
||||
const UChar sampleDefined[] = {0x523E, 0x4f88, 0xfffd};
|
||||
const UChar sampleBase[] = {0x0061, 0x0031, 0x03d2};
|
||||
|
|
@ -215,7 +219,7 @@ void UnicodeTest::TestMisc()
|
|||
void UnicodeTest::TestControlPrint()
|
||||
{
|
||||
const UChar sampleControl[] = {0x001b, 0x0097, 0x0082};
|
||||
const UChar sampleNonControl[] = {'a', 0x0031, 0x00e2};
|
||||
const UChar sampleNonControl[] = {0x61, 0x0031, 0x00e2};
|
||||
const UChar samplePrintable[] = {0x0042, 0x005f, 0x2014};
|
||||
const UChar sampleNonPrintable[] = {0x200c, 0x009f, 0x001c};
|
||||
int32_t i;
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ UnicodeSetTest::TestPatterns(void) {
|
|||
// Throw in a test of complement
|
||||
set.complement();
|
||||
UnicodeString exp;
|
||||
exp.append((UChar)0x0000).append("aeeoouu").append((UChar)('z'+1)).append((UChar)0xFFFF);
|
||||
exp.append((UChar)0x0000).append(UNICODE_STRING("aeeoouu", 7)).append(0x7b).append((UChar)0xFFFF);
|
||||
expectPairs(set, exp);
|
||||
}
|
||||
|
||||
|
|
@ -67,21 +67,21 @@ UnicodeSetTest::TestAddRemove(void) {
|
|||
UErrorCode status = U_ZERO_ERROR;
|
||||
|
||||
UnicodeSet set; // Construct empty set
|
||||
set.add('a', 'z');
|
||||
set.add(0x61, 0x7a);
|
||||
expectPairs(set, "az");
|
||||
set.remove('m', 'p');
|
||||
set.remove(0x6d, 0x70);
|
||||
expectPairs(set, "alqz");
|
||||
set.remove('e', 'g');
|
||||
set.remove(0x65, 0x67);
|
||||
expectPairs(set, "adhlqz");
|
||||
set.remove('d', 'i');
|
||||
set.remove(0x64, 0x69);
|
||||
expectPairs(set, "acjlqz");
|
||||
set.remove('c', 'r');
|
||||
set.remove(0x63, 0x72);
|
||||
expectPairs(set, "absz");
|
||||
set.add('f', 'q');
|
||||
set.add(0x66, 0x71);
|
||||
expectPairs(set, "abfqsz");
|
||||
set.remove('a', 'g');
|
||||
set.remove(0x61, 0x67);
|
||||
expectPairs(set, "hqsz");
|
||||
set.remove('a', 'z');
|
||||
set.remove(0x61, 0x7a);
|
||||
expectPairs(set, "");
|
||||
|
||||
// Try removing an entire set from another set
|
||||
|
|
@ -180,10 +180,10 @@ UnicodeSetTest::escape(const UnicodeString& s) {
|
|||
for (int32_t i=0; i<s.length(); ++i)
|
||||
{
|
||||
UChar c = s[(UTextOffset)i];
|
||||
if (' ' <= c && c <= (UChar)0x7F) {
|
||||
if (0x20 <= c && c <= (UChar)0x7F) {
|
||||
buf += c;
|
||||
} else {
|
||||
buf += '\\'; buf += 'u';
|
||||
buf += 0x5c; buf += 'u';
|
||||
buf += toHexString((c & 0xF000) >> 12);
|
||||
buf += toHexString((c & 0x0F00) >> 8);
|
||||
buf += toHexString((c & 0x00F0) >> 4);
|
||||
|
|
|
|||
|
|
@ -92,8 +92,8 @@ UnicodeStringTest::TestCompare()
|
|||
UnicodeString test5((UChar)0x5000);
|
||||
UnicodeString test6((UChar)0x5100);
|
||||
|
||||
UChar uniChars[] = { 't', 'h', 'i', 's', ' ', 'i', 's',
|
||||
' ', 'a', ' ', 't', 'e', 's', 't', 0 };
|
||||
UChar uniChars[] = { 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73,
|
||||
0x20, 0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0 };
|
||||
char chars[] = "this is a test";
|
||||
|
||||
// test operator== and operator!=
|
||||
|
|
@ -194,7 +194,7 @@ UnicodeStringTest::TestRemoveReplace()
|
|||
{
|
||||
UnicodeString test1("The rain in Spain stays mainly on the plain");
|
||||
UnicodeString test2("eat SPAMburgers!");
|
||||
UChar test3[] = { 'S', 'P', 'A', 'M', 'M', 0 };
|
||||
UChar test3[] = { 0x53, 0x50, 0x41, 0x4d, 0x4d, 0 };
|
||||
char test4[] = "SPAM";
|
||||
UnicodeString& test5 = test1;
|
||||
|
||||
|
|
@ -219,8 +219,8 @@ UnicodeStringTest::TestRemoveReplace()
|
|||
" got \"" + test1 + "\"");
|
||||
|
||||
for (UTextOffset i = 0; i < test1.length(); i++)
|
||||
if (test5[i] != 'S' && test5[i] != 'P' && test5[i] != 'A' && test5[i] != 'M' && test5[i] != ' ')
|
||||
test1[i] = 'x';
|
||||
if (test5[i] != 0x53 && test5[i] != 0x50 && test5[i] != 0x41 && test5[i] != 0x4d && test5[i] != 0x20)
|
||||
test1[i] = 0x78;
|
||||
|
||||
if (test1 != "xxx SPAM xx SPAM SPAM SPAM xx xxx SPAM")
|
||||
errln("One of the remove methods failed:\n"
|
||||
|
|
@ -236,22 +236,22 @@ void
|
|||
UnicodeStringTest::TestCaseConversion()
|
||||
{
|
||||
UChar uppercaseGreek[] =
|
||||
{ 0x399, 0x395, 0x3a3, 0x3a5, 0x3a3, ' ', 0x03a7, 0x3a1, 0x399, 0x3a3, 0x3a4,
|
||||
{ 0x399, 0x395, 0x3a3, 0x3a5, 0x3a3, 0x20, 0x03a7, 0x3a1, 0x399, 0x3a3, 0x3a4,
|
||||
0x39f, 0x3a3, 0 };
|
||||
// "IESUS CHRISTOS"
|
||||
|
||||
UChar lowercaseGreek[] =
|
||||
{ 0x3b9, 0x3b5, 0x3c3, 0x3c5, 0x3c2, ' ', 0x03c7, 0x3c1, 0x3b9, 0x3c3, 0x3c4,
|
||||
{ 0x3b9, 0x3b5, 0x3c3, 0x3c5, 0x3c2, 0x20, 0x03c7, 0x3c1, 0x3b9, 0x3c3, 0x3c4,
|
||||
0x3bf, 0x3c2, 0 };
|
||||
// "iesus christos"
|
||||
|
||||
UChar lowercaseTurkish[] =
|
||||
{ 'i', 's', 't', 'a', 'n', 'b', 'u', 'l', ',', ' ', 'n', 'o', 't', ' ', 'c', 'o',
|
||||
'n', 's', 't', 'a', 'n', 't', 0x0131, 'n', 'o', 'p', 'l', 'e', '!', 0 };
|
||||
{ 0x69, 0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x2c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x63, 0x6f,
|
||||
0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x0131, 0x6e, 0x6f, 0x70, 0x6c, 0x65, 0x21, 0 };
|
||||
|
||||
UChar uppercaseTurkish[] =
|
||||
{ 'T', 'O', 'P', 'K', 'A', 'P', 'I', ' ', 'P', 'A', 'L', 'A', 'C', 'E', ',', ' ',
|
||||
0x0130, 'S', 'T', 'A', 'N', 'B', 'U', 'L', 0 };
|
||||
{ 0x54, 0x4f, 0x50, 0x4b, 0x41, 0x50, 0x49, 0x20, 0x50, 0x41, 0x4c, 0x41, 0x43, 0x45, 0x2c, 0x20,
|
||||
0x0130, 0x53, 0x54, 0x41, 0x4e, 0x42, 0x55, 0x4c, 0 };
|
||||
|
||||
UnicodeString expectedResult;
|
||||
UnicodeString test3;
|
||||
|
|
@ -287,10 +287,10 @@ UnicodeStringTest::TestCaseConversion()
|
|||
if (test4 != expectedResult)
|
||||
errln("toUpper failed: expected \"" + expectedResult + "\", got \"" + test4 + "\".");
|
||||
|
||||
test3 = "Süßmayrstraße";
|
||||
test3 = CharsToUnicodeString("S\\u00FC\\u00DFmayrstra\\u00DFe");
|
||||
|
||||
test3.toUpper(Locale("de", "DE"));
|
||||
expectedResult = "SÜSSMAYRSTRASSE";
|
||||
expectedResult = CharsToUnicodeString("S\\u00DCSSMAYRSTRASSE");
|
||||
if (test3 != expectedResult)
|
||||
errln("toUpper failed: expected \"" + expectedResult + "\", got \"" + test3 + "\".");
|
||||
|
||||
|
|
@ -314,7 +314,7 @@ UnicodeStringTest::TestSearching()
|
|||
{
|
||||
UnicodeString test1("test test ttest tetest testesteststt");
|
||||
UnicodeString test2("test");
|
||||
UChar testChar = 't';
|
||||
UChar testChar = 0x74;
|
||||
|
||||
uint16_t occurrences = 0;
|
||||
UTextOffset startPos = 0;
|
||||
|
|
@ -486,10 +486,10 @@ UnicodeStringTest::TestFindAndReplace()
|
|||
void
|
||||
UnicodeStringTest::TestCellWidth()
|
||||
{
|
||||
UChar testData2[] = { 'M', 'o', 0x308, 't', 'l', 'e', 'y', ' ', 'C', 'r', 'u', 0x308, 'e', 0x0000 };
|
||||
UChar testData3[] = { '1', '9', '9', '7', 0x5e74, ' ', 0x516d, 0x6708, ' ', '0', '3', 0x65e5, 0x5e73, 0x6210, 0x0000 };
|
||||
UChar testData4[] = { '9', '7', 0xb144, '6', 0xc6d4, '0', '3', 0xc77c, 0x0000 };
|
||||
UChar testData5[] = { '9', '7', 0x1103, 0x1167, 0x11ab, '6', 0x110b, 0x117b, 0x11af, '0', '3', 0x110b, 0x1175, 0x11af, 0x0000 };
|
||||
UChar testData2[] = { 0x4d, 0x6f, 0x308, 0x74, 0x6c, 0x65, 0x79, 0x20, 0x43, 0x72, 0x75, 0x308, 0x65, 0x0000 };
|
||||
UChar testData3[] = { 0x31, 0x39, 0x39, 0x37, 0x5e74, 0x20, 0x516d, 0x6708, 0x20, 0x30, 0x33, 0x65e5, 0x5e73, 0x6210, 0x0000 };
|
||||
UChar testData4[] = { 0x39, 0x37, 0xb144, 0x36, 0xc6d4, 0x30, 0x33, 0xc77c, 0x0000 };
|
||||
UChar testData5[] = { 0x39, 0x37, 0x1103, 0x1167, 0x11ab, 0x36, 0x110b, 0x117b, 0x11af, 0x30, 0x33, 0x110b, 0x1175, 0x11af, 0x0000 };
|
||||
|
||||
UnicodeString test1("The rain in Spain stays mainly on the plain.");
|
||||
UnicodeString test2(testData2);
|
||||
|
|
@ -566,7 +566,7 @@ void
|
|||
UnicodeStringTest::TestStackAllocation()
|
||||
{
|
||||
UChar testString[] ={
|
||||
'T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 'c', 'r', 'a', 'z', 'y', ' ', 't', 'e', 's', 't', '.', 0 };
|
||||
0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x63, 0x72, 0x61, 0x7a, 0x79, 0x20, 0x74, 0x65, 0x73, 0x74, 0x2e, 0 };
|
||||
UChar guardWord = 0x4DED;
|
||||
UnicodeString* test = 0;
|
||||
|
||||
|
|
@ -588,9 +588,9 @@ UnicodeStringTest::TestStackAllocation()
|
|||
delete test;
|
||||
|
||||
UChar workingBuffer[] = {
|
||||
'N', 'o', 'w', ' ', 'i', 's', ' ', 't', 'h', 'e', ' ', 't', 'i', 'm', 'e', ' ',
|
||||
'f', 'o', 'r', ' ', 'a', 'l', 'l', ' ', 'm', 'e', 'n', ' ', 't', 'o', ' ',
|
||||
'c', 'o', 'm', 'e', 0xffff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 0x69, 0x6d, 0x65, 0x20,
|
||||
0x66, 0x6f, 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20, 0x6d, 0x65, 0x6e, 0x20, 0x74, 0x6f, 0x20,
|
||||
0x63, 0x6f, 0x6d, 0x65, 0xffff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
|
||||
UChar guardWord2 = 0x4DED;
|
||||
|
|
@ -610,7 +610,7 @@ UnicodeStringTest::TestStackAllocation()
|
|||
// the current implementation will always reallocate the memory
|
||||
// after it was aliased in case it was read-only;
|
||||
// therefore, this test must fail and we don't perform it
|
||||
if (workingBuffer[24] != 'g')
|
||||
if (workingBuffer[24] != 0x67)
|
||||
errln("insert() on stack-allocated UnicodeString didn't affect backing store");
|
||||
#endif
|
||||
|
||||
|
|
@ -623,7 +623,7 @@ UnicodeStringTest::TestStackAllocation()
|
|||
*test = "ha!";
|
||||
if (*test != "ha!")
|
||||
errln("Assignment to stack-allocated UnicodeString didn't work");
|
||||
if (workingBuffer[0] != 'N')
|
||||
if (workingBuffer[0] != 0x4e)
|
||||
errln("Change to UnicodeString after overflow are stil affecting original buffer");
|
||||
if (guardWord2 != 0x4DED)
|
||||
errln("Change to UnicodeString after overflow overwrote guard word!");
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue