349 lines
12 KiB
C++
349 lines
12 KiB
C++
/*
|
|
************************************************************************
|
|
* Copyright (c) 1997-2001, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
************************************************************************
|
|
*/
|
|
|
|
#include "normconf.h"
|
|
#include "unicode/normlzr.h"
|
|
#include "unicode/unicode.h"
|
|
#include "cstring.h"
|
|
#include "unicode/putil.h"
|
|
#include "filestrm.h"
|
|
|
|
#define ARRAY_LENGTH(array) (sizeof(array) / sizeof(array[0]))
|
|
|
|
#define CASE(id,test) case id: \
|
|
name = #test; \
|
|
if (exec) { \
|
|
logln(#test "---"); \
|
|
logln((UnicodeString)""); \
|
|
test(); \
|
|
} \
|
|
break
|
|
|
|
void NormalizerConformanceTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
|
|
switch (index) {
|
|
CASE(0,TestConformance);
|
|
// CASE(1,TestCase6);
|
|
default: name = ""; break;
|
|
}
|
|
}
|
|
|
|
#define FIELD_COUNT 5
|
|
|
|
NormalizerConformanceTest::NormalizerConformanceTest() :
|
|
normalizer(UnicodeString("", ""), Normalizer::COMPOSE) {}
|
|
|
|
NormalizerConformanceTest::~NormalizerConformanceTest() {}
|
|
|
|
/**
|
|
* Test the conformance of Normalizer to
|
|
* http://www.unicode.org/unicode/reports/tr15/conformance/Draft-TestSuite.txt.
|
|
* This file must be located at the path specified as TEST_SUITE_FILE.
|
|
*/
|
|
void NormalizerConformanceTest::TestConformance(void) {
|
|
enum { BUF_SIZE = 1024 };
|
|
char lineBuf[BUF_SIZE];
|
|
UnicodeString fields[FIELD_COUNT];
|
|
int32_t passCount = 0;
|
|
int32_t failCount = 0;
|
|
char newPath[256];
|
|
char backupPath[256];
|
|
FileStream *input = NULL;
|
|
|
|
/* Look inside ICU_DATA first */
|
|
strcpy(newPath, u_getDataDirectory());
|
|
strcat(newPath, "unidata" U_FILE_SEP_STRING );
|
|
strcat(newPath, TEST_SUITE_FILE);
|
|
|
|
strcpy(backupPath, u_getDataDirectory());
|
|
strcat(backupPath, ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data");
|
|
strcat(backupPath, U_FILE_SEP_STRING);
|
|
strcat(backupPath, "unidata" U_FILE_SEP_STRING );
|
|
strcat(backupPath, TEST_SUITE_FILE);
|
|
|
|
|
|
input = T_FileStream_open(newPath, "rb");
|
|
|
|
if (input == 0) {
|
|
input = T_FileStream_open(backupPath, "rb");
|
|
if (input == 0) {
|
|
errln("Failed to open either " + UnicodeString(newPath) + " or " + UnicodeString(backupPath) );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
for (int32_t count = 1;;++count) {
|
|
if (T_FileStream_eof(input)) {
|
|
break;
|
|
}
|
|
T_FileStream_readLine(input, lineBuf, (int32_t)sizeof(lineBuf));
|
|
if (lineBuf[0] == 0 || lineBuf[0] == 10 || lineBuf[0] == 13) continue;
|
|
|
|
// Expect 5 columns of this format:
|
|
// 1E0C;1E0C;0044 0323;1E0C;0044 0323; # <comments>
|
|
|
|
// Parse out the comment.
|
|
if (lineBuf[0] == '#') continue;
|
|
|
|
// Read separator lines starting with '@'
|
|
if (lineBuf[0] == '@') {
|
|
logln(lineBuf);
|
|
continue;
|
|
}
|
|
|
|
// Parse out the fields
|
|
if (!hexsplit(lineBuf, ';', fields, FIELD_COUNT)) {
|
|
errln((UnicodeString)"Unable to parse line " + count);
|
|
break; // Syntax error
|
|
}
|
|
if (checkConformance(fields, UnicodeString(lineBuf, ""))) {
|
|
++passCount;
|
|
} else {
|
|
++failCount;
|
|
}
|
|
if ((count % 1000) == 0) {
|
|
logln((UnicodeString)"Line " + count);
|
|
}
|
|
}
|
|
|
|
T_FileStream_close(input);
|
|
|
|
if (failCount != 0) {
|
|
errln((UnicodeString)"Total: " + failCount + " lines failed, " +
|
|
passCount + " lines passed");
|
|
} else {
|
|
logln((UnicodeString)"Total: " + passCount + " lines passed");
|
|
}
|
|
|
|
/*
|
|
* ### TODO: test that all assigned characters that are not mentioned
|
|
* as single code points in column 1
|
|
* do not change under any normalization.
|
|
* I.e., keep a list (UnicodeSet?) of all single code points in c1,
|
|
* then test that for all in (assigned-list) it is
|
|
* c1==NFC(c1)==NFD(c1)==NFKC(c1)==NFKD(c1)==FCD(c1)
|
|
*
|
|
* ### TODO: test FCD
|
|
* Idea: since FCD is not a normalization form with guaranteed results,
|
|
* test that quickCheck(NF*D(c1), isFCD)==TRUE and that quickCheck(FCD(NF*D(c1)), isNF*D)==TRUE.
|
|
* Also test special, controlled cases.
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Verify the conformance of the given line of the Unicode
|
|
* normalization (UTR 15) test suite file. For each line,
|
|
* there are five columns, corresponding to field[0]..field[4].
|
|
*
|
|
* The following invariants must be true for all conformant implementations
|
|
* c2 == NFC(c1) == NFC(c2) == NFC(c3)
|
|
* c3 == NFD(c1) == NFD(c2) == NFD(c3)
|
|
* c4 == NFKC(c1) == NFKC(c2) == NFKC(c3) == NFKC(c4) == NFKC(c5)
|
|
* c5 == NFKD(c1) == NFKD(c2) == NFKD(c3) == NFKD(c4) == NFKD(c5)
|
|
*
|
|
* @param field the 5 columns
|
|
* @param line the source line from the test suite file
|
|
* @return true if the test passes
|
|
*/
|
|
UBool NormalizerConformanceTest::checkConformance(const UnicodeString* field,
|
|
const UnicodeString& line) {
|
|
UBool pass = TRUE;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UnicodeString out;
|
|
int32_t fieldNum;
|
|
|
|
for (int32_t i=0; i<FIELD_COUNT; ++i) {
|
|
fieldNum = i+1;
|
|
if (i<3) {
|
|
Normalizer::normalize(field[i], Normalizer::COMPOSE, 0, out, status);
|
|
pass &= assertEqual("C", field[i], out, field[1], "c2!=C(c", fieldNum);
|
|
iterativeNorm(field[i], Normalizer::COMPOSE, out, +1);
|
|
pass &= assertEqual("C(+1)", field[i], out, field[1], "c2!=C(c", fieldNum);
|
|
iterativeNorm(field[i], Normalizer::COMPOSE, out, -1);
|
|
pass &= assertEqual("C(-1)", field[i], out, field[1], "c2!=C(c", fieldNum);
|
|
|
|
Normalizer::normalize(field[i], Normalizer::DECOMP, 0, out, status);
|
|
pass &= assertEqual("D", field[i], out, field[2], "c3!=D(c", fieldNum);
|
|
iterativeNorm(field[i], Normalizer::DECOMP, out, +1);
|
|
pass &= assertEqual("D(+1)", field[i], out, field[2], "c3!=D(c", fieldNum);
|
|
iterativeNorm(field[i], Normalizer::DECOMP, out, -1);
|
|
pass &= assertEqual("D(-1)", field[i], out, field[2], "c3!=D(c", fieldNum);
|
|
}
|
|
Normalizer::normalize(field[i], Normalizer::COMPOSE_COMPAT, 0, out, status);
|
|
pass &= assertEqual("KC", field[i], out, field[3], "c4!=KC(c", fieldNum);
|
|
iterativeNorm(field[i], Normalizer::COMPOSE_COMPAT, out, +1);
|
|
pass &= assertEqual("KC(+1)", field[i], out, field[3], "c4!=KC(c", fieldNum);
|
|
iterativeNorm(field[i], Normalizer::COMPOSE_COMPAT, out, -1);
|
|
pass &= assertEqual("KC(-1)", field[i], out, field[3], "c4!=KC(c", fieldNum);
|
|
|
|
Normalizer::normalize(field[i], Normalizer::DECOMP_COMPAT, 0, out, status);
|
|
pass &= assertEqual("KD", field[i], out, field[4], "c5!=KD(c", fieldNum);
|
|
iterativeNorm(field[i], Normalizer::DECOMP_COMPAT, out, +1);
|
|
pass &= assertEqual("KD(+1)", field[i], out, field[4], "c5!=KD(c", fieldNum);
|
|
iterativeNorm(field[i], Normalizer::DECOMP_COMPAT, out, -1);
|
|
pass &= assertEqual("KD(-1)", field[i], out, field[4], "c5!=KD(c", fieldNum);
|
|
}
|
|
if (U_FAILURE(status)) {
|
|
errln("Normalizer::normalize returned error status");
|
|
return FALSE;
|
|
}
|
|
if (!pass) {
|
|
errln((UnicodeString)"FAIL: " + line);
|
|
}
|
|
return pass;
|
|
}
|
|
|
|
/**
|
|
* Do a normalization using the iterative API in the given direction.
|
|
* @param dir either +1 or -1
|
|
*/
|
|
void NormalizerConformanceTest::iterativeNorm(const UnicodeString& str,
|
|
Normalizer::EMode mode,
|
|
UnicodeString& result,
|
|
int8_t dir) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
normalizer.setText(str, status);
|
|
normalizer.setMode(mode);
|
|
result.truncate(0);
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
UChar32 ch;
|
|
if (dir > 0) {
|
|
for (ch = normalizer.first(); ch != Normalizer::DONE;
|
|
ch = normalizer.next()) {
|
|
result.append(ch);
|
|
}
|
|
} else {
|
|
for (ch = normalizer.last(); ch != Normalizer::DONE;
|
|
ch = normalizer.previous()) {
|
|
result.insert(0, ch);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param op name of normalization form, e.g., "KC"
|
|
* @param s string being normalized
|
|
* @param got value received
|
|
* @param exp expected value
|
|
* @param msg description of this test
|
|
* @param return true if got == exp
|
|
*/
|
|
UBool NormalizerConformanceTest::assertEqual(const char *op,
|
|
const UnicodeString& s,
|
|
const UnicodeString& got,
|
|
const UnicodeString& exp,
|
|
const char *msg,
|
|
int32_t field)
|
|
{
|
|
if (exp == got)
|
|
return TRUE;
|
|
|
|
char *sChars, *gotChars, *expChars;
|
|
UnicodeString sPretty(prettify(s));
|
|
UnicodeString gotPretty(prettify(got));
|
|
UnicodeString expPretty(prettify(exp));
|
|
|
|
sChars = new char[sPretty.length() + 1];
|
|
gotChars = new char[gotPretty.length() + 1];
|
|
expChars = new char[expPretty.length() + 1];
|
|
|
|
sPretty.extract(0, sPretty.length(), sChars, sPretty.length() + 1);
|
|
sChars[sPretty.length()] = 0;
|
|
gotPretty.extract(0, gotPretty.length(), gotChars, gotPretty.length() + 1);
|
|
gotChars[gotPretty.length()] = 0;
|
|
expPretty.extract(0, expPretty.length(), expChars, expPretty.length() + 1);
|
|
expChars[expPretty.length()] = 0;
|
|
|
|
errln(" %s%d)%s(%s)=%s, exp. %s", msg, field, op, sChars, gotChars, expChars);
|
|
|
|
delete []sChars;
|
|
delete []gotChars;
|
|
delete []expChars;
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Split a string into pieces based on the given delimiter
|
|
* character. Then, parse the resultant fields from hex into
|
|
* characters. That is, "0040 0400;0C00;0899" -> new String[] {
|
|
* "\u0040\u0400", "\u0C00", "\u0899" }. The output is assumed to
|
|
* be of the proper length already, and exactly output.length
|
|
* fields are parsed. If there are too few an exception is
|
|
* thrown. If there are too many the extras are ignored.
|
|
*
|
|
* @return FALSE upon failure
|
|
*/
|
|
UBool NormalizerConformanceTest::hexsplit(const char *s, char delimiter,
|
|
UnicodeString output[], int32_t outputLength) {
|
|
const char *t = s;
|
|
char *end = NULL;
|
|
UChar32 c;
|
|
int32_t i;
|
|
int32_t pos = 0;
|
|
for (i=0; i<outputLength; ++i) {
|
|
// skip whitespace
|
|
while(*t == ' ' || *t == '\t') {
|
|
++t;
|
|
}
|
|
|
|
// read a sequence of code points
|
|
output[i].remove();
|
|
for(;;) {
|
|
c = (UChar32)uprv_strtoul(t, &end, 16);
|
|
|
|
if( (char *)t == end ||
|
|
(uint32_t)c > 0x10ffff ||
|
|
(*end != ' ' && *end != '\t' && *end != delimiter)
|
|
) {
|
|
errln(UnicodeString("Bad field ", "") + (i + 1) + " in " + UnicodeString(s, ""));
|
|
return FALSE;
|
|
}
|
|
|
|
output[i].append(c);
|
|
|
|
t = (const char *)end;
|
|
|
|
// skip whitespace
|
|
while(*t == ' ' || *t == '\t') {
|
|
++t;
|
|
}
|
|
|
|
if(*t == delimiter) {
|
|
++t;
|
|
break;
|
|
}
|
|
if(*t == 0) {
|
|
if((i + 1) == outputLength) {
|
|
return TRUE;
|
|
} else {
|
|
errln(UnicodeString("Missing field(s) in ", "") + s + " only " + (i + 1) + " out of " + outputLength);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Specific tests for debugging. These are generally failures taken from
|
|
// the conformance file, but culled out to make debugging easier.
|
|
|
|
void NormalizerConformanceTest::TestCase6(void) {
|
|
_testOneLine("0385;0385;00A8 0301;0020 0308 0301;0020 0308 0301;");
|
|
}
|
|
|
|
void NormalizerConformanceTest::_testOneLine(const char *line) {
|
|
UnicodeString fields[FIELD_COUNT];
|
|
if (!hexsplit(line, ';', fields, FIELD_COUNT)) {
|
|
errln((UnicodeString)"Unable to parse line " + line);
|
|
} else {
|
|
checkConformance(fields, line);
|
|
}
|
|
}
|