The Tor Browser / file comparison

comparison: intl/icu/source/tools/ctestfw/ctest.c

intl/icu/source/tools/ctestfw/ctest.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:fbbafd70d086
1 /*
2 ********************************************************************************
3 *
4 * Copyright (C) 1996-2013, International Business Machines
5 * Corporation and others. All Rights Reserved.
6 *
7 ********************************************************************************
8 */
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include <assert.h>
13 #include <stdarg.h>
14 #include <ctype.h>
15
16 #include "unicode/utrace.h"
17 #include "unicode/uclean.h"
18 #include "putilimp.h"
19 #include "udbgutil.h"
20
21 /* NOTES:
22 3/20/1999 srl - strncpy called w/o setting nulls at the end
23 */
24
25 #define MAXTESTNAME 128
26 #define MAXTESTS 512
27 #define MAX_TEST_LOG 4096
28
29 /**
30 * How may columns to indent the 'OK' markers.
31 */
32 #define FLAG_INDENT 45
33 /**
34 * How many lines of scrollage can go by before we need to remind the user what the test is.
35 */
36 #define PAGE_SIZE_LIMIT 25
37
38 #ifndef SHOW_TIMES
39 #define SHOW_TIMES 1
40 #endif
41
42 struct TestNode
43 {
44 void (*test)(void);
45 struct TestNode* sibling;
46 struct TestNode* child;
47 char name[1]; /* This is dynamically allocated off the end with malloc. */
48 };
49
50
51 static const struct TestNode* currentTest;
52
53 typedef enum { RUNTESTS, SHOWTESTS } TestMode;
54 #define TEST_SEPARATOR '/'
55
56 #ifndef C_TEST_IMPL
57 #define C_TEST_IMPL
58 #endif
59
60 #include "unicode/ctest.h"
61
62 static char ERROR_LOG[MAX_TEST_LOG][MAXTESTNAME];
63
64 /* Local prototypes */
65 static TestNode* addTestNode( TestNode *root, const char *name );
66
67 static TestNode *createTestNode(const char* name, int32_t nameLen);
68
69 static int strncmp_nullcheck( const char* s1,
70 const char* s2,
71 int n );
72
73 static void getNextLevel( const char* name,
74 int* nameLen,
75 const char** nextName );
76
77 static void iterateTestsWithLevel( const TestNode *root, int depth,
78 const TestNode** nodeList,
79 TestMode mode);
80
81 static void help ( const char *argv0 );
82
83 /**
84 * Do the work of logging an error. Doesn't increase the error count.
85 *
86 * @prefix optional prefix prepended to message, or NULL.
87 * @param pattern printf style pattern
88 * @param ap vprintf style arg list
89 */
90 static void vlog_err(const char *prefix, const char *pattern, va_list ap);
91 static void vlog_verbose(const char *prefix, const char *pattern, va_list ap);
92 static UBool vlog_knownIssue(const char *ticket, const char *pattern, va_list ap);
93
94 /**
95 * Log test structure, with indent
96 * @param pattern printf pattern
97 */
98 static void log_testinfo_i(const char *pattern, ...);
99
100 /**
101 * Log test structure, NO indent
102 * @param pattern printf pattern
103 */
104 static void log_testinfo(const char *pattern, ...);
105
106 /* If we need to make the framework multi-thread safe
107 we need to pass around the following vars
108 */
109 static int ERRONEOUS_FUNCTION_COUNT = 0;
110 static int ERROR_COUNT = 0; /* Count of errors from all tests. */
111 static int ONE_ERROR = 0; /* were there any other errors? */
112 static int DATA_ERROR_COUNT = 0; /* count of data related errors or warnings */
113 static int INDENT_LEVEL = 0;
114 static UBool NO_KNOWN = FALSE;
115 static void *knownList = NULL;
116 static char gTestName[1024] = "";
117 static UBool ON_LINE = FALSE; /* are we on the top line with our test name? */
118 static UBool HANGING_OUTPUT = FALSE; /* did the user leave us without a trailing \n ? */
119 static int GLOBAL_PRINT_COUNT = 0; /* global count of printouts */
120 int REPEAT_TESTS_INIT = 0; /* Was REPEAT_TESTS initialized? */
121 int REPEAT_TESTS = 1; /* Number of times to run the test */
122 int VERBOSITY = 0; /* be No-verbose by default */
123 int ERR_MSG =1; /* error messages will be displayed by default*/
124 int QUICK = 1; /* Skip some of the slower tests? */
125 int WARN_ON_MISSING_DATA = 0; /* Reduce data errs to warnings? */
126 UTraceLevel ICU_TRACE = UTRACE_OFF; /* ICU tracing level */
127 size_t MINIMUM_MEMORY_SIZE_FAILURE = (size_t)-1; /* Minimum library memory allocation window that will fail. */
128 size_t MAXIMUM_MEMORY_SIZE_FAILURE = (size_t)-1; /* Maximum library memory allocation window that will fail. */
129 static const char *ARGV_0 = "[ALL]";
130 static const char *XML_FILE_NAME=NULL;
131 static char XML_PREFIX[256];
132 static const char *SUMMARY_FILE = NULL;
133 FILE *XML_FILE = NULL;
134 /*-------------------------------------------*/
135
136 /* strncmp that also makes sure there's a \0 at s2[0] */
137 static int strncmp_nullcheck( const char* s1,
138 const char* s2,
139 int n )
140 {
141 if (((int)strlen(s2) >= n) && s2[n] != 0) {
142 return 3; /* null check fails */
143 }
144 else {
145 return strncmp ( s1, s2, n );
146 }
147 }
148
149 static void getNextLevel( const char* name,
150 int* nameLen,
151 const char** nextName )
152 {
153 /* Get the next component of the name */
154 *nextName = strchr(name, TEST_SEPARATOR);
155
156 if( *nextName != 0 )
157 {
158 char n[255];
159 *nameLen = (int)((*nextName) - name);
160 (*nextName)++; /* skip '/' */
161 strncpy(n, name, *nameLen);
162 n[*nameLen] = 0;
163 /*printf("->%s-< [%d] -> [%s]\n", name, *nameLen, *nextName);*/
164 }
165 else {
166 *nameLen = (int)strlen(name);
167 }
168 }
169
170 static TestNode *createTestNode(const char* name, int32_t nameLen)
171 {
172 TestNode *newNode;
173
174 newNode = (TestNode*)malloc(sizeof(TestNode) + (nameLen + 1));
175
176 newNode->test = NULL;
177 newNode->sibling = NULL;
178 newNode->child = NULL;
179
180 strncpy( newNode->name, name, nameLen );
181 newNode->name[nameLen] = 0;
182
183 return newNode;
184 }
185
186 void T_CTEST_EXPORT2
187 cleanUpTestTree(TestNode *tn)
188 {
189 if(tn->child != NULL) {
190 cleanUpTestTree(tn->child);
191 }
192 if(tn->sibling != NULL) {
193 cleanUpTestTree(tn->sibling);
194 }
195
196 free(tn);
197
198 }
199
200
201 void T_CTEST_EXPORT2
202 addTest(TestNode** root,
203 TestFunctionPtr test,
204 const char* name )
205 {
206 TestNode *newNode;
207
208 /*if this is the first Test created*/
209 if (*root == NULL)
210 *root = createTestNode("", 0);
211
212 newNode = addTestNode( *root, name );
213 assert(newNode != 0 );
214 /* printf("addTest: nreName = %s\n", newNode->name );*/
215
216 newNode->test = test;
217 }
218
219 /* non recursive insert function */
220 static TestNode *addTestNode ( TestNode *root, const char *name )
221 {
222 const char* nextName;
223 TestNode *nextNode, *curNode;
224 int nameLen; /* length of current 'name' */
225
226 /* remove leading slash */
227 if ( *name == TEST_SEPARATOR )
228 name++;
229
230 curNode = root;
231
232 for(;;)
233 {
234 /* Start with the next child */
235 nextNode = curNode->child;
236
237 getNextLevel ( name, &nameLen, &nextName );
238
239 /* printf("* %s\n", name );*/
240
241 /* if nextNode is already null, then curNode has no children
242 -- add them */
243 if( nextNode == NULL )
244 {
245 /* Add all children of the node */
246 do
247 {
248 /* Get the next component of the name */
249 getNextLevel(name, &nameLen, &nextName);
250
251 /* update curName to have the next name segment */
252 curNode->child = createTestNode(name, nameLen);
253 /* printf("*** added %s\n", curNode->child->name );*/
254 curNode = curNode->child;
255 name = nextName;
256 }
257 while( name != NULL );
258
259 return curNode;
260 }
261
262 /* Search across for the name */
263 while (strncmp_nullcheck ( name, nextNode->name, nameLen) != 0 )
264 {
265 curNode = nextNode;
266 nextNode = nextNode -> sibling;
267
268 if ( nextNode == NULL )
269 {
270 /* Did not find 'name' on this level. */
271 nextNode = createTestNode(name, nameLen);
272 curNode->sibling = nextNode;
273 break;
274 }
275 }
276
277 /* nextNode matches 'name' */
278
279 if (nextName == NULL) /* end of the line */
280 {
281 return nextNode;
282 }
283
284 /* Loop again with the next item */
285 name = nextName;
286 curNode = nextNode;
287 }
288 }
289
290 /**
291 * Log the time taken. May not output anything.
292 * @param deltaTime change in time
293 */
294 void T_CTEST_EXPORT2 str_timeDelta(char *str, UDate deltaTime) {
295 if (deltaTime > 110000.0 ) {
296 double mins = uprv_floor(deltaTime/60000.0);
297 sprintf(str, "[(%.0fm %.1fs)]", mins, (deltaTime-(mins*60000.0))/1000.0);
298 } else if (deltaTime > 1500.0) {
299 sprintf(str, "((%.1fs))", deltaTime/1000.0);
300 } else if(deltaTime>900.0) {
301 sprintf(str, "( %.2fs )", deltaTime/1000.0);
302 } else if(deltaTime > 5.0) {
303 sprintf(str, " (%.0fms) ", deltaTime);
304 } else {
305 str[0]=0; /* at least terminate it. */
306 }
307 }
308
309 static void print_timeDelta(UDate deltaTime) {
310 char str[256];
311 str_timeDelta(str, deltaTime);
312 if(str[0]) {
313 printf("%s", str);
314 }
315 }
316
317 /**
318 * Run or list tests (according to mode) in a subtree.
319 *
320 * @param root root of the subtree to operate on
321 * @param depth The depth of this tree (0=root)
322 * @param nodeList an array of MAXTESTS depth that's used for keeping track of where we are. nodeList[depth] points to the 'parent' at depth depth.
323 * @param mode what mode we are operating in.
324 */
325 static void iterateTestsWithLevel ( const TestNode* root,
326 int depth,
327 const TestNode** nodeList,
328 TestMode mode)
329 {
330 int i;
331
332 char pathToFunction[MAXTESTNAME] = "";
333 char separatorString[2] = { TEST_SEPARATOR, '\0'};
334 #if SHOW_TIMES
335 UDate allStartTime = -1, allStopTime = -1;
336 #endif
337
338 if(depth<2) {
339 allStartTime = uprv_getRawUTCtime();
340 }
341
342 if ( root == NULL )
343 return;
344
345 /* record the current root node, and increment depth. */
346 nodeList[depth++] = root;
347 /* depth is now the depth of root's children. */
348
349 /* Collect the 'path' to the current subtree. */
350 for ( i=0;i<(depth-1);i++ )
351 {
352 strcat(pathToFunction, nodeList[i]->name);
353 strcat(pathToFunction, separatorString);
354 }
355 strcat(pathToFunction, nodeList[i]->name); /* including 'root' */
356
357 /* print test name and space. */
358 INDENT_LEVEL = depth-1;
359 if(root->name[0]) {
360 log_testinfo_i("%s ", root->name);
361 } else {
362 log_testinfo_i("(%s) ", ARGV_0);
363 }
364 ON_LINE = TRUE; /* we are still on the line with the test name */
365
366
367 if ( (mode == RUNTESTS) &&
368 (root->test != NULL)) /* if root is a leaf node, run it */
369 {
370 int myERROR_COUNT = ERROR_COUNT;
371 int myGLOBAL_PRINT_COUNT = GLOBAL_PRINT_COUNT;
372 #if SHOW_TIMES
373 UDate startTime, stopTime;
374 char timeDelta[256];
375 char timeSeconds[256];
376 #else
377 const char timeDelta[] = "(unknown)";
378 const char timeSeconds[] = "0.000";
379 #endif
380 currentTest = root;
381 INDENT_LEVEL = depth; /* depth of subitems */
382 ONE_ERROR=0;
383 HANGING_OUTPUT=FALSE;
384 #if SHOW_TIMES
385 startTime = uprv_getRawUTCtime();
386 #endif
387 strcpy(gTestName, pathToFunction);
388 root->test(); /* PERFORM THE TEST ************************/
389 #if SHOW_TIMES
390 stopTime = uprv_getRawUTCtime();
391 #endif
392 if(HANGING_OUTPUT) {
393 log_testinfo("\n");
394 HANGING_OUTPUT=FALSE;
395 }
396 INDENT_LEVEL = depth-1; /* depth of root */
397 currentTest = NULL;
398 if((ONE_ERROR>0)&&(ERROR_COUNT==0)) {
399 ERROR_COUNT++; /* There was an error without a newline */
400 }
401 ONE_ERROR=0;
402
403 #if SHOW_TIMES
404 str_timeDelta(timeDelta, stopTime-startTime);
405 sprintf(timeSeconds, "%f", (stopTime-startTime)/1000.0);
406 #endif
407 ctest_xml_testcase(pathToFunction, pathToFunction, timeSeconds, (myERROR_COUNT!=ERROR_COUNT)?"error":NULL);
408
409 if (myERROR_COUNT != ERROR_COUNT) {
410 log_testinfo_i("} ---[%d ERRORS in %s] ", ERROR_COUNT - myERROR_COUNT, pathToFunction);
411 strcpy(ERROR_LOG[ERRONEOUS_FUNCTION_COUNT++], pathToFunction);
412 } else {
413 if(!ON_LINE) { /* had some output */
414 int spaces = FLAG_INDENT-(depth-1);
415 log_testinfo_i("} %*s[OK] ", spaces, "---");
416 if((GLOBAL_PRINT_COUNT-myGLOBAL_PRINT_COUNT)>PAGE_SIZE_LIMIT) {
417 log_testinfo(" %s ", pathToFunction); /* in case they forgot. */
418 }
419 } else {
420 /* put -- out at 30 sp. */
421 int spaces = FLAG_INDENT-(strlen(root->name)+depth);
422 if(spaces<0) spaces=0;
423 log_testinfo(" %*s[OK] ", spaces,"---");
424 }
425 }
426
427 #if SHOW_TIMES
428 if(timeDelta[0]) printf("%s", timeDelta);
429 #endif
430
431 ON_LINE = TRUE; /* we are back on-line */
432 }
433
434 INDENT_LEVEL = depth-1; /* root */
435
436 /* we want these messages to be at 0 indent. so just push the indent level breifly. */
437 if(mode==SHOWTESTS) {
438 log_testinfo("---%s%c\n",pathToFunction, nodeList[i]->test?' ':TEST_SEPARATOR );
439 }
440
441 INDENT_LEVEL = depth;
442
443 if(root->child) {
444 int myERROR_COUNT = ERROR_COUNT;
445 int myGLOBAL_PRINT_COUNT = GLOBAL_PRINT_COUNT;
446 if(mode!=SHOWTESTS) {
447 INDENT_LEVEL=depth-1;
448 log_testinfo("{\n");
449 INDENT_LEVEL=depth;
450 }
451
452 iterateTestsWithLevel ( root->child, depth, nodeList, mode );
453
454 if(mode!=SHOWTESTS) {
455 INDENT_LEVEL=depth-1;
456 log_testinfo_i("} "); /* TODO: summarize subtests */
457 if((depth>1) && (ERROR_COUNT > myERROR_COUNT)) {
458 log_testinfo("[%d %s in %s] ", ERROR_COUNT-myERROR_COUNT, (ERROR_COUNT-myERROR_COUNT)==1?"error":"errors", pathToFunction);
459 } else if((GLOBAL_PRINT_COUNT-myGLOBAL_PRINT_COUNT)>PAGE_SIZE_LIMIT || (depth<1)) {
460 if(pathToFunction[0]) {
461 log_testinfo(" %s ", pathToFunction); /* in case they forgot. */
462 } else {
463 log_testinfo(" / (%s) ", ARGV_0);
464 }
465 }
466
467 ON_LINE=TRUE;
468 }
469 }
470 depth--;
471
472 #if SHOW_TIMES
473 if(depth<2) {
474 allStopTime = uprv_getRawUTCtime();
475 print_timeDelta(allStopTime-allStartTime);
476 }
477 #endif
478
479 if(mode!=SHOWTESTS && ON_LINE) {
480 log_testinfo("\n");
481 }
482
483 if ( depth != 0 ) { /* DO NOT iterate over siblings of the root. TODO: why not? */
484 iterateTestsWithLevel ( root->sibling, depth, nodeList, mode );
485 }
486 }
487
488
489
490 void T_CTEST_EXPORT2
491 showTests ( const TestNode *root )
492 {
493 /* make up one for them */
494 const TestNode *nodeList[MAXTESTS];
495
496 if (root == NULL)
497 log_err("TEST CAN'T BE FOUND!");
498
499 iterateTestsWithLevel ( root, 0, nodeList, SHOWTESTS );
500
501 }
502
503 void T_CTEST_EXPORT2
504 runTests ( const TestNode *root )
505 {
506 int i;
507 const TestNode *nodeList[MAXTESTS];
508 /* make up one for them */
509
510
511 if (root == NULL)
512 log_err("TEST CAN'T BE FOUND!\n");
513
514 ERRONEOUS_FUNCTION_COUNT = ERROR_COUNT = 0;
515 iterateTestsWithLevel ( root, 0, nodeList, RUNTESTS );
516
517 /*print out result summary*/
518
519 ON_LINE=FALSE; /* just in case */
520
521 if(knownList != NULL) {
522 if( udbg_knownIssue_print(knownList) ) {
523 fprintf(stdout, "(To run suppressed tests, use the -K option.) \n\n");
524 }
525 udbg_knownIssue_close(knownList);
526 }
527
528 if (ERROR_COUNT)
529 {
530 fprintf(stdout,"\nSUMMARY:\n");
531 fflush(stdout);
532 fprintf(stdout,"******* [Total error count:\t%d]\n", ERROR_COUNT);
533 fflush(stdout);
534 fprintf(stdout, " Errors in\n");
535 for (i=0;i < ERRONEOUS_FUNCTION_COUNT; i++)
536 fprintf(stdout, "[%s]\n",ERROR_LOG[i]);
537 if(SUMMARY_FILE != NULL) {
538 FILE *summf = fopen(SUMMARY_FILE, "w");
539 if(summf!=NULL) {
540 for (i=0;i < ERRONEOUS_FUNCTION_COUNT; i++)
541 fprintf(summf, "%s\n",ERROR_LOG[i]);
542 fclose(summf);
543 }
544 }
545 }
546 else
547 {
548 log_testinfo("\n[All tests passed successfully...]\n");
549 }
550
551 if(DATA_ERROR_COUNT) {
552 if(WARN_ON_MISSING_DATA==0) {
553 log_testinfo("\t*Note* some errors are data-loading related. If the data used is not the \n"
554 "\tstock ICU data (i.e some have been added or removed), consider using\n"
555 "\tthe '-w' option to turn these errors into warnings.\n");
556 } else {
557 log_testinfo("\t*WARNING* some data-loading errors were ignored by the -w option.\n");
558 }
559 }
560 }
561
562 const char* T_CTEST_EXPORT2
563 getTestName(void)
564 {
565 if(currentTest != NULL) {
566 return currentTest->name;
567 } else {
568 return NULL;
569 }
570 }
571
572 const TestNode* T_CTEST_EXPORT2
573 getTest(const TestNode* root, const char* name)
574 {
575 const char* nextName;
576 TestNode *nextNode;
577 const TestNode* curNode;
578 int nameLen; /* length of current 'name' */
579
580 if (root == NULL) {
581 log_err("TEST CAN'T BE FOUND!\n");
582 return NULL;
583 }
584 /* remove leading slash */
585 if ( *name == TEST_SEPARATOR )
586 name++;
587
588 curNode = root;
589
590 for(;;)
591 {
592 /* Start with the next child */
593 nextNode = curNode->child;
594
595 getNextLevel ( name, &nameLen, &nextName );
596
597 /* printf("* %s\n", name );*/
598
599 /* if nextNode is already null, then curNode has no children
600 -- add them */
601 if( nextNode == NULL )
602 {
603 return NULL;
604 }
605
606 /* Search across for the name */
607 while (strncmp_nullcheck ( name, nextNode->name, nameLen) != 0 )
608 {
609 curNode = nextNode;
610 nextNode = nextNode -> sibling;
611
612 if ( nextNode == NULL )
613 {
614 /* Did not find 'name' on this level. */
615 return NULL;
616 }
617 }
618
619 /* nextNode matches 'name' */
620
621 if (nextName == NULL) /* end of the line */
622 {
623 return nextNode;
624 }
625
626 /* Loop again with the next item */
627 name = nextName;
628 curNode = nextNode;
629 }
630 }
631
632 /* =========== io functions ======== */
633
634 static void go_offline_with_marker(const char *mrk) {
635 UBool wasON_LINE = ON_LINE;
636
637 if(ON_LINE) {
638 log_testinfo(" {\n");
639 ON_LINE=FALSE;
640 }
641
642 if(!HANGING_OUTPUT || wasON_LINE) {
643 if(mrk != NULL) {
644 fputs(mrk, stdout);
645 }
646 }
647 }
648
649 static void go_offline() {
650 go_offline_with_marker(NULL);
651 }
652
653 static void go_offline_err() {
654 go_offline();
655 }
656
657 static void first_line_verbose() {
658 go_offline_with_marker("v");
659 }
660
661 static void first_line_err() {
662 go_offline_with_marker("!");
663 }
664
665 static void first_line_info() {
666 go_offline_with_marker("\"");
667 }
668
669 static void first_line_test() {
670 fputs(" ", stdout);
671 }
672
673
674 static void vlog_err(const char *prefix, const char *pattern, va_list ap)
675 {
676 if( ERR_MSG == FALSE){
677 return;
678 }
679 fputs("!", stdout); /* col 1 - bang */
680 fprintf(stdout, "%-*s", INDENT_LEVEL,"" );
681 if(prefix) {
682 fputs(prefix, stdout);
683 }
684 vfprintf(stdout, pattern, ap);
685 fflush(stdout);
686 va_end(ap);
687 if((*pattern==0) || (pattern[strlen(pattern)-1]!='\n')) {
688 HANGING_OUTPUT=1;
689 } else {
690 HANGING_OUTPUT=0;
691 }
692 GLOBAL_PRINT_COUNT++;
693 }
694
695 static UBool vlog_knownIssue(const char *ticket, const char *pattern, va_list ap)
696 {
697 char buf[2048];
698 UBool firstForTicket;
699 UBool firstForWhere;
700
701 if(NO_KNOWN) return FALSE;
702 if(pattern==NULL) pattern="";
703
704 vsprintf(buf, pattern, ap);
705 knownList = udbg_knownIssue_open(knownList, ticket, gTestName, buf,
706 &firstForTicket, &firstForWhere);
707
708 if(firstForTicket || firstForWhere) {
709 log_info("(Known issue #%s) %s", ticket, buf);
710 } else {
711 log_verbose("(Known issue #%s) %s", ticket, buf);
712 }
713
714 return TRUE;
715 }
716
717
718 void T_CTEST_EXPORT2
719 vlog_info(const char *prefix, const char *pattern, va_list ap)
720 {
721 first_line_info();
722 fprintf(stdout, "%-*s", INDENT_LEVEL,"" );
723 if(prefix) {
724 fputs(prefix, stdout);
725 }
726 vfprintf(stdout, pattern, ap);
727 fflush(stdout);
728 va_end(ap);
729 if((*pattern==0) || (pattern[strlen(pattern)-1]!='\n')) {
730 HANGING_OUTPUT=1;
731 } else {
732 HANGING_OUTPUT=0;
733 }
734 GLOBAL_PRINT_COUNT++;
735 }
736 /**
737 * Log test structure, with indent
738 */
739 static void log_testinfo_i(const char *pattern, ...)
740 {
741 va_list ap;
742 first_line_test();
743 fprintf(stdout, "%-*s", INDENT_LEVEL,"" );
744 va_start(ap, pattern);
745 vfprintf(stdout, pattern, ap);
746 fflush(stdout);
747 va_end(ap);
748 GLOBAL_PRINT_COUNT++;
749 }
750 /**
751 * Log test structure (no ident)
752 */
753 static void log_testinfo(const char *pattern, ...)
754 {
755 va_list ap;
756 va_start(ap, pattern);
757 first_line_test();
758 vfprintf(stdout, pattern, ap);
759 fflush(stdout);
760 va_end(ap);
761 GLOBAL_PRINT_COUNT++;
762 }
763
764
765 static void vlog_verbose(const char *prefix, const char *pattern, va_list ap)
766 {
767 if ( VERBOSITY == FALSE )
768 return;
769
770 first_line_verbose();
771 fprintf(stdout, "%-*s", INDENT_LEVEL,"" );
772 if(prefix) {
773 fputs(prefix, stdout);
774 }
775 vfprintf(stdout, pattern, ap);
776 fflush(stdout);
777 va_end(ap);
778 GLOBAL_PRINT_COUNT++;
779 if((*pattern==0) || (pattern[strlen(pattern)-1]!='\n')) {
780 HANGING_OUTPUT=1;
781 } else {
782 HANGING_OUTPUT=0;
783 }
784 }
785
786 void T_CTEST_EXPORT2
787 log_err(const char* pattern, ...)
788 {
789 va_list ap;
790 first_line_err();
791 if(strchr(pattern, '\n') != NULL) {
792 /*
793 * Count errors only if there is a line feed in the pattern
794 * so that we do not exaggerate our error count.
795 */
796 ++ERROR_COUNT;
797 } else {
798 /* Count at least one error. */
799 ONE_ERROR=1;
800 }
801 va_start(ap, pattern);
802 vlog_err(NULL, pattern, ap);
803 }
804
805 UBool T_CTEST_EXPORT2
806 log_knownIssue(const char *ticket, const char *pattern, ...) {
807 va_list ap;
808 va_start(ap, pattern);
809 return vlog_knownIssue(ticket, pattern, ap);
810 }
811
812 void T_CTEST_EXPORT2
813 log_err_status(UErrorCode status, const char* pattern, ...)
814 {
815 va_list ap;
816 va_start(ap, pattern);
817
818 if ((status == U_FILE_ACCESS_ERROR || status == U_MISSING_RESOURCE_ERROR)) {
819 ++DATA_ERROR_COUNT; /* for informational message at the end */
820
821 if (WARN_ON_MISSING_DATA == 0) {
822 first_line_err();
823 /* Fatal error. */
824 if (strchr(pattern, '\n') != NULL) {
825 ++ERROR_COUNT;
826 } else {
827 ++ONE_ERROR;
828 }
829 vlog_err(NULL, pattern, ap); /* no need for prefix in default case */
830 } else {
831 vlog_info("[DATA] ", pattern, ap);
832 }
833 } else {
834 first_line_err();
835 /* Fatal error. */
836 if(strchr(pattern, '\n') != NULL) {
837 ++ERROR_COUNT;
838 } else {
839 ++ONE_ERROR;
840 }
841 vlog_err(NULL, pattern, ap); /* no need for prefix in default case */
842 }
843 }
844
845 void T_CTEST_EXPORT2
846 log_info(const char* pattern, ...)
847 {
848 va_list ap;
849
850 va_start(ap, pattern);
851 vlog_info(NULL, pattern, ap);
852 }
853
854 void T_CTEST_EXPORT2
855 log_verbose(const char* pattern, ...)
856 {
857 va_list ap;
858
859 va_start(ap, pattern);
860 vlog_verbose(NULL, pattern, ap);
861 }
862
863
864 void T_CTEST_EXPORT2
865 log_data_err(const char* pattern, ...)
866 {
867 va_list ap;
868 va_start(ap, pattern);
869
870 go_offline_err();
871 ++DATA_ERROR_COUNT; /* for informational message at the end */
872
873 if(WARN_ON_MISSING_DATA == 0) {
874 /* Fatal error. */
875 if(strchr(pattern, '\n') != NULL) {
876 ++ERROR_COUNT;
877 }
878 vlog_err(NULL, pattern, ap); /* no need for prefix in default case */
879 } else {
880 vlog_info("[DATA] ", pattern, ap);
881 }
882 }
883
884
885 /*
886 * Tracing functions.
887 */
888 static int traceFnNestingDepth = 0;
889 U_CDECL_BEGIN
890 static void U_CALLCONV TraceEntry(const void *context, int32_t fnNumber) {
891 char buf[500];
892 utrace_format(buf, sizeof(buf), traceFnNestingDepth*3, "%s() enter.\n", utrace_functionName(fnNumber)); buf[sizeof(buf)-1]=0;
893 fputs(buf, stdout);
894 traceFnNestingDepth++;
895 }
896
897 static void U_CALLCONV TraceExit(const void *context, int32_t fnNumber, const char *fmt, va_list args) { char buf[500];
898
899 if (traceFnNestingDepth>0) {
900 traceFnNestingDepth--;
901 }
902 utrace_format(buf, sizeof(buf), traceFnNestingDepth*3, "%s() ", utrace_functionName(fnNumber)); buf[sizeof(buf)-1]=0;
903 fputs(buf, stdout);
904 utrace_vformat(buf, sizeof(buf), traceFnNestingDepth*3, fmt, args);
905 buf[sizeof(buf)-1]=0;
906 fputs(buf, stdout);
907 putc('\n', stdout);
908 }
909
910 static void U_CALLCONV TraceData(const void *context, int32_t fnNumber,
911 int32_t level, const char *fmt, va_list args) {
912 char buf[500];
913 utrace_vformat(buf, sizeof(buf), traceFnNestingDepth*3, fmt, args);
914 buf[sizeof(buf)-1]=0;
915 fputs(buf, stdout);
916 putc('\n', stdout);
917 }
918
919 static void *U_CALLCONV ctest_libMalloc(const void *context, size_t size) {
920 /*if (VERBOSITY) {
921 printf("Allocated %ld\n", (long)size);
922 }*/
923 if (MINIMUM_MEMORY_SIZE_FAILURE <= size && size <= MAXIMUM_MEMORY_SIZE_FAILURE) {
924 return NULL;
925 }
926 return malloc(size);
927 }
928 static void *U_CALLCONV ctest_libRealloc(const void *context, void *mem, size_t size) {
929 /*if (VERBOSITY) {
930 printf("Reallocated %ld\n", (long)size);
931 }*/
932 if (MINIMUM_MEMORY_SIZE_FAILURE <= size && size <= MAXIMUM_MEMORY_SIZE_FAILURE) {
933 /*free(mem);*/ /* Realloc doesn't free on failure. */
934 return NULL;
935 }
936 return realloc(mem, size);
937 }
938 static void U_CALLCONV ctest_libFree(const void *context, void *mem) {
939 free(mem);
940 }
941
942 int T_CTEST_EXPORT2
943 initArgs( int argc, const char* const argv[], ArgHandlerPtr argHandler, void *context)
944 {
945 int i;
946 int argSkip = 0;
947
948 VERBOSITY = FALSE;
949 ERR_MSG = TRUE;
950
951 ARGV_0=argv[0];
952
953 for( i=1; i<argc; i++)
954 {
955 if ( argv[i][0] == '/' )
956 {
957 /* We don't run the tests here. */
958 continue;
959 }
960 else if ((strcmp( argv[i], "-a") == 0) || (strcmp(argv[i],"-all") == 0))
961 {
962 /* We don't run the tests here. */
963 continue;
964 }
965 else if (strcmp( argv[i], "-v" )==0 || strcmp( argv[i], "-verbose")==0)
966 {
967 VERBOSITY = TRUE;
968 }
969 else if (strcmp( argv[i], "-l" )==0 )
970 {
971 /* doList = TRUE; */
972 }
973 else if (strcmp( argv[i], "-e1") == 0)
974 {
975 QUICK = -1;
976 }
977 else if (strcmp( argv[i], "-e") ==0)
978 {
979 QUICK = 0;
980 }
981 else if (strcmp( argv[i], "-K") ==0)
982 {
983 NO_KNOWN = 1;
984 }
985 else if (strncmp( argv[i], "-E",2) ==0)
986 {
987 SUMMARY_FILE=argv[i]+2;
988 }
989 else if (strcmp( argv[i], "-w") ==0)
990 {
991 WARN_ON_MISSING_DATA = TRUE;
992 }
993 else if (strcmp( argv[i], "-m") ==0)
994 {
995 UErrorCode errorCode = U_ZERO_ERROR;
996 if (i+1 < argc) {
997 char *endPtr = NULL;
998 i++;
999 MINIMUM_MEMORY_SIZE_FAILURE = (size_t)strtol(argv[i], &endPtr, 10);
1000 if (endPtr == argv[i]) {
1001 printf("Can't parse %s\n", argv[i]);
1002 help(argv[0]);
1003 return 0;
1004 }
1005 if (*endPtr == '-') {
1006 char *maxPtr = endPtr+1;
1007 endPtr = NULL;
1008 MAXIMUM_MEMORY_SIZE_FAILURE = (size_t)strtol(maxPtr, &endPtr, 10);
1009 if (endPtr == argv[i]) {
1010 printf("Can't parse %s\n", argv[i]);
1011 help(argv[0]);
1012 return 0;
1013 }
1014 }
1015 }
1016 /* Use the default value */
1017 u_setMemoryFunctions(NULL, ctest_libMalloc, ctest_libRealloc, ctest_libFree, &errorCode);
1018 if (U_FAILURE(errorCode)) {
1019 printf("u_setMemoryFunctions returned %s\n", u_errorName(errorCode));
1020 return 0;
1021 }
1022 }
1023 else if(strcmp( argv[i], "-n") == 0 || strcmp( argv[i], "-no_err_msg") == 0)
1024 {
1025 ERR_MSG = FALSE;
1026 }
1027 else if (strcmp( argv[i], "-r") == 0)
1028 {
1029 if (!REPEAT_TESTS_INIT) {
1030 REPEAT_TESTS++;
1031 }
1032 }
1033 else if (strcmp( argv[i], "-x") == 0)
1034 {
1035 if(++i>=argc) {
1036 printf("* Error: '-x' option requires an argument. usage: '-x outfile.xml'.\n");
1037 return 0;
1038 }
1039 if(ctest_xml_setFileName(argv[i])) { /* set the name */
1040 return 0;
1041 }
1042 }
1043 else if (strcmp( argv[i], "-t_info") == 0) {
1044 ICU_TRACE = UTRACE_INFO;
1045 }
1046 else if (strcmp( argv[i], "-t_error") == 0) {
1047 ICU_TRACE = UTRACE_ERROR;
1048 }
1049 else if (strcmp( argv[i], "-t_warn") == 0) {
1050 ICU_TRACE = UTRACE_WARNING;
1051 }
1052 else if (strcmp( argv[i], "-t_verbose") == 0) {
1053 ICU_TRACE = UTRACE_VERBOSE;
1054 }
1055 else if (strcmp( argv[i], "-t_oc") == 0) {
1056 ICU_TRACE = UTRACE_OPEN_CLOSE;
1057 }
1058 else if (strcmp( argv[i], "-h" )==0 || strcmp( argv[i], "--help" )==0)
1059 {
1060 help( argv[0] );
1061 return 0;
1062 }
1063 else if (argHandler != NULL && (argSkip = argHandler(i, argc, argv, context)) > 0)
1064 {
1065 i += argSkip - 1;
1066 }
1067 else
1068 {
1069 printf("* unknown option: %s\n", argv[i]);
1070 help( argv[0] );
1071 return 0;
1072 }
1073 }
1074 if (ICU_TRACE != UTRACE_OFF) {
1075 utrace_setFunctions(NULL, TraceEntry, TraceExit, TraceData);
1076 utrace_setLevel(ICU_TRACE);
1077 }
1078
1079 return 1; /* total error count */
1080 }
1081
1082 int T_CTEST_EXPORT2
1083 runTestRequest(const TestNode* root,
1084 int argc,
1085 const char* const argv[])
1086 {
1087 /**
1088 * This main will parse the l, v, h, n, and path arguments
1089 */
1090 const TestNode* toRun;
1091 int i;
1092 int doList = FALSE;
1093 int subtreeOptionSeen = FALSE;
1094
1095 int errorCount = 0;
1096
1097 toRun = root;
1098
1099 if(ctest_xml_init(ARGV_0)) {
1100 return 1; /* couldn't fire up XML thing */
1101 }
1102
1103 for( i=1; i<argc; i++)
1104 {
1105 if ( argv[i][0] == '/' )
1106 {
1107 printf("Selecting subtree '%s'\n", argv[i]);
1108
1109 if ( argv[i][1] == 0 )
1110 toRun = root;
1111 else
1112 toRun = getTest(root, argv[i]);
1113
1114 if ( toRun == NULL )
1115 {
1116 printf("* Could not find any matching subtree\n");
1117 return -1;
1118 }
1119
1120 ON_LINE=FALSE; /* just in case */
1121
1122 if( doList == TRUE)
1123 showTests(toRun);
1124 else
1125 runTests(toRun);
1126
1127 ON_LINE=FALSE; /* just in case */
1128
1129 errorCount += ERROR_COUNT;
1130
1131 subtreeOptionSeen = TRUE;
1132 } else if ((strcmp( argv[i], "-a") == 0) || (strcmp(argv[i],"-all") == 0)) {
1133 subtreeOptionSeen=FALSE;
1134 } else if (strcmp( argv[i], "-l") == 0) {
1135 doList = TRUE;
1136 }
1137 /* else option already handled by initArgs */
1138 }
1139
1140 if( subtreeOptionSeen == FALSE) /* no other subtree given, run the default */
1141 {
1142 ON_LINE=FALSE; /* just in case */
1143 if( doList == TRUE)
1144 showTests(toRun);
1145 else
1146 runTests(toRun);
1147 ON_LINE=FALSE; /* just in case */
1148
1149 errorCount += ERROR_COUNT;
1150 }
1151 else
1152 {
1153 if( ( doList == FALSE ) && ( errorCount > 0 ) )
1154 printf(" Total errors: %d\n", errorCount );
1155 }
1156
1157 REPEAT_TESTS_INIT = 1;
1158
1159 if(ctest_xml_fini()) {
1160 errorCount++;
1161 }
1162
1163 return errorCount; /* total error count */
1164 }
1165
1166 /**
1167 * Display program invocation arguments
1168 */
1169
1170 static void help ( const char *argv0 )
1171 {
1172 printf("Usage: %s [ -l ] [ -v ] [ -verbose] [-a] [ -all] [-n] [ -no_err_msg]\n"
1173 " [ -h ] [-t_info | -t_error | -t_warn | -t_oc | -t_verbose] [-m n[-q] ]\n"
1174 " [ /path/to/test ]\n",
1175 argv0);
1176 printf(" -l To get a list of test names\n");
1177 printf(" -e to do exhaustive testing\n");
1178 printf(" -verbose To turn ON verbosity\n");
1179 printf(" -v To turn ON verbosity(same as -verbose)\n");
1180 printf(" -x file.xml Write junit format output to file.xml\n");
1181 printf(" -h To print this message\n");
1182 printf(" -K to turn OFF suppressing known issues\n");
1183 printf(" -n To turn OFF printing error messages\n");
1184 printf(" -w Don't fail on data-loading errs, just warn. Useful if\n"
1185 " user has reduced/changed the common set of ICU data \n");
1186 printf(" -t_info | -t_error | -t_warn | -t_oc | -t_verbose Enable ICU tracing\n");
1187 printf(" -no_err_msg (same as -n) \n");
1188 printf(" -m n[-q] Min-Max memory size that will cause an allocation failure.\n");
1189 printf(" The default is the maximum value of size_t. Max is optional.\n");
1190 printf(" -r Repeat tests after calling u_cleanup \n");
1191 printf(" [/subtest] To run a subtest \n");
1192 printf(" eg: to run just the utility tests type: cintltest /tsutil) \n");
1193 }
1194
1195 int32_t T_CTEST_EXPORT2
1196 getTestOption ( int32_t testOption ) {
1197 switch (testOption) {
1198 case VERBOSITY_OPTION:
1199 return VERBOSITY;
1200 case WARN_ON_MISSING_DATA_OPTION:
1201 return WARN_ON_MISSING_DATA;
1202 case QUICK_OPTION:
1203 return QUICK;
1204 case REPEAT_TESTS_OPTION:
1205 return REPEAT_TESTS;
1206 case ERR_MSG_OPTION:
1207 return ERR_MSG;
1208 case ICU_TRACE_OPTION:
1209 return ICU_TRACE;
1210 default :
1211 return 0;
1212 }
1213 }
1214
1215 void T_CTEST_EXPORT2
1216 setTestOption ( int32_t testOption, int32_t value) {
1217 if (value == DECREMENT_OPTION_VALUE) {
1218 value = getTestOption(testOption);
1219 --value;
1220 }
1221 switch (testOption) {
1222 case VERBOSITY_OPTION:
1223 VERBOSITY = value;
1224 break;
1225 case WARN_ON_MISSING_DATA_OPTION:
1226 WARN_ON_MISSING_DATA = value;
1227 break;
1228 case QUICK_OPTION:
1229 QUICK = value;
1230 break;
1231 case REPEAT_TESTS_OPTION:
1232 REPEAT_TESTS = value;
1233 break;
1234 case ICU_TRACE_OPTION:
1235 ICU_TRACE = (UTraceLevel)value;
1236 break;
1237 default :
1238 break;
1239 }
1240 }
1241
1242
1243 /*
1244 * ================== JUnit support ================================
1245 */
1246
1247 int32_t
1248 T_CTEST_EXPORT2
1249 ctest_xml_setFileName(const char *name) {
1250 XML_FILE_NAME=name;
1251 return 0;
1252 }
1253
1254
1255 int32_t
1256 T_CTEST_EXPORT2
1257 ctest_xml_init(const char *rootName) {
1258 if(!XML_FILE_NAME) return 0;
1259 XML_FILE = fopen(XML_FILE_NAME,"w");
1260 if(!XML_FILE) {
1261 perror("fopen");
1262 fprintf(stderr," Error: couldn't open XML output file %s\n", XML_FILE_NAME);
1263 return 1;
1264 }
1265 while(*rootName&&!isalnum((int)*rootName)) {
1266 rootName++;
1267 }
1268 strcpy(XML_PREFIX,rootName);
1269 {
1270 char *p = XML_PREFIX+strlen(XML_PREFIX);
1271 for(p--;*p&&p>XML_PREFIX&&!isalnum((int)*p);p--) {
1272 *p=0;
1273 }
1274 }
1275 /* write prefix */
1276 fprintf(XML_FILE, "<testsuite name=\"%s\">\n", XML_PREFIX);
1277
1278 return 0;
1279 }
1280
1281 int32_t
1282 T_CTEST_EXPORT2
1283 ctest_xml_fini(void) {
1284 if(!XML_FILE) return 0;
1285
1286 fprintf(XML_FILE, "</testsuite>\n");
1287 fclose(XML_FILE);
1288 printf(" ( test results written to %s )\n", XML_FILE_NAME);
1289 XML_FILE=0;
1290 return 0;
1291 }
1292
1293
1294 int32_t
1295 T_CTEST_EXPORT2
1296 ctest_xml_testcase(const char *classname, const char *name, const char *timeSeconds, const char *failMsg) {
1297 if(!XML_FILE) return 0;
1298
1299 fprintf(XML_FILE, "\t<testcase classname=\"%s:%s\" name=\"%s:%s\" time=\"%s\"", XML_PREFIX, classname, XML_PREFIX, name, timeSeconds);
1300 if(failMsg) {
1301 fprintf(XML_FILE, ">\n\t\t<failure type=\"err\" message=\"%s\"/>\n\t</testcase>\n", failMsg);
1302 } else {
1303 fprintf(XML_FILE, "/>\n");
1304 }
1305
1306 return 0;
1307 }
1308
1309

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial