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