cut.c

   1 /*
   2  * libcut.inc
   3  * CUT 2.1
   4  *
   5  * Copyright (c) 2001-2002 Samuel A. Falvo II, William D. Tanksley
   6  * See CUT-LICENSE.TXT for details.
   7  *
   8  * Based on WDT's 'TestAssert' package.
   9  *
  10  * $log$
  11  */
  12
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <stdio.h>
  16 #include <stdarg.h>
  17 #include "cut.h"
  18
  19 #ifndef BOOL            /* Just in case -- helps in portability */
  20 #define BOOL int
  21 #endif
  22
  23 #ifndef FALSE
  24 #define FALSE (0)
  25 #endif
  26
  27 #ifndef TRUE
  28 #define TRUE 1
  29 #endif
  30
  31 typedef struct NameStackItem   NameStackItem;
  32 typedef struct NameStackItem  *NameStack;
  33
  34 struct NameStackItem
  35 {
  36   NameStackItem *      next;
  37   char *               name;
  38   CUTTakedownFunction *takedown;
  39 };
  40
  41 static int            breakpoint = 0;
  42 static int            count = 0;
  43 static BOOL           test_hit_error = FALSE;
  44 static NameStack      nameStack;
  45
  46 static void traceback( void );
  47 static void cut_exit( void );
  48
  49 /* I/O Functions */
  50
  51 static void print_string( char *string )
  52 {
  53   printf( "%s", string );
  54   fflush( stdout );
  55 }
  56
  57 static void print_string_as_error( char *filename, int lineNumber, char *string )
  58 {
  59   printf( "%s(%d): %s", filename, lineNumber, string );
  60   fflush( stdout );
  61 }
  62
  63 static void print_integer_as_expected( int i )
  64 {
  65   printf( "(signed) %d (unsigned) %u (hex) 0x%08X", i, i, i );
  66 }
  67
  68 static void print_integer( int i )
  69 {
  70   printf( "%d", i );
  71   fflush( stdout );
  72 }
  73
  74 static void print_integer_in_field( int i, int width )
  75 {
  76   printf( "%*d", width, i );
  77   fflush( stdout );
  78 }
  79
  80 static void new_line( void )
  81 {
  82   printf( "\n" );
  83   fflush( stdout );
  84 }
  85
  86 static void print_character( char ch )
  87 {
  88   printf( "%c", ch );
  89   fflush( stdout );
  90 }
  91
  92 static void dot( void )
  93 {
  94   print_character( '.' );
  95 }
  96
  97 static void space( void )
  98 {
  99   print_character( ' ' );
 100 }
 101
 102 /* Name Stack Functions */
 103
 104 static NameStackItem *stack_topOf( NameStack *stack )
 105 {
 106   return *stack;
 107 }
 108
 109 static BOOL stack_isEmpty( NameStack *stack )
 110 {
 111   return stack_topOf( stack ) == NULL;
 112 }
 113
 114 static BOOL stack_isNotEmpty( NameStack *stack )
 115 {
 116   return !( stack_isEmpty( stack ) );
 117 }
 118
 119 static void stack_push( NameStack *stack, char *name, CUTTakedownFunction *tdfunc )
 120 {
 121   NameStackItem *item;
 122
 123   item = (NameStackItem *)( malloc( sizeof( NameStackItem ) ) );
 124   if( item != NULL )
 125   {
 126     item -> next = stack_topOf( stack );
 127     item -> name = name;
 128     item -> takedown = tdfunc;
 129
 130     *stack = item;
 131   }
 132 }
 133
 134 static void stack_drop( NameStack *stack )
 135 {
 136   NameStackItem *oldItem;
 137
 138   if( stack_isNotEmpty( stack ) )
 139   {
 140     oldItem = stack_topOf( stack );
 141     *stack = oldItem -> next;
 142
 143     free( oldItem );
 144   }
 145 }
 146
 147 /* CUT Initialization and Takedown  Functions */
 148
 149 void cut_init( int brkpoint )
 150 {
 151   breakpoint = brkpoint;
 152   count = 0;
 153   test_hit_error = FALSE;
 154   nameStack = NULL;
 155
 156   if( brkpoint >= 0 )
 157   {
 158     print_string( "Breakpoint at test " );
 159     print_integer( brkpoint );
 160     new_line();
 161   }
 162 }
 163
 164 void cut_exit( void )
 165 {
 166   exit( test_hit_error != FALSE );
 167 }
 168
 169 /* User Interface functions */
 170
 171 static void print_group( int position, int base, int leftover )
 172 {
 173   if( !leftover )
 174     return;
 175
 176   print_integer_in_field( base, position );
 177   while( --leftover )
 178     dot();
 179 }
 180
 181 static void print_recap( int count )
 182 {
 183   int countsOnLastLine = count % 50;
 184   int groupsOnLastLine = countsOnLastLine / 10;
 185   int dotsLeftOver = countsOnLastLine % 10;
 186   int lastGroupLocation =
 187      countsOnLastLine - dotsLeftOver + ( 4 * groupsOnLastLine ) + 5;
 188
 189   if( dotsLeftOver == 0 )
 190   {
 191     if( countsOnLastLine == 0 )
 192       lastGroupLocation = 61;
 193     else
 194       lastGroupLocation -= 14;
 195
 196     print_group( lastGroupLocation, countsOnLastLine-10, 10);
 197   }
 198   else
 199   {
 200     print_group(
 201                 lastGroupLocation,
 202                 countsOnLastLine - dotsLeftOver,
 203                 dotsLeftOver
 204                );
 205   }
 206 }
 207
 208 void cut_break_formatting( void ) // DEPRECATED: Do not use in future software
 209 {
 210   new_line();
 211 }
 212
 213 void cut_resume_formatting( void )
 214 {
 215   new_line();
 216   print_recap( count );
 217 }
 218
 219 void cut_interject( const char *comment, ... )
 220 {
 221   va_list marker;
 222   va_start(marker,comment);
 223
 224   cut_break_formatting();
 225   vprintf(comment,marker);
 226   cut_resume_formatting();
 227
 228   va_end(marker);
 229 }
 230
 231 /* Test Progress Accounting functions */
 232
 233 void __cut_mark_point( char *filename, int lineNumber )
 234 {
 235   if( ( count % 10 ) == 0 )
 236   {
 237     if( ( count % 50 ) == 0 )
 238       new_line();
 239
 240     print_integer_in_field( count, 5 );
 241   }
 242   else
 243     dot();
 244
 245   count++;
 246   if( count == breakpoint )
 247   {
 248     print_string_as_error( filename, lineNumber, "Breakpoint hit" );
 249     new_line();
 250     traceback();
 251     cut_exit();
 252   }
 253 }
 254
 255 void __cut_assert_equals( // DEPRECATED: Do not use in future software
 256                          char *filename,
 257                          int   lineNumber,
 258                          char *message,
 259                          char *expression,
 260                          BOOL  success,
 261                          int   expected
 262                         )
 263 {
 264   __cut_mark_point( filename, lineNumber );
 265
 266   if( success != FALSE )
 267     return;
 268
 269   cut_break_formatting();
 270   print_string_as_error( filename, lineNumber, message );
 271   new_line();
 272   print_string_as_error( filename, lineNumber, "Failed expression: " );
 273   print_string( expression );
 274   new_line();
 275   print_string_as_error( filename, lineNumber, "Actual value: " );
 276   print_integer_as_expected( expected );
 277   new_line();
 278
 279   test_hit_error = TRUE;
 280   cut_resume_formatting();
 281 }
 282
 283
 284 void __cut_assert(
 285                   char *filename,
 286                   int   lineNumber,
 287                   char *message,
 288                   char *expression,
 289                   BOOL  success
 290                  )
 291 {
 292   __cut_mark_point( filename, lineNumber );
 293
 294   if( success != FALSE )
 295     return;
 296
 297   cut_break_formatting();
 298   print_string_as_error( filename, lineNumber, message );
 299   new_line();
 300   print_string_as_error( filename, lineNumber, "Failed expression: " );
 301   print_string( expression );
 302   new_line();
 303
 304   test_hit_error = TRUE;
 305   cut_resume_formatting();
 306 }
 307
 308
 309 /* Test Delineation and Teardown Support Functions */
 310
 311 static void traceback()
 312 {
 313   if( stack_isNotEmpty( &nameStack ) )
 314     print_string( "Traceback" );
 315   else
 316     print_string( "(No traceback available.)" );
 317
 318   while( stack_isNotEmpty( &nameStack ) )
 319   {
 320     print_string( ": " );
 321     print_string( stack_topOf( &nameStack ) -> name );
 322
 323     if( stack_topOf( &nameStack ) -> takedown != NULL )
 324     {
 325       print_string( "(taking down)" );
 326       stack_topOf( &nameStack ) -> takedown();
 327     }
 328
 329     stack_drop( &nameStack );
 330
 331     if( stack_isNotEmpty( &nameStack ) )
 332       space();
 333   }
 334
 335   new_line();
 336 }
 337
 338 void cut_start( char *name, CUTTakedownFunction *takedownFunction )
 339 {
 340   stack_push( &nameStack, name, takedownFunction );
 341 }
 342
 343 int __cut_check_errors( char *filename, int lineNumber )
 344 {
 345   if( test_hit_error || stack_isEmpty( &nameStack ) )
 346   {
 347     cut_break_formatting();
 348     if( stack_isEmpty( &nameStack ) )
 349       print_string_as_error( filename, lineNumber, "Missing cut_start(); no traceback possible." );
 350     else
 351       traceback();
 352
 353     cut_exit();
 354     return 0;
 355   } else return 1;
 356 }
 357
 358 void __cut_end( char *filename, int lineNumber, char *closingFrame )
 359 {
 360   if( test_hit_error || stack_isEmpty( &nameStack ) )
 361   {
 362     cut_break_formatting();
 363     if( stack_isEmpty( &nameStack ) )
 364       print_string_as_error( filename, lineNumber, "Missing cut_start(); no traceback possible." );
 365     else
 366       traceback();
 367
 368     cut_exit();
 369   }
 370   else
 371   {
 372     if( strcmp( stack_topOf( &nameStack ) -> name, closingFrame ) == 0 )
 373       stack_drop( &nameStack );
 374     else
 375     {
 376       print_string_as_error( filename, lineNumber, "Mismatched cut_end()." );
 377       traceback();
 378       cut_exit();
 379     }
 380   }
 381 }