/*
**********************************************************************
* Copyright (C) 2002-2012, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* file name: iotest.cpp
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:4
*
* created on: 2002feb21
* created by: George Rhoten
*/
#include "unicode/ustdio.h"
#include "unicode/uclean.h"
#include "unicode/ucnv.h"
#include "unicode/uchar.h"
#include "unicode/unistr.h"
#include "unicode/ustring.h"
#include "ustr_cnv.h"
#include "iotest.h"
#include "unicode/tstdtmod.h"
#include "putilimp.h"
#include <string.h>
#include <stdlib.h>
class DataDrivenLogger : public TestLog {
static const char* fgDataDir;
static char *fgTestDataPath;
public:
static void cleanUp() {
if (fgTestDataPath) {
free(fgTestDataPath);
fgTestDataPath = NULL;
}
}
virtual void errln( const UnicodeString &message ) {
char buffer[4000];
message.extract(0, message.length(), buffer, sizeof(buffer));
buffer[3999] = 0; /* NULL terminate */
log_err(buffer);
}
virtual void logln( const UnicodeString &message ) {
char buffer[4000];
message.extract(0, message.length(), buffer, sizeof(buffer));
buffer[3999] = 0; /* NULL terminate */
log_info(buffer);
}
virtual void dataerrln( const UnicodeString &message ) {
char buffer[4000];
message.extract(0, message.length(), buffer, sizeof(buffer));
buffer[3999] = 0; /* NULL terminate */
log_data_err(buffer);
}
static const char * pathToDataDirectory(void)
{
if(fgDataDir != NULL) {
return fgDataDir;
}
/* U_TOPSRCDIR is set by the makefiles on UNIXes when building cintltst and intltst
// to point to the top of the build hierarchy, which may or
// may not be the same as the source directory, depending on
// the configure options used. At any rate,
// set the data path to the built data from this directory.
// The value is complete with quotes, so it can be used
// as-is as a string constant.
*/
#if defined (U_TOPSRCDIR)
{
fgDataDir = U_TOPSRCDIR U_FILE_SEP_STRING "data" U_FILE_SEP_STRING;
}
#else
/* On Windows, the file name obtained from __FILE__ includes a full path.
* This file is "wherever\icu\source\test\cintltst\cintltst.c"
* Change to "wherever\icu\source\data"
*/
{
static char p[sizeof(__FILE__) + 10];
char *pBackSlash;
int i;
strcpy(p, __FILE__);
/* We want to back over three '\' chars. */
/* Only Windows should end up here, so looking for '\' is safe. */
for (i=1; i<=3; i++) {
pBackSlash = strrchr(p, U_FILE_SEP_CHAR);
if (pBackSlash != NULL) {
*pBackSlash = 0; /* Truncate the string at the '\' */
}
}
if (pBackSlash != NULL) {
/* We found and truncated three names from the path.
* Now append "source\data" and set the environment
*/
strcpy(pBackSlash, U_FILE_SEP_STRING "data" U_FILE_SEP_STRING );
fgDataDir = p;
}
else {
/* __FILE__ on MSVC7 does not contain the directory */
FILE *file = fopen(".." U_FILE_SEP_STRING".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "Makefile.in", "r");
if (file) {
fclose(file);
fgDataDir = ".." U_FILE_SEP_STRING".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING;
}
else {
fgDataDir = ".." U_FILE_SEP_STRING".." U_FILE_SEP_STRING".." U_FILE_SEP_STRING".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING;
}
}
}
#endif
return fgDataDir;
}
static const char* loadTestData(UErrorCode& err){
if( fgTestDataPath == NULL){
const char* directory=NULL;
UResourceBundle* test =NULL;
char* tdpath=NULL;
const char* tdrelativepath;
#if defined (U_TOPBUILDDIR)
tdrelativepath = "test" U_FILE_SEP_STRING "testdata" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;
directory = U_TOPBUILDDIR;
#else
tdrelativepath = ".." U_FILE_SEP_STRING "test" U_FILE_SEP_STRING "testdata" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;
directory = pathToDataDirectory();
#endif
tdpath = (char*) malloc(sizeof(char) *(( strlen(directory) * strlen(tdrelativepath)) + 100));
/* u_getDataDirectory shoul return \source\data ... set the
* directory to ..\source\data\..\test\testdata\out\testdata
*/
strcpy(tdpath, directory);
strcat(tdpath, tdrelativepath);
strcat(tdpath,"testdata");
test=ures_open(tdpath, "testtypes", &err);
if(U_FAILURE(err)){
err = U_FILE_ACCESS_ERROR;
log_data_err("Could not load testtypes.res in testdata bundle with path %s - %s\n", tdpath, u_errorName(err));
return "";
}
ures_close(test);
fgTestDataPath = tdpath;
}
return fgTestDataPath;
}
virtual const char* getTestDataPath(UErrorCode& err) {
return loadTestData(err);
}
};
const char* DataDrivenLogger::fgDataDir = NULL;
char* DataDrivenLogger::fgTestDataPath = NULL;
#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO
static int64_t
uto64(const UChar *buffer)
{
int64_t result = 0;
/* iterate through buffer */
while(*buffer) {
/* read the next digit */
result *= 16;
if (!u_isxdigit(*buffer)) {
log_err("\\u%04X is not a valid hex digit for this test\n", (UChar)*buffer);
}
result += *buffer - 0x0030 - (*buffer >= 0x0041 ? (*buffer >= 0x0061 ? 39 : 7) : 0);
buffer++;
}
return result;
}
#endif
U_CDECL_BEGIN
static void U_CALLCONV DataDrivenPrintf(void)
{
#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO
UErrorCode errorCode;
TestDataModule *dataModule;
TestData *testData;
const DataMap *testCase;
DataDrivenLogger logger;
UChar uBuffer[512];
char cBuffer[512];
char cFormat[sizeof(cBuffer)];
char cExpected[sizeof(cBuffer)];
UnicodeString tempStr;
UChar format[512];
UChar expectedResult[512];
UChar argument[512];
int32_t i;
int8_t i8;
int16_t i16;
int32_t i32;
int64_t i64;
double dbl;
int32_t uBufferLenReturned;
const char *fileLocale = "en_US_POSIX";
int32_t uFileBufferLenReturned;
LocalUFILEPointer testFile;
errorCode=U_ZERO_ERROR;
dataModule=TestDataModule::getTestDataModule("icuio", logger, errorCode);
if(U_SUCCESS(errorCode)) {
testData=dataModule->createTestData("printf", errorCode);
if(U_SUCCESS(errorCode)) {
for(i=0; testData->nextCase(testCase, errorCode); ++i) {
if(U_FAILURE(errorCode)) {
log_err("error retrieving icuio/printf test case %d - %s\n",
i, u_errorName(errorCode));
errorCode=U_ZERO_ERROR;
continue;
}
testFile.adoptInstead(u_fopen(STANDARD_TEST_FILE, "w", fileLocale, "UTF-8"));
if (testFile.isNull()) {
log_err("Can't open test file - %s\n",
STANDARD_TEST_FILE);
continue;
}
u_memset(uBuffer, 0x2A, sizeof(uBuffer)/sizeof(uBuffer[0]));
uBuffer[sizeof(uBuffer)/sizeof(uBuffer[0])-1] = 0;
tempStr=testCase->getString("format", errorCode);
tempStr.extract(format, sizeof(format)/sizeof(format[0]), errorCode);
tempStr=testCase->getString("result", errorCode);
tempStr.extract(expectedResult, sizeof(expectedResult)/sizeof(expectedResult[0]), errorCode);
tempStr=testCase->getString("argument", errorCode);
tempStr.extract(argument, sizeof(argument)/sizeof(argument[0]), errorCode);
u_austrncpy(cBuffer, format, sizeof(cBuffer));
if(U_FAILURE(errorCode)) {
log_err("error retrieving icuio/printf test case %d - %s\n",
i, u_errorName(errorCode));
errorCode=U_ZERO_ERROR;
continue;
}
log_verbose("Test %d: format=\"%s\"\n", i, cBuffer);
switch (testCase->getString("argumentType", errorCode)[0]) {
case 0x64: // 'd' double
dbl = atof(u_austrcpy(cBuffer, argument));
uBufferLenReturned = u_sprintf_u(uBuffer, format, dbl);
uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, dbl);
break;
case 0x31: // '1' int8_t
i8 = (int8_t)uto64(argument);
uBufferLenReturned = u_sprintf_u(uBuffer, format, i8);
uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, i8);
break;
case 0x32: // '2' int16_t
i16 = (int16_t)uto64(argument);
uBufferLenReturned = u_sprintf_u(uBuffer, format, i16);
uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, i16);
break;
case 0x34: // '4' int32_t
i32 = (int32_t)uto64(argument);
uBufferLenReturned = u_sprintf_u(uBuffer, format, i32);
uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, i32);
break;
case 0x38: // '8' int64_t
i64 = uto64(argument);
uBufferLenReturned = u_sprintf_u(uBuffer, format, i64);
uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, i64);
break;
case 0x73: // 's' char *
u_austrncpy(cBuffer, argument, sizeof(cBuffer));
uBufferLenReturned = u_sprintf_u(uBuffer, format, cBuffer);
uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, cBuffer);
break;
case 0x53: // 'S' UChar *
uBufferLenReturned = u_sprintf_u(uBuffer, format, argument);
uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, argument);
break;
default:
uBufferLenReturned = 0;
uFileBufferLenReturned = 0;
log_err("Unknown type %c for test %d\n", testCase->getString("argumentType", errorCode)[0], i);
}
if (u_strcmp(uBuffer, expectedResult) != 0) {
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
u_austrncpy(cFormat, format, sizeof(cFormat));
u_austrncpy(cExpected, expectedResult, sizeof(cExpected));
cBuffer[sizeof(cBuffer)-1] = 0;
log_err("FAILURE string test case %d \"%s\" - Got: \"%s\" Expected: \"%s\"\n",
i, cFormat, cBuffer, cExpected);
}
if (uBufferLenReturned <= 0) {
log_err("FAILURE test case %d - \"%s\" is an empty string.\n",
i, cBuffer);
}
else if (uBuffer[uBufferLenReturned-1] == 0
|| uBuffer[uBufferLenReturned] != 0
|| uBuffer[uBufferLenReturned+1] != 0x2A
|| uBuffer[uBufferLenReturned+2] != 0x2A)
{
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
cBuffer[sizeof(cBuffer)-1] = 0;
log_err("FAILURE test case %d - \"%s\" wrong amount of characters was written. Got %d.\n",
i, cBuffer, uBufferLenReturned);
}
testFile.adoptInstead(u_fopen(STANDARD_TEST_FILE, "r", fileLocale, "UTF-8"));
if (testFile.isNull()) {
log_err("Can't open test file - %s\n",
STANDARD_TEST_FILE);
}
uBuffer[0]=0;
u_fgets(uBuffer, sizeof(uBuffer)/sizeof(uBuffer[0]), testFile.getAlias());
if (u_strcmp(uBuffer, expectedResult) != 0) {
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
u_austrncpy(cFormat, format, sizeof(cFormat));
u_austrncpy(cExpected, expectedResult, sizeof(cExpected));
cBuffer[sizeof(cBuffer)-1] = 0;
log_err("FAILURE file test case %d \"%s\" - Got: \"%s\" Expected: \"%s\"\n",
i, cFormat, cBuffer, cExpected);
}
if (uFileBufferLenReturned != uBufferLenReturned)
{
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
cBuffer[sizeof(cBuffer)-1] = 0;
log_err("FAILURE uFileBufferLenReturned(%d) != uBufferLenReturned(%d)\n",
uFileBufferLenReturned, uBufferLenReturned);
}
if(U_FAILURE(errorCode)) {
log_err("error running icuio/printf test case %d - %s\n",
i, u_errorName(errorCode));
errorCode=U_ZERO_ERROR;
continue;
}
}
delete testData;
}
delete dataModule;
}
else {
log_data_err("Failed: could not load test icuio data\n");
}
#endif
}
U_CDECL_END
U_CDECL_BEGIN
static void U_CALLCONV DataDrivenScanf(void)
{
#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO
UErrorCode errorCode;
TestDataModule *dataModule;
TestData *testData;
const DataMap *testCase;
DataDrivenLogger logger;
UChar uBuffer[512];
char cBuffer[512];
char cExpected[sizeof(cBuffer)];
UnicodeString tempStr;
UChar format[512];
UChar expectedResult[512];
UChar argument[512];
int32_t i;
int8_t i8, expected8;
int16_t i16, expected16;
int32_t i32, expected32;
int64_t i64, expected64;
double dbl, expectedDbl;
volatile float flt, expectedFlt; // Use volatile in order to get around an Intel compiler issue.
int32_t uBufferLenReturned;
//const char *fileLocale = "en_US_POSIX";
//int32_t uFileBufferLenReturned;
//UFILE *testFile;
errorCode=U_ZERO_ERROR;
dataModule=TestDataModule::getTestDataModule("icuio", logger, errorCode);
if(U_SUCCESS(errorCode)) {
testData=dataModule->createTestData("scanf", errorCode);
if(U_SUCCESS(errorCode)) {
for(i=0; testData->nextCase(testCase, errorCode); ++i) {
if(U_FAILURE(errorCode)) {
log_err("error retrieving icuio/printf test case %d - %s\n",
i, u_errorName(errorCode));
errorCode=U_ZERO_ERROR;
continue;
}
/* testFile = u_fopen(STANDARD_TEST_FILE, "w", fileLocale, "UTF-8");
if (!testFile) {
log_err("Can't open test file - %s\n",
STANDARD_TEST_FILE);
}*/
u_memset(uBuffer, 0x2A, sizeof(uBuffer)/sizeof(uBuffer[0]));
uBuffer[sizeof(uBuffer)/sizeof(uBuffer[0])-1] = 0;
tempStr=testCase->getString("format", errorCode);
tempStr.extract(format, sizeof(format)/sizeof(format[0]), errorCode);
tempStr=testCase->getString("result", errorCode);
tempStr.extract(expectedResult, sizeof(expectedResult)/sizeof(expectedResult[0]), errorCode);
tempStr=testCase->getString("argument", errorCode);
tempStr.extract(argument, sizeof(argument)/sizeof(argument[0]), errorCode);
u_austrncpy(cBuffer, format, sizeof(cBuffer));
if(U_FAILURE(errorCode)) {
log_err("error retrieving icuio/printf test case %d - %s\n",
i, u_errorName(errorCode));
errorCode=U_ZERO_ERROR;
continue;
}
log_verbose("Test %d: format=\"%s\"\n", i, cBuffer);
switch (testCase->getString("argumentType", errorCode)[0]) {
case 0x64: // 'd' double
expectedDbl = atof(u_austrcpy(cBuffer, expectedResult));
uBufferLenReturned = u_sscanf_u(argument, format, &dbl);
//uFileBufferLenReturned = u_fscanf_u(testFile, format, dbl);
if (dbl != expectedDbl) {
log_err("error in scanf test case[%d] Got: %f Exp: %f\n",
i, dbl, expectedDbl);
}
break;
case 0x66: // 'f' float
expectedFlt = (float)atof(u_austrcpy(cBuffer, expectedResult));
uBufferLenReturned = u_sscanf_u(argument, format, &flt);
//uFileBufferLenReturned = u_fscanf_u(testFile, format, flt);
if (flt != expectedFlt) {
log_err("error in scanf test case[%d] Got: %f Exp: %f\n",
i, flt, expectedFlt);
}
break;
case 0x31: // '1' int8_t
expected8 = (int8_t)uto64(expectedResult);
uBufferLenReturned = u_sscanf_u(argument, format, &i8);
//uFileBufferLenReturned = u_fscanf_u(testFile, format, i8);
if (i8 != expected8) {
log_err("error in scanf test case[%d] Got: %02X Exp: %02X\n",
i, i8, expected8);
}
break;
case 0x32: // '2' int16_t
expected16 = (int16_t)uto64(expectedResult);
uBufferLenReturned = u_sscanf_u(argument, format, &i16);
//uFileBufferLenReturned = u_fscanf_u(testFile, format, i16);
if (i16 != expected16) {
log_err("error in scanf test case[%d] Got: %04X Exp: %04X\n",
i, i16, expected16);
}
break;
case 0x34: // '4' int32_t
expected32 = (int32_t)uto64(expectedResult);
uBufferLenReturned = u_sscanf_u(argument, format, &i32);
//uFileBufferLenReturned = u_fscanf_u(testFile, format, i32);
if (i32 != expected32) {
log_err("error in scanf test case[%d] Got: %08X Exp: %08X\n",
i, i32, expected32);
}
break;
case 0x38: // '8' int64_t
expected64 = uto64(expectedResult);
uBufferLenReturned = u_sscanf_u(argument, format, &i64);
//uFileBufferLenReturned = u_fscanf_u(testFile, format, i64);
if (i64 != expected64) {
log_err("error in scanf 64-bit. Test case = %d\n", i);
}
break;
case 0x73: // 's' char *
u_austrcpy(cExpected, expectedResult);
uBufferLenReturned = u_sscanf_u(argument, format, cBuffer);
//uFileBufferLenReturned = u_fscanf_u(testFile, format, cBuffer);
if (strcmp(cBuffer, cExpected) != 0) {
log_err("error in scanf char * string. Got \"%s\" Expected \"%s\". Test case = %d\n", cBuffer, cExpected, i);
}
break;
case 0x53: // 'S' UChar *
uBufferLenReturned = u_sscanf_u(argument, format, uBuffer);
//uFileBufferLenReturned = u_fscanf_u(testFile, format, argument);
if (u_strcmp(uBuffer, expectedResult) != 0) {
u_austrcpy(cExpected, format);
u_austrcpy(cBuffer, uBuffer);
log_err("error in scanf UChar * string %s Got: \"%s\". Test case = %d\n", cExpected, cBuffer, i);
}
break;
default:
uBufferLenReturned = 0;
//uFileBufferLenReturned = 0;
log_err("Unknown type %c for test %d\n", testCase->getString("argumentType", errorCode)[0], i);
}
if (uBufferLenReturned != 1) {
log_err("error scanf converted %d arguments. Test case = %d\n", uBufferLenReturned, i);
}
/* if (u_strcmp(uBuffer, expectedResult) != 0) {
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
u_austrncpy(cFormat, format, sizeof(cFormat));
u_austrncpy(cExpected, expectedResult, sizeof(cExpected));
cBuffer[sizeof(cBuffer)-1] = 0;
log_err("FAILURE string test case %d \"%s\" - Got: \"%s\" Expected: \"%s\"\n",
i, cFormat, cBuffer, cExpected);
}
if (uBuffer[uBufferLenReturned-1] == 0
|| uBuffer[uBufferLenReturned] != 0
|| uBuffer[uBufferLenReturned+1] != 0x2A
|| uBuffer[uBufferLenReturned+2] != 0x2A)
{
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
cBuffer[sizeof(cBuffer)-1] = 0;
log_err("FAILURE test case %d - \"%s\" wrong amount of characters was written. Got %d.\n",
i, cBuffer, uBufferLenReturned);
}*/
/* u_fclose(testFile);
testFile = u_fopen(STANDARD_TEST_FILE, "r", fileLocale, "UTF-8");
if (!testFile) {
log_err("Can't open test file - %s\n",
STANDARD_TEST_FILE);
}
uBuffer[0];
u_fgets(uBuffer, sizeof(uBuffer)/sizeof(uBuffer[0]), testFile);
if (u_strcmp(uBuffer, expectedResult) != 0) {
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
u_austrncpy(cFormat, format, sizeof(cFormat));
u_austrncpy(cExpected, expectedResult, sizeof(cExpected));
cBuffer[sizeof(cBuffer)-1] = 0;
log_err("FAILURE file test case %d \"%s\" - Got: \"%s\" Expected: \"%s\"\n",
i, cFormat, cBuffer, cExpected);
}
if (uFileBufferLenReturned != uBufferLenReturned)
{
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
cBuffer[sizeof(cBuffer)-1] = 0;
log_err("FAILURE uFileBufferLenReturned(%d) != uBufferLenReturned(%d)\n",
uFileBufferLenReturned, uBufferLenReturned);
}
*/
if(U_FAILURE(errorCode)) {
log_err("error running icuio/printf test case %d - %s\n",
i, u_errorName(errorCode));
errorCode=U_ZERO_ERROR;
continue;
}
// u_fclose(testFile);
}
delete testData;
}
delete dataModule;
}
else {
log_data_err("Failed: could not load test icuio data\n");
}
#endif
}
U_CDECL_END
U_CDECL_BEGIN
static void U_CALLCONV DataDrivenPrintfPrecision(void)
{
#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO
UErrorCode errorCode;
TestDataModule *dataModule;
TestData *testData;
const DataMap *testCase;
DataDrivenLogger logger;
UChar uBuffer[512];
char cBuffer[512];
char cFormat[sizeof(cBuffer)];
char cExpected[sizeof(cBuffer)];
UnicodeString tempStr;
UChar format[512];
UChar expectedResult[512];
UChar argument[512];
int32_t precision;
int32_t i;
int8_t i8;
int16_t i16;
int32_t i32;
int64_t i64;
double dbl;
int32_t uBufferLenReturned;
errorCode=U_ZERO_ERROR;
dataModule=TestDataModule::getTestDataModule("icuio", logger, errorCode);
if(U_SUCCESS(errorCode)) {
testData=dataModule->createTestData("printfPrecision", errorCode);
if(U_SUCCESS(errorCode)) {
for(i=0; testData->nextCase(testCase, errorCode); ++i) {
if(U_FAILURE(errorCode)) {
log_err("error retrieving icuio/printf test case %d - %s\n",
i, u_errorName(errorCode));
errorCode=U_ZERO_ERROR;
continue;
}
u_memset(uBuffer, 0x2A, sizeof(uBuffer)/sizeof(uBuffer[0]));
uBuffer[sizeof(uBuffer)/sizeof(uBuffer[0])-1] = 0;
tempStr=testCase->getString("format", errorCode);
tempStr.extract(format, sizeof(format)/sizeof(format[0]), errorCode);
tempStr=testCase->getString("result", errorCode);
tempStr.extract(expectedResult, sizeof(expectedResult)/sizeof(expectedResult[0]), errorCode);
tempStr=testCase->getString("argument", errorCode);
tempStr.extract(argument, sizeof(argument)/sizeof(argument[0]), errorCode);
precision=testCase->getInt28("precision", errorCode);
u_austrncpy(cBuffer, format, sizeof(cBuffer));
if(U_FAILURE(errorCode)) {
log_err("error retrieving icuio/printf test case %d - %s\n",
i, u_errorName(errorCode));
errorCode=U_ZERO_ERROR;
continue;
}
log_verbose("Test %d: format=\"%s\"\n", i, cBuffer);
switch (testCase->getString("argumentType", errorCode)[0]) {
case 0x64: // 'd' double
dbl = atof(u_austrcpy(cBuffer, argument));
uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, dbl);
break;
case 0x31: // '1' int8_t
i8 = (int8_t)uto64(argument);
uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, i8);
break;
case 0x32: // '2' int16_t
i16 = (int16_t)uto64(argument);
uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, i16);
break;
case 0x34: // '4' int32_t
i32 = (int32_t)uto64(argument);
uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, i32);
break;
case 0x38: // '8' int64_t
i64 = uto64(argument);
uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, i64);
break;
case 0x73: // 's' char *
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, cBuffer);
break;
case 0x53: // 'S' UChar *
uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, argument);
break;
default:
uBufferLenReturned = 0;
log_err("Unknown type %c for test %d\n", testCase->getString("argumentType", errorCode)[0], i);
}
if (u_strcmp(uBuffer, expectedResult) != 0) {
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
u_austrncpy(cFormat, format, sizeof(cFormat));
u_austrncpy(cExpected, expectedResult, sizeof(cExpected));
cBuffer[sizeof(cBuffer)-1] = 0;
log_err("FAILURE test case %d \"%s\" - Got: \"%s\" Expected: \"%s\"\n",
i, cFormat, cBuffer, cExpected);
}
if (uBufferLenReturned <= 0) {
log_err("FAILURE test case %d - \"%s\" is an empty string.\n",
i, cBuffer);
}
else if (uBuffer[uBufferLenReturned-1] == 0
|| uBuffer[uBufferLenReturned] != 0
|| uBuffer[uBufferLenReturned+1] != 0x2A
|| uBuffer[uBufferLenReturned+2] != 0x2A)
{
u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
cBuffer[sizeof(cBuffer)-1] = 0;
log_err("FAILURE test case %d - \"%s\" wrong amount of characters was written. Got %d.\n",
i, cBuffer, uBufferLenReturned);
}
if(U_FAILURE(errorCode)) {
log_err("error running icuio/printf test case %d - %s\n",
i, u_errorName(errorCode));
errorCode=U_ZERO_ERROR;
continue;
}
}
delete testData;
}
delete dataModule;
}
else {
log_data_err("Failed: could not load test icuio data\n");
}
#endif
}
U_CDECL_END
static void addAllTests(TestNode** root) {
addFileTest(root);
addStringTest(root);
addTranslitTest(root);
#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_LEGACY_CONVERSION
addTest(root, &DataDrivenPrintf, "datadriv/DataDrivenPrintf");
addTest(root, &DataDrivenPrintfPrecision, "datadriv/DataDrivenPrintfPrecision");
addTest(root, &DataDrivenScanf, "datadriv/DataDrivenScanf");
#endif
#if U_IOSTREAM_SOURCE >= 199711
addStreamTests(root);
#endif
}
/* returns the path to icu/source/data/out */
static const char *ctest_dataOutDir()
{
static const char *dataOutDir = NULL;
if(dataOutDir) {
return dataOutDir;
}
/* U_TOPBUILDDIR is set by the makefiles on UNIXes when building cintltst and intltst
// to point to the top of the build hierarchy, which may or
// may not be the same as the source directory, depending on
// the configure options used. At any rate,
// set the data path to the built data from this directory.
// The value is complete with quotes, so it can be used
// as-is as a string constant.
*/
#if defined (U_TOPBUILDDIR)
{
dataOutDir = U_TOPBUILDDIR "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;
}
#else
/* On Windows, the file name obtained from __FILE__ includes a full path.
* This file is "wherever\icu\source\test\cintltst\cintltst.c"
* Change to "wherever\icu\source\data"
*/
{
static char p[sizeof(__FILE__) + 20];
char *pBackSlash;
int i;
strcpy(p, __FILE__);
/* We want to back over three '\' chars. */
/* Only Windows should end up here, so looking for '\' is safe. */
for (i=1; i<=3; i++) {
pBackSlash = strrchr(p, U_FILE_SEP_CHAR);
if (pBackSlash != NULL) {
*pBackSlash = 0; /* Truncate the string at the '\' */
}
}
if (pBackSlash != NULL) {
/* We found and truncated three names from the path.
* Now append "source\data" and set the environment
*/
strcpy(pBackSlash, U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING);
dataOutDir = p;
}
else {
/* __FILE__ on MSVC7 does not contain the directory */
FILE *file = fopen(".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "Makefile.in", "r");
if (file) {
fclose(file);
dataOutDir = ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;
}
else {
dataOutDir = ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;
}
}
}
#endif
return dataOutDir;
}
/* ctest_setICU_DATA - if the ICU_DATA environment variable is not already
* set, try to deduce the directory in which ICU was built,
* and set ICU_DATA to "icu/source/data" in that location.
* The intent is to allow the tests to have a good chance
* of running without requiring that the user manually set
* ICU_DATA. Common data isn't a problem, since it is
* picked up via a static (build time) reference, but the
* tests dynamically load some data.
*/
static void ctest_setICU_DATA() {
/* No location for the data dir was identifiable.
* Add other fallbacks for the test data location here if the need arises
*/
if (getenv("ICU_DATA") == NULL) {
/* If ICU_DATA isn't set, set it to the usual location */
u_setDataDirectory(ctest_dataOutDir());
}
}
U_CDECL_BEGIN
/*
* Note: this assumes that context is a pointer to STANDARD_TEST_FILE. It would be
* cleaner to define an acutal context with a string pointer in it and set STANDARD_TEST_FILE
* after the call to initArgs()...
*/
static int U_CALLCONV argHandler(int arg, int /*argc*/, const char * const argv[], void *context)
{
const char **str = (const char **) context;
if (argv[arg][0] != '/' && argv[arg][0] != '-') {
*str = argv[arg];
return 1;
}
return 0;
}
U_CDECL_END
int main(int argc, char* argv[])
{
int32_t nerrors = 0;
TestNode *root = NULL;
UErrorCode errorCode = U_ZERO_ERROR;
UDate startTime, endTime;
int32_t diffTime;
startTime = uprv_getRawUTCtime();
/* Check whether ICU will initialize without forcing the build data directory into
* the ICU_DATA path. Success here means either the data dll contains data, or that
* this test program was run with ICU_DATA set externally. Failure of this check
* is normal when ICU data is not packaged into a shared library.
*
* Whether or not this test succeeds, we want to cleanup and reinitialize
* with a data path so that data loading from individual files can be tested.
*/
u_init(&errorCode);
if (U_FAILURE(errorCode)) {
fprintf(stderr,
"#### Note: ICU Init without build-specific setDataDirectory() failed.\n");
}
u_cleanup();
errorCode = U_ZERO_ERROR;
if (!initArgs(argc, argv, argHandler, (void *) &STANDARD_TEST_FILE)) {
/* Error already displayed. */
return -1;
}
/* Initialize ICU */
ctest_setICU_DATA(); /* u_setDataDirectory() must happen Before u_init() */
u_init(&errorCode);
if (U_FAILURE(errorCode)) {
fprintf(stderr,
"#### ERROR! %s: u_init() failed with status = \"%s\".\n"
"*** Check the ICU_DATA environment variable and \n"
"*** check that the data files are present.\n", argv[0], u_errorName(errorCode));
return 1;
}
fprintf(stdout, "Default charset for this run is %s\n", ucnv_getDefaultName());
addAllTests(&root);
nerrors = runTestRequest(root, argc, argv);
#if 1
{
FILE* fileToRemove = fopen(STANDARD_TEST_FILE, "r");
/* This should delete any temporary files. */
if (fileToRemove) {
fclose(fileToRemove);
log_verbose("Deleting: %s\n", STANDARD_TEST_FILE);
if (remove(STANDARD_TEST_FILE) != 0) {
/* Maybe someone didn't close the file correctly. */
fprintf(stderr, "FAIL: Could not delete %s\n", STANDARD_TEST_FILE);
nerrors += 1;
}
}
}
#endif
cleanUpTestTree(root);
DataDrivenLogger::cleanUp();
u_cleanup();
endTime = uprv_getRawUTCtime();
diffTime = (int32_t)(endTime - startTime);
printf("Elapsed Time: %02d:%02d:%02d.%03d\n",
(int)((diffTime%U_MILLIS_PER_DAY)/U_MILLIS_PER_HOUR),
(int)((diffTime%U_MILLIS_PER_HOUR)/U_MILLIS_PER_MINUTE),
(int)((diffTime%U_MILLIS_PER_MINUTE)/U_MILLIS_PER_SECOND),
(int)(diffTime%U_MILLIS_PER_SECOND));
return nerrors;
}