1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
3 /********************************************************************
4 * COPYRIGHT:
5 * Copyright (c) 1998-2016, International Business Machines Corporation and
6 * others. All Rights Reserved.
7 ********************************************************************/
8 /*
9 * File udatatst.c
10 *
11 * Modification History:
12 *
13 * Date Name Description
14 * 02/22/2000 Madhu Creation
15 ******************************************************************************
16 */
17
18 #include "unicode/utypes.h"
19 #include "unicode/putil.h"
20 #include "unicode/udata.h"
21 #include "unicode/ucal.h"
22 #include "unicode/uchar.h"
23 #include "unicode/ucnv.h"
24 #include "unicode/ures.h"
25 #include "unicode/ustring.h"
26 #include "unicode/uclean.h"
27 #include "cmemory.h"
28 #include "cstring.h"
29 #include "filestrm.h"
30 #include "udatamem.h"
31 #include "cintltst.h"
32 #include "ubrkimpl.h"
33 #include "toolutil.h" /* for uprv_fileExists() */
34 #include <stdlib.h>
35 #include <stdio.h>
36
37 /* includes for TestSwapData() */
38 #include "udataswp.h"
39
40 /* swapping implementations in common */
41 #include "uresdata.h"
42 #include "ucnv_io.h"
43 #include "uprops.h"
44 #include "ucase.h"
45 #include "ucol_imp.h"
46 #include "ucol_swp.h"
47 #include "ucnv_bld.h"
48 #include "sprpimpl.h"
49 #include "rbbidata.h"
50
51 /* swapping implementation in i18n */
52 #include "uspoof_impl.h"
53
54 U_CAPI int32_t U_EXPORT2
55 unorm2_swap(const UDataSwapper *ds,
56 const void *inData, int32_t length, void *outData,
57 UErrorCode *pErrorCode);
58
59 /* other definitions and prototypes */
60
61 #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
62 static void TestUDataOpen(void);
63 static void TestUDataOpenChoiceDemo1(void);
64 static void TestUDataOpenChoiceDemo2(void);
65 static void TestUDataGetInfo(void);
66 static void TestUDataGetMemory(void);
67 static void TestErrorConditions(void);
68 static void TestAppData(void);
69 static void TestSwapData(void);
70 #endif
71 static void TestUDataSetAppData(void);
72 static void TestICUDataName(void);
73 static void PointerTableOfContents(void);
74 static void SetBadCommonData(void);
75 static void TestUDataFileAccess(void);
76 #if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
77 static void TestTZDataDir(void);
78 #endif
79
80 void addUDataTest(TestNode** root);
81
82 void
addUDataTest(TestNode ** root)83 addUDataTest(TestNode** root)
84 {
85 #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
86 addTest(root, &TestUDataOpen, "udatatst/TestUDataOpen" );
87 addTest(root, &TestUDataOpenChoiceDemo1, "udatatst/TestUDataOpenChoiceDemo1");
88 addTest(root, &TestUDataOpenChoiceDemo2, "udatatst/TestUDataOpenChoiceDemo2");
89 addTest(root, &TestUDataGetInfo, "udatatst/TestUDataGetInfo" );
90 addTest(root, &TestUDataGetMemory, "udatatst/TestUDataGetMemory" );
91 addTest(root, &TestErrorConditions, "udatatst/TestErrorConditions");
92 addTest(root, &TestAppData, "udatatst/TestAppData" );
93 addTest(root, &TestSwapData, "udatatst/TestSwapData" );
94 #endif
95 addTest(root, &TestUDataSetAppData, "udatatst/TestUDataSetAppData" );
96 addTest(root, &TestICUDataName, "udatatst/TestICUDataName" );
97 addTest(root, &PointerTableOfContents, "udatatst/PointerTableOfContents" );
98 addTest(root, &SetBadCommonData, "udatatst/SetBadCommonData" );
99 addTest(root, &TestUDataFileAccess, "udatatst/TestUDataFileAccess" );
100 #if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
101 addTest(root, &TestTZDataDir, "udatatst/TestTZDataDir" );
102 #endif
103 }
104
105 #if 0
106 static void lots_of_mallocs()
107 {
108 int q;
109 for(q=1;q<100;q++)
110 {
111 free(malloc(q));
112 malloc(q*2);
113 }
114
115 }
116 #endif
117
118 #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
TestUDataOpen()119 static void TestUDataOpen(){
120 UDataMemory *result;
121 UErrorCode status=U_ZERO_ERROR;
122 const char* memMap[][2]={
123 {"root", "res"},
124 {"cnvalias", "icu"},
125 {"unames", "icu"},
126 {"ibm-37_P100-1995", "cnv"}
127 };
128 const char* name = "test";
129 const char* type = "icu";
130 const char dirSepString[] = {U_FILE_SEP_CHAR, 0};
131 const char pathSepString[] = {U_PATH_SEP_CHAR, 0};
132
133
134 char* path=(char*)malloc(sizeof(char) * (strlen(ctest_dataOutDir())
135 + strlen(U_ICUDATA_NAME)
136 + strlen("/build/tmp/..")+1 ) );
137
138 char *icuDataFilePath = 0;
139
140 const char* testPath=loadTestData(&status);
141 if(U_FAILURE(status)) {
142 log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status));
143 free(path);
144 return;
145 }
146
147 /* lots_of_mallocs(); */
148 log_verbose("Testing udata_open(%s)\n", testPath);
149 result=udata_open(testPath, type, name, &status);
150 if(U_FAILURE(status)){
151 log_data_err("FAIL: udata_open() failed for path = %s, name=%s, type=%s, \n errorcode=%s\n", testPath, name, type, myErrorName(status));
152 } else {
153 log_verbose("PASS: udata_open worked\n");
154 udata_close(result);
155 }
156
157 {
158 strcat(strcpy(path, ctest_dataOutDir()), U_ICUDATA_NAME);
159
160 /* If the ICU system common data file is present in this confiugration,
161 * verify that udata_open can explicitly fetch items from it.
162 * If packaging mode == dll, the file may not exist. So, if the file is
163 * missing, skip this test without error.
164 */
165 icuDataFilePath = (char *)uprv_malloc(strlen(path) + 10);
166 strcpy(icuDataFilePath, path);
167 strcat(icuDataFilePath, ".dat");
168 /* lots_of_mallocs(); */
169 if (uprv_fileExists(icuDataFilePath))
170 {
171 int i;
172 log_verbose("Testing udata_open() on %s\n", icuDataFilePath);
173 for(i=0; i<UPRV_LENGTHOF(memMap); i++){
174 /* lots_of_mallocs(); */
175 status=U_ZERO_ERROR;
176 result=udata_open(path, memMap[i][1], memMap[i][0], &status);
177 if(U_FAILURE(status)) {
178 log_data_err("FAIL: udata_open() failed for path = %s, name=%s, type=%s, \n errorcode=%s\n", path, memMap[i][0], memMap[i][1], myErrorName(status));
179 } else {
180 log_verbose("PASS: udata_open worked for path = %s, name=%s, type=%s\n", path, memMap[i][0], memMap[i][1]);
181 udata_close(result);
182 }
183 }
184 }
185 else
186 {
187 /* lots_of_mallocs(); */
188 log_verbose("Skipping tests of udata_open() on %s. File not present in this configuration.\n",
189 icuDataFilePath);
190 }
191 uprv_free(icuDataFilePath);
192 }
193 /* try again, adding /tmp */
194 {
195 strcpy(path, ctest_dataOutDir());
196 strcat(path, "tmp");
197 strcat(path, dirSepString);
198 strcat(path, U_ICUDATA_NAME);
199
200 /* If the ICU system common data file is present in this confiugration,
201 * verify that udata_open can explicitly fetch items from it.
202 * If packaging mode == dll, the file may not exist. So, if the file is
203 * missing, skip this test without error.
204 */
205 icuDataFilePath = (char *)malloc(strlen(path) + 10);
206 strcpy(icuDataFilePath, path);
207 strcat(icuDataFilePath, ".dat");
208 /* lots_of_mallocs(); */
209 if (uprv_fileExists(icuDataFilePath))
210 {
211 int i;
212 log_verbose("Testing udata_open() on %s\n", icuDataFilePath);
213 for(i=0; i<UPRV_LENGTHOF(memMap); i++){
214 /* lots_of_mallocs(); */
215 status=U_ZERO_ERROR;
216 result=udata_open(path, memMap[i][1], memMap[i][0], &status);
217 if(U_FAILURE(status)) {
218 log_data_err("FAIL: udata_open() failed for path = %s, name=%s, type=%s, \n errorcode=%s\n", path, memMap[i][0], memMap[i][1], myErrorName(status));
219 } else {
220 log_verbose("PASS: udata_open worked for path = %s, name=%s, type=%s\n", path, memMap[i][0], memMap[i][1]);
221 udata_close(result);
222 }
223 }
224 }
225 else
226 {
227 /* lots_of_mallocs(); */
228 log_verbose("Skipping tests of udata_open() on %s. File not present in this configuration.\n",
229 icuDataFilePath);
230 }
231 }
232
233 free(icuDataFilePath);
234 icuDataFilePath = NULL;
235 /* lots_of_mallocs(); */
236
237 /* If the ICU individual files used to build the ICU system common data are
238 * present in this configuration,
239 * verify that udata_open can explicitly open them.
240 * These data files are present in the ICU data/build directory after a build
241 * completes. Tests are most commonly run with the data directory pointing
242 * back into this directory structure, but this is not required. Soooo, if
243 * the files are missing, skip this test without error.
244 */
245 /* lots_of_mallocs(); */
246 icuDataFilePath = (char *)malloc(strlen(ctest_dataOutDir()) + 50);
247 strcpy(icuDataFilePath, ctest_dataOutDir());
248 strcat(icuDataFilePath, "build");
249 strcat(icuDataFilePath, dirSepString);
250 strcat(icuDataFilePath, U_ICUDATA_NAME);
251 strcat(icuDataFilePath, dirSepString);
252 strcat(icuDataFilePath, "cnvalias.icu");
253
254 /* lots_of_mallocs(); */
255 if (uprv_fileExists(icuDataFilePath))
256 {
257 int i;
258 log_verbose("%s exists, so..\n", icuDataFilePath);
259 strcpy(icuDataFilePath, ctest_dataOutDir());
260 strcat(icuDataFilePath, "build");
261 strcat(icuDataFilePath, dirSepString);
262 strcat(icuDataFilePath, U_ICUDATA_NAME);
263 log_verbose("Testing udata_open() on %s\n", icuDataFilePath);
264 for(i=0; i<UPRV_LENGTHOF(memMap); i++){
265 status=U_ZERO_ERROR;
266 result=udata_open(icuDataFilePath, memMap[i][1], memMap[i][0], &status);
267 if(U_FAILURE(status)) {
268 log_data_err("FAIL: udata_open() failed for path = %s, name=%s, type=%s, \n errorcode=%s\n", icuDataFilePath, memMap[i][0], memMap[i][1], myErrorName(status));
269 } else {
270 log_verbose("PASS: udata_open worked for path = %s, name=%s, type=%s\n", icuDataFilePath, memMap[i][0], memMap[i][1]);
271 udata_close(result);
272 }
273 }
274 }
275 else
276 {
277 log_verbose("Skipping tests of udata_open() on %s. File not present in this configuration.\n",
278 icuDataFilePath);
279 }
280
281 free(icuDataFilePath);
282 icuDataFilePath = NULL;
283
284 /*
285 * Test fallback file names for open of separate data files.
286 * With these params to udata_open:
287 * path = wherever/testdata
288 * type = typ
289 * name = nam
290 * these files will be tried first:
291 * wherever/testudata_nam.typ
292 * testudata_nam.typ
293 * A test data file named testudata_nam.typ exists for the purpose of testing this.
294 */
295 log_verbose("Testing udata_open, with base_name.type style fallback to individual file.\n");
296
297 status = U_ZERO_ERROR;
298 result = udata_open( testPath, "typ", "nam", &status);
299 if (status != U_ZERO_ERROR) {
300 log_data_err("FAIL: udata_open( \"%s\", \"typ\", \"nam\") returned status %s\n", testPath, u_errorName(status));
301 }
302 udata_close(result);
303 free(icuDataFilePath);
304
305
306 /* This type of path is deprecated */
307 /*
308 * Another fallback test. Paths ending with a trailing directory separator
309 * take a slightly different code path, with the "base name" from the path
310 * being empty in the internal udata_open logic.
311 */
312
313 /* log_verbose("Testing udata_open, with path containing a trailing directory separator.\n"); */
314 /* icuDataFilePath = (char *)malloc(strlen(u_getDataDirectory()) + 50); */
315 /* strcpy(icuDataFilePath, testPath); */
316 /* status = U_ZERO_ERROR; */
317 /* result = udata_open( icuDataFilePath, "cnv", "test1", &status); */
318 /* if (status != U_ZERO_ERROR) { */
319 /* log_err("FAIL: udata_open( \"%s\", \"cnv\", \"test1\") returned status %s\n", icuDataFilePath, u_errorName(status)); */
320 /* } */
321 /* udata_close(result); */
322 /* free(icuDataFilePath); */
323
324
325 log_verbose("Testing udata_open() with a non existing binary file\n");
326 result=udata_open("testdata", "tst", "nonexist", &status);
327 if(status==U_FILE_ACCESS_ERROR){
328 log_verbose("Opening udata_open with non-existing file handled correctly.\n");
329 status=U_ZERO_ERROR;
330 } else {
331 log_err("calling udata_open with non-existing file [testdata | nonexist.tst] not handled correctly\n. Expected: U_FILE_ACCESS_ERROR, Got: %s\n", myErrorName(status));
332 if(U_SUCCESS(status)) {
333 udata_close(result);
334 }
335 }
336
337 if(result != NULL){
338 log_err("calling udata_open with non-existing file didn't return a null value\n");
339 } else {
340 log_verbose("calling udat_open with non-existing file returned null as expected\n");
341 }
342
343 /*
344 * Try opening data with absurdly long path and name, to trigger buffer size
345 * overflow handling code.
346 */
347 {
348 char longTestPath[1024]; /* Implementation goes to heap at length of 128. */
349 char longName[1024];
350
351 /* Try a very long nonexistent directory path.
352 * udata_open should still succeed. Opening with the path will fail,
353 * then fall back to skipping the directory portion of the path.
354 */
355 log_verbose("Testing udata_open() with really long names\n");
356 longTestPath[0] = 0;
357 strcat(longTestPath, "bogus_directory_name");
358 while (strlen(longTestPath) < 500) {
359 strcat(longTestPath, dirSepString);
360 strcat(longTestPath, "bogus_directory_name");
361 }
362 strcat(longTestPath, pathSepString);
363 strcat(longTestPath, testPath);
364 result=udata_open(longTestPath, type, name, &status);
365 if(U_FAILURE(status)){
366 log_data_err("FAIL: udata_open() failed for path = %s\n name=%s, type=%s, \n errorcode=%s\n",
367 longTestPath, name, type, myErrorName(status));
368 } else {
369 log_verbose("PASS: udata_open worked\n");
370 udata_close(result);
371 }
372
373 /* Try a very long name. Won't open, but shouldn't blow up.
374 */
375 longName[0] = 0;
376 while (strlen(longName) < 500) {
377 strcat(longName, name);
378 strcat(longName, "_");
379 }
380 strcat(longName, dirSepString);
381 strcat(longName, name);
382
383 result=udata_open(longTestPath, type, longName, &status);
384 if (status != U_FILE_ACCESS_ERROR) {
385 log_data_err("FAIL: udata_open() failed for path = %s\n name=%s, type=%s, \n errorcode=%s\n",
386 longTestPath, longName, type, myErrorName(status));
387 }
388 udata_close(result);
389 }
390
391 free(path);
392 }
393 #endif
394
395 typedef struct {
396 uint16_t headerSize;
397 uint8_t magic1, magic2;
398 UDataInfo info;
399 char padding[8];
400 uint32_t count, reserved;
401 /*
402 const struct {
403 const char *const name;
404 const void *const data;
405 } toc[1];
406 */
407 int32_t fakeNameAndData[4];
408 } ICU_COMMON_Data_Header;
409
410 static const ICU_COMMON_Data_Header gEmptyHeader = {
411 32, /* headerSize */
412 0xda, /* magic1, (see struct MappedData in udata.c) */
413 0x27, /* magic2 */
414 { /*UDataInfo */
415 sizeof(UDataInfo), /* size */
416 0, /* reserved */
417
418 #if U_IS_BIG_ENDIAN
419 1,
420 #else
421 0,
422 #endif
423
424 U_CHARSET_FAMILY,
425 sizeof(UChar),
426 0, /* reserved */
427 { /* data format identifier */
428 0x43, 0x6d, 0x6e, 0x44}, /* "CmnD" */
429 {1, 0, 0, 0}, /* format version major, minor, milli, micro */
430 {0, 0, 0, 0} /* dataVersion */
431 },
432 {0,0,0,0,0,0,0,0}, /* Padding[8] */
433 0, /* count */
434 0, /* Reserved */
435 { /* TOC structure */
436 /* { */
437 0 , 0 , 0, 0 /* name and data entries. Count says there are none, */
438 /* but put one in just in case. */
439 /* } */
440 }
441 };
442
443
TestUDataSetAppData()444 static void TestUDataSetAppData(){
445 /* UDataMemory *dataItem;*/
446
447 UErrorCode status=U_ZERO_ERROR;
448
449 /*
450 * First we try some monkey business and try to do bad things.
451 */
452
453 status=U_ZERO_ERROR;
454 udata_setAppData("appData1", NULL, &status);
455 if (status != U_ILLEGAL_ARGUMENT_ERROR) {
456 log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData1\", NULL, status) should have failed."
457 " It returned status of %s\n", u_errorName(status));
458 return;
459 }
460 /* The following call should fail.
461 If the following works with a bad UErrorCode, then later calls to appData1 should fail. */
462 udata_setAppData("appData1", &gEmptyHeader, &status);
463
464 /*
465 * Got testdata.dat into memory, now we try setAppData using the memory image.
466 */
467
468 status=U_ZERO_ERROR;
469 udata_setAppData("appData1", &gEmptyHeader, &status);
470 if (status != U_ZERO_ERROR) {
471 log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData1\", fileBuf, status) "
472 " returned status of %s\n", u_errorName(status));
473 return;
474 }
475
476 udata_setAppData("appData2", &gEmptyHeader, &status);
477 if (status != U_ZERO_ERROR) {
478 log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData2\", fileBuf, status) "
479 " returned status of %s\n", u_errorName(status));
480 return;
481 }
482
483 /* If we try to setAppData with the same name a second time, we should get a
484 * a using default warning.
485 */
486 udata_setAppData("appData2", &gEmptyHeader, &status);
487 if (status != U_USING_DEFAULT_WARNING) {
488 log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData2\", fileBuf, status) "
489 " returned status of %s, expected U_USING_DEFAULT_WARNING.\n", u_errorName(status));
490 }
491
492
493 /** It is no longer correct to use udata_setAppData to change the
494 package of a contained item.
495
496 dataItem = udata_open("appData1", "res", "te_IN", &status); **/
497 }
498
safeGetICUDataDirectory()499 static char *safeGetICUDataDirectory() {
500 const char *dataDir = u_getDataDirectory(); /* Returned string vanashes with u_cleanup */
501 char *retStr = NULL;
502 if (dataDir != NULL) {
503 retStr = (char *)malloc(strlen(dataDir)+1);
504 strcpy(retStr, dataDir);
505 }
506 return retStr;
507 }
508
TestUDataFileAccess()509 static void TestUDataFileAccess(){
510 UErrorCode status;
511 char *icuDataDir;
512 icuDataDir = safeGetICUDataDirectory(); /* save icu data dir, so we can put it back
513 * after doing u_cleanup(). */
514
515 /** UDATA_NO_FILES, ICU does not access the file system for data loading. */
516 status=U_ZERO_ERROR;
517 u_cleanup();
518 udata_setFileAccess(UDATA_NO_FILES,&status);
519 u_init(&status);
520 if(U_FAILURE(status) && *icuDataDir == 0){
521 log_data_err("udata_setFileAccess(UDATA_NO_FILES) failed with ICU_DATA=\"\" err=%s\n", u_errorName(status));
522 }
523
524 /** UDATA_ONLY_PACKAGES, ICU only loads data from packages, not from single files. */
525 status=U_ZERO_ERROR;
526 u_cleanup();
527 udata_setFileAccess(UDATA_ONLY_PACKAGES,&status);
528 u_init(&status);
529
530 /** UDATA_PACKAGES_FIRST, ICU loads data from packages first, and only from single files
531 if the data cannot be found in a package. */
532 status=U_ZERO_ERROR;
533 u_cleanup();
534 udata_setFileAccess(UDATA_PACKAGES_FIRST,&status);
535 u_init(&status);
536
537 /** UDATA_FILES_FIRST, ICU looks for data in single files first, then in packages. (default) */
538 status=U_ZERO_ERROR;
539 u_cleanup();
540 udata_setFileAccess(UDATA_FILES_FIRST,&status);
541 u_init(&status);
542
543 /** An alias for the default access mode. */
544 status=U_ZERO_ERROR;
545 u_cleanup();
546 udata_setFileAccess(UDATA_DEFAULT_ACCESS,&status);
547 u_setDataDirectory(icuDataDir);
548 u_init(&status);
549 if(U_FAILURE(status)){
550 log_err_status(status, "%s\n", u_errorName(status));
551 }
552 free(icuDataDir);
553 ctest_resetICU();
554 }
555
556
557 static UBool U_CALLCONV
isAcceptable1(void * context,const char * type,const char * name,const UDataInfo * pInfo)558 isAcceptable1(void *context,
559 const char *type, const char *name,
560 const UDataInfo *pInfo) {
561
562 if( pInfo->size>=20 &&
563 pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
564 pInfo->charsetFamily==U_CHARSET_FAMILY &&
565 pInfo->dataFormat[0]==0x43 && /* dataFormat="CvAl" */
566 pInfo->dataFormat[1]==0x76 &&
567 pInfo->dataFormat[2]==0x41 &&
568 pInfo->dataFormat[3]==0x6c &&
569 pInfo->formatVersion[0]==3 )
570 {
571 log_verbose("The data from \"%s.%s\" IS acceptable using the verifing function isAcceptable1()\n", name, type);
572 return TRUE;
573 } else {
574 log_verbose("The data from \"%s.%s\" IS NOT acceptable using the verifing function isAcceptable1():-\n"
575 "\tsize = %d\n"
576 "\tisBigEndian = %d\n"
577 "\tcharsetFamily = %d\n"
578 "\tformatVersion[0] = %d\n"
579 "\tdataVersion[0] = %d\n"
580 "\tdataFormat = %c%c%c%c\n",
581 name, type, pInfo->size, pInfo->isBigEndian, pInfo->charsetFamily, pInfo->formatVersion[0],
582 pInfo->dataVersion[0], pInfo->dataFormat[0], pInfo->dataFormat[1], pInfo->dataFormat[2],
583 pInfo->dataFormat[3]);
584 log_verbose("Call another verifing function to accept the data\n");
585 return FALSE;
586 }
587 }
588
589 static UBool U_CALLCONV
isAcceptable2(void * context,const char * type,const char * name,const UDataInfo * pInfo)590 isAcceptable2(void *context,
591 const char *type, const char *name,
592 const UDataInfo *pInfo){
593 UVersionInfo unicodeVersion;
594
595 u_getUnicodeVersion(unicodeVersion);
596
597 if( pInfo->size>=20 &&
598 pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
599 pInfo->charsetFamily==U_CHARSET_FAMILY &&
600 pInfo->dataFormat[0]==0x75 && /* dataFormat="unam" */
601 pInfo->dataFormat[1]==0x6e &&
602 pInfo->dataFormat[2]==0x61 &&
603 pInfo->dataFormat[3]==0x6d &&
604 pInfo->formatVersion[0]==1 &&
605 pInfo->dataVersion[0]==unicodeVersion[0] )
606 {
607 log_verbose("The data from \"%s.%s\" IS acceptable using the verifing function isAcceptable2()\n", name, type);
608 return TRUE;
609 } else {
610 log_verbose("The data from \"%s.%s\" IS NOT acceptable using the verifing function isAcceptable2()\n", name, type);
611
612 return FALSE;
613 }
614
615
616 }
617 static UBool U_CALLCONV
isAcceptable3(void * context,const char * type,const char * name,const UDataInfo * pInfo)618 isAcceptable3(void *context,
619 const char *type, const char *name,
620 const UDataInfo *pInfo){
621
622 if( pInfo->size>=20 &&
623 pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
624 pInfo->charsetFamily==U_CHARSET_FAMILY &&
625 pInfo->dataFormat[0]==0x54 && /* dataFormat="test" */
626 pInfo->dataFormat[1]==0x65 &&
627 pInfo->dataFormat[2]==0x73 &&
628 pInfo->dataFormat[3]==0x74 &&
629 pInfo->formatVersion[0]==1 &&
630 pInfo->dataVersion[0]==1 ) {
631 log_verbose("The data from \"%s.%s\" IS acceptable using the verifing function isAcceptable3()\n", name, type);
632
633 return TRUE;
634 } else {
635 log_verbose("The data from \"%s.%s\" IS NOT acceptable using the verifing function isAcceptable3()\n", name, type);
636 return FALSE;
637 }
638
639
640 }
641
642 #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
TestUDataOpenChoiceDemo1()643 static void TestUDataOpenChoiceDemo1() {
644 UDataMemory *result;
645 UErrorCode status=U_ZERO_ERROR;
646
647 const char* name[]={
648 "cnvalias",
649 "unames",
650 "test",
651 "nam"
652 };
653 const char* type="icu";
654 const char* testPath="testdata";
655 const char* fullTestDataPath = loadTestData(&status);
656 if(U_FAILURE(status)) {
657 log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status));
658 return;
659 }
660
661 result=udata_openChoice(NULL, "icu", name[0], isAcceptable1, NULL, &status);
662 if(U_FAILURE(status)){
663 log_data_err("FAIL: udata_openChoice() failed name=%s, type=%s, \n errorcode=%s\n", name[0], type, myErrorName(status));
664 } else {
665 log_verbose("PASS: udata_openChoice worked\n");
666 udata_close(result);
667 }
668
669 status=U_ZERO_ERROR;
670 result=udata_openChoice(NULL, type, name[1], isAcceptable1, NULL, &status);
671 if(U_FAILURE(status)){
672 status=U_ZERO_ERROR;
673 result=udata_openChoice(NULL, type, name[1], isAcceptable2, NULL, &status);
674 if(U_FAILURE(status)){
675 log_data_err("FAIL: udata_openChoice() failed name=%s, type=%s, \n errorcode=%s\n", name[1], type, myErrorName(status));
676 }
677 }
678 else {
679 log_err("FAIL: udata_openChoice() unexpectedly passed. name=%s, type=%s, \n errorcode=%s\n", name[1], type, myErrorName(status));
680 }
681
682 if(U_SUCCESS(status)){
683 udata_close(result);
684 }
685
686 status=U_ZERO_ERROR;
687 result=udata_openChoice(testPath, type, name[2], isAcceptable1, NULL, &status);
688 if(U_FAILURE(status)){
689 status=U_ZERO_ERROR;
690 result=udata_openChoice(testPath, type, name[2], isAcceptable3, NULL, &status);
691 if(U_FAILURE(status)){
692 log_data_err("FAIL: udata_openChoice() failed path=%s name=%s, type=%s, \n errorcode=%s\n", testPath, name[2], type, myErrorName(status));
693 }
694 }
695 else {
696 log_err("FAIL: udata_openChoice() unexpectedly passed. name=%s, type=%s, \n errorcode=%s\n", name[2], type, myErrorName(status));
697 }
698
699 if(U_SUCCESS(status)){
700 udata_close(result);
701 }
702
703 status=U_ZERO_ERROR;
704 type="typ";
705 result=udata_openChoice(fullTestDataPath, type, name[3], isAcceptable1, NULL, &status);
706 if(status != U_INVALID_FORMAT_ERROR){
707 log_err("FAIL: udata_openChoice() did not fail as expected. name=%s, type=%s, \n errorcode=%s\n", name[3], type, myErrorName(status));
708 }
709
710 status=U_USELESS_COLLATOR_ERROR;
711 result=udata_openChoice(fullTestDataPath, type, name[3], isAcceptable1, NULL, &status);
712 if(status != U_USELESS_COLLATOR_ERROR){
713 log_err("FAIL: udata_openChoice() did not fail as expected. name=%s, type=%s, \n errorcode=%s\n", name[3], type, myErrorName(status));
714 }
715 }
716
717 static UBool U_CALLCONV
isAcceptable(void * context,const char * type,const char * name,const UDataInfo * pInfo)718 isAcceptable(void *context,
719 const char *type, const char *name,
720 const UDataInfo *pInfo){
721 if( pInfo->size>=20 &&
722 pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
723 pInfo->charsetFamily==U_CHARSET_FAMILY &&
724 pInfo->dataFormat[0]==0x54 && /* dataFormat="test" */
725 pInfo->dataFormat[1]==0x65 &&
726 pInfo->dataFormat[2]==0x73 &&
727 pInfo->dataFormat[3]==0x74 &&
728 pInfo->formatVersion[0]==1 &&
729 pInfo->dataVersion[0]==1 &&
730 *((int*)context) == 2 ) {
731 log_verbose("The data from\"%s.%s\" IS acceptable using the verifing function isAcceptable()\n", name, type);
732
733 return TRUE;
734 } else {
735 log_verbose("The data from \"%s.%s\" IS NOT acceptable using the verifing function isAcceptable()\n", name, type);
736 return FALSE;
737 }
738 }
739
740
741 /* This test checks to see if the isAcceptable function is being called correctly. */
742
TestUDataOpenChoiceDemo2()743 static void TestUDataOpenChoiceDemo2() {
744 UDataMemory *result;
745 UErrorCode status=U_ZERO_ERROR;
746 int i;
747 int p=2;
748
749 const char* name="test";
750 const char* type="icu";
751 const char* path = loadTestData(&status);
752 if(U_FAILURE(status)) {
753 log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status));
754 return;
755 }
756
757 result=udata_openChoice(path, type, name, isAcceptable, &p, &status);
758 if(U_FAILURE(status)){
759 log_data_err("failed to load data at p=%s t=%s n=%s, isAcceptable", path, type, name);
760 }
761 if(U_SUCCESS(status) ) {
762 udata_close(result);
763 }
764
765 p=0;
766 for(i=0;i<2; i++){
767 result=udata_openChoice(path, type, name, isAcceptable, &p, &status);
768 if(p<2) {
769 if(U_FAILURE(status) && status==U_INVALID_FORMAT_ERROR){
770 log_verbose("Loads the data but rejects it as expected %s\n", myErrorName(status));
771 status=U_ZERO_ERROR;
772 p++;
773 }
774 else {
775 log_data_err("FAIL: failed to either load the data or to reject the loaded data. ERROR=%s\n", myErrorName(status) );
776 }
777 }
778 else if(p == 2) {
779 if(U_FAILURE(status)) {
780 log_data_err("FAIL: failed to load the data and accept it. ERROR=%s\n", myErrorName(status) );
781 }
782 else {
783 log_verbose("Loads the data and accepts it for p==2 as expected\n");
784 udata_close(result);
785 }
786 }
787 }
788 }
789
TestUDataGetInfo()790 static void TestUDataGetInfo() {
791
792 UDataMemory *result;
793 /* UDataInfo cf. udata.h */
794 static UDataInfo dataInfo={
795 30, /*sizeof(UDataInfo),*/
796 0,
797
798 U_IS_BIG_ENDIAN,
799 U_CHARSET_FAMILY,
800 sizeof(UChar),
801 0,
802
803 {0x54, 0x65, 0x73, 0x74}, /* dataFormat="Test" */
804 {9, 0, 0, 0}, /* formatVersion */
805 {4, 0, 0, 0} /* dataVersion */
806 };
807 UErrorCode status=U_ZERO_ERROR;
808 const char* name="cnvalias";
809 const char* name2="test";
810 const char* type="icu";
811
812 const char* testPath=loadTestData(&status);
813 if(U_FAILURE(status)) {
814 log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status));
815 return;
816 }
817
818 log_verbose("Testing udata_getInfo() for cnvalias.icu\n");
819 result=udata_open(NULL, "icu", name, &status);
820 if(U_FAILURE(status)){
821 log_data_err("FAIL: udata_open() failed for path = NULL, name=%s, type=%s, \n errorcode=%s\n", name, type, myErrorName(status));
822 return;
823 }
824 udata_getInfo(result, &dataInfo);
825 if(dataInfo.size==20 && dataInfo.size!=30 &&
826 dataInfo.isBigEndian==U_IS_BIG_ENDIAN &&
827 dataInfo.charsetFamily==U_CHARSET_FAMILY &&
828 dataInfo.dataFormat[0]==0x43 && dataInfo.dataFormat[0]!=0x54 && /* dataFormat="CvAl" and not "Test". The values are set for cnvalias.dat*/
829 dataInfo.dataFormat[1]==0x76 && dataInfo.dataFormat[1]!=0x65 &&
830 dataInfo.dataFormat[2]==0x41 && dataInfo.dataFormat[2]!=0x73 &&
831 dataInfo.dataFormat[3]==0x6c && dataInfo.dataFormat[3]!=0x74 &&
832 dataInfo.formatVersion[0]!=9 && /*formatVersion is also set to the one for cnvalias*/
833 dataInfo.dataVersion[0]!=4 && /*dataVersion*/
834 dataInfo.dataVersion[1]!=0 ){
835 log_verbose("PASS: udata_getInfo() filled in the right values\n");
836 } else {
837 log_err("FAIL: udata_getInfo() filled in the wrong values\n");
838 }
839 udata_close(result);
840
841
842 log_verbose("Testing udata_getInfo() for test.icu\n");
843 result=udata_open(testPath, type, name2, &status);
844 if(U_FAILURE(status)) {
845 log_data_err("FAIL: udata_open() failed for path=%s name2=%s, type=%s, \n errorcode=%s\n", testPath, name2, type, myErrorName(status));
846 return;
847 }
848 udata_getInfo(result, &dataInfo);
849 if(dataInfo.size==20 &&
850 dataInfo.isBigEndian==U_IS_BIG_ENDIAN &&
851 dataInfo.charsetFamily==U_CHARSET_FAMILY &&
852 dataInfo.dataFormat[0]==0x54 && /* dataFormat="Test". The values are set for test.dat*/
853 dataInfo.dataFormat[1]==0x65 &&
854 dataInfo.dataFormat[2]==0x73 &&
855 dataInfo.dataFormat[3]==0x74 &&
856 dataInfo.formatVersion[0]==1 && /*formatVersion is also set to the one for test*/
857 dataInfo.dataVersion[0]==1 && /*dataVersion*/
858 dataInfo.dataVersion[1]==0 )
859 {
860 log_verbose("PASS: udata_getInfo() filled in the right values\n");
861 } else {
862 log_err("FAIL: udata_getInfo() filled in the wrong values\n");
863 }
864 udata_close(result);
865 }
866
TestUDataGetMemory()867 static void TestUDataGetMemory() {
868
869 UDataMemory *result;
870 const int32_t *table=NULL;
871 uint16_t* intValue=0;
872 UErrorCode status=U_ZERO_ERROR;
873 const char* name="cnvalias";
874 const char* type;
875
876 const char* name2="test";
877
878 const char* testPath = loadTestData(&status);
879 if(U_FAILURE(status)) {
880 log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status));
881 return;
882 }
883
884 type="icu";
885 log_verbose("Testing udata_getMemory() for \"cnvalias.icu\"\n");
886 result=udata_openChoice(NULL, type, name, isAcceptable1, NULL, &status);
887 if(U_FAILURE(status)){
888 log_data_err("FAIL: udata_openChoice() failed for name=%s, type=%s, \n errorcode=%s\n", name, type, myErrorName(status));
889 return;
890 }
891 table=(const int32_t *)udata_getMemory(result);
892
893 /* The alias table may list more converters than what's actually available now. [grhoten] */
894 if(ucnv_countAvailable() > table[1]) /*???*/
895 log_err("FAIL: udata_getMemory() failed ucnv_countAvailable returned = %d, expected = %d\n", ucnv_countAvailable(), table[1+2*(*table)]);
896
897 udata_close(result);
898
899 type="icu";
900 log_verbose("Testing udata_getMemory for \"test.icu\"()\n");
901 result=udata_openChoice(testPath, type, name2, isAcceptable3, NULL, &status);
902 if(U_FAILURE(status)){
903 log_data_err("FAIL: udata_openChoice() failed for path=%s name=%s, type=%s, \n errorcode=%s\n", testPath, name2, type, myErrorName(status));
904 return;
905 }
906 intValue=(uint16_t *)udata_getMemory(result);
907 /*printf("%d ..... %s", *(intValue), intValue+1));*/
908 if( *intValue != 2000 || strcmp((char*)(intValue+1), "YEAR") != 0 )
909 log_err("FAIL: udata_getMemory() failed: intValue :- Expected:2000 Got:%d \n\tstringValue:- Expected:YEAR Got:%s\n", *intValue, (intValue+1));
910
911 udata_close(result);
912
913 }
914
TestErrorConditions()915 static void TestErrorConditions(){
916
917 UDataMemory *result=NULL;
918 UErrorCode status=U_ZERO_ERROR;
919 uint16_t* intValue=0;
920 static UDataInfo dataInfo={
921 30, /*sizeof(UDataInfo),*/
922 0,
923
924 U_IS_BIG_ENDIAN,
925 U_CHARSET_FAMILY,
926 sizeof(UChar),
927 0,
928
929 {0x54, 0x65, 0x73, 0x74}, /* dataFormat="Test" */
930 {9, 0, 0, 0}, /* formatVersion */
931 {4, 0, 0, 0} /* dataVersion */
932 };
933
934 const char* name = "test";
935 const char* type="icu";
936
937 const char *testPath = loadTestData(&status);
938 if(U_FAILURE(status)) {
939 log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status));
940 return;
941 }
942
943 status = U_ILLEGAL_ARGUMENT_ERROR;
944 /*Try udata_open with status != U_ZERO_ERROR*/
945 log_verbose("Testing udata_open() with status != U_ZERO_ERROR\n");
946 result=udata_open(testPath, type, name, &status);
947 if(result != NULL){
948 log_data_err("FAIL: udata_open() is supposed to fail for path = %s, name=%s, type=%s, \n errorcode !=U_ZERO_ERROR\n", testPath, name, type);
949 udata_close(result);
950
951 } else {
952 log_verbose("PASS: udata_open with errorCode != U_ZERO_ERROR failed as expected\n");
953 }
954
955 /*Try udata_open with data name=NULL*/
956 log_verbose("Testing udata_open() with data name=NULL\n");
957 status=U_ZERO_ERROR;
958 result=udata_open(testPath, type, NULL, &status);
959 if(U_FAILURE(status)){
960 if(status != U_ILLEGAL_ARGUMENT_ERROR || result != NULL){
961 log_err("FAIL: udata_open() with name=NULL should return NULL and errocode U_ILLEGAL_ARGUMENT_ERROR, GOT: errorcode=%s\n", myErrorName(status));
962 }else{
963 log_verbose("PASS: udata_open with name=NULL failed as expected and errorcode = %s as expected\n", myErrorName(status));
964 }
965 }else{
966 log_err("FAIL: udata_open() with data name=NULL is supposed to fail for path = %s, name=NULL type=%s errorcode=U_ZERO_ERROR \n", testPath, type);
967 udata_close(result);
968 }
969
970
971 /*Try udata_openChoice with status != U_ZERO_ERROR*/
972 log_verbose("Testing udata_openChoice() with status != U_ZERO_ERROR\n");
973 status=U_ILLEGAL_ARGUMENT_ERROR;
974 result=udata_openChoice(testPath, type, name, isAcceptable3, NULL, &status);
975 if(result != NULL){
976 log_err("FAIL: udata_openChoice() is supposed to fail for path = %s, name=%s, type=%s, \n errorcode != U_ZERO_ERROR\n", testPath, name, type);
977 udata_close(result);
978 } else {
979 log_verbose("PASS: udata_openChoice() with errorCode != U_ZERO_ERROR failed as expected\n");
980 }
981
982 /*Try udata_open with data name=NULL*/
983 log_verbose("Testing udata_openChoice() with data name=NULL\n");
984 status=U_ZERO_ERROR;
985 result=udata_openChoice(testPath, type, NULL, isAcceptable3, NULL, &status);
986 if(U_FAILURE(status)){
987 if(status != U_ILLEGAL_ARGUMENT_ERROR || result != NULL){
988 log_err("FAIL: udata_openChoice() with name=NULL should return NULL and errocode U_ILLEGAL_ARGUMENT_ERROR, GOT: errorcode=%s\n", myErrorName(status));
989 }else{
990 log_verbose("PASS: udata_openChoice with name=NULL failed as expected and errorcode = %s as expected\n", myErrorName(status));
991 }
992 }else{
993 log_err("FAIL: udata_openChoice() with data name=NULL is supposed to fail for path = %s, name=NULL type=%s errorcode=U_ZERO_ERROR \n", testPath, type);
994 udata_close(result);
995 }
996
997 /*Try udata_getMemory with UDataMemory=NULL*/
998 log_verbose("Testing udata_getMemory with UDataMemory=NULL\n");
999 intValue=(uint16_t*)udata_getMemory(NULL);
1000 if(intValue != NULL){
1001 log_err("FAIL: udata_getMemory with UDataMemory = NULL is supposed to fail\n");
1002 }
1003
1004 /*Try udata_getInfo with UDataMemory=NULL*/
1005 status=U_ZERO_ERROR;
1006 udata_getInfo(NULL, &dataInfo);
1007 if(dataInfo.size != 0){
1008 log_err("FAIL : udata_getInfo with UDataMemory = NULL us supposed to fail\n");
1009 }
1010
1011 /*Try udata_openChoice with a non existing binary file*/
1012 log_verbose("Testing udata_openChoice() with a non existing binary file\n");
1013 result=udata_openChoice(testPath, "tst", "nonexist", isAcceptable3, NULL, &status);
1014 if(status==U_FILE_ACCESS_ERROR){
1015 log_verbose("Opening udata_openChoice with non-existing file handled correctly.\n");
1016 status=U_ZERO_ERROR;
1017 } else {
1018 log_err("calling udata_open with non-existing file not handled correctly\n. Expected: U_FILE_ACCESS_ERROR, Got: %s\n", myErrorName(status));
1019 if(U_SUCCESS(status)) {
1020 udata_close(result);
1021 }
1022 }
1023
1024 if(result != NULL){
1025 log_err("calling udata_open with non-existing file didn't return a null value\n");
1026 } else {
1027 log_verbose("calling udat_open with non-existing file returned null as expected\n");
1028 }
1029 }
1030
1031 /* Test whether apps and ICU can each have their own root.res */
TestAppData()1032 static void TestAppData()
1033 {
1034 UResourceBundle *icu, *app;
1035 UResourceBundle *tmp = NULL;
1036 UResourceBundle *tmp2 = NULL;
1037
1038 const UChar *appString;
1039 const UChar *icuString;
1040
1041 int32_t len;
1042
1043 UErrorCode status = U_ZERO_ERROR;
1044 char testMsgBuf[256];
1045
1046 const char* testPath=loadTestData(&status);
1047 if(U_FAILURE(status)) {
1048 log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status));
1049 return;
1050 }
1051
1052 icu = ures_open(NULL, "root", &status);
1053 if(U_FAILURE(status))
1054 {
1055 log_data_err("%s:%d: Couldn't open root ICU bundle- %s", __FILE__, __LINE__, u_errorName(status));
1056 return;
1057 }
1058 /* log_info("Open icu root: %s size_%d\n", u_errorName(status), ures_getSize(icu)); */
1059 status = U_ZERO_ERROR;
1060
1061 app = ures_open(testPath, "root", &status);
1062 if(U_FAILURE(status))
1063 {
1064 log_data_err("%s:%d: Couldn't open app ICU bundle [%s]- %s", __FILE__, __LINE__, testPath, u_errorName(status));
1065 return;
1066 }
1067 /* log_info("Open app: %s, size %d\n", u_errorName(status), ures_getSize(app)); */
1068
1069 tmp = ures_getByKey(icu, "Version", tmp, &status);
1070 if(U_FAILURE(status))
1071 {
1072 log_err("%s:%d: Couldn't get Version string from ICU root bundle- %s", __FILE__, __LINE__, u_errorName(status));
1073 return;
1074 }
1075
1076 icuString = ures_getString(tmp, &len, &status);
1077 if(U_FAILURE(status))
1078 {
1079 log_err("%s:%d: Couldn't get string from Version string from ICU root bundle- %s", __FILE__, __LINE__, u_errorName(status));
1080 return;
1081 }
1082 /* log_info("icuString=%p - %s\n", icuString, austrdup(icuString)); */
1083
1084
1085 tmp2 = ures_getByKey(app, "Version", tmp2, &status);
1086 if(U_FAILURE(status))
1087 {
1088 log_err("%s:%d: Couldn't get Version string from App root bundle- %s", __FILE__, __LINE__, u_errorName(status));
1089 return;
1090 }
1091
1092 appString = ures_getString(tmp2, &len, &status);
1093 if(U_FAILURE(status))
1094 {
1095 log_err("%s:%d: Couldn't get string from Version string from App root bundle- %s", __FILE__, __LINE__, u_errorName(status));
1096 return;
1097 }
1098
1099 /* log_info("appString=%p - %s\n", appString, austrdup(appString)); */
1100
1101
1102 if(!u_strcmp(icuString, appString))
1103 {
1104 log_err("%s:%d: Error! Expected ICU and App root version strings to be DIFFERENT but they are both %s and %s\n", __FILE__, __LINE__, austrdup(icuString),
1105 austrdup(appString));
1106 }
1107 else
1108 {
1109 log_verbose("%s:%d: appstr=%s, icustr=%s\n", __FILE__,
1110 __LINE__, u_austrcpy(testMsgBuf, appString), u_austrcpy(testMsgBuf, icuString));
1111 }
1112
1113 ures_close(tmp);
1114 ures_close(tmp2);
1115 ures_close(icu);
1116 ures_close(app);
1117 }
1118 #endif
1119
TestICUDataName()1120 static void TestICUDataName()
1121 {
1122 UVersionInfo icuVersion;
1123 char expectDataName[20];
1124 unsigned int expectLen = 8;
1125
1126 char typeChar = '?';
1127
1128 /* Print out the version # we have .. */
1129 log_verbose("utypes.h says U_ICUDATA_NAME = %s\n", U_ICUDATA_NAME);
1130
1131 /* Build up the version # we expect to get */
1132 u_getVersion(icuVersion);
1133
1134 switch(U_CHARSET_FAMILY)
1135 {
1136 case U_ASCII_FAMILY:
1137 switch((int)U_IS_BIG_ENDIAN)
1138 {
1139 case 1:
1140 typeChar = 'b';
1141 break;
1142 case 0:
1143 typeChar = 'l';
1144 break;
1145 default:
1146 log_err("Expected 1 or 0 for U_IS_BIG_ENDIAN, got %d!\n", (int)U_IS_BIG_ENDIAN);
1147 /* return; */
1148 }
1149 break;
1150 case U_EBCDIC_FAMILY:
1151 typeChar = 'e';
1152 break;
1153 }
1154
1155 /* Only major number is needed. */
1156 sprintf(expectDataName, "%s%d%c",
1157 "icudt",
1158 (int)icuVersion[0],
1159 typeChar);
1160
1161 log_verbose("Expected: %s\n", expectDataName);
1162 if(uprv_strlen(expectDataName) != expectLen)
1163 {
1164 log_err("*Expected* length is wrong (test err?), should be %d is %d\n",
1165 expectLen, uprv_strlen(expectDataName));
1166 }
1167
1168 if(uprv_strlen(U_ICUDATA_NAME) != expectLen)
1169 {
1170 log_err("U_ICUDATA_NAME length should be %d is %d\n",
1171 expectLen, uprv_strlen(U_ICUDATA_NAME));
1172 }
1173
1174 if(uprv_strcmp(U_ICUDATA_NAME, expectDataName))
1175 {
1176 log_err("U_ICUDATA_NAME should be %s but is %s\n",
1177 expectDataName, U_ICUDATA_NAME);
1178 }
1179
1180 /* ICUDATA_NAME comes from the build system on *nix */
1181 #ifdef ICUDATA_NAME
1182 if(uprv_strcmp(U_ICUDATA_NAME, ICUDATA_NAME))
1183 {
1184 log_err("ICUDATA_NAME and U_ICUDATA_NAME don't match: "
1185 "ICUDATA_NAME=%s, U_ICUDATA_NAME=%s. Check configure.in, icudefs.mk.in, utypes.h...\n", ICUDATA_NAME, U_ICUDATA_NAME);
1186 }
1187 else
1188 {
1189 log_verbose("ICUDATA_NAME=%s (from icudefs.mk), U_ICUDATA_NAME=%s (from utypes.h)\n", ICUDATA_NAME, U_ICUDATA_NAME);
1190 }
1191 #endif
1192
1193 }
1194
1195 /* test data swapping ------------------------------------------------------- */
1196
1197 #if U_PLATFORM == U_PF_OS400
1198 /* See comments in genccode.c on when this special implementation can be removed. */
1199 static const struct {
1200 double bogus;
1201 const char *bytes;
1202 } gOffsetTOCAppDataItem1={ 0.0, /* alignment bytes */
1203 "\x00\x14" /* sizeof(UDataInfo) *//* MappedData { */
1204 "\xda"
1205 "\x27" /* } */
1206 "\x00\x14" /* sizeof(UDataInfo) *//* UDataInfo { */
1207 "\0\0"
1208 "\1" /* U_IS_BIG_ENDIAN */
1209 "\1" /* U_CHARSET_FAMILY */
1210 "\2" /* U_SIZEOF_WHAR_T */
1211 "\0"
1212 "\x31\x31\x31\x31"
1213 "\0\0\0\0"
1214 "\0\0\0\0" /* } */
1215 };
1216 #else
1217 static const struct {
1218 double bogus;
1219 MappedData bytes1;
1220 UDataInfo bytes2;
1221 uint8_t bytes3;
1222 } gOffsetTOCAppDataItem1={
1223 0.0, /* alignment bytes */
1224 { sizeof(UDataInfo), 0xda, 0x27 }, /* MappedData */
1225
1226 {sizeof(UDataInfo),
1227 0,
1228
1229 U_IS_BIG_ENDIAN,
1230 U_CHARSET_FAMILY,
1231 sizeof(UChar),
1232 0,
1233
1234 {0x31, 0x31, 0x31, 0x31}, /* dataFormat="1111" */
1235 {0, 0, 0, 0}, /* formatVersion */
1236 {0, 0, 0, 0}} /* dataVersion */
1237 };
1238 #endif
1239
1240 static const UChar gOffsetTOCGarbage[] = { /* "I have been very naughty!" */
1241 0x49, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x62, 0x65, 0x65, 0x6E,
1242 0x20, 0x76, 0x65, 0x72, 0x79, 0x20, 0x6E, 0x61, 0x75, 0x67, 0x68, 0x74, 0x79, 0x21
1243 };
1244
1245 /* Original source: icu/source/tools/genccode */
1246 static const struct {
1247 uint16_t headerSize;
1248 uint8_t magic1, magic2;
1249 UDataInfo info;
1250 char padding[8];
1251 uint32_t count, reserved;
1252 const struct {
1253 const char *const name;
1254 const void *const data;
1255 } toc[3];
1256 } gOffsetTOCAppData_dat = {
1257 32, /* headerSize */
1258 0xda, /* magic1, (see struct MappedData in udata.c) */
1259 0x27, /* magic2 */
1260 { /*UDataInfo */
1261 sizeof(UDataInfo), /* size */
1262 0, /* reserved */
1263 U_IS_BIG_ENDIAN,
1264 U_CHARSET_FAMILY,
1265 sizeof(UChar),
1266 0, /* reserved */
1267 { /* data format identifier */
1268 0x54, 0x6f, 0x43, 0x50}, /* "ToCP" */
1269 {1, 0, 0, 0}, /* format version major, minor, milli, micro */
1270 {0, 0, 0, 0} /* dataVersion */
1271 },
1272 {0,0,0,0,0,0,0,0}, /* Padding[8] */
1273 3, /* count */
1274 0, /* Reserved */
1275 { /* TOC structure */
1276 { "OffsetTOCAppData/a/b", &gOffsetTOCAppDataItem1 },
1277 { "OffsetTOCAppData/gOffsetTOCAppDataItem1", &gOffsetTOCAppDataItem1 },
1278 { "OffsetTOCAppData/gOffsetTOCGarbage", &gOffsetTOCGarbage }
1279 }
1280 };
1281
1282 /* Unfortunately, dictionaries are in a C++ header */
1283 U_CAPI int32_t U_EXPORT2
1284 udict_swap(const UDataSwapper *ds, const void *inData, int32_t length, void *outData, UErrorCode *pErrorCode);
1285
1286 /* test cases for maximum data swapping code coverage */
1287 static const struct {
1288 const char *name, *type;
1289 UDataSwapFn *swapFn;
1290 } swapCases[]={
1291 /* resource bundles */
1292
1293 /* resource bundle with many data types */
1294 {"*testtypes", "res", ures_swap},
1295 /* resource bundle with collation data */
1296 {"ja", "res", ures_swap},
1297 /* resource bundle with options-only collation data */
1298 {"ru", "res", ures_swap},
1299 {"el", "res", ures_swap},
1300 /* ICU's root */
1301 {"root", "res", ures_swap},
1302 /* Test a 32-bit key table. This is large. */
1303 {"*testtable32", "res", ures_swap},
1304
1305 /* ICU 4.2 resource bundle - data format 1.2 (little-endian ASCII) */
1306 {"*old_l_testtypes", "res", ures_swap},
1307 /* same for big-endian EBCDIC */
1308 {"*old_e_testtypes", "res", ures_swap},
1309
1310 #if !UCONFIG_NO_COLLATION
1311 /* standalone collation data files */
1312 {"ucadata", "icu", ucol_swap},
1313 #if 0
1314 /* Starting with ICU 53, the "inverse UCA" data is integrated into ucadata.icu. */
1315 {"invuca", "icu", ucol_swapInverseUCA},
1316 #endif
1317 #endif
1318
1319 #if !UCONFIG_NO_LEGACY_CONVERSION
1320 /* conversion table files */
1321
1322 /* SBCS conversion table file without extension */
1323 {"ibm-913_P100-2000", "cnv", ucnv_swap},
1324 /* EBCDIC_STATEFUL conversion table file with extension */
1325 {"ibm-1390_P110-2003", "cnv", ucnv_swap},
1326 /* DBCS extension-only conversion table file */
1327 {"ibm-16684_P110-2003", "cnv", ucnv_swap},
1328 /* EUC-TW (3-byte) conversion table file without extension */
1329 {"ibm-964_P110-1999", "cnv", ucnv_swap},
1330 /* GB 18030 (4-byte) conversion table file without extension */
1331 {"gb18030", "cnv", ucnv_swap},
1332 /* MBCS conversion table file with extension */
1333 {"*test4x", "cnv", ucnv_swap},
1334 /*
1335 * MBCS conversion table file without extension,
1336 * to test swapping and preflighting of UTF-8-friendly mbcsIndex[].
1337 */
1338 {"jisx-212", "cnv", ucnv_swap},
1339 #endif
1340
1341 #if !UCONFIG_NO_CONVERSION
1342 /* alias table */
1343 {"cnvalias", "icu", ucnv_swapAliases},
1344 #endif
1345
1346 #if !UCONFIG_NO_IDNA
1347 {"rfc3491", "spp", usprep_swap},
1348 #endif
1349
1350 #if !UCONFIG_NO_BREAK_ITERATION
1351 {"char", "brk", ubrk_swap},
1352 {"thaidict", "dict",udict_swap},
1353 #endif
1354
1355 #if 0
1356 /*
1357 * Starting with ICU 4.8, the Unicode property (value) aliases data
1358 * is hardcoded in the ICU4C common library.
1359 * The swapper was moved to the toolutil library for swapping for ICU4J.
1360 */
1361 /* Unicode properties */
1362 {"pnames", "icu", upname_swap},
1363 #endif
1364
1365 #if 0
1366 /*
1367 * Starting with ICU4C 3.4, the core Unicode properties files
1368 * (uprops.icu, ucase.icu, ubidi.icu, unorm.icu)
1369 * are hardcoded in the common DLL and therefore not included
1370 * in the data package any more.
1371 * Their swapping code is moved from the common DLL to the icuswap tool so that
1372 * we need not jump through hoops (like adding snapshots of these files
1373 * to testdata) for code coverage in tests.
1374 * See Jitterbug 4497.
1375 *
1376 * ICU4C 4.4 adds normalization data files again, e.g., nfkc.nrm.
1377 */
1378 {"uprops", "icu", uprops_swap},
1379 {"ucase", "icu", ucase_swap},
1380 {"ubidi", "icu", ubidi_swap},
1381 #endif
1382 #if !UCONFIG_NO_NORMALIZATION && !UCONFIG_ONLY_COLLATION
1383 {"nfkc", "nrm", unorm2_swap},
1384 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
1385 {"confusables", "cfu", uspoof_swap}, /* spoof data missing without regex */
1386 #endif
1387
1388 #endif
1389 {"unames", "icu", uchar_swapNames}
1390 /* the last item should not be #if'ed so that it can reliably omit the last comma */
1391 };
1392
1393 /* Large enough for the largest swappable data item. */
1394 #define SWAP_BUFFER_SIZE 1800000
1395
1396 static void U_CALLCONV
printError(void * context,const char * fmt,va_list args)1397 printError(void *context, const char *fmt, va_list args) {
1398 vlog_info("[swap] ", fmt, args);
1399 log_err("\n"); /* Register error */
1400 }
1401
1402 static void
TestSwapCase(UDataMemory * pData,const char * name,UDataSwapFn * swapFn,uint8_t * buffer,uint8_t * buffer2)1403 TestSwapCase(UDataMemory *pData, const char *name,
1404 UDataSwapFn *swapFn,
1405 uint8_t *buffer, uint8_t *buffer2) {
1406 UDataSwapper *ds;
1407 const void *inData, *inHeader;
1408 int32_t length, dataLength, length2, headerLength;
1409
1410 UErrorCode errorCode;
1411 UErrorCode badStatus;
1412
1413 UBool inEndian, oppositeEndian;
1414 uint8_t inCharset, oppositeCharset;
1415
1416 /* First we check that swapFn handles failures as expected. */
1417 errorCode = U_UNSUPPORTED_ERROR;
1418 length = swapFn(NULL, NULL, 0, buffer, &errorCode);
1419 if (length != 0 || errorCode != U_UNSUPPORTED_ERROR) {
1420 log_err("%s() did not fail as expected - %s\n", name, u_errorName(errorCode));
1421 }
1422 errorCode = U_ZERO_ERROR;
1423 length = swapFn(NULL, NULL, 0, buffer, &errorCode);
1424 if (length != 0 || errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
1425 log_err("%s() did not fail as expected with bad arguments - %s\n", name, u_errorName(errorCode));
1426 }
1427
1428
1429 /* Continue with the rest of the tests. */
1430 errorCode = U_ZERO_ERROR;
1431 inData=udata_getMemory(pData);
1432
1433 /*
1434 * get the data length if possible, to verify that swapping and preflighting
1435 * handles the entire data
1436 */
1437 dataLength=udata_getLength(pData);
1438
1439 /*
1440 * get the header and its length
1441 * all of the swap implementation functions require the header to be included
1442 */
1443 inHeader=udata_getRawMemory(pData);
1444 headerLength=(int32_t)((const char *)inData-(const char *)inHeader);
1445
1446 /* first swap to opposite endianness but same charset family */
1447 errorCode=U_ZERO_ERROR;
1448 ds=udata_openSwapperForInputData(inHeader, headerLength,
1449 !U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, &errorCode);
1450 if(U_FAILURE(errorCode)) {
1451 log_err("udata_openSwapperForInputData(%s->!isBig+same charset) failed - %s\n",
1452 name, u_errorName(errorCode));
1453 return;
1454 }
1455
1456 inEndian=ds->inIsBigEndian;
1457 inCharset=ds->inCharset;
1458
1459 oppositeEndian=!inEndian;
1460 oppositeCharset= inCharset==U_ASCII_FAMILY ? U_EBCDIC_FAMILY : U_ASCII_FAMILY;
1461
1462 /* make this test work with data files that are built for a different platform */
1463 if(inEndian!=U_IS_BIG_ENDIAN || inCharset!=U_CHARSET_FAMILY) {
1464 udata_closeSwapper(ds);
1465 ds=udata_openSwapper(inEndian, inCharset, oppositeEndian, inCharset, &errorCode);
1466 if(U_FAILURE(errorCode)) {
1467 log_err("udata_openSwapper(%s->!isBig+same charset) failed - %s\n",
1468 name, u_errorName(errorCode));
1469 return;
1470 }
1471 }
1472
1473 /*
1474 Check error checking of swappable data not specific to this swapper.
1475 This should always fail.
1476 */
1477 badStatus = U_ZERO_ERROR;
1478 length=swapFn(ds, &gOffsetTOCAppData_dat, -1, NULL, &badStatus);
1479 if(badStatus != U_UNSUPPORTED_ERROR) {
1480 log_err("swapFn(%s->!isBig+same charset) unexpectedly succeeded on bad data - %s\n",
1481 name, u_errorName(errorCode));
1482 udata_closeSwapper(ds);
1483 return;
1484 }
1485
1486 /* Now allow errors to be printed */
1487 ds->printError=printError;
1488
1489 /* preflight the length */
1490 length=swapFn(ds, inHeader, -1, NULL, &errorCode);
1491 if(U_FAILURE(errorCode)) {
1492 log_err("swapFn(preflight %s->!isBig+same charset) failed - %s\n",
1493 name, u_errorName(errorCode));
1494 udata_closeSwapper(ds);
1495 return;
1496 }
1497
1498 /* compare the preflighted length against the data length */
1499 if(dataLength>=0 && (length+15)<(headerLength+dataLength)) {
1500 log_err("swapFn(preflight %s->!isBig+same charset) length too small: %d < data length %d\n",
1501 name, length, (headerLength+dataLength));
1502 udata_closeSwapper(ds);
1503 return;
1504 }
1505
1506 /* swap, not in-place */
1507 length2=swapFn(ds, inHeader, length, buffer, &errorCode);
1508 udata_closeSwapper(ds);
1509 if(U_FAILURE(errorCode)) {
1510 log_err("swapFn(%s->!isBig+same charset) failed - %s\n",
1511 name, u_errorName(errorCode));
1512 return;
1513 }
1514
1515 /* compare the swap length against the preflighted length */
1516 if(length2!=length) {
1517 log_err("swapFn(%s->!isBig+same charset) length differs from preflighting: %d != preflighted %d\n",
1518 name, length2, length);
1519 return;
1520 }
1521
1522 /* next swap to opposite charset family */
1523 ds=udata_openSwapper(oppositeEndian, inCharset,
1524 oppositeEndian, oppositeCharset,
1525 &errorCode);
1526 if(U_FAILURE(errorCode)) {
1527 log_err("udata_openSwapper(%s->!isBig+other charset) failed - %s\n",
1528 name, u_errorName(errorCode));
1529 return;
1530 }
1531 ds->printError=printError;
1532
1533 /* swap in-place */
1534 length2=swapFn(ds, buffer, length, buffer, &errorCode);
1535 udata_closeSwapper(ds);
1536 if(U_FAILURE(errorCode)) {
1537 log_err("swapFn(%s->!isBig+other charset) failed - %s\n",
1538 name, u_errorName(errorCode));
1539 return;
1540 }
1541
1542 /* compare the swap length against the original length */
1543 if(length2!=length) {
1544 log_err("swapFn(%s->!isBig+other charset) length differs from original: %d != original %d\n",
1545 name, length2, length);
1546 return;
1547 }
1548
1549 /* finally swap to original platform values */
1550 ds=udata_openSwapper(oppositeEndian, oppositeCharset,
1551 inEndian, inCharset,
1552 &errorCode);
1553 if(U_FAILURE(errorCode)) {
1554 log_err("udata_openSwapper(%s->back to original) failed - %s\n",
1555 name, u_errorName(errorCode));
1556 return;
1557 }
1558 ds->printError=printError;
1559
1560 /* swap, not in-place */
1561 length2=swapFn(ds, buffer, length, buffer2, &errorCode);
1562 udata_closeSwapper(ds);
1563 if(U_FAILURE(errorCode)) {
1564 log_err("swapFn(%s->back to original) failed - %s\n",
1565 name, u_errorName(errorCode));
1566 return;
1567 }
1568
1569 /* compare the swap length against the original length */
1570 if(length2!=length) {
1571 log_err("swapFn(%s->back to original) length differs from original: %d != original %d\n",
1572 name, length2, length);
1573 return;
1574 }
1575
1576 /* compare the final contents with the original */
1577 if(0!=uprv_memcmp(inHeader, buffer2, length)) {
1578 const uint8_t *original;
1579 uint8_t diff[8];
1580 int32_t i, j;
1581
1582 log_err("swapFn(%s->back to original) contents differs from original\n",
1583 name);
1584
1585 /* find the first difference */
1586 original=(const uint8_t *)inHeader;
1587 for(i=0; i<length && original[i]==buffer2[i]; ++i) {}
1588
1589 /* find the next byte that is the same */
1590 for(j=i+1; j<length && original[j]!=buffer2[j]; ++j) {}
1591 log_info(" difference at index %d=0x%x, until index %d=0x%x\n", i, i, j, j);
1592
1593 /* round down to the last 4-boundary for better result output */
1594 i&=~3;
1595 log_info("showing bytes from index %d=0x%x (length %d=0x%x):\n", i, i, length, length);
1596
1597 /* print 8 bytes but limit to the buffer contents */
1598 length2=i+sizeof(diff);
1599 if(length2>length) {
1600 length2=length;
1601 }
1602
1603 /* print the original bytes */
1604 uprv_memset(diff, 0, sizeof(diff));
1605 for(j=i; j<length2; ++j) {
1606 diff[j-i]=original[j];
1607 }
1608 log_info(" original: %02x %02x %02x %02x %02x %02x %02x %02x\n",
1609 diff[0], diff[1], diff[2], diff[3], diff[4], diff[5], diff[6], diff[7]);
1610
1611 /* print the swapped bytes */
1612 uprv_memset(diff, 0, sizeof(diff));
1613 for(j=i; j<length2; ++j) {
1614 diff[j-i]=buffer2[j];
1615 }
1616 log_info(" swapped: %02x %02x %02x %02x %02x %02x %02x %02x\n",
1617 diff[0], diff[1], diff[2], diff[3], diff[4], diff[5], diff[6], diff[7]);
1618 }
1619 }
1620
1621 static void U_CALLCONV
printErrorToString(void * context,const char * fmt,va_list args)1622 printErrorToString(void *context, const char *fmt, va_list args) {
1623 vsprintf((char *)context, fmt, args);
1624 }
1625
1626 #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
1627 static void
TestSwapData()1628 TestSwapData() {
1629 char name[100];
1630 UDataSwapper *ds;
1631 UDataMemory *pData;
1632 uint8_t *buffer;
1633 const char *pkg, *nm, *testPath;
1634 UErrorCode errorCode = U_ZERO_ERROR;
1635 int32_t i;
1636
1637 buffer=(uint8_t *)malloc(2*SWAP_BUFFER_SIZE);
1638 if(buffer==NULL) {
1639 log_err("unable to allocate %d bytes\n", 2*SWAP_BUFFER_SIZE);
1640 return;
1641 }
1642
1643 testPath=loadTestData(&errorCode);
1644 if(U_FAILURE(errorCode)) {
1645 log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(errorCode));
1646 }
1647
1648 /* Test that printError works as expected. */
1649 errorCode=U_USELESS_COLLATOR_ERROR;
1650 ds=udata_openSwapper(U_IS_BIG_ENDIAN, U_ASCII_FAMILY,
1651 !U_IS_BIG_ENDIAN, U_ASCII_FAMILY,
1652 &errorCode);
1653 if (ds != NULL || errorCode != U_USELESS_COLLATOR_ERROR) {
1654 log_err("udata_openSwapper should have returned NULL with bad argument\n", name);
1655 }
1656 errorCode=U_ZERO_ERROR;
1657 ds=udata_openSwapper(U_IS_BIG_ENDIAN, U_ASCII_FAMILY,
1658 !U_IS_BIG_ENDIAN, U_ASCII_FAMILY,
1659 &errorCode);
1660 ds->printError=printErrorToString;
1661 ds->printErrorContext=name;
1662 udata_printError(ds, "This %s a %s", "is", "test");
1663 udata_closeSwapper(ds);
1664 if (strcmp(name, "This is a test") != 0) {
1665 log_err("udata_printError can't properly print error messages. Got = %s\n", name);
1666 }
1667 errorCode = U_USELESS_COLLATOR_ERROR;
1668 ds=udata_openSwapperForInputData(NULL, 0,
1669 !U_IS_BIG_ENDIAN, U_ASCII_FAMILY,
1670 &errorCode);
1671 if (ds != NULL || errorCode != U_USELESS_COLLATOR_ERROR) {
1672 log_err("udata_openSwapperForInputData should have returned NULL with bad argument\n", name);
1673 }
1674 errorCode=U_ZERO_ERROR;
1675 ds=udata_openSwapperForInputData(NULL, 0,
1676 !U_IS_BIG_ENDIAN, U_ASCII_FAMILY,
1677 &errorCode);
1678 if (ds != NULL || errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
1679 log_err("udata_openSwapperForInputData should have returned NULL with bad argument\n", name);
1680 }
1681 errorCode=U_ZERO_ERROR;
1682 memset(buffer, 0, sizeof(2*SWAP_BUFFER_SIZE));
1683 ds=udata_openSwapperForInputData(buffer, 2*SWAP_BUFFER_SIZE,
1684 !U_IS_BIG_ENDIAN, U_ASCII_FAMILY,
1685 &errorCode);
1686 if (ds != NULL || errorCode != U_UNSUPPORTED_ERROR) {
1687 log_err("udata_openSwapperForInputData should have returned NULL with bad argument\n", name);
1688 }
1689 errorCode=U_ZERO_ERROR;
1690
1691 /* Test argument checking. ucol_swap is normally tested via ures_swap, and isn't normally called directly. */
1692 #if !UCONFIG_NO_COLLATION
1693 ucol_swap(NULL, NULL, -1, NULL, &errorCode);
1694 if (errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
1695 log_err("ucol_swap did not fail as expected\n", name);
1696 }
1697 errorCode=U_ZERO_ERROR;
1698 #endif
1699
1700 for(i=0; i<UPRV_LENGTHOF(swapCases); ++i) {
1701 /* build the name for logging */
1702 errorCode=U_ZERO_ERROR;
1703 if(swapCases[i].name[0]=='*') {
1704 pkg=testPath;
1705 nm=swapCases[i].name+1;
1706 uprv_strcpy(name, "testdata");
1707 } else if (uprv_strcmp(swapCases[i].type, "brk")==0
1708 || uprv_strcmp(swapCases[i].type, "dict")==0) {
1709 pkg=U_ICUDATA_BRKITR;
1710 nm=swapCases[i].name;
1711 uprv_strcpy(name, U_ICUDATA_BRKITR);
1712 #if !UCONFIG_NO_COLLATION
1713 } else if (uprv_strcmp(swapCases[i].name, "ucadata")==0
1714 || uprv_strcmp(swapCases[i].name, "invuca")==0) {
1715 pkg=U_ICUDATA_COLL;
1716 nm=swapCases[i].name;
1717 uprv_strcpy(name, U_ICUDATA_COLL);
1718 #endif /* !UCONFIG_NO_COLLATION */
1719 } else {
1720 pkg=NULL;
1721 nm=swapCases[i].name;
1722 uprv_strcpy(name, "NULL");
1723 }
1724 uprv_strcat(name, "/");
1725 uprv_strcat(name, nm);
1726 uprv_strcat(name, ".");
1727 uprv_strcat(name, swapCases[i].type);
1728
1729 pData=udata_open(pkg, swapCases[i].type, nm, &errorCode);
1730
1731 if(U_SUCCESS(errorCode)) {
1732 TestSwapCase(pData, name, swapCases[i].swapFn, buffer, buffer+SWAP_BUFFER_SIZE);
1733 udata_close(pData);
1734 } else {
1735 log_data_err("udata_open(%s) failed - %s\n",
1736 name, u_errorName(errorCode));
1737 }
1738 }
1739
1740 free(buffer);
1741 }
1742 #endif
1743
PointerTableOfContents()1744 static void PointerTableOfContents() {
1745 UDataMemory *dataItem;
1746 UErrorCode status=U_ZERO_ERROR;
1747
1748 /*
1749 * Got testdata.dat into memory, now we try setAppData using the memory image.
1750 */
1751
1752 status=U_ZERO_ERROR;
1753 udata_setAppData("OffsetTOCAppData", &gOffsetTOCAppData_dat, &status);
1754 if (status != U_ZERO_ERROR) {
1755 log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData1\", fileBuf, status) \n"
1756 " returned status of %s\n", u_errorName(status));
1757 return;
1758 }
1759
1760 dataItem = udata_open("OffsetTOCAppData", "", "gOffsetTOCAppDataItem1", &status);
1761 if (U_FAILURE(status)) {
1762 log_err("FAIL: gOffsetTOCAppDataItem1 could not be opened. status = %s\n", u_errorName(status));
1763 }
1764 if (udata_getMemory(dataItem) != NULL) {
1765 log_verbose("FAIL: udata_getMemory(dataItem) passed\n");
1766 }
1767 else {
1768 log_err("FAIL: udata_getMemory returned NULL\n", u_errorName(status));
1769 }
1770 udata_close(dataItem);
1771
1772 dataItem = udata_open("OffsetTOCAppData-a", "", "b", &status);
1773 if (U_FAILURE(status)) {
1774 log_err("FAIL: gOffsetTOCAppDataItem1 in tree \"a\" could not be opened. status = %s\n", u_errorName(status));
1775 }
1776 if (udata_getMemory(dataItem) != NULL) {
1777 log_verbose("FAIL: udata_getMemory(dataItem) in tree \"a\" passed\n");
1778 }
1779 else {
1780 log_err("FAIL: udata_getMemory returned NULL\n", u_errorName(status));
1781 }
1782 udata_close(dataItem);
1783
1784 dataItem = udata_open("OffsetTOCAppData", "", "gOffsetTOCGarbage", &status);
1785 if (U_SUCCESS(status)) {
1786 log_err("FAIL: gOffsetTOCGarbage should not be opened. status = %s\n", u_errorName(status));
1787 }
1788 dataItem = udata_open("OffsetTOCAppData", "", "gOffsetTOCNonExistent", &status);
1789 if (U_SUCCESS(status)) {
1790 log_err("FAIL: gOffsetTOCNonExistent should not be found. status = %s\n", u_errorName(status));
1791 }
1792
1793 }
1794
SetBadCommonData(void)1795 static void SetBadCommonData(void) {
1796 /* It's difficult to test that udata_setCommonData really works within the test framework.
1797 So we just test that foolish people can't do bad things. */
1798 UErrorCode status;
1799 char badBuffer[sizeof(gOffsetTOCAppData_dat)];
1800
1801 memset(badBuffer, 0, sizeof(badBuffer));
1802 strcpy(badBuffer, "Hello! I'm not good data.");
1803
1804 /* Check that we don't do anything */
1805 status = U_FILE_ACCESS_ERROR;
1806 udata_setCommonData(&gOffsetTOCAppData_dat, &status);
1807 if (status != U_FILE_ACCESS_ERROR) {
1808 log_err("FAIL: udata_setCommonData changed the failure code.\n");
1809 }
1810 /* Check that we fail correctly */
1811 status = U_ZERO_ERROR;
1812 udata_setCommonData(NULL, &status);
1813 if (status != U_ILLEGAL_ARGUMENT_ERROR) {
1814 log_err("FAIL: udata_setCommonData did not fail with bad arguments.\n");
1815 }
1816
1817 /* Check that we verify that the data isn't bad */
1818 status = U_ZERO_ERROR;
1819 udata_setAppData("invalid path", badBuffer, &status);
1820 if (status != U_INVALID_FORMAT_ERROR) {
1821 log_err("FAIL: udata_setAppData doesn't verify data validity.\n");
1822 }
1823 }
1824
1825 // Check the override loading of time zone .res files from a specified path
1826 //
1827 // Hand testing notes:
1828 // 1. Run this test with the environment variable set. The following should induce faiures:
1829 // ICU_TIMEZONE_FILES_DIR=../testdata/out/build LD_LIBRARY_PATH=../../lib:../../stubdata:../../tools/ctestfw:$LD_LIBRARY_PATH ./cintltst /udatatst/TestTZDataDir
1830 // 2. Build ICU with with U_TIMEZONE_FILES_DIR defined. This should also induce failures.
1831 // CPPFLAGS=-DU_TIMEZONE_FILES_DIR\=`pwd`/test/testdata/out/testdata ./runConfigureICU Linux
1832 // make check
1833
TestTZDataDir(void)1834 static void TestTZDataDir(void) {
1835 #if !UCONFIG_NO_FORMATTING
1836 UErrorCode status = U_ZERO_ERROR;
1837 const char *tzDataVersion;
1838 const char *testDataPath;
1839
1840 // Verify that default ICU time zone data version is something newer than 2014a.
1841 tzDataVersion = ucal_getTZDataVersion(&status);
1842 // printf("tz data version is %s\n", tzDataVersion);
1843 if (U_FAILURE(status)) {
1844 log_data_err("Failed call to ucal_getTZDataVersion - %s\n", u_errorName(status));
1845 return;
1846 } else if (strcmp("2014a", tzDataVersion) == 0) {
1847 log_err("File %s:%d - expected something newer than time zone data 2014a.\n", __FILE__, __LINE__, tzDataVersion);
1848 }
1849
1850 testDataPath = loadTestData(&status);
1851 // The path produced by loadTestData() will look something like
1852 // whatever/.../testdata/out/testdata
1853 // The test data puts an old (2014a) version of the time zone data there.
1854
1855 // Switch ICU to the testdata version of zoneinfo64.res, which is verison 2014a.
1856 ctest_resetICU();
1857 u_setTimeZoneFilesDirectory(testDataPath, &status);
1858 tzDataVersion = ucal_getTZDataVersion(&status);
1859 if (strcmp("2014a", tzDataVersion) != 0) {
1860 log_err("File %s:%d - expected \"2014a\"; actual \"%s\"\n", __FILE__, __LINE__, tzDataVersion);
1861 }
1862
1863 ctest_resetICU(); // Return ICU to using its standard tz data.
1864 tzDataVersion = ucal_getTZDataVersion(&status);
1865 // printf("tz data version is %s\n", tzDataVersion);
1866 if (strcmp("2014a", tzDataVersion) == 0) {
1867 log_err("File %s:%d - expected something newer than time zone data 2014a.\n", __FILE__, __LINE__, tzDataVersion);
1868 }
1869 #endif
1870 }
1871