1 /*
2 ************************************************************************
3 * Copyright (c) 1997-2010, International Business Machines
4 * Corporation and others. All Rights Reserved.
5 ************************************************************************
6 */
7
8 #include "unicode/utypes.h"
9
10 #if !UCONFIG_NO_NORMALIZATION
11
12 #include "unicode/uchar.h"
13 #include "unicode/normlzr.h"
14 #include "unicode/uniset.h"
15 #include "unicode/putil.h"
16 #include "cstring.h"
17 #include "filestrm.h"
18 #include "normconf.h"
19 #include <stdio.h>
20
21 #define ARRAY_LENGTH(array) (sizeof(array) / sizeof(array[0]))
22
23 #define CASE(id,test,exec) case id: \
24 name = #test; \
25 if (exec) { \
26 logln(#test "---"); \
27 logln((UnicodeString)""); \
28 test(); \
29 } \
30 break
31
runIndexedTest(int32_t index,UBool exec,const char * & name,char *)32 void NormalizerConformanceTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
33 switch (index) {
34 CASE(0, TestConformance, exec);
35 #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
36 CASE(1, TestConformance32, exec);
37 #endif
38 // CASE(2, TestCase6);
39 default: name = ""; break;
40 }
41 }
42
43 #define FIELD_COUNT 5
44
NormalizerConformanceTest()45 NormalizerConformanceTest::NormalizerConformanceTest() :
46 normalizer(UnicodeString(), UNORM_NFC) {}
47
~NormalizerConformanceTest()48 NormalizerConformanceTest::~NormalizerConformanceTest() {}
49
50 // more interesting conformance test cases, not in the unicode.org NormalizationTest.txt
51 static const char *moreCases[]={
52 // Markus 2001aug30
53 "0061 0332 0308;00E4 0332;0061 0332 0308;00E4 0332;0061 0332 0308; # Markus 0",
54
55 // Markus 2001oct26 - test edge case for iteration: U+0f73.cc==0 but decomposition.lead.cc==129
56 "0061 0301 0F73;00E1 0F71 0F72;0061 0F71 0F72 0301;00E1 0F71 0F72;0061 0F71 0F72 0301; # Markus 1"
57 };
58
compare(const UnicodeString & s1,const UnicodeString & s2)59 void NormalizerConformanceTest::compare(const UnicodeString& s1, const UnicodeString& s2){
60 UErrorCode status=U_ZERO_ERROR;
61 // TODO: Re-enable this tests after UTC fixes UAX 21
62 if(s1.indexOf((UChar32)0x0345)>=0)return;
63 if(Normalizer::compare(s1,s2,U_FOLD_CASE_DEFAULT,status)!=0){
64 errln("Normalizer::compare() failed for s1: " + prettify(s1) + " s2: " +prettify(s2));
65 }
66 }
67
68 FileStream *
openNormalizationTestFile(const char * filename)69 NormalizerConformanceTest::openNormalizationTestFile(const char *filename) {
70 char unidataPath[2000];
71 const char *folder;
72 FileStream *input;
73 UErrorCode errorCode;
74
75 // look inside ICU_DATA first
76 folder=pathToDataDirectory();
77 if(folder!=NULL) {
78 strcpy(unidataPath, folder);
79 strcat(unidataPath, "unidata" U_FILE_SEP_STRING);
80 strcat(unidataPath, filename);
81 input=T_FileStream_open(unidataPath, "rb");
82 if(input!=NULL) {
83 return input;
84 }
85 }
86
87 // find icu/source/data/unidata relative to the test data
88 errorCode=U_ZERO_ERROR;
89 folder=loadTestData(errorCode);
90 if(U_SUCCESS(errorCode)) {
91 strcpy(unidataPath, folder);
92 strcat(unidataPath, U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".."
93 U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".."
94 U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "unidata" U_FILE_SEP_STRING);
95 strcat(unidataPath, filename);
96 input=T_FileStream_open(unidataPath, "rb");
97 if(input!=NULL) {
98 return input;
99 }
100 }
101
102 // look in icu/source/test/testdata/out/build
103 errorCode=U_ZERO_ERROR;
104 folder=loadTestData(errorCode);
105 if(U_SUCCESS(errorCode)) {
106 strcpy(unidataPath, folder);
107 strcat(unidataPath, U_FILE_SEP_STRING);
108 strcat(unidataPath, filename);
109 input=T_FileStream_open(unidataPath, "rb");
110 if(input!=NULL) {
111 return input;
112 }
113 }
114
115 // look in icu/source/test/testdata
116 errorCode=U_ZERO_ERROR;
117 folder=loadTestData(errorCode);
118 if(U_SUCCESS(errorCode)) {
119 strcpy(unidataPath, folder);
120 strcat(unidataPath, U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING);
121 strcat(unidataPath, filename);
122 input=T_FileStream_open(unidataPath, "rb");
123 if(input!=NULL) {
124 return input;
125 }
126 }
127
128 // find icu/source/data/unidata relative to U_TOPSRCDIR
129 #if defined(U_TOPSRCDIR)
130 strcpy(unidataPath, U_TOPSRCDIR U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "unidata" U_FILE_SEP_STRING);
131 strcat(unidataPath, filename);
132 input=T_FileStream_open(unidataPath, "rb");
133 if(input!=NULL) {
134 return input;
135 }
136
137 strcpy(unidataPath, U_TOPSRCDIR U_FILE_SEP_STRING "test" U_FILE_SEP_STRING "testdata" U_FILE_SEP_STRING);
138 strcat(unidataPath, filename);
139 input=T_FileStream_open(unidataPath, "rb");
140 if(input!=NULL) {
141 return input;
142 }
143 #endif
144
145 dataerrln("Failed to open %s", filename);
146 return NULL;
147 }
148
149 /**
150 * Test the conformance of Normalizer to
151 * http://www.unicode.org/Public/UNIDATA/NormalizationTest.txt
152 */
TestConformance()153 void NormalizerConformanceTest::TestConformance() {
154 TestConformance(openNormalizationTestFile("NormalizationTest.txt"), 0);
155 }
156
TestConformance32()157 void NormalizerConformanceTest::TestConformance32() {
158 TestConformance(openNormalizationTestFile("NormalizationTest-3.2.0.txt"), UNORM_UNICODE_3_2);
159 }
160
TestConformance(FileStream * input,int32_t options)161 void NormalizerConformanceTest::TestConformance(FileStream *input, int32_t options) {
162 enum { BUF_SIZE = 1024 };
163 char lineBuf[BUF_SIZE];
164 UnicodeString fields[FIELD_COUNT];
165 UErrorCode status = U_ZERO_ERROR;
166 int32_t passCount = 0;
167 int32_t failCount = 0;
168 UChar32 c;
169
170 if(input==NULL) {
171 return;
172 }
173
174 // UnicodeSet for all code points that are not mentioned in NormalizationTest.txt
175 UnicodeSet other(0, 0x10ffff);
176
177 int32_t count, countMoreCases = sizeof(moreCases)/sizeof(moreCases[0]);
178 for (count = 1;;++count) {
179 if (!T_FileStream_eof(input)) {
180 T_FileStream_readLine(input, lineBuf, (int32_t)sizeof(lineBuf));
181 } else {
182 // once NormalizationTest.txt is finished, use moreCases[]
183 if(count > countMoreCases) {
184 count = 0;
185 } else if(count == countMoreCases) {
186 // all done
187 break;
188 }
189 uprv_strcpy(lineBuf, moreCases[count]);
190 }
191 if (lineBuf[0] == 0 || lineBuf[0] == '\n' || lineBuf[0] == '\r') continue;
192
193 // Expect 5 columns of this format:
194 // 1E0C;1E0C;0044 0323;1E0C;0044 0323; # <comments>
195
196 // Parse out the comment.
197 if (lineBuf[0] == '#') continue;
198
199 // Read separator lines starting with '@'
200 if (lineBuf[0] == '@') {
201 logln(lineBuf);
202 continue;
203 }
204
205 // Parse out the fields
206 if (!hexsplit(lineBuf, ';', fields, FIELD_COUNT)) {
207 errln((UnicodeString)"Unable to parse line " + count);
208 break; // Syntax error
209 }
210
211 // Remove a single code point from the "other" UnicodeSet
212 if(fields[0].length()==fields[0].moveIndex32(0, 1)) {
213 c=fields[0].char32At(0);
214 if(0xac20<=c && c<=0xd73f && quick) {
215 // not an exhaustive test run: skip most Hangul syllables
216 if(c==0xac20) {
217 other.remove(0xac20, 0xd73f);
218 }
219 continue;
220 }
221 other.remove(c);
222 }
223
224 if (checkConformance(fields, lineBuf, options, status)) {
225 ++passCount;
226 } else {
227 ++failCount;
228 if(status == U_FILE_ACCESS_ERROR) {
229 dataerrln("Something is wrong with the normalizer, skipping the rest of the test.");
230 break;
231 }
232 }
233 if ((count % 1000) == 0) {
234 logln("Line %d", count);
235 }
236 }
237
238 T_FileStream_close(input);
239
240 /*
241 * Test that all characters that are not mentioned
242 * as single code points in column 1
243 * do not change under any normalization.
244 */
245
246 // remove U+ffff because that is the end-of-iteration sentinel value
247 other.remove(0xffff);
248
249 for(c=0; c<=0x10ffff; quick ? c+=113 : ++c) {
250 if(0x30000<=c && c<0xe0000) {
251 c=0xe0000;
252 }
253 if(!other.contains(c)) {
254 continue;
255 }
256
257 fields[0]=fields[1]=fields[2]=fields[3]=fields[4].setTo(c);
258 sprintf(lineBuf, "not mentioned code point U+%04lx", (long)c);
259
260 if (checkConformance(fields, lineBuf, options, status)) {
261 ++passCount;
262 } else {
263 ++failCount;
264 if(status == U_FILE_ACCESS_ERROR) {
265 dataerrln("Something is wrong with the normalizer, skipping the rest of the test.: %s", u_errorName(status));
266 break;
267 }
268 }
269 if ((c % 0x1000) == 0) {
270 logln("Code point U+%04lx", c);
271 }
272 }
273
274 if (failCount != 0) {
275 dataerrln((UnicodeString)"Total: " + failCount + " lines/code points failed, " +
276 passCount + " lines/code points passed");
277 } else {
278 logln((UnicodeString)"Total: " + passCount + " lines/code points passed");
279 }
280 }
281
282 /**
283 * Verify the conformance of the given line of the Unicode
284 * normalization (UTR 15) test suite file. For each line,
285 * there are five columns, corresponding to field[0]..field[4].
286 *
287 * The following invariants must be true for all conformant implementations
288 * c2 == NFC(c1) == NFC(c2) == NFC(c3)
289 * c3 == NFD(c1) == NFD(c2) == NFD(c3)
290 * c4 == NFKC(c1) == NFKC(c2) == NFKC(c3) == NFKC(c4) == NFKC(c5)
291 * c5 == NFKD(c1) == NFKD(c2) == NFKD(c3) == NFKD(c4) == NFKD(c5)
292 *
293 * @param field the 5 columns
294 * @param line the source line from the test suite file
295 * @return true if the test passes
296 */
checkConformance(const UnicodeString * field,const char * line,int32_t options,UErrorCode & status)297 UBool NormalizerConformanceTest::checkConformance(const UnicodeString* field,
298 const char *line,
299 int32_t options,
300 UErrorCode &status) {
301 UBool pass = TRUE, result;
302 //UErrorCode status = U_ZERO_ERROR;
303 UnicodeString out, fcd;
304 int32_t fieldNum;
305
306 for (int32_t i=0; i<FIELD_COUNT; ++i) {
307 fieldNum = i+1;
308 if (i<3) {
309 Normalizer::normalize(field[i], UNORM_NFC, options, out, status);
310 if (U_FAILURE(status)) {
311 dataerrln("Error running normalize UNORM_NFC: %s", u_errorName(status));
312 } else {
313 pass &= assertEqual("C", field[i], out, field[1], "c2!=C(c", fieldNum);
314 iterativeNorm(field[i], UNORM_NFC, options, out, +1);
315 pass &= assertEqual("C(+1)", field[i], out, field[1], "c2!=C(c", fieldNum);
316 iterativeNorm(field[i], UNORM_NFC, options, out, -1);
317 pass &= assertEqual("C(-1)", field[i], out, field[1], "c2!=C(c", fieldNum);
318 }
319
320 Normalizer::normalize(field[i], UNORM_NFD, options, out, status);
321 if (U_FAILURE(status)) {
322 dataerrln("Error running normalize UNORM_NFD: %s", u_errorName(status));
323 } else {
324 pass &= assertEqual("D", field[i], out, field[2], "c3!=D(c", fieldNum);
325 iterativeNorm(field[i], UNORM_NFD, options, out, +1);
326 pass &= assertEqual("D(+1)", field[i], out, field[2], "c3!=D(c", fieldNum);
327 iterativeNorm(field[i], UNORM_NFD, options, out, -1);
328 pass &= assertEqual("D(-1)", field[i], out, field[2], "c3!=D(c", fieldNum);
329 }
330 }
331 Normalizer::normalize(field[i], UNORM_NFKC, options, out, status);
332 if (U_FAILURE(status)) {
333 dataerrln("Error running normalize UNORM_NFKC: %s", u_errorName(status));
334 } else {
335 pass &= assertEqual("KC", field[i], out, field[3], "c4!=KC(c", fieldNum);
336 iterativeNorm(field[i], UNORM_NFKC, options, out, +1);
337 pass &= assertEqual("KC(+1)", field[i], out, field[3], "c4!=KC(c", fieldNum);
338 iterativeNorm(field[i], UNORM_NFKC, options, out, -1);
339 pass &= assertEqual("KC(-1)", field[i], out, field[3], "c4!=KC(c", fieldNum);
340 }
341
342 Normalizer::normalize(field[i], UNORM_NFKD, options, out, status);
343 if (U_FAILURE(status)) {
344 dataerrln("Error running normalize UNORM_NFKD: %s", u_errorName(status));
345 } else {
346 pass &= assertEqual("KD", field[i], out, field[4], "c5!=KD(c", fieldNum);
347 iterativeNorm(field[i], UNORM_NFKD, options, out, +1);
348 pass &= assertEqual("KD(+1)", field[i], out, field[4], "c5!=KD(c", fieldNum);
349 iterativeNorm(field[i], UNORM_NFKD, options, out, -1);
350 pass &= assertEqual("KD(-1)", field[i], out, field[4], "c5!=KD(c", fieldNum);
351 }
352 }
353 compare(field[1],field[2]);
354 compare(field[0],field[1]);
355 // test quick checks
356 if(UNORM_NO == Normalizer::quickCheck(field[1], UNORM_NFC, options, status)) {
357 errln("Normalizer error: quickCheck(NFC(s), UNORM_NFC) is UNORM_NO");
358 pass = FALSE;
359 }
360 if(UNORM_NO == Normalizer::quickCheck(field[2], UNORM_NFD, options, status)) {
361 errln("Normalizer error: quickCheck(NFD(s), UNORM_NFD) is UNORM_NO");
362 pass = FALSE;
363 }
364 if(UNORM_NO == Normalizer::quickCheck(field[3], UNORM_NFKC, options, status)) {
365 errln("Normalizer error: quickCheck(NFKC(s), UNORM_NFKC) is UNORM_NO");
366 pass = FALSE;
367 }
368 if(UNORM_NO == Normalizer::quickCheck(field[4], UNORM_NFKD, options, status)) {
369 errln("Normalizer error: quickCheck(NFKD(s), UNORM_NFKD) is UNORM_NO");
370 pass = FALSE;
371 }
372
373 // branch on options==0 for better code coverage
374 if(options==0) {
375 result = Normalizer::isNormalized(field[1], UNORM_NFC, status);
376 } else {
377 result = Normalizer::isNormalized(field[1], UNORM_NFC, options, status);
378 }
379 if(!result) {
380 dataerrln("Normalizer error: isNormalized(NFC(s), UNORM_NFC) is FALSE");
381 pass = FALSE;
382 }
383 if(field[0]!=field[1] && Normalizer::isNormalized(field[0], UNORM_NFC, options, status)) {
384 errln("Normalizer error: isNormalized(s, UNORM_NFC) is TRUE");
385 pass = FALSE;
386 }
387 if(!Normalizer::isNormalized(field[3], UNORM_NFKC, options, status)) {
388 dataerrln("Normalizer error: isNormalized(NFKC(s), UNORM_NFKC) is FALSE");
389 pass = FALSE;
390 }
391 if(field[0]!=field[3] && Normalizer::isNormalized(field[0], UNORM_NFKC, options, status)) {
392 errln("Normalizer error: isNormalized(s, UNORM_NFKC) is TRUE");
393 pass = FALSE;
394 }
395
396 // test FCD quick check and "makeFCD"
397 Normalizer::normalize(field[0], UNORM_FCD, options, fcd, status);
398 if(UNORM_NO == Normalizer::quickCheck(fcd, UNORM_FCD, options, status)) {
399 errln("Normalizer error: quickCheck(FCD(s), UNORM_FCD) is UNORM_NO");
400 pass = FALSE;
401 }
402 if(UNORM_NO == Normalizer::quickCheck(field[2], UNORM_FCD, options, status)) {
403 errln("Normalizer error: quickCheck(NFD(s), UNORM_FCD) is UNORM_NO");
404 pass = FALSE;
405 }
406 if(UNORM_NO == Normalizer::quickCheck(field[4], UNORM_FCD, options, status)) {
407 errln("Normalizer error: quickCheck(NFKD(s), UNORM_FCD) is UNORM_NO");
408 pass = FALSE;
409 }
410
411 Normalizer::normalize(fcd, UNORM_NFD, options, out, status);
412 if(out != field[2]) {
413 dataerrln("Normalizer error: NFD(FCD(s))!=NFD(s)");
414 pass = FALSE;
415 }
416
417 if (U_FAILURE(status)) {
418 dataerrln("Normalizer::normalize returned error status: %s", u_errorName(status));
419 pass = FALSE;
420 }
421
422 if(field[0]!=field[2]) {
423 // two strings that are canonically equivalent must test
424 // equal under a canonical caseless match
425 // see UAX #21 Case Mappings and Jitterbug 2021 and
426 // Unicode Technical Committee meeting consensus 92-C31
427 int32_t rc;
428
429 status=U_ZERO_ERROR;
430 rc=Normalizer::compare(field[0], field[2], (options<<UNORM_COMPARE_NORM_OPTIONS_SHIFT)|U_COMPARE_IGNORE_CASE, status);
431 if(U_FAILURE(status)) {
432 dataerrln("Normalizer::compare(case-insensitive) sets %s", u_errorName(status));
433 pass=FALSE;
434 } else if(rc!=0) {
435 errln("Normalizer::compare(original, NFD, case-insensitive) returned %d instead of 0 for equal", rc);
436 pass=FALSE;
437 }
438 }
439
440 if (!pass) {
441 dataerrln("FAIL: %s", line);
442 }
443 return pass;
444 }
445
446 /**
447 * Do a normalization using the iterative API in the given direction.
448 * @param dir either +1 or -1
449 */
iterativeNorm(const UnicodeString & str,UNormalizationMode mode,int32_t options,UnicodeString & result,int8_t dir)450 void NormalizerConformanceTest::iterativeNorm(const UnicodeString& str,
451 UNormalizationMode mode, int32_t options,
452 UnicodeString& result,
453 int8_t dir) {
454 UErrorCode status = U_ZERO_ERROR;
455 normalizer.setText(str, status);
456 normalizer.setMode(mode);
457 normalizer.setOption(-1, 0); // reset all options
458 normalizer.setOption(options, 1); // set desired options
459 result.truncate(0);
460 if (U_FAILURE(status)) {
461 return;
462 }
463 UChar32 ch;
464 if (dir > 0) {
465 for (ch = normalizer.first(); ch != Normalizer::DONE;
466 ch = normalizer.next()) {
467 result.append(ch);
468 }
469 } else {
470 for (ch = normalizer.last(); ch != Normalizer::DONE;
471 ch = normalizer.previous()) {
472 result.insert(0, ch);
473 }
474 }
475 }
476
477 /**
478 * @param op name of normalization form, e.g., "KC"
479 * @param s string being normalized
480 * @param got value received
481 * @param exp expected value
482 * @param msg description of this test
483 * @param return true if got == exp
484 */
assertEqual(const char * op,const UnicodeString & s,const UnicodeString & got,const UnicodeString & exp,const char * msg,int32_t field)485 UBool NormalizerConformanceTest::assertEqual(const char *op,
486 const UnicodeString& s,
487 const UnicodeString& got,
488 const UnicodeString& exp,
489 const char *msg,
490 int32_t field)
491 {
492 if (exp == got)
493 return TRUE;
494
495 char *sChars, *gotChars, *expChars;
496 UnicodeString sPretty(prettify(s));
497 UnicodeString gotPretty(prettify(got));
498 UnicodeString expPretty(prettify(exp));
499
500 sChars = new char[sPretty.length() + 1];
501 gotChars = new char[gotPretty.length() + 1];
502 expChars = new char[expPretty.length() + 1];
503
504 sPretty.extract(0, sPretty.length(), sChars, sPretty.length() + 1);
505 sChars[sPretty.length()] = 0;
506 gotPretty.extract(0, gotPretty.length(), gotChars, gotPretty.length() + 1);
507 gotChars[gotPretty.length()] = 0;
508 expPretty.extract(0, expPretty.length(), expChars, expPretty.length() + 1);
509 expChars[expPretty.length()] = 0;
510
511 errln(" %s%d)%s(%s)=%s, exp. %s", msg, field, op, sChars, gotChars, expChars);
512
513 delete []sChars;
514 delete []gotChars;
515 delete []expChars;
516 return FALSE;
517 }
518
519 /**
520 * Split a string into pieces based on the given delimiter
521 * character. Then, parse the resultant fields from hex into
522 * characters. That is, "0040 0400;0C00;0899" -> new String[] {
523 * "\u0040\u0400", "\u0C00", "\u0899" }. The output is assumed to
524 * be of the proper length already, and exactly output.length
525 * fields are parsed. If there are too few an exception is
526 * thrown. If there are too many the extras are ignored.
527 *
528 * @return FALSE upon failure
529 */
hexsplit(const char * s,char delimiter,UnicodeString output[],int32_t outputLength)530 UBool NormalizerConformanceTest::hexsplit(const char *s, char delimiter,
531 UnicodeString output[], int32_t outputLength) {
532 const char *t = s;
533 char *end = NULL;
534 UChar32 c;
535 int32_t i;
536 for (i=0; i<outputLength; ++i) {
537 // skip whitespace
538 while(*t == ' ' || *t == '\t') {
539 ++t;
540 }
541
542 // read a sequence of code points
543 output[i].remove();
544 for(;;) {
545 c = (UChar32)uprv_strtoul(t, &end, 16);
546
547 if( (char *)t == end ||
548 (uint32_t)c > 0x10ffff ||
549 (*end != ' ' && *end != '\t' && *end != delimiter)
550 ) {
551 errln(UnicodeString("Bad field ", "") + (i + 1) + " in " + UnicodeString(s, ""));
552 return FALSE;
553 }
554
555 output[i].append(c);
556
557 t = (const char *)end;
558
559 // skip whitespace
560 while(*t == ' ' || *t == '\t') {
561 ++t;
562 }
563
564 if(*t == delimiter) {
565 ++t;
566 break;
567 }
568 if(*t == 0) {
569 if((i + 1) == outputLength) {
570 return TRUE;
571 } else {
572 errln(UnicodeString("Missing field(s) in ", "") + s + " only " + (i + 1) + " out of " + outputLength);
573 return FALSE;
574 }
575 }
576 }
577 }
578 return TRUE;
579 }
580
581 // Specific tests for debugging. These are generally failures taken from
582 // the conformance file, but culled out to make debugging easier.
583
TestCase6(void)584 void NormalizerConformanceTest::TestCase6(void) {
585 _testOneLine("0385;0385;00A8 0301;0020 0308 0301;0020 0308 0301;");
586 }
587
_testOneLine(const char * line)588 void NormalizerConformanceTest::_testOneLine(const char *line) {
589 UErrorCode status = U_ZERO_ERROR;
590 UnicodeString fields[FIELD_COUNT];
591 if (!hexsplit(line, ';', fields, FIELD_COUNT)) {
592 errln((UnicodeString)"Unable to parse line " + line);
593 } else {
594 checkConformance(fields, line, 0, status);
595 }
596 }
597
598 #endif /* #if !UCONFIG_NO_NORMALIZATION */
599