+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
* COPYRIGHT:
- * Copyright (c) 1998-2003, International Business Machines Corporation and
+ * Copyright (c) 1998-2016, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
/*
-* File test.c
+* 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 <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
+#include "ubrkimpl.h"
+#include "toolutil.h" /* for uprv_fileExists() */
#include <stdlib.h>
#include <stdio.h>
-#ifdef WIN32
-#include <io.h>
-#else
-#include <unistd.h>
-#endif
+/* 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 TestUDataSetAppData(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, &TestUDataSetAppData, "udatatst/TestUDataSetAppData" );
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
}
#endif
+#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
static void TestUDataOpen(){
UDataMemory *result;
UErrorCode status=U_ZERO_ERROR;
const char* memMap[][2]={
- {"tz", "icu"},
+ {"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* 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")+1 ) );
+ + strlen("/build/tmp/..")+1 ) );
char *icuDataFilePath = 0;
- struct stat stat_buf;
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(); */
-
- strcat(strcpy(path, ctest_dataOutDir()), U_ICUDATA_NAME);
-
- log_verbose("Testing udata_open()\n");
+ log_verbose("Testing udata_open(%s)\n", testPath);
result=udata_open(testPath, type, name, &status);
if(U_FAILURE(status)){
- log_err("FAIL: udata_open() failed for path = %s, name=%s, type=%s, \n errorcode=%s\n", testPath, name, type, myErrorName(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);
}
- /* 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 (stat(icuDataFilePath, &stat_buf) == 0)
{
- int i;
- log_verbose("Testing udata_open() on %s\n", icuDataFilePath);
- for(i=0; i<sizeof(memMap)/sizeof(memMap[0]); i++){
- /* lots_of_mallocs(); */
+ 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<UPRV_LENGTHOF(memMap); i++){
+ /* lots_of_mallocs(); */
status=U_ZERO_ERROR;
result=udata_open(path, memMap[i][1], memMap[i][0], &status);
if(U_FAILURE(status)) {
- log_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));
+ 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);
}
- else
+ /* try again, adding /tmp */
{
- /* lots_of_mallocs(); */
- log_verbose("Skipping tests of udata_open() on %s. File not present in this configuration.\n",
- icuDataFilePath);
+ 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<UPRV_LENGTHOF(memMap); 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(); */
strcat(icuDataFilePath, "build");
strcat(icuDataFilePath, dirSepString);
strcat(icuDataFilePath, U_ICUDATA_NAME);
- strcat(icuDataFilePath, "_");
- strcat(icuDataFilePath, "tz.icu");
+ strcat(icuDataFilePath, dirSepString);
+ strcat(icuDataFilePath, "cnvalias.icu");
/* lots_of_mallocs(); */
- if (stat(icuDataFilePath, &stat_buf) == 0)
+ if (uprv_fileExists(icuDataFilePath))
{
int i;
log_verbose("%s exists, so..\n", icuDataFilePath);
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++){
+ for(i=0; i<UPRV_LENGTHOF(memMap); i++){
status=U_ZERO_ERROR;
result=udata_open(icuDataFilePath, memMap[i][1], memMap[i][0], &status);
if(U_FAILURE(status)) {
- log_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));
+ 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);
status = U_ZERO_ERROR;
result = udata_open( testPath, "typ", "nam", &status);
if (status != U_ZERO_ERROR) {
- log_err("FAIL: udata_open( \"%s\", \"typ\", \"nam\") returned status %s\n", testPath, u_errorName(status));
+ log_data_err("FAIL: udata_open( \"%s\", \"typ\", \"nam\") returned status %s\n", testPath, u_errorName(status));
}
udata_close(result);
free(icuDataFilePath);
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;
- int fileHandle = 0; /* We are going to read the testdata.dat file */
- struct stat statBuf;
- size_t fileSize = 0;
- char *fileBuf = 0;
- size_t i;
-
- /* Open the testdata.dat file, using normal */
- const char* tdrelativepath = loadTestData(&status);
- char* filePath=(char*)malloc(sizeof(char) * (strlen(tdrelativepath) + strlen(".dat") +1 +strlen(tdrelativepath)) );
-
- strcpy(filePath, tdrelativepath);
- strcat(filePath, ".dat");
-
- log_verbose("Testing udata_setAppData() with %s\n", filePath);
-
-#ifdef WIN32
- fileHandle = open( filePath, O_RDONLY | O_BINARY );
-#else
- fileHandle = open( filePath, O_RDONLY);
-#endif
- if( fileHandle == -1 ) {
- log_err("FAIL: TestUDataSetAppData() can not open(\"%s\", O_RDONLY)\n", filePath);
- goto cleanupAndReturn;
- }
-
- /*
- *Find the size of testdata.dat, and read the whole thing into memory
+ /*
+ * First we try some monkey business and try to do bad things.
*/
- if (fstat(fileHandle, &statBuf) == 0) {
- fileSize = statBuf.st_size;
- }
- if (fileSize == 0) {
- log_err("FAIL: TestUDataSetAppData() can not find size of file \"%s\".\n", filePath);
- goto cleanupAndReturn;
- }
- fileBuf = (char *)ctst_malloc(fileSize);
- if (fileBuf == 0) {
- log_err("FAIL: TestUDataSetAppData() can not malloc(%d) for file \"%s\".\n", fileSize, filePath);
- goto cleanupAndReturn;
- }
-
- i = read(fileHandle, fileBuf, fileSize);
- if (i != fileSize) {
- log_err("FAIL: TestUDataSetAppData() error reading file \"%s\".\n", filePath);
- goto cleanupAndReturn;
+ 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", fileBuf, &status);
+ 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));
- goto cleanupAndReturn;
+ return;
}
- udata_setAppData("appData2", fileBuf, &status);
+ 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));
- goto cleanupAndReturn;
+ return;
}
/* If we try to setAppData with the same name a second time, we should get a
* a using default warning.
*/
- udata_setAppData("appData2", fileBuf, &status);
+ 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));
package of a contained item.
dataItem = udata_open("appData1", "res", "te_IN", &status); **/
+}
-cleanupAndReturn:
- /* Note: fileBuf is not deleted because ICU retains a pointer to it
- * forever (until ICU is shut down).
- */
- if (fileHandle > 0) {
- close(fileHandle);
+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));
}
- free(filePath);
- return;
+
+ /** 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();
}
isAcceptable1(void *context,
const char *type, const char *name,
const UDataInfo *pInfo) {
+ (void)context; // suppress compiler warnings about unused variable
if( pInfo->size>=20 &&
pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
isAcceptable2(void *context,
const char *type, const char *name,
const UDataInfo *pInfo){
+ (void)context; // suppress compiler warnings about unused variable
UVersionInfo unicodeVersion;
u_getUnicodeVersion(unicodeVersion);
isAcceptable3(void *context,
const char *type, const char *name,
const UDataInfo *pInfo){
+ (void)context; // suppress compiler warnings about unused variable
if( pInfo->size>=20 &&
pInfo->isBigEndian==U_IS_BIG_ENDIAN &&
}
+#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"
+ "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_err("FAIL: udata_openChoice() failed name=%s, type=%s, \n errorcode=%s\n", name[0], type, myErrorName(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_err("FAIL: udata_openChoice() failed name=%s, type=%s, \n errorcode=%s\n", name[1], type, myErrorName(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_err("FAIL: udata_openChoice() failed path=%s name=%s, type=%s, \n errorcode=%s\n", testPath, name[2], type, myErrorName(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
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_err("failed to load data at p=%s t=%s n=%s, isAcceptable", path, type, name);
+ 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++;
}
else {
- log_err("FAIL: failed to either load the data or to reject the loaded data. ERROR=%s\n", myErrorName(status) );
+ 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_err("FAIL: failed to load the data and accept it. ERROR=%s\n", myErrorName(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");
}
}
-
static void TestUDataGetInfo() {
UDataMemory *result;
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_err("FAIL: udata_open() failed for path = NULL, name=%s, type=%s, \n errorcode=%s\n", name, type, myErrorName(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);
log_verbose("Testing udata_getInfo() for test.icu\n");
result=udata_open(testPath, type, name2, &status);
if(U_FAILURE(status)) {
- log_err("FAIL: udata_open() failed for path=%s name2=%s, type=%s, \n errorcode=%s\n", testPath, name2, type, myErrorName(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);
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_err("FAIL: udata_openChoice() failed for name=%s, type=%s, \n errorcode=%s\n", name, type, myErrorName(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);
log_verbose("Testing udata_getMemory for \"test.icu\"()\n");
result=udata_openChoice(testPath, type, name2, isAcceptable3, NULL, &status);
if(U_FAILURE(status)){
- log_err("FAIL: udata_openChoice() failed for path=%s name=%s, type=%s, \n errorcode=%s\n", testPath, name2, type, myErrorName(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);
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_err("FAIL: udata_open() is supposed to fail for path = %s, name=%s, type=%s, \n errorcode !=U_ZERO_ERROR\n", testPath, name, type);
+ 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 {
/* 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);
-
- icu = ures_open(NULL, "root", &status);
- if(U_FAILURE(status))
- {
- log_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_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);
+ 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()
{
switch(U_CHARSET_FAMILY)
{
case U_ASCII_FAMILY:
- switch(U_IS_BIG_ENDIAN)
+ switch((int)U_IS_BIG_ENDIAN)
{
case 1:
typeChar = 'b';
break;
}
- sprintf(expectDataName, "%s%d%d%c",
+ /* Only major number is needed. */
+ sprintf(expectDataName, "%s%d%c",
"icudt",
(int)icuVersion[0],
- (int)icuVersion[1],
typeChar);
log_verbose("Expected: %s\n", expectDataName);
#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 */
+ 0
+};
+#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) {
+ (void)context; // suppress compiler warnings about unused variable
+ 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
+}
projects / apple / icu.git / blobdiff