1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 2002-2010, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
6
7 /**
8 * UCAConformanceTest performs conformance tests defined in the data
9 * files. ICU ships with stub data files, as the whole test are too
10 * long. To do the whole test, download the test files.
11 */
12
13 #include "unicode/utypes.h"
14
15 #if !UCONFIG_NO_COLLATION
16
17 #include "ucaconf.h"
18 #include "unicode/ustring.h"
19 #include "cstring.h"
20 #include "uparse.h"
21
UCAConformanceTest()22 UCAConformanceTest::UCAConformanceTest() :
23 rbUCA(NULL),
24 testFile(NULL),
25 status(U_ZERO_ERROR)
26 {
27 UCA = ucol_open("root", &status);
28 if(U_FAILURE(status)) {
29 errln("ERROR - UCAConformanceTest: Unable to open UCA collator!");
30 }
31
32 const char *srcDir = IntlTest::getSourceTestData(status);
33 if (U_FAILURE(status)) {
34 dataerrln("Could not open test data %s", u_errorName(status));
35 return;
36 }
37 uprv_strcpy(testDataPath, srcDir);
38 uprv_strcat(testDataPath, "CollationTest_");
39 }
40
~UCAConformanceTest()41 UCAConformanceTest::~UCAConformanceTest()
42 {
43 ucol_close(UCA);
44 if(rbUCA) {
45 ucol_close(rbUCA);
46 }
47 if(testFile) {
48 fclose(testFile);
49 }
50 }
51
runIndexedTest(int32_t index,UBool exec,const char * & name,char *)52 void UCAConformanceTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par */)
53 {
54 if (exec) logln("TestSuite UCAConformanceTest: ");
55 if(U_SUCCESS(status)) {
56 switch (index) {
57 case 0: name = "TestTableNonIgnorable"; if (exec) TestTableNonIgnorable(/* par */); break;
58 case 1: name = "TestTableShifted"; if (exec) TestTableShifted(/* par */); break;
59 case 2: name = "TestRulesNonIgnorable"; if (exec) TestRulesNonIgnorable(/* par */); break;
60 case 3: name = "TestRulesShifted"; if (exec) TestRulesShifted(/* par */); break;
61 default: name = ""; break;
62 }
63 } else {
64 name = "";
65 }
66 }
67
initRbUCA()68 void UCAConformanceTest::initRbUCA()
69 {
70 if(!rbUCA) {
71 UParseError parseError;
72 UChar *ucarules;
73 // preflight rules
74 int32_t size = ucol_getRulesEx(UCA, UCOL_FULL_RULES, NULL, 0);
75 ucarules = (UChar *)malloc(size * sizeof(UChar));
76
77 size = ucol_getRulesEx(UCA, UCOL_FULL_RULES, ucarules, size);
78 rbUCA = ucol_openRules(ucarules, size, UCOL_DEFAULT, UCOL_TERTIARY,
79 &parseError, &status);
80 free(ucarules);
81 if (U_FAILURE(status)) {
82 errln("Failure creating UCA rule-based collator: %s", u_errorName(status));
83 return;
84 }
85 }
86 }
87
setCollNonIgnorable(UCollator * coll)88 void UCAConformanceTest::setCollNonIgnorable(UCollator *coll)
89 {
90 ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
91 ucol_setAttribute(coll, UCOL_CASE_FIRST, UCOL_OFF, &status);
92 ucol_setAttribute(coll, UCOL_CASE_LEVEL, UCOL_OFF, &status);
93 ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_TERTIARY, &status);
94 ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, &status);
95 }
96
setCollShifted(UCollator * coll)97 void UCAConformanceTest::setCollShifted(UCollator *coll)
98 {
99 ucol_setAttribute(coll, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
100 ucol_setAttribute(coll, UCOL_CASE_FIRST, UCOL_OFF, &status);
101 ucol_setAttribute(coll, UCOL_CASE_LEVEL, UCOL_OFF, &status);
102 ucol_setAttribute(coll, UCOL_STRENGTH, UCOL_QUATERNARY, &status);
103 ucol_setAttribute(coll, UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, &status);
104 }
105
openTestFile(const char * type)106 void UCAConformanceTest::openTestFile(const char *type)
107 {
108 const char *ext = ".txt";
109 if(testFile) {
110 fclose(testFile);
111 }
112 char buffer[1024];
113 uprv_strcpy(buffer, testDataPath);
114 uprv_strcat(buffer, type);
115 int32_t bufLen = (int32_t)uprv_strlen(buffer);
116
117 // we try to open 3 files:
118 // path/CollationTest_type.txt
119 // path/CollationTest_type_SHORT.txt
120 // path/CollationTest_type_STUB.txt
121 // we are going to test with the first one that we manage to open.
122
123 uprv_strcpy(buffer+bufLen, ext);
124
125 testFile = fopen(buffer, "rb");
126
127 if(testFile == 0) {
128 uprv_strcpy(buffer+bufLen, "_SHORT");
129 uprv_strcat(buffer, ext);
130 testFile = fopen(buffer, "rb");
131
132 if(testFile == 0) {
133 uprv_strcpy(buffer+bufLen, "_STUB");
134 uprv_strcat(buffer, ext);
135 testFile = fopen(buffer, "rb");
136
137 if (testFile == 0) {
138 *(buffer+bufLen) = 0;
139 dataerrln("Could not open any of the conformance test files, tried opening base %s\n", buffer);
140 return;
141 } else {
142 infoln(
143 "INFO: Working with the stub file.\n"
144 "If you need the full conformance test, please\n"
145 "download the appropriate data files from:\n"
146 "http://source.icu-project.org/repos/icu/tools/trunk/unicodetools/com/ibm/text/data/");
147 }
148 }
149 }
150 }
151
testConformance(UCollator * coll)152 void UCAConformanceTest::testConformance(UCollator *coll)
153 {
154 if(testFile == 0) {
155 return;
156 }
157
158 int32_t line = 0;
159
160 UChar b1[1024], b2[1024];
161 UChar *buffer = b1, *oldB = NULL;
162
163 char lineB1[1024], lineB2[1024];
164 char *lineB = lineB1, *oldLineB = lineB2;
165
166 uint8_t sk1[1024], sk2[1024];
167 uint8_t *oldSk = NULL, *newSk = sk1;
168
169 int32_t resLen = 0, oldLen = 0;
170 int32_t buflen = 0, oldBlen = 0;
171 uint32_t first = 0;
172 uint32_t offset = 0;
173 UnicodeString oldS, newS;
174
175
176 while (fgets(lineB, 1024, testFile) != NULL) {
177 // remove trailing whitespace
178 u_rtrim(lineB);
179 offset = 0;
180
181 line++;
182 if(*lineB == 0 || strlen(lineB) < 3 || lineB[0] == '#') {
183 continue;
184 }
185 offset = u_parseString(lineB, buffer, 1024, &first, &status);
186 if(U_FAILURE(status)) {
187 errln("Error parsing line %ld (%s): %s\n",
188 (long)line, u_errorName(status), lineB);
189 status = U_ZERO_ERROR;
190 }
191 buflen = offset;
192 buffer[offset++] = 0;
193
194 resLen = ucol_getSortKey(coll, buffer, buflen, newSk, 1024);
195
196 int32_t res = 0, cmpres = 0, cmpres2 = 0;
197
198 if(oldSk != NULL) {
199 res = strcmp((char *)oldSk, (char *)newSk);
200 cmpres = ucol_strcoll(coll, oldB, oldBlen, buffer, buflen);
201 cmpres2 = ucol_strcoll(coll, buffer, buflen, oldB, oldBlen);
202
203 if(cmpres != -cmpres2) {
204 errln("Compare result not symmetrical on line %i", line);
205 }
206
207 if(((res&0x80000000) != (cmpres&0x80000000)) || (res == 0 && cmpres != 0) || (res != 0 && cmpres == 0)) {
208 errln("Difference between ucol_strcoll and sortkey compare on line %i", line);
209 errln(" Previous data line %s", oldLineB);
210 errln(" Current data line %s", lineB);
211 }
212
213 if(res > 0) {
214 errln("Line %i is not greater or equal than previous line", line);
215 errln(" Previous data line %s", oldLineB);
216 errln(" Current data line %s", lineB);
217 prettify(CollationKey(oldSk, oldLen), oldS);
218 prettify(CollationKey(newSk, resLen), newS);
219 errln(" Previous key: "+oldS);
220 errln(" Current key: "+newS);
221 } else if(res == 0) { /* equal */
222 res = u_strcmpCodePointOrder(oldB, buffer);
223 if (res == 0) {
224 errln("Probable error in test file on line %i (comparing identical strings)", line);
225 errln(" Data line %s", lineB);
226 }
227 /*
228 * UCA 6.0 test files can have lines that compare == if they are
229 * different strings but canonically equivalent.
230 else if (res > 0) {
231 errln("Sortkeys are identical, but code point compare gives >0 on line %i", line);
232 errln(" Previous data line %s", oldLineB);
233 errln(" Current data line %s", lineB);
234 }
235 */
236 }
237 }
238
239 // swap buffers
240 oldLineB = lineB;
241 oldB = buffer;
242 oldSk = newSk;
243 if(lineB == lineB1) {
244 lineB = lineB2;
245 buffer = b2;
246 newSk = sk2;
247 } else {
248 lineB = lineB1;
249 buffer = b1;
250 newSk = sk1;
251 }
252 oldLen = resLen;
253 oldBlen = buflen;
254 }
255 }
256
TestTableNonIgnorable()257 void UCAConformanceTest::TestTableNonIgnorable(/* par */) {
258 setCollNonIgnorable(UCA);
259 openTestFile("NON_IGNORABLE");
260 testConformance(UCA);
261 }
262
TestTableShifted()263 void UCAConformanceTest::TestTableShifted(/* par */) {
264 setCollShifted(UCA);
265 openTestFile("SHIFTED");
266 testConformance(UCA);
267 }
268
TestRulesNonIgnorable()269 void UCAConformanceTest::TestRulesNonIgnorable(/* par */) {
270 initRbUCA();
271
272 if(U_SUCCESS(status)) {
273 setCollNonIgnorable(rbUCA);
274 openTestFile("NON_IGNORABLE");
275 testConformance(rbUCA);
276 }
277 }
278
TestRulesShifted()279 void UCAConformanceTest::TestRulesShifted(/* par */) {
280 logln("This test is currently disabled, as it is impossible to "
281 "wholly represent fractional UCA using tailoring rules.");
282 return;
283
284 initRbUCA();
285
286 if(U_SUCCESS(status)) {
287 setCollShifted(rbUCA);
288 openTestFile("SHIFTED");
289 testConformance(rbUCA);
290 }
291 }
292
293 #endif /* #if !UCONFIG_NO_COLLATION */
294