Index: source/test/cintltst/udatatst.c |
diff --git a/source/test/cintltst/udatatst.c b/source/test/cintltst/udatatst.c |
deleted file mode 100644 |
index b0740dae1b32d972223ad102e0322cd3699887f1..0000000000000000000000000000000000000000 |
--- a/source/test/cintltst/udatatst.c |
+++ /dev/null |
@@ -1,1868 +0,0 @@ |
-/******************************************************************** |
- * COPYRIGHT: |
- * Copyright (c) 1998-2014, International Business Machines Corporation and |
- * others. All Rights Reserved. |
- ********************************************************************/ |
-/* |
-* File udatatst.c |
-* |
-* Modification History: |
-* |
-* Date Name Description |
-* 02/22/2000 Madhu Creation |
-****************************************************************************** |
-*/ |
- |
-#include "unicode/utypes.h" |
-#include "unicode/putil.h" |
-#include "unicode/udata.h" |
-#include "unicode/ucal.h" |
-#include "unicode/uchar.h" |
-#include "unicode/ucnv.h" |
-#include "unicode/ures.h" |
-#include "unicode/ustring.h" |
-#include "unicode/uclean.h" |
-#include "cmemory.h" |
-#include "cstring.h" |
-#include "filestrm.h" |
-#include "udatamem.h" |
-#include "cintltst.h" |
-#include "ubrkimpl.h" |
-#include "toolutil.h" /* for uprv_fileExists() */ |
-#include <stdlib.h> |
-#include <stdio.h> |
- |
-/* includes for TestSwapData() */ |
-#include "udataswp.h" |
- |
-/* swapping implementations in common */ |
-#include "uresdata.h" |
-#include "ucnv_io.h" |
-#include "uprops.h" |
-#include "ucase.h" |
-#include "ucol_imp.h" |
-#include "ucol_swp.h" |
-#include "ucnv_bld.h" |
-#include "sprpimpl.h" |
-#include "rbbidata.h" |
- |
-/* swapping implementation in i18n */ |
-#include "uspoof_impl.h" |
- |
-U_CAPI int32_t U_EXPORT2 |
-unorm2_swap(const UDataSwapper *ds, |
- const void *inData, int32_t length, void *outData, |
- UErrorCode *pErrorCode); |
- |
-/* other definitions and prototypes */ |
- |
-#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION |
-static void TestUDataOpen(void); |
-static void TestUDataOpenChoiceDemo1(void); |
-static void TestUDataOpenChoiceDemo2(void); |
-static void TestUDataGetInfo(void); |
-static void TestUDataGetMemory(void); |
-static void TestErrorConditions(void); |
-static void TestAppData(void); |
-static void TestSwapData(void); |
-#endif |
-static void TestUDataSetAppData(void); |
-static void TestICUDataName(void); |
-static void PointerTableOfContents(void); |
-static void SetBadCommonData(void); |
-static void TestUDataFileAccess(void); |
-#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION |
-static void TestTZDataDir(void); |
-#endif |
- |
-void addUDataTest(TestNode** root); |
- |
-void |
-addUDataTest(TestNode** root) |
-{ |
-#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION |
- addTest(root, &TestUDataOpen, "udatatst/TestUDataOpen" ); |
- addTest(root, &TestUDataOpenChoiceDemo1, "udatatst/TestUDataOpenChoiceDemo1"); |
- addTest(root, &TestUDataOpenChoiceDemo2, "udatatst/TestUDataOpenChoiceDemo2"); |
- addTest(root, &TestUDataGetInfo, "udatatst/TestUDataGetInfo" ); |
- addTest(root, &TestUDataGetMemory, "udatatst/TestUDataGetMemory" ); |
- addTest(root, &TestErrorConditions, "udatatst/TestErrorConditions"); |
- addTest(root, &TestAppData, "udatatst/TestAppData" ); |
- addTest(root, &TestSwapData, "udatatst/TestSwapData" ); |
-#endif |
- addTest(root, &TestUDataSetAppData, "udatatst/TestUDataSetAppData" ); |
- addTest(root, &TestICUDataName, "udatatst/TestICUDataName" ); |
- addTest(root, &PointerTableOfContents, "udatatst/PointerTableOfContents" ); |
- addTest(root, &SetBadCommonData, "udatatst/SetBadCommonData" ); |
- addTest(root, &TestUDataFileAccess, "udatatst/TestUDataFileAccess" ); |
-#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION |
- addTest(root, &TestTZDataDir, "udatatst/TestTZDataDir" ); |
-#endif |
-} |
- |
-#if 0 |
-static void lots_of_mallocs() |
-{ |
- int q; |
- for(q=1;q<100;q++) |
- { |
- free(malloc(q)); |
- malloc(q*2); |
- } |
- |
-} |
-#endif |
- |
-#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION |
-static void TestUDataOpen(){ |
- UDataMemory *result; |
- UErrorCode status=U_ZERO_ERROR; |
- const char* memMap[][2]={ |
- {"root", "res"}, |
- {"cnvalias", "icu"}, |
- {"unames", "icu"}, |
- {"ibm-37_P100-1995", "cnv"} |
- }; |
- const char* name = "test"; |
- const char* type = "icu"; |
- const char dirSepString[] = {U_FILE_SEP_CHAR, 0}; |
- const char pathSepString[] = {U_PATH_SEP_CHAR, 0}; |
- |
- |
- char* path=(char*)malloc(sizeof(char) * (strlen(ctest_dataOutDir()) |
- + strlen(U_ICUDATA_NAME) |
- + strlen("/build/tmp/..")+1 ) ); |
- |
- char *icuDataFilePath = 0; |
- |
- const char* testPath=loadTestData(&status); |
- if(U_FAILURE(status)) { |
- log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status)); |
- free(path); |
- return; |
- } |
- |
- /* lots_of_mallocs(); */ |
- log_verbose("Testing udata_open(%s)\n", testPath); |
- result=udata_open(testPath, type, name, &status); |
- if(U_FAILURE(status)){ |
- log_data_err("FAIL: udata_open() failed for path = %s, name=%s, type=%s, \n errorcode=%s\n", testPath, name, type, myErrorName(status)); |
- } else { |
- log_verbose("PASS: udata_open worked\n"); |
- udata_close(result); |
- } |
- |
- { |
- strcat(strcpy(path, ctest_dataOutDir()), U_ICUDATA_NAME); |
- |
- /* If the ICU system common data file is present in this confiugration, |
- * verify that udata_open can explicitly fetch items from it. |
- * If packaging mode == dll, the file may not exist. So, if the file is |
- * missing, skip this test without error. |
- */ |
- icuDataFilePath = (char *)uprv_malloc(strlen(path) + 10); |
- strcpy(icuDataFilePath, path); |
- strcat(icuDataFilePath, ".dat"); |
- /* lots_of_mallocs(); */ |
- if (uprv_fileExists(icuDataFilePath)) |
- { |
- int i; |
- log_verbose("Testing udata_open() on %s\n", icuDataFilePath); |
- for(i=0; i<sizeof(memMap)/sizeof(memMap[0]); i++){ |
- /* lots_of_mallocs(); */ |
- status=U_ZERO_ERROR; |
- result=udata_open(path, memMap[i][1], memMap[i][0], &status); |
- if(U_FAILURE(status)) { |
- 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)); |
- } else { |
- log_verbose("PASS: udata_open worked for path = %s, name=%s, type=%s\n", path, memMap[i][0], memMap[i][1]); |
- udata_close(result); |
- } |
- } |
- } |
- else |
- { |
- /* lots_of_mallocs(); */ |
- log_verbose("Skipping tests of udata_open() on %s. File not present in this configuration.\n", |
- icuDataFilePath); |
- } |
- uprv_free(icuDataFilePath); |
- } |
- /* try again, adding /tmp */ |
- { |
- strcpy(path, ctest_dataOutDir()); |
- strcat(path, "tmp"); |
- strcat(path, dirSepString); |
- strcat(path, U_ICUDATA_NAME); |
- |
- /* If the ICU system common data file is present in this confiugration, |
- * verify that udata_open can explicitly fetch items from it. |
- * If packaging mode == dll, the file may not exist. So, if the file is |
- * missing, skip this test without error. |
- */ |
- icuDataFilePath = (char *)malloc(strlen(path) + 10); |
- strcpy(icuDataFilePath, path); |
- strcat(icuDataFilePath, ".dat"); |
- /* lots_of_mallocs(); */ |
- if (uprv_fileExists(icuDataFilePath)) |
- { |
- int i; |
- log_verbose("Testing udata_open() on %s\n", icuDataFilePath); |
- for(i=0; i<sizeof(memMap)/sizeof(memMap[0]); i++){ |
- /* lots_of_mallocs(); */ |
- status=U_ZERO_ERROR; |
- result=udata_open(path, memMap[i][1], memMap[i][0], &status); |
- if(U_FAILURE(status)) { |
- 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)); |
- } else { |
- log_verbose("PASS: udata_open worked for path = %s, name=%s, type=%s\n", path, memMap[i][0], memMap[i][1]); |
- udata_close(result); |
- } |
- } |
- } |
- else |
- { |
- /* lots_of_mallocs(); */ |
- log_verbose("Skipping tests of udata_open() on %s. File not present in this configuration.\n", |
- icuDataFilePath); |
- } |
- } |
- |
- free(icuDataFilePath); |
- icuDataFilePath = NULL; |
- /* lots_of_mallocs(); */ |
- |
- /* If the ICU individual files used to build the ICU system common data are |
- * present in this configuration, |
- * verify that udata_open can explicitly open them. |
- * These data files are present in the ICU data/build directory after a build |
- * completes. Tests are most commonly run with the data directory pointing |
- * back into this directory structure, but this is not required. Soooo, if |
- * the files are missing, skip this test without error. |
- */ |
- /* lots_of_mallocs(); */ |
- icuDataFilePath = (char *)malloc(strlen(ctest_dataOutDir()) + 50); |
- strcpy(icuDataFilePath, ctest_dataOutDir()); |
- strcat(icuDataFilePath, "build"); |
- strcat(icuDataFilePath, dirSepString); |
- strcat(icuDataFilePath, U_ICUDATA_NAME); |
- strcat(icuDataFilePath, dirSepString); |
- strcat(icuDataFilePath, "cnvalias.icu"); |
- |
- /* lots_of_mallocs(); */ |
- if (uprv_fileExists(icuDataFilePath)) |
- { |
- int i; |
- log_verbose("%s exists, so..\n", icuDataFilePath); |
- strcpy(icuDataFilePath, ctest_dataOutDir()); |
- strcat(icuDataFilePath, "build"); |
- strcat(icuDataFilePath, dirSepString); |
- strcat(icuDataFilePath, U_ICUDATA_NAME); |
- log_verbose("Testing udata_open() on %s\n", icuDataFilePath); |
- for(i=0; i<sizeof(memMap)/sizeof(memMap[0]); i++){ |
- status=U_ZERO_ERROR; |
- result=udata_open(icuDataFilePath, memMap[i][1], memMap[i][0], &status); |
- if(U_FAILURE(status)) { |
- 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)); |
- } else { |
- log_verbose("PASS: udata_open worked for path = %s, name=%s, type=%s\n", icuDataFilePath, memMap[i][0], memMap[i][1]); |
- udata_close(result); |
- } |
- } |
- } |
- else |
- { |
- log_verbose("Skipping tests of udata_open() on %s. File not present in this configuration.\n", |
- icuDataFilePath); |
- } |
- |
- free(icuDataFilePath); |
- icuDataFilePath = NULL; |
- |
- /* |
- * Test fallback file names for open of separate data files. |
- * With these params to udata_open: |
- * path = wherever/testdata |
- * type = typ |
- * name = nam |
- * these files will be tried first: |
- * wherever/testudata_nam.typ |
- * testudata_nam.typ |
- * A test data file named testudata_nam.typ exists for the purpose of testing this. |
- */ |
- log_verbose("Testing udata_open, with base_name.type style fallback to individual file.\n"); |
- |
- status = U_ZERO_ERROR; |
- result = udata_open( testPath, "typ", "nam", &status); |
- if (status != U_ZERO_ERROR) { |
- log_data_err("FAIL: udata_open( \"%s\", \"typ\", \"nam\") returned status %s\n", testPath, u_errorName(status)); |
- } |
- udata_close(result); |
- free(icuDataFilePath); |
- |
- |
- /* This type of path is deprecated */ |
- /* |
- * Another fallback test. Paths ending with a trailing directory separator |
- * take a slightly different code path, with the "base name" from the path |
- * being empty in the internal udata_open logic. |
- */ |
- |
-/* log_verbose("Testing udata_open, with path containing a trailing directory separator.\n"); */ |
-/* icuDataFilePath = (char *)malloc(strlen(u_getDataDirectory()) + 50); */ |
-/* strcpy(icuDataFilePath, testPath); */ |
-/* status = U_ZERO_ERROR; */ |
-/* result = udata_open( icuDataFilePath, "cnv", "test1", &status); */ |
-/* if (status != U_ZERO_ERROR) { */ |
-/* log_err("FAIL: udata_open( \"%s\", \"cnv\", \"test1\") returned status %s\n", icuDataFilePath, u_errorName(status)); */ |
-/* } */ |
-/* udata_close(result); */ |
-/* free(icuDataFilePath); */ |
- |
- |
- log_verbose("Testing udata_open() with a non existing binary file\n"); |
- result=udata_open("testdata", "tst", "nonexist", &status); |
- if(status==U_FILE_ACCESS_ERROR){ |
- log_verbose("Opening udata_open with non-existing file handled correctly.\n"); |
- status=U_ZERO_ERROR; |
- } else { |
- 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)); |
- if(U_SUCCESS(status)) { |
- udata_close(result); |
- } |
- } |
- |
- if(result != NULL){ |
- log_err("calling udata_open with non-existing file didn't return a null value\n"); |
- } else { |
- log_verbose("calling udat_open with non-existing file returned null as expected\n"); |
- } |
- |
- /* |
- * Try opening data with absurdly long path and name, to trigger buffer size |
- * overflow handling code. |
- */ |
- { |
- char longTestPath[1024]; /* Implementation goes to heap at length of 128. */ |
- char longName[1024]; |
- |
- /* Try a very long nonexistent directory path. |
- * udata_open should still succeed. Opening with the path will fail, |
- * then fall back to skipping the directory portion of the path. |
- */ |
- log_verbose("Testing udata_open() with really long names\n"); |
- longTestPath[0] = 0; |
- strcat(longTestPath, "bogus_directory_name"); |
- while (strlen(longTestPath) < 500) { |
- strcat(longTestPath, dirSepString); |
- strcat(longTestPath, "bogus_directory_name"); |
- } |
- strcat(longTestPath, pathSepString); |
- strcat(longTestPath, testPath); |
- result=udata_open(longTestPath, type, name, &status); |
- if(U_FAILURE(status)){ |
- log_data_err("FAIL: udata_open() failed for path = %s\n name=%s, type=%s, \n errorcode=%s\n", |
- longTestPath, name, type, myErrorName(status)); |
- } else { |
- log_verbose("PASS: udata_open worked\n"); |
- udata_close(result); |
- } |
- |
- /* Try a very long name. Won't open, but shouldn't blow up. |
- */ |
- longName[0] = 0; |
- while (strlen(longName) < 500) { |
- strcat(longName, name); |
- strcat(longName, "_"); |
- } |
- strcat(longName, dirSepString); |
- strcat(longName, name); |
- |
- result=udata_open(longTestPath, type, longName, &status); |
- if (status != U_FILE_ACCESS_ERROR) { |
- log_data_err("FAIL: udata_open() failed for path = %s\n name=%s, type=%s, \n errorcode=%s\n", |
- longTestPath, longName, type, myErrorName(status)); |
- } |
- udata_close(result); |
- } |
- |
- free(path); |
-} |
-#endif |
- |
-typedef struct { |
- uint16_t headerSize; |
- uint8_t magic1, magic2; |
- UDataInfo info; |
- char padding[8]; |
- uint32_t count, reserved; |
- /* |
- const struct { |
- const char *const name; |
- const void *const data; |
- } toc[1]; |
- */ |
- int32_t fakeNameAndData[4]; |
-} ICU_COMMON_Data_Header; |
- |
-static const ICU_COMMON_Data_Header gEmptyHeader = { |
- 32, /* headerSize */ |
- 0xda, /* magic1, (see struct MappedData in udata.c) */ |
- 0x27, /* magic2 */ |
- { /*UDataInfo */ |
- sizeof(UDataInfo), /* size */ |
- 0, /* reserved */ |
- |
-#if U_IS_BIG_ENDIAN |
- 1, |
-#else |
- 0, |
-#endif |
- |
- U_CHARSET_FAMILY, |
- sizeof(UChar), |
- 0, /* reserved */ |
- { /* data format identifier */ |
- 0x43, 0x6d, 0x6e, 0x44}, /* "CmnD" */ |
- {1, 0, 0, 0}, /* format version major, minor, milli, micro */ |
- {0, 0, 0, 0} /* dataVersion */ |
- }, |
- {0,0,0,0,0,0,0,0}, /* Padding[8] */ |
- 0, /* count */ |
- 0, /* Reserved */ |
- { /* TOC structure */ |
-/* { */ |
- 0 , 0 , 0, 0 /* name and data entries. Count says there are none, */ |
- /* but put one in just in case. */ |
-/* } */ |
- } |
-}; |
- |
- |
-static void TestUDataSetAppData(){ |
-/* UDataMemory *dataItem;*/ |
- |
- UErrorCode status=U_ZERO_ERROR; |
- |
- /* |
- * First we try some monkey business and try to do bad things. |
- */ |
- |
- status=U_ZERO_ERROR; |
- udata_setAppData("appData1", NULL, &status); |
- if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
- log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData1\", NULL, status) should have failed." |
- " It returned status of %s\n", u_errorName(status)); |
- return; |
- } |
- /* The following call should fail. |
- If the following works with a bad UErrorCode, then later calls to appData1 should fail. */ |
- udata_setAppData("appData1", &gEmptyHeader, &status); |
- |
- /* |
- * Got testdata.dat into memory, now we try setAppData using the memory image. |
- */ |
- |
- status=U_ZERO_ERROR; |
- udata_setAppData("appData1", &gEmptyHeader, &status); |
- if (status != U_ZERO_ERROR) { |
- log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData1\", fileBuf, status) " |
- " returned status of %s\n", u_errorName(status)); |
- return; |
- } |
- |
- udata_setAppData("appData2", &gEmptyHeader, &status); |
- if (status != U_ZERO_ERROR) { |
- log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData2\", fileBuf, status) " |
- " returned status of %s\n", u_errorName(status)); |
- return; |
- } |
- |
- /* If we try to setAppData with the same name a second time, we should get a |
- * a using default warning. |
- */ |
- udata_setAppData("appData2", &gEmptyHeader, &status); |
- if (status != U_USING_DEFAULT_WARNING) { |
- log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData2\", fileBuf, status) " |
- " returned status of %s, expected U_USING_DEFAULT_WARNING.\n", u_errorName(status)); |
- } |
- |
- |
- /** It is no longer correct to use udata_setAppData to change the |
- package of a contained item. |
- |
- dataItem = udata_open("appData1", "res", "te_IN", &status); **/ |
-} |
- |
-static char *safeGetICUDataDirectory() { |
- const char *dataDir = u_getDataDirectory(); /* Returned string vanashes with u_cleanup */ |
- char *retStr = NULL; |
- if (dataDir != NULL) { |
- retStr = (char *)malloc(strlen(dataDir)+1); |
- strcpy(retStr, dataDir); |
- } |
- return retStr; |
-} |
- |
-static void TestUDataFileAccess(){ |
- UErrorCode status; |
- char *icuDataDir; |
- icuDataDir = safeGetICUDataDirectory(); /* save icu data dir, so we can put it back |
- * after doing u_cleanup(). */ |
- |
- /** UDATA_NO_FILES, ICU does not access the file system for data loading. */ |
- status=U_ZERO_ERROR; |
- u_cleanup(); |
- udata_setFileAccess(UDATA_NO_FILES,&status); |
- u_init(&status); |
- if(U_FAILURE(status) && *icuDataDir == 0){ |
- log_data_err("udata_setFileAccess(UDATA_NO_FILES) failed with ICU_DATA=\"\" err=%s\n", u_errorName(status)); |
- } |
- |
- /** UDATA_ONLY_PACKAGES, ICU only loads data from packages, not from single files. */ |
- status=U_ZERO_ERROR; |
- u_cleanup(); |
- udata_setFileAccess(UDATA_ONLY_PACKAGES,&status); |
- u_init(&status); |
- |
- /** UDATA_PACKAGES_FIRST, ICU loads data from packages first, and only from single files |
- if the data cannot be found in a package. */ |
- status=U_ZERO_ERROR; |
- u_cleanup(); |
- udata_setFileAccess(UDATA_PACKAGES_FIRST,&status); |
- u_init(&status); |
- |
- /** UDATA_FILES_FIRST, ICU looks for data in single files first, then in packages. (default) */ |
- status=U_ZERO_ERROR; |
- u_cleanup(); |
- udata_setFileAccess(UDATA_FILES_FIRST,&status); |
- u_init(&status); |
- |
- /** An alias for the default access mode. */ |
- status=U_ZERO_ERROR; |
- u_cleanup(); |
- udata_setFileAccess(UDATA_DEFAULT_ACCESS,&status); |
- u_setDataDirectory(icuDataDir); |
- u_init(&status); |
- if(U_FAILURE(status)){ |
- log_err_status(status, "%s\n", u_errorName(status)); |
- } |
- free(icuDataDir); |
- ctest_resetICU(); |
-} |
- |
- |
-static UBool U_CALLCONV |
-isAcceptable1(void *context, |
- const char *type, const char *name, |
- const UDataInfo *pInfo) { |
- |
- if( pInfo->size>=20 && |
- pInfo->isBigEndian==U_IS_BIG_ENDIAN && |
- pInfo->charsetFamily==U_CHARSET_FAMILY && |
- pInfo->dataFormat[0]==0x43 && /* dataFormat="CvAl" */ |
- pInfo->dataFormat[1]==0x76 && |
- pInfo->dataFormat[2]==0x41 && |
- pInfo->dataFormat[3]==0x6c && |
- pInfo->formatVersion[0]==3 ) |
- { |
- log_verbose("The data from \"%s.%s\" IS acceptable using the verifing function isAcceptable1()\n", name, type); |
- return TRUE; |
- } else { |
- log_verbose("The data from \"%s.%s\" IS NOT acceptable using the verifing function isAcceptable1():-\n" |
- "\tsize = %d\n" |
- "\tisBigEndian = %d\n" |
- "\tcharsetFamily = %d\n" |
- "\tformatVersion[0] = %d\n" |
- "\tdataVersion[0] = %d\n" |
- "\tdataFormat = %c%c%c%c\n", |
- name, type, pInfo->size, pInfo->isBigEndian, pInfo->charsetFamily, pInfo->formatVersion[0], |
- pInfo->dataVersion[0], pInfo->dataFormat[0], pInfo->dataFormat[1], pInfo->dataFormat[2], |
- pInfo->dataFormat[3]); |
- log_verbose("Call another verifing function to accept the data\n"); |
- return FALSE; |
- } |
-} |
- |
-static UBool U_CALLCONV |
-isAcceptable2(void *context, |
- const char *type, const char *name, |
- const UDataInfo *pInfo){ |
- UVersionInfo unicodeVersion; |
- |
- u_getUnicodeVersion(unicodeVersion); |
- |
- if( pInfo->size>=20 && |
- pInfo->isBigEndian==U_IS_BIG_ENDIAN && |
- pInfo->charsetFamily==U_CHARSET_FAMILY && |
- pInfo->dataFormat[0]==0x75 && /* dataFormat="unam" */ |
- pInfo->dataFormat[1]==0x6e && |
- pInfo->dataFormat[2]==0x61 && |
- pInfo->dataFormat[3]==0x6d && |
- pInfo->formatVersion[0]==1 && |
- pInfo->dataVersion[0]==unicodeVersion[0] ) |
- { |
- log_verbose("The data from \"%s.%s\" IS acceptable using the verifing function isAcceptable2()\n", name, type); |
- return TRUE; |
- } else { |
- log_verbose("The data from \"%s.%s\" IS NOT acceptable using the verifing function isAcceptable2()\n", name, type); |
- |
- return FALSE; |
- } |
- |
- |
-} |
-static UBool U_CALLCONV |
-isAcceptable3(void *context, |
- const char *type, const char *name, |
- const UDataInfo *pInfo){ |
- |
- if( pInfo->size>=20 && |
- pInfo->isBigEndian==U_IS_BIG_ENDIAN && |
- pInfo->charsetFamily==U_CHARSET_FAMILY && |
- pInfo->dataFormat[0]==0x54 && /* dataFormat="test" */ |
- pInfo->dataFormat[1]==0x65 && |
- pInfo->dataFormat[2]==0x73 && |
- pInfo->dataFormat[3]==0x74 && |
- pInfo->formatVersion[0]==1 && |
- pInfo->dataVersion[0]==1 ) { |
- log_verbose("The data from \"%s.%s\" IS acceptable using the verifing function isAcceptable3()\n", name, type); |
- |
- return TRUE; |
- } else { |
- log_verbose("The data from \"%s.%s\" IS NOT acceptable using the verifing function isAcceptable3()\n", name, type); |
- return FALSE; |
- } |
- |
- |
-} |
- |
-#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION |
-static void TestUDataOpenChoiceDemo1() { |
- UDataMemory *result; |
- UErrorCode status=U_ZERO_ERROR; |
- |
- const char* name[]={ |
- "cnvalias", |
- "unames", |
- "test", |
- "nam" |
- }; |
- const char* type="icu"; |
- const char* testPath="testdata"; |
- const char* fullTestDataPath = loadTestData(&status); |
- if(U_FAILURE(status)) { |
- log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status)); |
- return; |
- } |
- |
- result=udata_openChoice(NULL, "icu", name[0], isAcceptable1, NULL, &status); |
- if(U_FAILURE(status)){ |
- log_data_err("FAIL: udata_openChoice() failed name=%s, type=%s, \n errorcode=%s\n", name[0], type, myErrorName(status)); |
- } else { |
- log_verbose("PASS: udata_openChoice worked\n"); |
- udata_close(result); |
- } |
- |
- status=U_ZERO_ERROR; |
- result=udata_openChoice(NULL, type, name[1], isAcceptable1, NULL, &status); |
- if(U_FAILURE(status)){ |
- status=U_ZERO_ERROR; |
- result=udata_openChoice(NULL, type, name[1], isAcceptable2, NULL, &status); |
- if(U_FAILURE(status)){ |
- log_data_err("FAIL: udata_openChoice() failed name=%s, type=%s, \n errorcode=%s\n", name[1], type, myErrorName(status)); |
- } |
- } |
- else { |
- log_err("FAIL: udata_openChoice() unexpectedly passed. name=%s, type=%s, \n errorcode=%s\n", name[1], type, myErrorName(status)); |
- } |
- |
- if(U_SUCCESS(status)){ |
- udata_close(result); |
- } |
- |
- status=U_ZERO_ERROR; |
- result=udata_openChoice(testPath, type, name[2], isAcceptable1, NULL, &status); |
- if(U_FAILURE(status)){ |
- status=U_ZERO_ERROR; |
- result=udata_openChoice(testPath, type, name[2], isAcceptable3, NULL, &status); |
- if(U_FAILURE(status)){ |
- log_data_err("FAIL: udata_openChoice() failed path=%s name=%s, type=%s, \n errorcode=%s\n", testPath, name[2], type, myErrorName(status)); |
- } |
- } |
- else { |
- log_err("FAIL: udata_openChoice() unexpectedly passed. name=%s, type=%s, \n errorcode=%s\n", name[2], type, myErrorName(status)); |
- } |
- |
- if(U_SUCCESS(status)){ |
- udata_close(result); |
- } |
- |
- status=U_ZERO_ERROR; |
- type="typ"; |
- result=udata_openChoice(fullTestDataPath, type, name[3], isAcceptable1, NULL, &status); |
- if(status != U_INVALID_FORMAT_ERROR){ |
- log_err("FAIL: udata_openChoice() did not fail as expected. name=%s, type=%s, \n errorcode=%s\n", name[3], type, myErrorName(status)); |
- } |
- |
- status=U_USELESS_COLLATOR_ERROR; |
- result=udata_openChoice(fullTestDataPath, type, name[3], isAcceptable1, NULL, &status); |
- if(status != U_USELESS_COLLATOR_ERROR){ |
- log_err("FAIL: udata_openChoice() did not fail as expected. name=%s, type=%s, \n errorcode=%s\n", name[3], type, myErrorName(status)); |
- } |
-} |
- |
-static UBool U_CALLCONV |
-isAcceptable(void *context, |
- const char *type, const char *name, |
- const UDataInfo *pInfo){ |
- if( pInfo->size>=20 && |
- pInfo->isBigEndian==U_IS_BIG_ENDIAN && |
- pInfo->charsetFamily==U_CHARSET_FAMILY && |
- pInfo->dataFormat[0]==0x54 && /* dataFormat="test" */ |
- pInfo->dataFormat[1]==0x65 && |
- pInfo->dataFormat[2]==0x73 && |
- pInfo->dataFormat[3]==0x74 && |
- pInfo->formatVersion[0]==1 && |
- pInfo->dataVersion[0]==1 && |
- *((int*)context) == 2 ) { |
- log_verbose("The data from\"%s.%s\" IS acceptable using the verifing function isAcceptable()\n", name, type); |
- |
- return TRUE; |
- } else { |
- log_verbose("The data from \"%s.%s\" IS NOT acceptable using the verifing function isAcceptable()\n", name, type); |
- return FALSE; |
- } |
-} |
- |
- |
-/* This test checks to see if the isAcceptable function is being called correctly. */ |
- |
-static void TestUDataOpenChoiceDemo2() { |
- UDataMemory *result; |
- UErrorCode status=U_ZERO_ERROR; |
- int i; |
- int p=2; |
- |
- const char* name="test"; |
- const char* type="icu"; |
- const char* path = loadTestData(&status); |
- if(U_FAILURE(status)) { |
- log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status)); |
- return; |
- } |
- |
- result=udata_openChoice(path, type, name, isAcceptable, &p, &status); |
- if(U_FAILURE(status)){ |
- log_data_err("failed to load data at p=%s t=%s n=%s, isAcceptable", path, type, name); |
- } |
- if(U_SUCCESS(status) ) { |
- udata_close(result); |
- } |
- |
- p=0; |
- for(i=0;i<2; i++){ |
- result=udata_openChoice(path, type, name, isAcceptable, &p, &status); |
- if(p<2) { |
- if(U_FAILURE(status) && status==U_INVALID_FORMAT_ERROR){ |
- log_verbose("Loads the data but rejects it as expected %s\n", myErrorName(status)); |
- status=U_ZERO_ERROR; |
- p++; |
- } |
- else { |
- log_data_err("FAIL: failed to either load the data or to reject the loaded data. ERROR=%s\n", myErrorName(status) ); |
- } |
- } |
- else if(p == 2) { |
- if(U_FAILURE(status)) { |
- log_data_err("FAIL: failed to load the data and accept it. ERROR=%s\n", myErrorName(status) ); |
- } |
- else { |
- log_verbose("Loads the data and accepts it for p==2 as expected\n"); |
- udata_close(result); |
- } |
- } |
- } |
-} |
- |
-static void TestUDataGetInfo() { |
- |
- UDataMemory *result; |
- /* UDataInfo cf. udata.h */ |
- static UDataInfo dataInfo={ |
- 30, /*sizeof(UDataInfo),*/ |
- 0, |
- |
- U_IS_BIG_ENDIAN, |
- U_CHARSET_FAMILY, |
- sizeof(UChar), |
- 0, |
- |
- {0x54, 0x65, 0x73, 0x74}, /* dataFormat="Test" */ |
- {9, 0, 0, 0}, /* formatVersion */ |
- {4, 0, 0, 0} /* dataVersion */ |
- }; |
- UErrorCode status=U_ZERO_ERROR; |
- const char* name="cnvalias"; |
- const char* name2="test"; |
- const char* type="icu"; |
- |
- const char* testPath=loadTestData(&status); |
- if(U_FAILURE(status)) { |
- log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status)); |
- return; |
- } |
- |
- log_verbose("Testing udata_getInfo() for cnvalias.icu\n"); |
- result=udata_open(NULL, "icu", name, &status); |
- if(U_FAILURE(status)){ |
- log_data_err("FAIL: udata_open() failed for path = NULL, name=%s, type=%s, \n errorcode=%s\n", name, type, myErrorName(status)); |
- return; |
- } |
- udata_getInfo(result, &dataInfo); |
- if(dataInfo.size==20 && dataInfo.size!=30 && |
- dataInfo.isBigEndian==U_IS_BIG_ENDIAN && |
- dataInfo.charsetFamily==U_CHARSET_FAMILY && |
- dataInfo.dataFormat[0]==0x43 && dataInfo.dataFormat[0]!=0x54 && /* dataFormat="CvAl" and not "Test". The values are set for cnvalias.dat*/ |
- dataInfo.dataFormat[1]==0x76 && dataInfo.dataFormat[1]!=0x65 && |
- dataInfo.dataFormat[2]==0x41 && dataInfo.dataFormat[2]!=0x73 && |
- dataInfo.dataFormat[3]==0x6c && dataInfo.dataFormat[3]!=0x74 && |
- dataInfo.formatVersion[0]!=9 && /*formatVersion is also set to the one for cnvalias*/ |
- dataInfo.dataVersion[0]!=4 && /*dataVersion*/ |
- dataInfo.dataVersion[1]!=0 ){ |
- log_verbose("PASS: udata_getInfo() filled in the right values\n"); |
- } else { |
- log_err("FAIL: udata_getInfo() filled in the wrong values\n"); |
- } |
- udata_close(result); |
- |
- |
- log_verbose("Testing udata_getInfo() for test.icu\n"); |
- result=udata_open(testPath, type, name2, &status); |
- if(U_FAILURE(status)) { |
- log_data_err("FAIL: udata_open() failed for path=%s name2=%s, type=%s, \n errorcode=%s\n", testPath, name2, type, myErrorName(status)); |
- return; |
- } |
- udata_getInfo(result, &dataInfo); |
- if(dataInfo.size==20 && |
- dataInfo.isBigEndian==U_IS_BIG_ENDIAN && |
- dataInfo.charsetFamily==U_CHARSET_FAMILY && |
- dataInfo.dataFormat[0]==0x54 && /* dataFormat="Test". The values are set for test.dat*/ |
- dataInfo.dataFormat[1]==0x65 && |
- dataInfo.dataFormat[2]==0x73 && |
- dataInfo.dataFormat[3]==0x74 && |
- dataInfo.formatVersion[0]==1 && /*formatVersion is also set to the one for test*/ |
- dataInfo.dataVersion[0]==1 && /*dataVersion*/ |
- dataInfo.dataVersion[1]==0 ) |
- { |
- log_verbose("PASS: udata_getInfo() filled in the right values\n"); |
- } else { |
- log_err("FAIL: udata_getInfo() filled in the wrong values\n"); |
- } |
- udata_close(result); |
-} |
- |
-static void TestUDataGetMemory() { |
- |
- UDataMemory *result; |
- const int32_t *table=NULL; |
- uint16_t* intValue=0; |
- UErrorCode status=U_ZERO_ERROR; |
- const char* name="cnvalias"; |
- const char* type; |
- |
- const char* name2="test"; |
- |
- const char* testPath = loadTestData(&status); |
- if(U_FAILURE(status)) { |
- log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status)); |
- return; |
- } |
- |
- type="icu"; |
- log_verbose("Testing udata_getMemory() for \"cnvalias.icu\"\n"); |
- result=udata_openChoice(NULL, type, name, isAcceptable1, NULL, &status); |
- if(U_FAILURE(status)){ |
- log_data_err("FAIL: udata_openChoice() failed for name=%s, type=%s, \n errorcode=%s\n", name, type, myErrorName(status)); |
- return; |
- } |
- table=(const int32_t *)udata_getMemory(result); |
- |
- /* The alias table may list more converters than what's actually available now. [grhoten] */ |
- if(ucnv_countAvailable() > table[1]) /*???*/ |
- log_err("FAIL: udata_getMemory() failed ucnv_countAvailable returned = %d, expected = %d\n", ucnv_countAvailable(), table[1+2*(*table)]); |
- |
- udata_close(result); |
- |
- type="icu"; |
- log_verbose("Testing udata_getMemory for \"test.icu\"()\n"); |
- result=udata_openChoice(testPath, type, name2, isAcceptable3, NULL, &status); |
- if(U_FAILURE(status)){ |
- log_data_err("FAIL: udata_openChoice() failed for path=%s name=%s, type=%s, \n errorcode=%s\n", testPath, name2, type, myErrorName(status)); |
- return; |
- } |
- intValue=(uint16_t *)udata_getMemory(result); |
- /*printf("%d ..... %s", *(intValue), intValue+1));*/ |
- if( *intValue != 2000 || strcmp((char*)(intValue+1), "YEAR") != 0 ) |
- log_err("FAIL: udata_getMemory() failed: intValue :- Expected:2000 Got:%d \n\tstringValue:- Expected:YEAR Got:%s\n", *intValue, (intValue+1)); |
- |
- udata_close(result); |
- |
-} |
- |
-static void TestErrorConditions(){ |
- |
- UDataMemory *result=NULL; |
- UErrorCode status=U_ZERO_ERROR; |
- uint16_t* intValue=0; |
- static UDataInfo dataInfo={ |
- 30, /*sizeof(UDataInfo),*/ |
- 0, |
- |
- U_IS_BIG_ENDIAN, |
- U_CHARSET_FAMILY, |
- sizeof(UChar), |
- 0, |
- |
- {0x54, 0x65, 0x73, 0x74}, /* dataFormat="Test" */ |
- {9, 0, 0, 0}, /* formatVersion */ |
- {4, 0, 0, 0} /* dataVersion */ |
- }; |
- |
- const char* name = "test"; |
- const char* type="icu"; |
- |
- const char *testPath = loadTestData(&status); |
- if(U_FAILURE(status)) { |
- log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status)); |
- return; |
- } |
- |
- status = U_ILLEGAL_ARGUMENT_ERROR; |
- /*Try udata_open with status != U_ZERO_ERROR*/ |
- log_verbose("Testing udata_open() with status != U_ZERO_ERROR\n"); |
- result=udata_open(testPath, type, name, &status); |
- if(result != NULL){ |
- 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); |
- udata_close(result); |
- |
- } else { |
- log_verbose("PASS: udata_open with errorCode != U_ZERO_ERROR failed as expected\n"); |
- } |
- |
- /*Try udata_open with data name=NULL*/ |
- log_verbose("Testing udata_open() with data name=NULL\n"); |
- status=U_ZERO_ERROR; |
- result=udata_open(testPath, type, NULL, &status); |
- if(U_FAILURE(status)){ |
- if(status != U_ILLEGAL_ARGUMENT_ERROR || result != NULL){ |
- log_err("FAIL: udata_open() with name=NULL should return NULL and errocode U_ILLEGAL_ARGUMENT_ERROR, GOT: errorcode=%s\n", myErrorName(status)); |
- }else{ |
- log_verbose("PASS: udata_open with name=NULL failed as expected and errorcode = %s as expected\n", myErrorName(status)); |
- } |
- }else{ |
- 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); |
- udata_close(result); |
- } |
- |
- |
- /*Try udata_openChoice with status != U_ZERO_ERROR*/ |
- log_verbose("Testing udata_openChoice() with status != U_ZERO_ERROR\n"); |
- status=U_ILLEGAL_ARGUMENT_ERROR; |
- result=udata_openChoice(testPath, type, name, isAcceptable3, NULL, &status); |
- if(result != NULL){ |
- 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); |
- udata_close(result); |
- } else { |
- log_verbose("PASS: udata_openChoice() with errorCode != U_ZERO_ERROR failed as expected\n"); |
- } |
- |
- /*Try udata_open with data name=NULL*/ |
- log_verbose("Testing udata_openChoice() with data name=NULL\n"); |
- status=U_ZERO_ERROR; |
- result=udata_openChoice(testPath, type, NULL, isAcceptable3, NULL, &status); |
- if(U_FAILURE(status)){ |
- if(status != U_ILLEGAL_ARGUMENT_ERROR || result != NULL){ |
- log_err("FAIL: udata_openChoice() with name=NULL should return NULL and errocode U_ILLEGAL_ARGUMENT_ERROR, GOT: errorcode=%s\n", myErrorName(status)); |
- }else{ |
- log_verbose("PASS: udata_openChoice with name=NULL failed as expected and errorcode = %s as expected\n", myErrorName(status)); |
- } |
- }else{ |
- 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); |
- udata_close(result); |
- } |
- |
- /*Try udata_getMemory with UDataMemory=NULL*/ |
- log_verbose("Testing udata_getMemory with UDataMemory=NULL\n"); |
- intValue=(uint16_t*)udata_getMemory(NULL); |
- if(intValue != NULL){ |
- log_err("FAIL: udata_getMemory with UDataMemory = NULL is supposed to fail\n"); |
- } |
- |
- /*Try udata_getInfo with UDataMemory=NULL*/ |
- status=U_ZERO_ERROR; |
- udata_getInfo(NULL, &dataInfo); |
- if(dataInfo.size != 0){ |
- log_err("FAIL : udata_getInfo with UDataMemory = NULL us supposed to fail\n"); |
- } |
- |
- /*Try udata_openChoice with a non existing binary file*/ |
- log_verbose("Testing udata_openChoice() with a non existing binary file\n"); |
- result=udata_openChoice(testPath, "tst", "nonexist", isAcceptable3, NULL, &status); |
- if(status==U_FILE_ACCESS_ERROR){ |
- log_verbose("Opening udata_openChoice with non-existing file handled correctly.\n"); |
- status=U_ZERO_ERROR; |
- } else { |
- log_err("calling udata_open with non-existing file not handled correctly\n. Expected: U_FILE_ACCESS_ERROR, Got: %s\n", myErrorName(status)); |
- if(U_SUCCESS(status)) { |
- udata_close(result); |
- } |
- } |
- |
- if(result != NULL){ |
- log_err("calling udata_open with non-existing file didn't return a null value\n"); |
- } else { |
- log_verbose("calling udat_open with non-existing file returned null as expected\n"); |
- } |
-} |
- |
-/* Test whether apps and ICU can each have their own root.res */ |
-static void TestAppData() |
-{ |
- UResourceBundle *icu, *app; |
- UResourceBundle *tmp = NULL; |
- UResourceBundle *tmp2 = NULL; |
- |
- const UChar *appString; |
- const UChar *icuString; |
- |
- int32_t len; |
- |
- UErrorCode status = U_ZERO_ERROR; |
- char testMsgBuf[256]; |
- |
- const char* testPath=loadTestData(&status); |
- if(U_FAILURE(status)) { |
- log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status)); |
- return; |
- } |
- |
- icu = ures_open(NULL, "root", &status); |
- if(U_FAILURE(status)) |
- { |
- log_data_err("%s:%d: Couldn't open root ICU bundle- %s", __FILE__, __LINE__, u_errorName(status)); |
- return; |
- } |
- /* log_info("Open icu root: %s size_%d\n", u_errorName(status), ures_getSize(icu)); */ |
- status = U_ZERO_ERROR; |
- |
- app = ures_open(testPath, "root", &status); |
- if(U_FAILURE(status)) |
- { |
- log_data_err("%s:%d: Couldn't open app ICU bundle [%s]- %s", __FILE__, __LINE__, testPath, u_errorName(status)); |
- return; |
- } |
- /* log_info("Open app: %s, size %d\n", u_errorName(status), ures_getSize(app)); */ |
- |
- tmp = ures_getByKey(icu, "Version", tmp, &status); |
- if(U_FAILURE(status)) |
- { |
- log_err("%s:%d: Couldn't get Version string from ICU root bundle- %s", __FILE__, __LINE__, u_errorName(status)); |
- return; |
- } |
- |
- icuString = ures_getString(tmp, &len, &status); |
- if(U_FAILURE(status)) |
- { |
- log_err("%s:%d: Couldn't get string from Version string from ICU root bundle- %s", __FILE__, __LINE__, u_errorName(status)); |
- return; |
- } |
- /* log_info("icuString=%p - %s\n", icuString, austrdup(icuString)); */ |
- |
- |
- tmp2 = ures_getByKey(app, "Version", tmp2, &status); |
- if(U_FAILURE(status)) |
- { |
- log_err("%s:%d: Couldn't get Version string from App root bundle- %s", __FILE__, __LINE__, u_errorName(status)); |
- return; |
- } |
- |
- appString = ures_getString(tmp2, &len, &status); |
- if(U_FAILURE(status)) |
- { |
- log_err("%s:%d: Couldn't get string from Version string from App root bundle- %s", __FILE__, __LINE__, u_errorName(status)); |
- return; |
- } |
- |
- /* log_info("appString=%p - %s\n", appString, austrdup(appString)); */ |
- |
- |
- if(!u_strcmp(icuString, appString)) |
- { |
- 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), |
- austrdup(appString)); |
- } |
- else |
- { |
- log_verbose("%s:%d: appstr=%s, icustr=%s\n", __FILE__, |
- __LINE__, u_austrcpy(testMsgBuf, appString), u_austrcpy(testMsgBuf, icuString)); |
- } |
- |
- ures_close(tmp); |
- ures_close(tmp2); |
- ures_close(icu); |
- ures_close(app); |
-} |
-#endif |
- |
-static void TestICUDataName() |
-{ |
- UVersionInfo icuVersion; |
- char expectDataName[20]; |
- unsigned int expectLen = 8; |
- |
- char typeChar = '?'; |
- |
- /* Print out the version # we have .. */ |
- log_verbose("utypes.h says U_ICUDATA_NAME = %s\n", U_ICUDATA_NAME); |
- |
- /* Build up the version # we expect to get */ |
- u_getVersion(icuVersion); |
- |
- switch(U_CHARSET_FAMILY) |
- { |
- case U_ASCII_FAMILY: |
- switch((int)U_IS_BIG_ENDIAN) |
- { |
- case 1: |
- typeChar = 'b'; |
- break; |
- case 0: |
- typeChar = 'l'; |
- break; |
- default: |
- log_err("Expected 1 or 0 for U_IS_BIG_ENDIAN, got %d!\n", (int)U_IS_BIG_ENDIAN); |
- /* return; */ |
- } |
- break; |
- case U_EBCDIC_FAMILY: |
- typeChar = 'e'; |
- break; |
- } |
- |
- /* Only major number is needed. */ |
- sprintf(expectDataName, "%s%d%c", |
- "icudt", |
- (int)icuVersion[0], |
- typeChar); |
- |
- log_verbose("Expected: %s\n", expectDataName); |
- if(uprv_strlen(expectDataName) != expectLen) |
- { |
- log_err("*Expected* length is wrong (test err?), should be %d is %d\n", |
- expectLen, uprv_strlen(expectDataName)); |
- } |
- |
- if(uprv_strlen(U_ICUDATA_NAME) != expectLen) |
- { |
- log_err("U_ICUDATA_NAME length should be %d is %d\n", |
- expectLen, uprv_strlen(U_ICUDATA_NAME)); |
- } |
- |
- if(uprv_strcmp(U_ICUDATA_NAME, expectDataName)) |
- { |
- log_err("U_ICUDATA_NAME should be %s but is %s\n", |
- expectDataName, U_ICUDATA_NAME); |
- } |
- |
- /* ICUDATA_NAME comes from the build system on *nix */ |
-#ifdef ICUDATA_NAME |
- if(uprv_strcmp(U_ICUDATA_NAME, ICUDATA_NAME)) |
- { |
- log_err("ICUDATA_NAME and U_ICUDATA_NAME don't match: " |
- "ICUDATA_NAME=%s, U_ICUDATA_NAME=%s. Check configure.in, icudefs.mk.in, utypes.h...\n", ICUDATA_NAME, U_ICUDATA_NAME); |
- } |
- else |
- { |
- log_verbose("ICUDATA_NAME=%s (from icudefs.mk), U_ICUDATA_NAME=%s (from utypes.h)\n", ICUDATA_NAME, U_ICUDATA_NAME); |
- } |
-#endif |
- |
-} |
- |
-/* test data swapping ------------------------------------------------------- */ |
- |
-#if U_PLATFORM == U_PF_OS400 |
-/* See comments in genccode.c on when this special implementation can be removed. */ |
-static const struct { |
- double bogus; |
- const char *bytes; |
-} gOffsetTOCAppDataItem1={ 0.0, /* alignment bytes */ |
- "\x00\x14" /* sizeof(UDataInfo) *//* MappedData { */ |
- "\xda" |
- "\x27" /* } */ |
- "\x00\x14" /* sizeof(UDataInfo) *//* UDataInfo { */ |
- "\0\0" |
- "\1" /* U_IS_BIG_ENDIAN */ |
- "\1" /* U_CHARSET_FAMILY */ |
- "\2" /* U_SIZEOF_WHAR_T */ |
- "\0" |
- "\x31\x31\x31\x31" |
- "\0\0\0\0" |
- "\0\0\0\0" /* } */ |
-}; |
-#else |
-static const struct { |
- double bogus; |
- MappedData bytes1; |
- UDataInfo bytes2; |
- uint8_t bytes3; |
-} gOffsetTOCAppDataItem1={ |
- 0.0, /* alignment bytes */ |
- { sizeof(UDataInfo), 0xda, 0x27 }, /* MappedData */ |
- |
- {sizeof(UDataInfo), |
- 0, |
- |
- U_IS_BIG_ENDIAN, |
- U_CHARSET_FAMILY, |
- sizeof(UChar), |
- 0, |
- |
- {0x31, 0x31, 0x31, 0x31}, /* dataFormat="1111" */ |
- {0, 0, 0, 0}, /* formatVersion */ |
- {0, 0, 0, 0}} /* dataVersion */ |
-}; |
-#endif |
- |
-static const UChar gOffsetTOCGarbage[] = { /* "I have been very naughty!" */ |
- 0x49, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x62, 0x65, 0x65, 0x6E, |
- 0x20, 0x76, 0x65, 0x72, 0x79, 0x20, 0x6E, 0x61, 0x75, 0x67, 0x68, 0x74, 0x79, 0x21 |
-}; |
- |
-/* Original source: icu/source/tools/genccode */ |
-static const struct { |
- uint16_t headerSize; |
- uint8_t magic1, magic2; |
- UDataInfo info; |
- char padding[8]; |
- uint32_t count, reserved; |
- const struct { |
- const char *const name; |
- const void *const data; |
- } toc[3]; |
-} gOffsetTOCAppData_dat = { |
- 32, /* headerSize */ |
- 0xda, /* magic1, (see struct MappedData in udata.c) */ |
- 0x27, /* magic2 */ |
- { /*UDataInfo */ |
- sizeof(UDataInfo), /* size */ |
- 0, /* reserved */ |
- U_IS_BIG_ENDIAN, |
- U_CHARSET_FAMILY, |
- sizeof(UChar), |
- 0, /* reserved */ |
- { /* data format identifier */ |
- 0x54, 0x6f, 0x43, 0x50}, /* "ToCP" */ |
- {1, 0, 0, 0}, /* format version major, minor, milli, micro */ |
- {0, 0, 0, 0} /* dataVersion */ |
- }, |
- {0,0,0,0,0,0,0,0}, /* Padding[8] */ |
- 3, /* count */ |
- 0, /* Reserved */ |
- { /* TOC structure */ |
- { "OffsetTOCAppData/a/b", &gOffsetTOCAppDataItem1 }, |
- { "OffsetTOCAppData/gOffsetTOCAppDataItem1", &gOffsetTOCAppDataItem1 }, |
- { "OffsetTOCAppData/gOffsetTOCGarbage", &gOffsetTOCGarbage } |
- } |
-}; |
- |
-/* Unfortunately, dictionaries are in a C++ header */ |
-U_CAPI int32_t U_EXPORT2 |
-udict_swap(const UDataSwapper *ds, const void *inData, int32_t length, void *outData, UErrorCode *pErrorCode); |
- |
-/* test cases for maximum data swapping code coverage */ |
-static const struct { |
- const char *name, *type; |
- UDataSwapFn *swapFn; |
-} swapCases[]={ |
- /* resource bundles */ |
- |
- /* resource bundle with many data types */ |
- {"*testtypes", "res", ures_swap}, |
- /* resource bundle with collation data */ |
- {"ja", "res", ures_swap}, |
- /* resource bundle with options-only collation data */ |
- {"ru", "res", ures_swap}, |
- {"el", "res", ures_swap}, |
- /* ICU's root */ |
- {"root", "res", ures_swap}, |
- /* Test a 32-bit key table. This is large. */ |
- {"*testtable32", "res", ures_swap}, |
- |
- /* ICU 4.2 resource bundle - data format 1.2 (little-endian ASCII) */ |
- {"*old_l_testtypes", "res", ures_swap}, |
- /* same for big-endian EBCDIC */ |
- {"*old_e_testtypes", "res", ures_swap}, |
- |
-#if !UCONFIG_NO_COLLATION |
- /* standalone collation data files */ |
- {"ucadata", "icu", ucol_swap}, |
-#if 0 |
- /* Starting with ICU 53, the "inverse UCA" data is integrated into ucadata.icu. */ |
- {"invuca", "icu", ucol_swapInverseUCA}, |
-#endif |
-#endif |
- |
-#if !UCONFIG_NO_LEGACY_CONVERSION |
- /* conversion table files */ |
- |
- /* SBCS conversion table file without extension */ |
- {"ibm-913_P100-2000", "cnv", ucnv_swap}, |
- /* EBCDIC_STATEFUL conversion table file with extension */ |
- {"ibm-1390_P110-2003", "cnv", ucnv_swap}, |
- /* DBCS extension-only conversion table file */ |
- {"ibm-16684_P110-2003", "cnv", ucnv_swap}, |
- /* EUC-TW (3-byte) conversion table file without extension */ |
- {"ibm-964_P110-1999", "cnv", ucnv_swap}, |
- /* GB 18030 (4-byte) conversion table file without extension */ |
- {"gb18030", "cnv", ucnv_swap}, |
- /* MBCS conversion table file with extension */ |
- {"*test4x", "cnv", ucnv_swap}, |
- /* |
- * MBCS conversion table file without extension, |
- * to test swapping and preflighting of UTF-8-friendly mbcsIndex[]. |
- */ |
- {"jisx-212", "cnv", ucnv_swap}, |
-#endif |
- |
-#if !UCONFIG_NO_CONVERSION |
- /* alias table */ |
- {"cnvalias", "icu", ucnv_swapAliases}, |
-#endif |
- |
-#if !UCONFIG_NO_IDNA |
- {"rfc3491", "spp", usprep_swap}, |
-#endif |
- |
-#if !UCONFIG_NO_BREAK_ITERATION |
- {"char", "brk", ubrk_swap}, |
- {"thaidict", "dict",udict_swap}, |
-#endif |
- |
-#if 0 |
- /* |
- * Starting with ICU 4.8, the Unicode property (value) aliases data |
- * is hardcoded in the ICU4C common library. |
- * The swapper was moved to the toolutil library for swapping for ICU4J. |
- */ |
- /* Unicode properties */ |
- {"pnames", "icu", upname_swap}, |
-#endif |
- |
-#if 0 |
- /* |
- * Starting with ICU4C 3.4, the core Unicode properties files |
- * (uprops.icu, ucase.icu, ubidi.icu, unorm.icu) |
- * are hardcoded in the common DLL and therefore not included |
- * in the data package any more. |
- * Their swapping code is moved from the common DLL to the icuswap tool so that |
- * we need not jump through hoops (like adding snapshots of these files |
- * to testdata) for code coverage in tests. |
- * See Jitterbug 4497. |
- * |
- * ICU4C 4.4 adds normalization data files again, e.g., nfkc.nrm. |
- */ |
- {"uprops", "icu", uprops_swap}, |
- {"ucase", "icu", ucase_swap}, |
- {"ubidi", "icu", ubidi_swap}, |
-#endif |
-#if !UCONFIG_NO_NORMALIZATION && !UCONFIG_ONLY_COLLATION |
- {"nfkc", "nrm", unorm2_swap}, |
-#if !UCONFIG_NO_REGULAR_EXPRESSIONS |
- {"confusables", "cfu", uspoof_swap}, /* spoof data missing without regex */ |
-#endif |
- |
-#endif |
- {"unames", "icu", uchar_swapNames} |
- /* the last item should not be #if'ed so that it can reliably omit the last comma */ |
-}; |
- |
-/* Large enough for the largest swappable data item. */ |
-#define SWAP_BUFFER_SIZE 1800000 |
- |
-static void U_CALLCONV |
-printError(void *context, const char *fmt, va_list args) { |
- vlog_info("[swap] ", fmt, args); |
- log_err("\n"); /* Register error */ |
-} |
- |
-static void |
-TestSwapCase(UDataMemory *pData, const char *name, |
- UDataSwapFn *swapFn, |
- uint8_t *buffer, uint8_t *buffer2) { |
- UDataSwapper *ds; |
- const void *inData, *inHeader; |
- int32_t length, dataLength, length2, headerLength; |
- |
- UErrorCode errorCode; |
- UErrorCode badStatus; |
- |
- UBool inEndian, oppositeEndian; |
- uint8_t inCharset, oppositeCharset; |
- |
- /* First we check that swapFn handles failures as expected. */ |
- errorCode = U_UNSUPPORTED_ERROR; |
- length = swapFn(NULL, NULL, 0, buffer, &errorCode); |
- if (length != 0 || errorCode != U_UNSUPPORTED_ERROR) { |
- log_err("%s() did not fail as expected - %s\n", name, u_errorName(errorCode)); |
- } |
- errorCode = U_ZERO_ERROR; |
- length = swapFn(NULL, NULL, 0, buffer, &errorCode); |
- if (length != 0 || errorCode != U_ILLEGAL_ARGUMENT_ERROR) { |
- log_err("%s() did not fail as expected with bad arguments - %s\n", name, u_errorName(errorCode)); |
- } |
- |
- |
- /* Continue with the rest of the tests. */ |
- errorCode = U_ZERO_ERROR; |
- inData=udata_getMemory(pData); |
- |
- /* |
- * get the data length if possible, to verify that swapping and preflighting |
- * handles the entire data |
- */ |
- dataLength=udata_getLength(pData); |
- |
- /* |
- * get the header and its length |
- * all of the swap implementation functions require the header to be included |
- */ |
- inHeader=udata_getRawMemory(pData); |
- headerLength=(int32_t)((const char *)inData-(const char *)inHeader); |
- |
- /* first swap to opposite endianness but same charset family */ |
- errorCode=U_ZERO_ERROR; |
- ds=udata_openSwapperForInputData(inHeader, headerLength, |
- !U_IS_BIG_ENDIAN, U_CHARSET_FAMILY, &errorCode); |
- if(U_FAILURE(errorCode)) { |
- log_err("udata_openSwapperForInputData(%s->!isBig+same charset) failed - %s\n", |
- name, u_errorName(errorCode)); |
- return; |
- } |
- |
- inEndian=ds->inIsBigEndian; |
- inCharset=ds->inCharset; |
- |
- oppositeEndian=!inEndian; |
- oppositeCharset= inCharset==U_ASCII_FAMILY ? U_EBCDIC_FAMILY : U_ASCII_FAMILY; |
- |
- /* make this test work with data files that are built for a different platform */ |
- if(inEndian!=U_IS_BIG_ENDIAN || inCharset!=U_CHARSET_FAMILY) { |
- udata_closeSwapper(ds); |
- ds=udata_openSwapper(inEndian, inCharset, oppositeEndian, inCharset, &errorCode); |
- if(U_FAILURE(errorCode)) { |
- log_err("udata_openSwapper(%s->!isBig+same charset) failed - %s\n", |
- name, u_errorName(errorCode)); |
- return; |
- } |
- } |
- |
- /* |
- Check error checking of swappable data not specific to this swapper. |
- This should always fail. |
- */ |
- badStatus = U_ZERO_ERROR; |
- length=swapFn(ds, &gOffsetTOCAppData_dat, -1, NULL, &badStatus); |
- if(badStatus != U_UNSUPPORTED_ERROR) { |
- log_err("swapFn(%s->!isBig+same charset) unexpectedly succeeded on bad data - %s\n", |
- name, u_errorName(errorCode)); |
- udata_closeSwapper(ds); |
- return; |
- } |
- |
- /* Now allow errors to be printed */ |
- ds->printError=printError; |
- |
- /* preflight the length */ |
- length=swapFn(ds, inHeader, -1, NULL, &errorCode); |
- if(U_FAILURE(errorCode)) { |
- log_err("swapFn(preflight %s->!isBig+same charset) failed - %s\n", |
- name, u_errorName(errorCode)); |
- udata_closeSwapper(ds); |
- return; |
- } |
- |
- /* compare the preflighted length against the data length */ |
- if(dataLength>=0 && (length+15)<(headerLength+dataLength)) { |
- log_err("swapFn(preflight %s->!isBig+same charset) length too small: %d < data length %d\n", |
- name, length, (headerLength+dataLength)); |
- udata_closeSwapper(ds); |
- return; |
- } |
- |
- /* swap, not in-place */ |
- length2=swapFn(ds, inHeader, length, buffer, &errorCode); |
- udata_closeSwapper(ds); |
- if(U_FAILURE(errorCode)) { |
- log_err("swapFn(%s->!isBig+same charset) failed - %s\n", |
- name, u_errorName(errorCode)); |
- return; |
- } |
- |
- /* compare the swap length against the preflighted length */ |
- if(length2!=length) { |
- log_err("swapFn(%s->!isBig+same charset) length differs from preflighting: %d != preflighted %d\n", |
- name, length2, length); |
- return; |
- } |
- |
- /* next swap to opposite charset family */ |
- ds=udata_openSwapper(oppositeEndian, inCharset, |
- oppositeEndian, oppositeCharset, |
- &errorCode); |
- if(U_FAILURE(errorCode)) { |
- log_err("udata_openSwapper(%s->!isBig+other charset) failed - %s\n", |
- name, u_errorName(errorCode)); |
- return; |
- } |
- ds->printError=printError; |
- |
- /* swap in-place */ |
- length2=swapFn(ds, buffer, length, buffer, &errorCode); |
- udata_closeSwapper(ds); |
- if(U_FAILURE(errorCode)) { |
- log_err("swapFn(%s->!isBig+other charset) failed - %s\n", |
- name, u_errorName(errorCode)); |
- return; |
- } |
- |
- /* compare the swap length against the original length */ |
- if(length2!=length) { |
- log_err("swapFn(%s->!isBig+other charset) length differs from original: %d != original %d\n", |
- name, length2, length); |
- return; |
- } |
- |
- /* finally swap to original platform values */ |
- ds=udata_openSwapper(oppositeEndian, oppositeCharset, |
- inEndian, inCharset, |
- &errorCode); |
- if(U_FAILURE(errorCode)) { |
- log_err("udata_openSwapper(%s->back to original) failed - %s\n", |
- name, u_errorName(errorCode)); |
- return; |
- } |
- ds->printError=printError; |
- |
- /* swap, not in-place */ |
- length2=swapFn(ds, buffer, length, buffer2, &errorCode); |
- udata_closeSwapper(ds); |
- if(U_FAILURE(errorCode)) { |
- log_err("swapFn(%s->back to original) failed - %s\n", |
- name, u_errorName(errorCode)); |
- return; |
- } |
- |
- /* compare the swap length against the original length */ |
- if(length2!=length) { |
- log_err("swapFn(%s->back to original) length differs from original: %d != original %d\n", |
- name, length2, length); |
- return; |
- } |
- |
- /* compare the final contents with the original */ |
- if(0!=uprv_memcmp(inHeader, buffer2, length)) { |
- const uint8_t *original; |
- uint8_t diff[8]; |
- int32_t i, j; |
- |
- log_err("swapFn(%s->back to original) contents differs from original\n", |
- name); |
- |
- /* find the first difference */ |
- original=(const uint8_t *)inHeader; |
- for(i=0; i<length && original[i]==buffer2[i]; ++i) {} |
- |
- /* find the next byte that is the same */ |
- for(j=i+1; j<length && original[j]!=buffer2[j]; ++j) {} |
- log_info(" difference at index %d=0x%x, until index %d=0x%x\n", i, i, j, j); |
- |
- /* round down to the last 4-boundary for better result output */ |
- i&=~3; |
- log_info("showing bytes from index %d=0x%x (length %d=0x%x):\n", i, i, length, length); |
- |
- /* print 8 bytes but limit to the buffer contents */ |
- length2=i+sizeof(diff); |
- if(length2>length) { |
- length2=length; |
- } |
- |
- /* print the original bytes */ |
- uprv_memset(diff, 0, sizeof(diff)); |
- for(j=i; j<length2; ++j) { |
- diff[j-i]=original[j]; |
- } |
- log_info(" original: %02x %02x %02x %02x %02x %02x %02x %02x\n", |
- diff[0], diff[1], diff[2], diff[3], diff[4], diff[5], diff[6], diff[7]); |
- |
- /* print the swapped bytes */ |
- uprv_memset(diff, 0, sizeof(diff)); |
- for(j=i; j<length2; ++j) { |
- diff[j-i]=buffer2[j]; |
- } |
- log_info(" swapped: %02x %02x %02x %02x %02x %02x %02x %02x\n", |
- diff[0], diff[1], diff[2], diff[3], diff[4], diff[5], diff[6], diff[7]); |
- } |
-} |
- |
-static void U_CALLCONV |
-printErrorToString(void *context, const char *fmt, va_list args) { |
- vsprintf((char *)context, fmt, args); |
-} |
- |
-#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION |
-static void |
-TestSwapData() { |
- char name[100]; |
- UDataSwapper *ds; |
- UDataMemory *pData; |
- uint8_t *buffer; |
- const char *pkg, *nm, *testPath; |
- UErrorCode errorCode = U_ZERO_ERROR; |
- int32_t i; |
- |
- buffer=(uint8_t *)malloc(2*SWAP_BUFFER_SIZE); |
- if(buffer==NULL) { |
- log_err("unable to allocate %d bytes\n", 2*SWAP_BUFFER_SIZE); |
- return; |
- } |
- |
- testPath=loadTestData(&errorCode); |
- if(U_FAILURE(errorCode)) { |
- log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(errorCode)); |
- } |
- |
- /* Test that printError works as expected. */ |
- errorCode=U_USELESS_COLLATOR_ERROR; |
- ds=udata_openSwapper(U_IS_BIG_ENDIAN, U_ASCII_FAMILY, |
- !U_IS_BIG_ENDIAN, U_ASCII_FAMILY, |
- &errorCode); |
- if (ds != NULL || errorCode != U_USELESS_COLLATOR_ERROR) { |
- log_err("udata_openSwapper should have returned NULL with bad argument\n", name); |
- } |
- errorCode=U_ZERO_ERROR; |
- ds=udata_openSwapper(U_IS_BIG_ENDIAN, U_ASCII_FAMILY, |
- !U_IS_BIG_ENDIAN, U_ASCII_FAMILY, |
- &errorCode); |
- ds->printError=printErrorToString; |
- ds->printErrorContext=name; |
- udata_printError(ds, "This %s a %s", "is", "test"); |
- udata_closeSwapper(ds); |
- if (strcmp(name, "This is a test") != 0) { |
- log_err("udata_printError can't properly print error messages. Got = %s\n", name); |
- } |
- errorCode = U_USELESS_COLLATOR_ERROR; |
- ds=udata_openSwapperForInputData(NULL, 0, |
- !U_IS_BIG_ENDIAN, U_ASCII_FAMILY, |
- &errorCode); |
- if (ds != NULL || errorCode != U_USELESS_COLLATOR_ERROR) { |
- log_err("udata_openSwapperForInputData should have returned NULL with bad argument\n", name); |
- } |
- errorCode=U_ZERO_ERROR; |
- ds=udata_openSwapperForInputData(NULL, 0, |
- !U_IS_BIG_ENDIAN, U_ASCII_FAMILY, |
- &errorCode); |
- if (ds != NULL || errorCode != U_ILLEGAL_ARGUMENT_ERROR) { |
- log_err("udata_openSwapperForInputData should have returned NULL with bad argument\n", name); |
- } |
- errorCode=U_ZERO_ERROR; |
- memset(buffer, 0, sizeof(2*SWAP_BUFFER_SIZE)); |
- ds=udata_openSwapperForInputData(buffer, 2*SWAP_BUFFER_SIZE, |
- !U_IS_BIG_ENDIAN, U_ASCII_FAMILY, |
- &errorCode); |
- if (ds != NULL || errorCode != U_UNSUPPORTED_ERROR) { |
- log_err("udata_openSwapperForInputData should have returned NULL with bad argument\n", name); |
- } |
- errorCode=U_ZERO_ERROR; |
- |
- /* Test argument checking. ucol_swap is normally tested via ures_swap, and isn't normally called directly. */ |
-#if !UCONFIG_NO_COLLATION |
- ucol_swap(NULL, NULL, -1, NULL, &errorCode); |
- if (errorCode != U_ILLEGAL_ARGUMENT_ERROR) { |
- log_err("ucol_swap did not fail as expected\n", name); |
- } |
- errorCode=U_ZERO_ERROR; |
-#endif |
- |
- for(i=0; i<UPRV_LENGTHOF(swapCases); ++i) { |
- /* build the name for logging */ |
- errorCode=U_ZERO_ERROR; |
- if(swapCases[i].name[0]=='*') { |
- pkg=testPath; |
- nm=swapCases[i].name+1; |
- uprv_strcpy(name, "testdata"); |
- } else if (uprv_strcmp(swapCases[i].type, "brk")==0 |
- || uprv_strcmp(swapCases[i].type, "dict")==0) { |
- pkg=U_ICUDATA_BRKITR; |
- nm=swapCases[i].name; |
- uprv_strcpy(name, U_ICUDATA_BRKITR); |
-#if !UCONFIG_NO_COLLATION |
- } else if (uprv_strcmp(swapCases[i].name, "ucadata")==0 |
- || uprv_strcmp(swapCases[i].name, "invuca")==0) { |
- pkg=U_ICUDATA_COLL; |
- nm=swapCases[i].name; |
- uprv_strcpy(name, U_ICUDATA_COLL); |
-#endif /* !UCONFIG_NO_COLLATION */ |
- } else { |
- pkg=NULL; |
- nm=swapCases[i].name; |
- uprv_strcpy(name, "NULL"); |
- } |
- uprv_strcat(name, "/"); |
- uprv_strcat(name, nm); |
- uprv_strcat(name, "."); |
- uprv_strcat(name, swapCases[i].type); |
- |
- pData=udata_open(pkg, swapCases[i].type, nm, &errorCode); |
- |
- if(U_SUCCESS(errorCode)) { |
- TestSwapCase(pData, name, swapCases[i].swapFn, buffer, buffer+SWAP_BUFFER_SIZE); |
- udata_close(pData); |
- } else { |
- log_data_err("udata_open(%s) failed - %s\n", |
- name, u_errorName(errorCode)); |
- } |
- } |
- |
- free(buffer); |
-} |
-#endif |
- |
-static void PointerTableOfContents() { |
- UDataMemory *dataItem; |
- UErrorCode status=U_ZERO_ERROR; |
- |
- /* |
- * Got testdata.dat into memory, now we try setAppData using the memory image. |
- */ |
- |
- status=U_ZERO_ERROR; |
- udata_setAppData("OffsetTOCAppData", &gOffsetTOCAppData_dat, &status); |
- if (status != U_ZERO_ERROR) { |
- log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData1\", fileBuf, status) \n" |
- " returned status of %s\n", u_errorName(status)); |
- return; |
- } |
- |
- dataItem = udata_open("OffsetTOCAppData", "", "gOffsetTOCAppDataItem1", &status); |
- if (U_FAILURE(status)) { |
- log_err("FAIL: gOffsetTOCAppDataItem1 could not be opened. status = %s\n", u_errorName(status)); |
- } |
- if (udata_getMemory(dataItem) != NULL) { |
- log_verbose("FAIL: udata_getMemory(dataItem) passed\n"); |
- } |
- else { |
- log_err("FAIL: udata_getMemory returned NULL\n", u_errorName(status)); |
- } |
- udata_close(dataItem); |
- |
- dataItem = udata_open("OffsetTOCAppData-a", "", "b", &status); |
- if (U_FAILURE(status)) { |
- log_err("FAIL: gOffsetTOCAppDataItem1 in tree \"a\" could not be opened. status = %s\n", u_errorName(status)); |
- } |
- if (udata_getMemory(dataItem) != NULL) { |
- log_verbose("FAIL: udata_getMemory(dataItem) in tree \"a\" passed\n"); |
- } |
- else { |
- log_err("FAIL: udata_getMemory returned NULL\n", u_errorName(status)); |
- } |
- udata_close(dataItem); |
- |
- dataItem = udata_open("OffsetTOCAppData", "", "gOffsetTOCGarbage", &status); |
- if (U_SUCCESS(status)) { |
- log_err("FAIL: gOffsetTOCGarbage should not be opened. status = %s\n", u_errorName(status)); |
- } |
- dataItem = udata_open("OffsetTOCAppData", "", "gOffsetTOCNonExistent", &status); |
- if (U_SUCCESS(status)) { |
- log_err("FAIL: gOffsetTOCNonExistent should not be found. status = %s\n", u_errorName(status)); |
- } |
- |
-} |
- |
-static void SetBadCommonData(void) { |
- /* It's difficult to test that udata_setCommonData really works within the test framework. |
- So we just test that foolish people can't do bad things. */ |
- UErrorCode status; |
- char badBuffer[sizeof(gOffsetTOCAppData_dat)]; |
- |
- memset(badBuffer, 0, sizeof(badBuffer)); |
- strcpy(badBuffer, "Hello! I'm not good data."); |
- |
- /* Check that we don't do anything */ |
- status = U_FILE_ACCESS_ERROR; |
- udata_setCommonData(&gOffsetTOCAppData_dat, &status); |
- if (status != U_FILE_ACCESS_ERROR) { |
- log_err("FAIL: udata_setCommonData changed the failure code.\n"); |
- } |
- /* Check that we fail correctly */ |
- status = U_ZERO_ERROR; |
- udata_setCommonData(NULL, &status); |
- if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
- log_err("FAIL: udata_setCommonData did not fail with bad arguments.\n"); |
- } |
- |
- /* Check that we verify that the data isn't bad */ |
- status = U_ZERO_ERROR; |
- udata_setAppData("invalid path", badBuffer, &status); |
- if (status != U_INVALID_FORMAT_ERROR) { |
- log_err("FAIL: udata_setAppData doesn't verify data validity.\n"); |
- } |
-} |
- |
-// Check the override loading of time zone .res files from a specified path |
-// |
-// Hand testing notes: |
-// 1. Run this test with the environment variable set. The following should induce faiures: |
-// ICU_TIMEZONE_FILES_DIR=../testdata/out/build LD_LIBRARY_PATH=../../lib:../../stubdata:../../tools/ctestfw:$LD_LIBRARY_PATH ./cintltst /udatatst/TestTZDataDir |
-// 2. Build ICU with with U_TIMEZONE_FILES_DIR defined. This should also induce failures. |
-// CPPFLAGS=-DU_TIMEZONE_FILES_DIR\=`pwd`/test/testdata/out/testdata ./runConfigureICU Linux |
-// make check |
- |
-static void TestTZDataDir(void) { |
-#if !UCONFIG_NO_FORMATTING |
- UErrorCode status = U_ZERO_ERROR; |
- const char *tzDataVersion; |
- const char *testDataPath; |
- |
- // Verify that default ICU time zone data version is something newer than 2014a. |
- tzDataVersion = ucal_getTZDataVersion(&status); |
- // printf("tz data version is %s\n", tzDataVersion); |
- if (U_FAILURE(status)) { |
- log_data_err("Failed call to ucal_getTZDataVersion - %s\n", u_errorName(status)); |
- return; |
- } else if (strcmp("2014a", tzDataVersion) == 0) { |
- log_err("File %s:%d - expected something newer than time zone data 2014a.\n", __FILE__, __LINE__, tzDataVersion); |
- } |
- |
- testDataPath = loadTestData(&status); |
- // The path produced by loadTestData() will look something like |
- // whatever/.../testdata/out/testdata |
- // The test data puts an old (2014a) version of the time zone data there. |
- |
- // Switch ICU to the testdata version of zoneinfo64.res, which is verison 2014a. |
- ctest_resetICU(); |
- u_setTimeZoneFilesDirectory(testDataPath, &status); |
- tzDataVersion = ucal_getTZDataVersion(&status); |
- if (strcmp("2014a", tzDataVersion) != 0) { |
- log_err("File %s:%d - expected \"2014a\"; actual \"%s\"\n", __FILE__, __LINE__, tzDataVersion); |
- } |
- |
- ctest_resetICU(); // Return ICU to using its standard tz data. |
- tzDataVersion = ucal_getTZDataVersion(&status); |
- // printf("tz data version is %s\n", tzDataVersion); |
- if (strcmp("2014a", tzDataVersion) == 0) { |
- log_err("File %s:%d - expected something newer than time zone data 2014a.\n", __FILE__, __LINE__, tzDataVersion); |
- } |
-#endif |
-} |