]> git.saurik.com Git - apple/icu.git/blame_incremental - icuSources/test/iotest/iotest.cpp
projects / apple / icu.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
ICU-551.51.4.tar.gz
[apple/icu.git] / icuSources / test / iotest / iotest.cpp
... / ...
CommitLineData
1/*
2**********************************************************************
3* Copyright (C) 2002-2012, International Business Machines
4* Corporation and others. All Rights Reserved.
5**********************************************************************
6* file name: iotest.cpp
7* encoding: US-ASCII
8* tab size: 8 (not used)
9* indentation:4
10*
11* created on: 2002feb21
12* created by: George Rhoten
13*/
14
15
16#include "unicode/ustdio.h"
17#include "unicode/uclean.h"
18
19#include "unicode/ucnv.h"
20#include "unicode/uchar.h"
21#include "unicode/unistr.h"
22#include "unicode/ustring.h"
23#include "ustr_cnv.h"
24#include "iotest.h"
25#include "unicode/tstdtmod.h"
26#include "putilimp.h"
27
28#include <string.h>
29#include <stdlib.h>
30
31class DataDrivenLogger : public TestLog {
32 static const char* fgDataDir;
33 static char *fgTestDataPath;
34
35public:
36 static void cleanUp() {
37 if (fgTestDataPath) {
38 free(fgTestDataPath);
39 fgTestDataPath = NULL;
40 }
41 }
42 virtual void errln( const UnicodeString &message ) {
43 char buffer[4000];
44 message.extract(0, message.length(), buffer, sizeof(buffer));
45 buffer[3999] = 0; /* NULL terminate */
46 log_err(buffer);
47 }
48
49 virtual void logln( const UnicodeString &message ) {
50 char buffer[4000];
51 message.extract(0, message.length(), buffer, sizeof(buffer));
52 buffer[3999] = 0; /* NULL terminate */
53 log_info(buffer);
54 }
55
56 virtual void dataerrln( const UnicodeString &message ) {
57 char buffer[4000];
58 message.extract(0, message.length(), buffer, sizeof(buffer));
59 buffer[3999] = 0; /* NULL terminate */
60 log_data_err(buffer);
61 }
62
63 static const char * pathToDataDirectory(void)
64 {
65
66 if(fgDataDir != NULL) {
67 return fgDataDir;
68 }
69
70 /* U_TOPSRCDIR is set by the makefiles on UNIXes when building cintltst and intltst
71 // to point to the top of the build hierarchy, which may or
72 // may not be the same as the source directory, depending on
73 // the configure options used. At any rate,
74 // set the data path to the built data from this directory.
75 // The value is complete with quotes, so it can be used
76 // as-is as a string constant.
77 */
78 #if defined (U_TOPSRCDIR)
79 {
80 fgDataDir = U_TOPSRCDIR U_FILE_SEP_STRING "data" U_FILE_SEP_STRING;
81 }
82 #else
83
84 /* On Windows, the file name obtained from __FILE__ includes a full path.
85 * This file is "wherever\icu\source\test\cintltst\cintltst.c"
86 * Change to "wherever\icu\source\data"
87 */
88 {
89 static char p[sizeof(__FILE__) + 10];
90 char *pBackSlash;
91 int i;
92
93 strcpy(p, __FILE__);
94 /* We want to back over three '\' chars. */
95 /* Only Windows should end up here, so looking for '\' is safe. */
96 for (i=1; i<=3; i++) {
97 pBackSlash = strrchr(p, U_FILE_SEP_CHAR);
98 if (pBackSlash != NULL) {
99 *pBackSlash = 0; /* Truncate the string at the '\' */
100 }
101 }
102
103 if (pBackSlash != NULL) {
104 /* We found and truncated three names from the path.
105 * Now append "source\data" and set the environment
106 */
107 strcpy(pBackSlash, U_FILE_SEP_STRING "data" U_FILE_SEP_STRING );
108 fgDataDir = p;
109 }
110 else {
111 /* __FILE__ on MSVC7 does not contain the directory */
112 FILE *file = fopen(".." U_FILE_SEP_STRING".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "Makefile.in", "r");
113 if (file) {
114 fclose(file);
115 fgDataDir = ".." U_FILE_SEP_STRING".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING;
116 }
117 else {
118 fgDataDir = ".." U_FILE_SEP_STRING".." U_FILE_SEP_STRING".." U_FILE_SEP_STRING".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING;
119 }
120 }
121 }
122 #endif
123
124 return fgDataDir;
125
126 }
127
128 static const char* loadTestData(UErrorCode& err){
129 if( fgTestDataPath == NULL){
130 const char* directory=NULL;
131 UResourceBundle* test =NULL;
132 char* tdpath=NULL;
133 const char* tdrelativepath;
134
135#if defined (U_TOPBUILDDIR)
136 tdrelativepath = "test" U_FILE_SEP_STRING "testdata" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;
137 directory = U_TOPBUILDDIR;
138#else
139 tdrelativepath = ".." U_FILE_SEP_STRING "test" U_FILE_SEP_STRING "testdata" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;
140 directory = pathToDataDirectory();
141#endif
142
143 tdpath = (char*) malloc(sizeof(char) *(( strlen(directory) * strlen(tdrelativepath)) + 100));
144
145
146 /* u_getDataDirectory shoul return \source\data ... set the
147 * directory to ..\source\data\..\test\testdata\out\testdata
148 */
149 strcpy(tdpath, directory);
150 strcat(tdpath, tdrelativepath);
151 strcat(tdpath,"testdata");
152
153 test=ures_open(tdpath, "testtypes", &err);
154
155 if(U_FAILURE(err)){
156 err = U_FILE_ACCESS_ERROR;
157 log_data_err("Could not load testtypes.res in testdata bundle with path %s - %s\n", tdpath, u_errorName(err));
158 return "";
159 }
160 ures_close(test);
161 fgTestDataPath = tdpath;
162 }
163 return fgTestDataPath;
164 }
165
166 virtual const char* getTestDataPath(UErrorCode& err) {
167 return loadTestData(err);
168 }
169};
170
171const char* DataDrivenLogger::fgDataDir = NULL;
172char* DataDrivenLogger::fgTestDataPath = NULL;
173
174#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO
175static int64_t
176uto64(const UChar *buffer)
177{
178 int64_t result = 0;
179 /* iterate through buffer */
180 while(*buffer) {
181 /* read the next digit */
182 result *= 16;
183 if (!u_isxdigit(*buffer)) {
184 log_err("\\u%04X is not a valid hex digit for this test\n", (UChar)*buffer);
185 }
186 result += *buffer - 0x0030 - (*buffer >= 0x0041 ? (*buffer >= 0x0061 ? 39 : 7) : 0);
187 buffer++;
188 }
189 return result;
190}
191#endif
192
193U_CDECL_BEGIN
194static void U_CALLCONV DataDrivenPrintf(void)
195{
196#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO
197 UErrorCode errorCode;
198 TestDataModule *dataModule;
199 TestData *testData;
200 const DataMap *testCase;
201 DataDrivenLogger logger;
202 UChar uBuffer[512];
203 char cBuffer[512];
204 char cFormat[sizeof(cBuffer)];
205 char cExpected[sizeof(cBuffer)];
206 UnicodeString tempStr;
207 UChar format[512];
208 UChar expectedResult[512];
209 UChar argument[512];
210 int32_t i;
211 int8_t i8;
212 int16_t i16;
213 int32_t i32;
214 int64_t i64;
215 double dbl;
216 int32_t uBufferLenReturned;
217
218 const char *fileLocale = "en_US_POSIX";
219 int32_t uFileBufferLenReturned;
220 LocalUFILEPointer testFile;
221
222 errorCode=U_ZERO_ERROR;
223 dataModule=TestDataModule::getTestDataModule("icuio", logger, errorCode);
224 if(U_SUCCESS(errorCode)) {
225 testData=dataModule->createTestData("printf", errorCode);
226 if(U_SUCCESS(errorCode)) {
227 for(i=0; testData->nextCase(testCase, errorCode); ++i) {
228 if(U_FAILURE(errorCode)) {
229 log_err("error retrieving icuio/printf test case %d - %s\n",
230 i, u_errorName(errorCode));
231 errorCode=U_ZERO_ERROR;
232 continue;
233 }
234 testFile.adoptInstead(u_fopen(STANDARD_TEST_FILE, "w", fileLocale, "UTF-8"));
235 if (testFile.isNull()) {
236 log_err("Can't open test file - %s\n",
237 STANDARD_TEST_FILE);
238 continue;
239 }
240 u_memset(uBuffer, 0x2A, sizeof(uBuffer)/sizeof(uBuffer[0]));
241 uBuffer[sizeof(uBuffer)/sizeof(uBuffer[0])-1] = 0;
242 tempStr=testCase->getString("format", errorCode);
243 tempStr.extract(format, sizeof(format)/sizeof(format[0]), errorCode);
244 tempStr=testCase->getString("result", errorCode);
245 tempStr.extract(expectedResult, sizeof(expectedResult)/sizeof(expectedResult[0]), errorCode);
246 tempStr=testCase->getString("argument", errorCode);
247 tempStr.extract(argument, sizeof(argument)/sizeof(argument[0]), errorCode);
248 u_austrncpy(cBuffer, format, sizeof(cBuffer));
249 if(U_FAILURE(errorCode)) {
250 log_err("error retrieving icuio/printf test case %d - %s\n",
251 i, u_errorName(errorCode));
252 errorCode=U_ZERO_ERROR;
253 continue;
254 }
255 log_verbose("Test %d: format=\"%s\"\n", i, cBuffer);
256 switch (testCase->getString("argumentType", errorCode)[0]) {
257 case 0x64: // 'd' double
258 dbl = atof(u_austrcpy(cBuffer, argument));
259 uBufferLenReturned = u_sprintf_u(uBuffer, format, dbl);
260 uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, dbl);
261 break;
262 case 0x31: // '1' int8_t
263 i8 = (int8_t)uto64(argument);
264 uBufferLenReturned = u_sprintf_u(uBuffer, format, i8);
265 uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, i8);
266 break;
267 case 0x32: // '2' int16_t
268 i16 = (int16_t)uto64(argument);
269 uBufferLenReturned = u_sprintf_u(uBuffer, format, i16);
270 uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, i16);
271 break;
272 case 0x34: // '4' int32_t
273 i32 = (int32_t)uto64(argument);
274 uBufferLenReturned = u_sprintf_u(uBuffer, format, i32);
275 uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, i32);
276 break;
277 case 0x38: // '8' int64_t
278 i64 = uto64(argument);
279 uBufferLenReturned = u_sprintf_u(uBuffer, format, i64);
280 uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, i64);
281 break;
282 case 0x73: // 's' char *
283 u_austrncpy(cBuffer, argument, sizeof(cBuffer));
284 uBufferLenReturned = u_sprintf_u(uBuffer, format, cBuffer);
285 uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, cBuffer);
286 break;
287 case 0x53: // 'S' UChar *
288 uBufferLenReturned = u_sprintf_u(uBuffer, format, argument);
289 uFileBufferLenReturned = u_fprintf_u(testFile.getAlias(), format, argument);
290 break;
291 default:
292 uBufferLenReturned = 0;
293 uFileBufferLenReturned = 0;
294 log_err("Unknown type %c for test %d\n", testCase->getString("argumentType", errorCode)[0], i);
295 }
296 if (u_strcmp(uBuffer, expectedResult) != 0) {
297 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
298 u_austrncpy(cFormat, format, sizeof(cFormat));
299 u_austrncpy(cExpected, expectedResult, sizeof(cExpected));
300 cBuffer[sizeof(cBuffer)-1] = 0;
301 log_err("FAILURE string test case %d \"%s\" - Got: \"%s\" Expected: \"%s\"\n",
302 i, cFormat, cBuffer, cExpected);
303 }
304 if (uBufferLenReturned <= 0) {
305 log_err("FAILURE test case %d - \"%s\" is an empty string.\n",
306 i, cBuffer);
307 }
308 else if (uBuffer[uBufferLenReturned-1] == 0
309 || uBuffer[uBufferLenReturned] != 0
310 || uBuffer[uBufferLenReturned+1] != 0x2A
311 || uBuffer[uBufferLenReturned+2] != 0x2A)
312 {
313 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
314 cBuffer[sizeof(cBuffer)-1] = 0;
315 log_err("FAILURE test case %d - \"%s\" wrong amount of characters was written. Got %d.\n",
316 i, cBuffer, uBufferLenReturned);
317 }
318 testFile.adoptInstead(u_fopen(STANDARD_TEST_FILE, "r", fileLocale, "UTF-8"));
319 if (testFile.isNull()) {
320 log_err("Can't open test file - %s\n",
321 STANDARD_TEST_FILE);
322 }
323 uBuffer[0]=0;
324 u_fgets(uBuffer, sizeof(uBuffer)/sizeof(uBuffer[0]), testFile.getAlias());
325 if (u_strcmp(uBuffer, expectedResult) != 0) {
326 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
327 u_austrncpy(cFormat, format, sizeof(cFormat));
328 u_austrncpy(cExpected, expectedResult, sizeof(cExpected));
329 cBuffer[sizeof(cBuffer)-1] = 0;
330 log_err("FAILURE file test case %d \"%s\" - Got: \"%s\" Expected: \"%s\"\n",
331 i, cFormat, cBuffer, cExpected);
332 }
333 if (uFileBufferLenReturned != uBufferLenReturned)
334 {
335 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
336 cBuffer[sizeof(cBuffer)-1] = 0;
337 log_err("FAILURE uFileBufferLenReturned(%d) != uBufferLenReturned(%d)\n",
338 uFileBufferLenReturned, uBufferLenReturned);
339 }
340
341 if(U_FAILURE(errorCode)) {
342 log_err("error running icuio/printf test case %d - %s\n",
343 i, u_errorName(errorCode));
344 errorCode=U_ZERO_ERROR;
345 continue;
346 }
347 }
348 delete testData;
349 }
350 delete dataModule;
351 }
352 else {
353 log_data_err("Failed: could not load test icuio data\n");
354 }
355#endif
356}
357U_CDECL_END
358
359U_CDECL_BEGIN
360static void U_CALLCONV DataDrivenScanf(void)
361{
362#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO
363 UErrorCode errorCode;
364 TestDataModule *dataModule;
365 TestData *testData;
366 const DataMap *testCase;
367 DataDrivenLogger logger;
368 UChar uBuffer[512];
369 char cBuffer[512];
370 char cExpected[sizeof(cBuffer)];
371 UnicodeString tempStr;
372 UChar format[512];
373 UChar expectedResult[512];
374 UChar argument[512];
375 int32_t i;
376 int8_t i8, expected8;
377 int16_t i16, expected16;
378 int32_t i32, expected32;
379 int64_t i64, expected64;
380 double dbl, expectedDbl;
381 volatile float flt, expectedFlt; // Use volatile in order to get around an Intel compiler issue.
382 int32_t uBufferLenReturned;
383
384 //const char *fileLocale = "en_US_POSIX";
385 //int32_t uFileBufferLenReturned;
386 //UFILE *testFile;
387
388 errorCode=U_ZERO_ERROR;
389 dataModule=TestDataModule::getTestDataModule("icuio", logger, errorCode);
390 if(U_SUCCESS(errorCode)) {
391 testData=dataModule->createTestData("scanf", errorCode);
392 if(U_SUCCESS(errorCode)) {
393 for(i=0; testData->nextCase(testCase, errorCode); ++i) {
394 if(U_FAILURE(errorCode)) {
395 log_err("error retrieving icuio/printf test case %d - %s\n",
396 i, u_errorName(errorCode));
397 errorCode=U_ZERO_ERROR;
398 continue;
399 }
400/* testFile = u_fopen(STANDARD_TEST_FILE, "w", fileLocale, "UTF-8");
401 if (!testFile) {
402 log_err("Can't open test file - %s\n",
403 STANDARD_TEST_FILE);
404 }*/
405 u_memset(uBuffer, 0x2A, sizeof(uBuffer)/sizeof(uBuffer[0]));
406 uBuffer[sizeof(uBuffer)/sizeof(uBuffer[0])-1] = 0;
407 tempStr=testCase->getString("format", errorCode);
408 tempStr.extract(format, sizeof(format)/sizeof(format[0]), errorCode);
409 tempStr=testCase->getString("result", errorCode);
410 tempStr.extract(expectedResult, sizeof(expectedResult)/sizeof(expectedResult[0]), errorCode);
411 tempStr=testCase->getString("argument", errorCode);
412 tempStr.extract(argument, sizeof(argument)/sizeof(argument[0]), errorCode);
413 u_austrncpy(cBuffer, format, sizeof(cBuffer));
414 if(U_FAILURE(errorCode)) {
415 log_err("error retrieving icuio/printf test case %d - %s\n",
416 i, u_errorName(errorCode));
417 errorCode=U_ZERO_ERROR;
418 continue;
419 }
420 log_verbose("Test %d: format=\"%s\"\n", i, cBuffer);
421 switch (testCase->getString("argumentType", errorCode)[0]) {
422 case 0x64: // 'd' double
423 expectedDbl = atof(u_austrcpy(cBuffer, expectedResult));
424 uBufferLenReturned = u_sscanf_u(argument, format, &dbl);
425 //uFileBufferLenReturned = u_fscanf_u(testFile, format, dbl);
426 if (dbl != expectedDbl) {
427 log_err("error in scanf test case[%d] Got: %f Exp: %f\n",
428 i, dbl, expectedDbl);
429 }
430 break;
431 case 0x66: // 'f' float
432 expectedFlt = (float)atof(u_austrcpy(cBuffer, expectedResult));
433 uBufferLenReturned = u_sscanf_u(argument, format, &flt);
434 //uFileBufferLenReturned = u_fscanf_u(testFile, format, flt);
435 if (flt != expectedFlt) {
436 log_err("error in scanf test case[%d] Got: %f Exp: %f\n",
437 i, flt, expectedFlt);
438 }
439 break;
440 case 0x31: // '1' int8_t
441 expected8 = (int8_t)uto64(expectedResult);
442 uBufferLenReturned = u_sscanf_u(argument, format, &i8);
443 //uFileBufferLenReturned = u_fscanf_u(testFile, format, i8);
444 if (i8 != expected8) {
445 log_err("error in scanf test case[%d] Got: %02X Exp: %02X\n",
446 i, i8, expected8);
447 }
448 break;
449 case 0x32: // '2' int16_t
450 expected16 = (int16_t)uto64(expectedResult);
451 uBufferLenReturned = u_sscanf_u(argument, format, &i16);
452 //uFileBufferLenReturned = u_fscanf_u(testFile, format, i16);
453 if (i16 != expected16) {
454 log_err("error in scanf test case[%d] Got: %04X Exp: %04X\n",
455 i, i16, expected16);
456 }
457 break;
458 case 0x34: // '4' int32_t
459 expected32 = (int32_t)uto64(expectedResult);
460 uBufferLenReturned = u_sscanf_u(argument, format, &i32);
461 //uFileBufferLenReturned = u_fscanf_u(testFile, format, i32);
462 if (i32 != expected32) {
463 log_err("error in scanf test case[%d] Got: %08X Exp: %08X\n",
464 i, i32, expected32);
465 }
466 break;
467 case 0x38: // '8' int64_t
468 expected64 = uto64(expectedResult);
469 uBufferLenReturned = u_sscanf_u(argument, format, &i64);
470 //uFileBufferLenReturned = u_fscanf_u(testFile, format, i64);
471 if (i64 != expected64) {
472 log_err("error in scanf 64-bit. Test case = %d\n", i);
473 }
474 break;
475 case 0x73: // 's' char *
476 u_austrcpy(cExpected, expectedResult);
477 uBufferLenReturned = u_sscanf_u(argument, format, cBuffer);
478 //uFileBufferLenReturned = u_fscanf_u(testFile, format, cBuffer);
479 if (strcmp(cBuffer, cExpected) != 0) {
480 log_err("error in scanf char * string. Got \"%s\" Expected \"%s\". Test case = %d\n", cBuffer, cExpected, i);
481 }
482 break;
483 case 0x53: // 'S' UChar *
484 uBufferLenReturned = u_sscanf_u(argument, format, uBuffer);
485 //uFileBufferLenReturned = u_fscanf_u(testFile, format, argument);
486 if (u_strcmp(uBuffer, expectedResult) != 0) {
487 u_austrcpy(cExpected, format);
488 u_austrcpy(cBuffer, uBuffer);
489 log_err("error in scanf UChar * string %s Got: \"%s\". Test case = %d\n", cExpected, cBuffer, i);
490 }
491 break;
492 default:
493 uBufferLenReturned = 0;
494 //uFileBufferLenReturned = 0;
495 log_err("Unknown type %c for test %d\n", testCase->getString("argumentType", errorCode)[0], i);
496 }
497 if (uBufferLenReturned != 1) {
498 log_err("error scanf converted %d arguments. Test case = %d\n", uBufferLenReturned, i);
499 }
500/* if (u_strcmp(uBuffer, expectedResult) != 0) {
501 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
502 u_austrncpy(cFormat, format, sizeof(cFormat));
503 u_austrncpy(cExpected, expectedResult, sizeof(cExpected));
504 cBuffer[sizeof(cBuffer)-1] = 0;
505 log_err("FAILURE string test case %d \"%s\" - Got: \"%s\" Expected: \"%s\"\n",
506 i, cFormat, cBuffer, cExpected);
507 }
508 if (uBuffer[uBufferLenReturned-1] == 0
509 || uBuffer[uBufferLenReturned] != 0
510 || uBuffer[uBufferLenReturned+1] != 0x2A
511 || uBuffer[uBufferLenReturned+2] != 0x2A)
512 {
513 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
514 cBuffer[sizeof(cBuffer)-1] = 0;
515 log_err("FAILURE test case %d - \"%s\" wrong amount of characters was written. Got %d.\n",
516 i, cBuffer, uBufferLenReturned);
517 }*/
518/* u_fclose(testFile);
519 testFile = u_fopen(STANDARD_TEST_FILE, "r", fileLocale, "UTF-8");
520 if (!testFile) {
521 log_err("Can't open test file - %s\n",
522 STANDARD_TEST_FILE);
523 }
524 uBuffer[0];
525 u_fgets(uBuffer, sizeof(uBuffer)/sizeof(uBuffer[0]), testFile);
526 if (u_strcmp(uBuffer, expectedResult) != 0) {
527 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
528 u_austrncpy(cFormat, format, sizeof(cFormat));
529 u_austrncpy(cExpected, expectedResult, sizeof(cExpected));
530 cBuffer[sizeof(cBuffer)-1] = 0;
531 log_err("FAILURE file test case %d \"%s\" - Got: \"%s\" Expected: \"%s\"\n",
532 i, cFormat, cBuffer, cExpected);
533 }
534 if (uFileBufferLenReturned != uBufferLenReturned)
535 {
536 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
537 cBuffer[sizeof(cBuffer)-1] = 0;
538 log_err("FAILURE uFileBufferLenReturned(%d) != uBufferLenReturned(%d)\n",
539 uFileBufferLenReturned, uBufferLenReturned);
540 }
541*/
542 if(U_FAILURE(errorCode)) {
543 log_err("error running icuio/printf test case %d - %s\n",
544 i, u_errorName(errorCode));
545 errorCode=U_ZERO_ERROR;
546 continue;
547 }
548// u_fclose(testFile);
549 }
550 delete testData;
551 }
552 delete dataModule;
553 }
554 else {
555 log_data_err("Failed: could not load test icuio data\n");
556 }
557#endif
558}
559U_CDECL_END
560
561U_CDECL_BEGIN
562static void U_CALLCONV DataDrivenPrintfPrecision(void)
563{
564#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_FILE_IO
565 UErrorCode errorCode;
566 TestDataModule *dataModule;
567 TestData *testData;
568 const DataMap *testCase;
569 DataDrivenLogger logger;
570 UChar uBuffer[512];
571 char cBuffer[512];
572 char cFormat[sizeof(cBuffer)];
573 char cExpected[sizeof(cBuffer)];
574 UnicodeString tempStr;
575 UChar format[512];
576 UChar expectedResult[512];
577 UChar argument[512];
578 int32_t precision;
579 int32_t i;
580 int8_t i8;
581 int16_t i16;
582 int32_t i32;
583 int64_t i64;
584 double dbl;
585 int32_t uBufferLenReturned;
586
587 errorCode=U_ZERO_ERROR;
588 dataModule=TestDataModule::getTestDataModule("icuio", logger, errorCode);
589 if(U_SUCCESS(errorCode)) {
590 testData=dataModule->createTestData("printfPrecision", errorCode);
591 if(U_SUCCESS(errorCode)) {
592 for(i=0; testData->nextCase(testCase, errorCode); ++i) {
593 if(U_FAILURE(errorCode)) {
594 log_err("error retrieving icuio/printf test case %d - %s\n",
595 i, u_errorName(errorCode));
596 errorCode=U_ZERO_ERROR;
597 continue;
598 }
599 u_memset(uBuffer, 0x2A, sizeof(uBuffer)/sizeof(uBuffer[0]));
600 uBuffer[sizeof(uBuffer)/sizeof(uBuffer[0])-1] = 0;
601 tempStr=testCase->getString("format", errorCode);
602 tempStr.extract(format, sizeof(format)/sizeof(format[0]), errorCode);
603 tempStr=testCase->getString("result", errorCode);
604 tempStr.extract(expectedResult, sizeof(expectedResult)/sizeof(expectedResult[0]), errorCode);
605 tempStr=testCase->getString("argument", errorCode);
606 tempStr.extract(argument, sizeof(argument)/sizeof(argument[0]), errorCode);
607 precision=testCase->getInt28("precision", errorCode);
608 u_austrncpy(cBuffer, format, sizeof(cBuffer));
609 if(U_FAILURE(errorCode)) {
610 log_err("error retrieving icuio/printf test case %d - %s\n",
611 i, u_errorName(errorCode));
612 errorCode=U_ZERO_ERROR;
613 continue;
614 }
615 log_verbose("Test %d: format=\"%s\"\n", i, cBuffer);
616 switch (testCase->getString("argumentType", errorCode)[0]) {
617 case 0x64: // 'd' double
618 dbl = atof(u_austrcpy(cBuffer, argument));
619 uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, dbl);
620 break;
621 case 0x31: // '1' int8_t
622 i8 = (int8_t)uto64(argument);
623 uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, i8);
624 break;
625 case 0x32: // '2' int16_t
626 i16 = (int16_t)uto64(argument);
627 uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, i16);
628 break;
629 case 0x34: // '4' int32_t
630 i32 = (int32_t)uto64(argument);
631 uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, i32);
632 break;
633 case 0x38: // '8' int64_t
634 i64 = uto64(argument);
635 uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, i64);
636 break;
637 case 0x73: // 's' char *
638 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
639 uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, cBuffer);
640 break;
641 case 0x53: // 'S' UChar *
642 uBufferLenReturned = u_sprintf_u(uBuffer, format, precision, argument);
643 break;
644 default:
645 uBufferLenReturned = 0;
646 log_err("Unknown type %c for test %d\n", testCase->getString("argumentType", errorCode)[0], i);
647 }
648 if (u_strcmp(uBuffer, expectedResult) != 0) {
649 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
650 u_austrncpy(cFormat, format, sizeof(cFormat));
651 u_austrncpy(cExpected, expectedResult, sizeof(cExpected));
652 cBuffer[sizeof(cBuffer)-1] = 0;
653 log_err("FAILURE test case %d \"%s\" - Got: \"%s\" Expected: \"%s\"\n",
654 i, cFormat, cBuffer, cExpected);
655 }
656 if (uBufferLenReturned <= 0) {
657 log_err("FAILURE test case %d - \"%s\" is an empty string.\n",
658 i, cBuffer);
659 }
660 else if (uBuffer[uBufferLenReturned-1] == 0
661 || uBuffer[uBufferLenReturned] != 0
662 || uBuffer[uBufferLenReturned+1] != 0x2A
663 || uBuffer[uBufferLenReturned+2] != 0x2A)
664 {
665 u_austrncpy(cBuffer, uBuffer, sizeof(cBuffer));
666 cBuffer[sizeof(cBuffer)-1] = 0;
667 log_err("FAILURE test case %d - \"%s\" wrong amount of characters was written. Got %d.\n",
668 i, cBuffer, uBufferLenReturned);
669 }
670 if(U_FAILURE(errorCode)) {
671 log_err("error running icuio/printf test case %d - %s\n",
672 i, u_errorName(errorCode));
673 errorCode=U_ZERO_ERROR;
674 continue;
675 }
676 }
677 delete testData;
678 }
679 delete dataModule;
680 }
681 else {
682 log_data_err("Failed: could not load test icuio data\n");
683 }
684#endif
685}
686U_CDECL_END
687
688static void addAllTests(TestNode** root) {
689 addFileTest(root);
690 addStringTest(root);
691 addTranslitTest(root);
692
693#if !UCONFIG_NO_FORMATTING && !UCONFIG_NO_LEGACY_CONVERSION
694 addTest(root, &DataDrivenPrintf, "datadriv/DataDrivenPrintf");
695 addTest(root, &DataDrivenPrintfPrecision, "datadriv/DataDrivenPrintfPrecision");
696 addTest(root, &DataDrivenScanf, "datadriv/DataDrivenScanf");
697#endif
698#if U_IOSTREAM_SOURCE >= 199711
699 addStreamTests(root);
700#endif
701}
702
703/* returns the path to icu/source/data/out */
704static const char *ctest_dataOutDir()
705{
706 static const char *dataOutDir = NULL;
707
708 if(dataOutDir) {
709 return dataOutDir;
710 }
711
712 /* U_TOPBUILDDIR is set by the makefiles on UNIXes when building cintltst and intltst
713 // to point to the top of the build hierarchy, which may or
714 // may not be the same as the source directory, depending on
715 // the configure options used. At any rate,
716 // set the data path to the built data from this directory.
717 // The value is complete with quotes, so it can be used
718 // as-is as a string constant.
719 */
720#if defined (U_TOPBUILDDIR)
721 {
722 dataOutDir = U_TOPBUILDDIR "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;
723 }
724#else
725
726 /* On Windows, the file name obtained from __FILE__ includes a full path.
727 * This file is "wherever\icu\source\test\cintltst\cintltst.c"
728 * Change to "wherever\icu\source\data"
729 */
730 {
731 static char p[sizeof(__FILE__) + 20];
732 char *pBackSlash;
733 int i;
734
735 strcpy(p, __FILE__);
736 /* We want to back over three '\' chars. */
737 /* Only Windows should end up here, so looking for '\' is safe. */
738 for (i=1; i<=3; i++) {
739 pBackSlash = strrchr(p, U_FILE_SEP_CHAR);
740 if (pBackSlash != NULL) {
741 *pBackSlash = 0; /* Truncate the string at the '\' */
742 }
743 }
744
745 if (pBackSlash != NULL) {
746 /* We found and truncated three names from the path.
747 * Now append "source\data" and set the environment
748 */
749 strcpy(pBackSlash, U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING);
750 dataOutDir = p;
751 }
752 else {
753 /* __FILE__ on MSVC7 does not contain the directory */
754 FILE *file = fopen(".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "Makefile.in", "r");
755 if (file) {
756 fclose(file);
757 dataOutDir = ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;
758 }
759 else {
760 dataOutDir = ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data" U_FILE_SEP_STRING "out" U_FILE_SEP_STRING;
761 }
762 }
763 }
764#endif
765
766 return dataOutDir;
767}
768
769/* ctest_setICU_DATA - if the ICU_DATA environment variable is not already
770 * set, try to deduce the directory in which ICU was built,
771 * and set ICU_DATA to "icu/source/data" in that location.
772 * The intent is to allow the tests to have a good chance
773 * of running without requiring that the user manually set
774 * ICU_DATA. Common data isn't a problem, since it is
775 * picked up via a static (build time) reference, but the
776 * tests dynamically load some data.
777 */
778static void ctest_setICU_DATA() {
779
780 /* No location for the data dir was identifiable.
781 * Add other fallbacks for the test data location here if the need arises
782 */
783 if (getenv("ICU_DATA") == NULL) {
784 /* If ICU_DATA isn't set, set it to the usual location */
785 u_setDataDirectory(ctest_dataOutDir());
786 }
787}
788
789U_CDECL_BEGIN
790/*
791 * Note: this assumes that context is a pointer to STANDARD_TEST_FILE. It would be
792 * cleaner to define an acutal context with a string pointer in it and set STANDARD_TEST_FILE
793 * after the call to initArgs()...
794 */
795static int U_CALLCONV argHandler(int arg, int /*argc*/, const char * const argv[], void *context)
796{
797 const char **str = (const char **) context;
798
799 if (argv[arg][0] != '/' && argv[arg][0] != '-') {
800 *str = argv[arg];
801 return 1;
802 }
803
804 return 0;
805}
806U_CDECL_END
807
808int main(int argc, char* argv[])
809{
810 int32_t nerrors = 0;
811 TestNode *root = NULL;
812 UErrorCode errorCode = U_ZERO_ERROR;
813 UDate startTime, endTime;
814 int32_t diffTime;
815
816 startTime = uprv_getRawUTCtime();
817
818 /* Check whether ICU will initialize without forcing the build data directory into
819 * the ICU_DATA path. Success here means either the data dll contains data, or that
820 * this test program was run with ICU_DATA set externally. Failure of this check
821 * is normal when ICU data is not packaged into a shared library.
822 *
823 * Whether or not this test succeeds, we want to cleanup and reinitialize
824 * with a data path so that data loading from individual files can be tested.
825 */
826 u_init(&errorCode);
827 if (U_FAILURE(errorCode)) {
828 fprintf(stderr,
829 "#### Note: ICU Init without build-specific setDataDirectory() failed.\n");
830 }
831 u_cleanup();
832 errorCode = U_ZERO_ERROR;
833 if (!initArgs(argc, argv, argHandler, (void *) &STANDARD_TEST_FILE)) {
834 /* Error already displayed. */
835 return -1;
836 }
837
838 /* Initialize ICU */
839 ctest_setICU_DATA(); /* u_setDataDirectory() must happen Before u_init() */
840 u_init(&errorCode);
841 if (U_FAILURE(errorCode)) {
842 fprintf(stderr,
843 "#### ERROR! %s: u_init() failed with status = \"%s\".\n"
844 "*** Check the ICU_DATA environment variable and \n"
845 "*** check that the data files are present.\n", argv[0], u_errorName(errorCode));
846 return 1;
847 }
848
849 fprintf(stdout, "Default charset for this run is %s\n", ucnv_getDefaultName());
850
851 addAllTests(&root);
852 nerrors = runTestRequest(root, argc, argv);
853
854#if 1
855 {
856 FILE* fileToRemove = fopen(STANDARD_TEST_FILE, "r");
857 /* This should delete any temporary files. */
858 if (fileToRemove) {
859 fclose(fileToRemove);
860 log_verbose("Deleting: %s\n", STANDARD_TEST_FILE);
861 if (remove(STANDARD_TEST_FILE) != 0) {
862 /* Maybe someone didn't close the file correctly. */
863 fprintf(stderr, "FAIL: Could not delete %s\n", STANDARD_TEST_FILE);
864 nerrors += 1;
865 }
866 }
867 }
868#endif
869
870 cleanUpTestTree(root);
871 DataDrivenLogger::cleanUp();
872 u_cleanup();
873
874 endTime = uprv_getRawUTCtime();
875 diffTime = (int32_t)(endTime - startTime);
876 printf("Elapsed Time: %02d:%02d:%02d.%03d\n",
877 (int)((diffTime%U_MILLIS_PER_DAY)/U_MILLIS_PER_HOUR),
878 (int)((diffTime%U_MILLIS_PER_HOUR)/U_MILLIS_PER_MINUTE),
879 (int)((diffTime%U_MILLIS_PER_MINUTE)/U_MILLIS_PER_SECOND),
880 (int)(diffTime%U_MILLIS_PER_SECOND));
881
882 return nerrors;
883}
mirror of ICU