test.c

   1 #include <stdbool.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4
   5 #include "error.h"
   6 #include "jack.h"
   7 #include "parse.h"
   8 #include "test.h"
   9 #include "token.h"
  10
  11 #define PASSED 0
  12 #define FAILED 1
  13
  14 void test_msg_start(char *msg)
  15 {
  16         int msg_length = strlen(msg);
  17         printf("%s", msg);
  18
  19         /* 74 is 80 - length of "PASSED" */
  20         while(msg_length < 74)
  21         {
  22                 putchar('.');
  23                 msg_length++;
  24         }
  25 }
  26
  27 void test_msg_end(int pass)
  28 {
  29         if(pass == PASSED)
  30         {
  31                 printf("PASSED\n");
  32         } else {
  33                 printf("FAILED\n");
  34                 exit_error(0, "UNIT TESTING FAILED");
  35         }
  36 }
  37
  38 int test_c_comments()
  39 {
  40         int result = 0;
  41         char *pStart = NULL;
  42         char source[] = "/* this is a test */ \tclass \0";
  43
  44         test_msg_start("Testing C Comments");
  45
  46         pC = pStart = source;
  47         pC = advance(pC, pT);
  48
  49         /* token should be correct */
  50         if(strcmp(pT, "class") != 0) { result++; }
  51
  52         /* pointer to code should be in correct position */
  53         if(pC - pStart != 27) { result++; }
  54
  55         if(result == PASSED)
  56         {
  57                 test_msg_end(PASSED);
  58         } else {
  59                 test_msg_end(FAILED);
  60         }
  61
  62         return result;
  63 }
  64
  65 int test_nested_c_comments()
  66 {
  67         int result = 0;
  68         char *pStart = NULL;
  69         char source[] = "/* this /*is a test */ \tclass \0";
  70
  71         test_msg_start("Testing Nested C Comments");
  72         pC = pStart = source;
  73         pC = advance(pC, pT);
  74
  75         /* token should be correct */
  76         if(strcmp(pT, "class") != 0) { result++; }
  77
  78         /* pointer to code should be in correct position */
  79         if(pC - pStart != 29) { result++; }
  80
  81         if(result == PASSED)
  82         {
  83                 test_msg_end(PASSED);
  84         } else {
  85                 test_msg_end(FAILED);
  86         }
  87
  88         return result;
  89 }
  90
  91 int test_cpp_comments()
  92 {
  93         int result = 0;
  94         char *pStart = NULL;
  95         char source[] = "// this is a test\nclass \0";
  96
  97         test_msg_start("Testing C++ Comments");
  98         pC = pStart = source;
  99         pC = advance(pC, pT);
 100
 101         /* token should be correct */
 102         if(strcmp(pT, "class") != 0) { result++; }
 103
 104         /* pointer to code should be in correct position */
 105         if(pC - pStart != 23) { result++; }
 106
 107         if(result == PASSED)
 108         {
 109                 test_msg_end(PASSED);
 110         } else {
 111                 test_msg_end(FAILED);
 112         }
 113
 114         return result;
 115 }
 116
 117 int test_nested_cpp_comments()
 118 {
 119         int result = 0;
 120         char *pStart = NULL;
 121         char source[] = "// this is a //test\nclass \0";
 122
 123         test_msg_start("Testing Nested C++ Comments");
 124         pC = pStart = source;
 125         pC = advance(pC, pT);
 126
 127         /* token should be correct */
 128         if(strcmp(pT, "class") != 0) { result++; }
 129
 130         /* pointer to code should be in correct position */
 131         if(pC - pStart != 25) { result++; }
 132
 133         if(result == PASSED)
 134         {
 135                 test_msg_end(PASSED);
 136         } else {
 137                 test_msg_end(FAILED);
 138         }
 139
 140         return result;
 141 }
 142
 143 int test_literal_strings()
 144 {
 145         int result = 0;
 146         char *pStart = NULL;
 147         char source[] = "\"S\" \0";
 148
 149         test_msg_start("Testing String Literals");
 150         pC = pStart = source;
 151         pC = advance(pC, pT);
 152
 153         /* token should be correct */
 154         if(strcmp(pT, "S") != 0) { result++; }
 155
 156         /* pointer to code should be in correct position */
 157         if(pC - pStart != 3) { result++; }
 158
 159         if(result == PASSED)
 160         {
 161                 test_msg_end(PASSED);
 162         } else {
 163                 test_msg_end(FAILED);
 164         }
 165
 166         return result;
 167 }
 168
 169 int test_symbol_recog()
 170 {
 171         int result = 0;
 172         char *pStart = NULL;
 173         char source[] = "(){\0";
 174
 175         test_msg_start("Testing Symbol Recognition");
 176         pC = pStart = source;
 177         pC = advance(pC, pT);
 178
 179         /* token should be correct */
 180         if(strcmp(pT, "(") != 0) { result++; }
 181
 182         /* pointer to code should be in correct position */
 183         if(pC - pStart != 1) { result++; }
 184
 185         if(result == PASSED)
 186         {
 187                 test_msg_end(PASSED);
 188         } else {
 189                 test_msg_end(FAILED);
 190         }
 191
 192         return result;
 193 }
 194
 195 int test_keyword_recog()
 196 {
 197         int result = 0;
 198         return result;
 199 }
 200
 201 int test_token_type()
 202 {
 203         int result = 0;
 204         int i = 0;
 205
 206         test_msg_start("Testing Token Type Recognition");
 207
 208         while(keywords[i] != NULL)
 209         {
 210                 strcpy(pT, keywords[i]);
 211                 tk = -1; /* be certain this value is changed */
 212                 tk = token_type(pT);
 213                 if(tk != KEYWORD) { result++; }
 214                 i++;
 215         }
 216
 217         if(result == PASSED)
 218         {
 219                 test_msg_end(PASSED);
 220         } else {
 221                 test_msg_end(FAILED);
 222         }
 223
 224         return result;
 225 }
 226
 227 int test_end_of_code()
 228 {
 229         int result = 0;
 230         char source[] = "\n\0";
 231
 232         test_msg_start("Testing For EOF Source");
 233
 234         pC = source;
 235         result = has_more_tokens(pC);
 236
 237         if(result == PASSED)
 238         {
 239                 test_msg_end(PASSED);
 240         } else {
 241                 test_msg_end(FAILED);
 242         }
 243
 244         return result;
 245 }
 246
 247 int test_no_code()
 248 {
 249         int result = 0;
 250         test_msg_start("Testing For NULL Source");
 251
 252         pC = NULL;
 253         result = has_more_tokens(pC);
 254
 255         if(result == PASSED)
 256         {
 257                 test_msg_end(PASSED);
 258         } else {
 259                 test_msg_end(FAILED);
 260         }
 261
 262         return result;
 263 }
 264
 265 int test_parse_expression()
 266 {
 267         int result = 0;
 268         char source[] = "-(-(2 + (-12 / 12)*83));\n";
 269
 270         test_msg_start("Testing Expression Parsing - Numerical");
 271
 272         pC = source;
 273         pC = advance(pC, pT);
 274         tk = token_type(pT);
 275
 276         parse_expression(0);
 277
 278         /* pointer to code should be in correct position */
 279         if(pC - source != 24) { result++; }
 280
 281         /* token should be correct */
 282         if(strcmp(pT, ";") != 0) { result++; }
 283
 284         if(result == PASSED)
 285         {
 286                 test_msg_end(PASSED);
 287         } else {
 288                 test_msg_end(FAILED);
 289         }
 290
 291         return result;
 292 }
 293
 294 int test_parse_expression_keyword()
 295 {
 296         int result = 0, i = 0;
 297         char *source[] =
 298                 {
 299                                 "true;\n",
 300                                 "null;\n",
 301                                 "this;\n",
 302                                 "false;\n"
 303                 };
 304
 305         test_msg_start("Testing Expression Parsing - Keywords");
 306
 307         while(i <= 3)
 308         {
 309                 pC = source[i];
 310                 pC = advance(pC, pT);
 311                 tk = token_type(pT);
 312
 313                 parse_expression(0);
 314
 315                 /* pointer to code should be in correct position */
 316                 if(i <= 2)
 317                 {
 318                         if(pC - source[i] != 5) { result++; }
 319                 } else {
 320                         if(pC - source[i] != 6) { result++; }
 321                 }
 322
 323                 /* token should be correct */
 324                 if(strcmp(pT, ";") != 0) { result++; }
 325                 i++;
 326         }
 327
 328         if(result == PASSED)
 329         {
 330                 test_msg_end(PASSED);
 331         } else {
 332                 test_msg_end(FAILED);
 333         }
 334
 335         return result;
 336 }
 337
 338 int test_parse_expression_nested_array()
 339 {
 340         int result = 0;
 341         char source[] = "data1[data2[12]];\n";
 342
 343         test_msg_start("Testing Expression Parsing - Nested Arrays");
 344
 345         pC = source;
 346         pC = advance(pC, pT);
 347         tk = token_type(pT);
 348
 349         parse_expression(0);
 350
 351         /* pointer to code should be in correct position */
 352         if(pC - source != 17) { result++; }
 353
 354         /* token should be correct */
 355         if(strcmp(pT, ";") != 0) { result++; }
 356
 357         if(result == PASSED)
 358         {
 359                 test_msg_end(PASSED);
 360         } else {
 361                 test_msg_end(FAILED);
 362         }
 363
 364         return result;
 365 }
 366
 367 int test_parse_expression_nested_sub()
 368 {
 369         int result = 0;
 370         char source[] = "data1(data2(12));\n";
 371
 372         test_msg_start("Testing Expression Parsing - Nested Subroutine");
 373
 374         pC = source;
 375         pC = advance(pC, pT);
 376         tk = token_type(pT);
 377
 378         parse_expression(0);
 379
 380         /* pointer to code should be in correct position */
 381         if(pC - source != 17) { result++; }
 382
 383         /* token should be correct */
 384         if(strcmp(pT, ";") != 0) { result++; }
 385
 386         if(result == PASSED)
 387         {
 388                 test_msg_end(PASSED);
 389         } else {
 390                 test_msg_end(FAILED);
 391         }
 392
 393         return result;
 394 }
 395
 396 int test_parse_expression_class_sub()
 397 {
 398         int result = 0;
 399         char source[] = "class_name.sub_name();\n";
 400
 401         test_msg_start("Testing Expression Parsing - Class Subroutine");
 402
 403         pC = source;
 404         pC = advance(pC, pT);
 405         tk = token_type(pT);
 406
 407         parse_expression(0);
 408
 409         /* pointer to code should be in correct position */
 410         if(pC - source != 22) { result++; }
 411
 412         /* token should be correct */
 413         if(strcmp(pT, ";") != 0) { result++; }
 414
 415         if(result == PASSED)
 416         {
 417                 test_msg_end(PASSED);
 418         } else {
 419                 test_msg_end(FAILED);
 420         }
 421
 422         return result;
 423 }
 424
 425 int test_parse_expression_list()
 426 {
 427         int result = 0;
 428         char source[] = "class_name.sub_name(87, var_name);\n";
 429
 430         test_msg_start("Testing Expression Parsing - Expression List");
 431
 432         pC = source;
 433         pC = advance(pC, pT);
 434         tk = token_type(pT);
 435
 436         parse_expression(0);
 437
 438         /* pointer to code should be in correct position */
 439         if(pC - source != 34) { result++; }
 440
 441         /* token should be correct */
 442         if(strcmp(pT, ";") != 0) { result++; }
 443
 444         if(result == PASSED)
 445         {
 446                 test_msg_end(PASSED);
 447         } else {
 448                 test_msg_end(FAILED);
 449         }
 450
 451         return result;
 452 }
 453
 454 int test_all()
 455 {
 456         int result = 0;
 457
 458         /* modify settings regardless of command line options */
 459         settings.tokens = 0;
 460
 461         result += test_c_comments();
 462         result += test_nested_c_comments();
 463         result += test_cpp_comments();
 464         result += test_nested_cpp_comments();
 465         result += test_literal_strings();
 466         result += test_symbol_recog();
 467         result += test_keyword_recog();
 468         result += test_token_type();
 469         result += test_end_of_code();
 470         result += test_no_code();
 471         result += test_parse_expression();
 472         result += test_parse_expression_keyword();
 473         result += test_parse_expression_nested_array();
 474         result += test_parse_expression_nested_sub();
 475         result += test_parse_expression_class_sub();
 476         result += test_parse_expression_list();
 477
 478         return result;
 479 }