dyninstAPI/tests/src/test1.mutatee.c

   1
   2 /* Test application (Mutatee) */
   3
   4 #include <stdio.h>
   5 #include <sys/types.h>
   6 #include <signal.h>
   7 #include <string.h>
   8 #include <stdlib.h>
   9 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
  10 #include <unistd.h>
  11 #endif
  12 #ifdef i386_unknown_nt4_0
  13 #define WIN32_LEAN_AND_MEAN
  14 #include <windows.h>
  15 #endif
  16
  17 /* XXX Currently, there's a bug in the library that prevents a subroutine call
  18  * instrumentation point from being recognized if it is the first instruction
  19  * in a function.  The following variable is used in this program in a number
  20  * of kludges to get around this.
  21  */
  22 int kludge;
  23
  24 // control debug printf statements
  25 #define dprintf if (debugPrint) printf
  26 int debugPrint = 0;
  27
  28 #define RET13_1 1300100
  29
  30 #define RAN17_1 1701000
  31
  32 #define RET17_1 1700100
  33 #define RET17_2 1700200
  34
  35 #define MAGIC19_1 1900100
  36
  37 #define TRUE    1
  38 #define FALSE   0
  39
  40 int isAttached = 0;
  41
  42 int globalVariable1_1 = 0;
  43 int globalVariable3_1 = 31;
  44 int globalVariable4_1 = 41;
  45 int globalVariable5_1 = 51;
  46 int globalVariable5_2 = 51;
  47
  48 int globalVariable6_1 = 0xdeadbeef;
  49 int globalVariable6_2 = 0xdeadbeef;
  50 int globalVariable6_3 = 0xdeadbeef;
  51 int globalVariable6_4 = 0xdeadbeef;
  52 int globalVariable6_5 = 0xdeadbeef;
  53 int globalVariable6_6 = 0xdeadbeef;
  54
  55 int globalVariable7_1 = 71, globalVariable7_2 = 71,
  56     globalVariable7_3 = 71, globalVariable7_4 = 71,
  57     globalVariable7_5 = 71, globalVariable7_6 = 71,
  58     globalVariable7_7 = 71, globalVariable7_8 = 71,
  59     globalVariable7_9 = 71, globalVariable7_10 = 71,
  60     globalVariable7_11 = 71, globalVariable7_12 = 71,
  61     globalVariable7_13 = 71, globalVariable7_14 = 71,
  62     globalVariable7_15 = 71, globalVariable7_16 = 71;
  63
  64
  65 int globalVariable8_1 = 1;
  66
  67 int globalVariable10_1 = 0, globalVariable10_2 = 0,
  68     globalVariable10_3 = 0, globalVariable10_4 = 0;
  69
  70 int globalVariable11_1 = 0, globalVariable11_2 = 0,
  71     globalVariable11_3 = 0, globalVariable11_4 = 0, globalVariable11_5 = 0;
  72
  73 int globalVariable12_1 = 0;
  74
  75 int globalVariable13_1 = 0;
  76
  77 int globalVariable14_1 = 0;
  78 int globalVariable14_2 = 0;
  79
  80 int globalVariable15_1 = 0;
  81 int globalVariable15_2 = 0;
  82 int globalVariable15_3 = 0;
  83
  84 int globalVariable16_1 = 0;
  85 int globalVariable16_2 = 0;
  86 int globalVariable16_3 = 0;
  87 int globalVariable16_4 = 0;
  88
  89 int globalVariable17_1 = 0;
  90 int globalVariable17_2 = 0;
  91
  92 int globalVariable18_1 = 42;
  93
  94 int globalVariable19_1 = 0xdeadbeef;
  95
  96 /*
  97  * Check to see if the mutator has attached to us.
  98  */
  99 int checkIfAttached()
 100 {
 101     return isAttached;
 102 }
 103
 104 /*
 105  * Stop the process (in order to wait for the mutator to finish what it's
 106  * doing and restart us).
 107  */
 108 void stop_process()
 109 {
 110 #ifdef i386_unknown_nt4_0
 111     DebugBreak();
 112 #else
 113     kill(getpid(), SIGSTOP);
 114 #endif
 115 }
 116
 117 void call1_1()
 118 {
 119     dprintf("call1() called - setting globalVariable1_1 = 11\n");
 120     globalVariable1_1 = 11;
 121 }
 122
 123 void call2_1(int arg1, int arg2, char *arg3)
 124 {
 125     if ((arg1 == 1) && (arg2 == 2) && (!strcmp(arg3, "testString2_1"))) {
 126         printf("Passed test #2 (three parameter function)\n");
 127     } else {
 128         printf("**Failed** test #2 (three parameter function)\n");
 129         if (arg1 != 1)
 130             printf("    arg1 = %d, should be 1\n", arg1);
 131         if (arg1 != 2)
 132             printf("    arg2 = %d, should be 2\n", arg2);
 133         if (strcmp(arg3, "testString2_1"))
 134             printf("    arg3 = %s, should be \"testString2_1\"\n", arg3);
 135     }
 136 }
 137
 138 void call3_1(int arg1, int arg2)
 139 {
 140     if ((arg1 == 31) && (arg2 == 32))  {
 141         printf("Passed test #3 (passing variables to functions)\n");
 142     } else {
 143         printf("**Failed** test #3 (passing variables to functions)\n");
 144         printf("    arg1 = %d, should be 31\n", arg1);
 145         printf("    arg2 = %d, should be 32\n", arg2);
 146     }
 147 }
 148
 149 int call9_1(int p1, int p2, int p3, int p4, int p5)
 150 {
 151     int x;
 152     x = (((p1 + p2) + (p3 + p4) + (p5)));
 153     if (x != (91 + 92 + 93 + 94 + 95 )) {
 154       printf("**Failed** test case #9 (preserve registers - funcCall)\n");
 155       if (p1 != 91) printf("    call9_1 parameter 1 is %d not 91\n", p1);
 156       if (p2 != 92) printf("    call9_1 parameter 2 is %d not 92\n", p2);
 157       if (p3 != 93) printf("    call9_1 parameter 2 is %d not 93\n", p3);
 158       if (p4 != 94) printf("    call9_1 parameter 4 is %d not 94\n", p4);
 159       if (p5 != 95) printf("    call9_1 parameter 5 is %d not 95\n", p5);
 160       exit(-1);
 161     }
 162     dprintf("inside call9_1\n");
 163     return x;
 164 }
 165
 166 void call10_1()
 167 {
 168     if (globalVariable10_4 == 0) {
 169         globalVariable10_4 = 1; // update marker of call order
 170         globalVariable10_1 = 1; // flag that this was called first
 171     }
 172 }
 173
 174
 175 void call10_2()
 176 {
 177     if (globalVariable10_4 == 1) {
 178         globalVariable10_4 = 2; // update marker of call order
 179         globalVariable10_2 = 1; // flag that this was called first
 180     }
 181 }
 182
 183 void call10_3()
 184 {
 185     if (globalVariable10_4 == 2) {
 186         globalVariable10_4 = 3; // update marker of call order
 187         globalVariable10_3 = 1; // flag that this was called first
 188     }
 189 }
 190
 191 void call11_1()
 192 {
 193     if (globalVariable11_1 == 0) globalVariable11_2 = 1;
 194 }
 195
 196 void call11_2()
 197 {
 198     if (globalVariable11_1 == 1) globalVariable11_3 = 1;
 199 }
 200
 201 void call11_3()
 202 {
 203     if (globalVariable11_1 == 2) globalVariable11_4 = 1;
 204 }
 205
 206 void call11_4()
 207 {
 208     if (globalVariable11_1 == 3) globalVariable11_5 = 1;
 209
 210     if (globalVariable11_2 && globalVariable11_3 &&
 211         globalVariable11_4 && globalVariable11_5) {
 212         printf("Passed test #11 (snippets at entry,exit,call)\n");
 213     } else {
 214         printf("**Failed test #11 (snippets at entry,exit,call)\n");
 215         if (!globalVariable11_2)
 216             printf("    entry snippet not called at the correct time\n");
 217         if (!globalVariable11_3)
 218             printf("    pre call snippet not called at the correct time\n");
 219         if (!globalVariable11_4)
 220             printf("    post call snippet not called at the correct time\n");
 221         if (!globalVariable11_5)
 222             printf("    exit snippet not called at the correct time\n");
 223     }
 224 }
 225
 226 void call12_1()
 227 {
 228     globalVariable12_1++;
 229 }
 230
 231 void call13_1(int a1, int a2, int a3, int a4, int a5)
 232 {
 233     if (a1 == 131) globalVariable13_1 |= 1;
 234     if (a2 == 132) globalVariable13_1 |= 2;
 235     if (a3 == 133) globalVariable13_1 |= 4;
 236     if (a4 == 134) globalVariable13_1 |= 8;
 237     if (a5 == 135) globalVariable13_1 |= 16;
 238     dprintf("a1 = %d\n", a1);
 239     dprintf("a2 = %d\n", a2);
 240     dprintf("a3 = %d\n", a3);
 241     dprintf("a4 = %d\n", a4);
 242     dprintf("a5 = %d\n", a5);
 243 }
 244
 245 void call13_2(int ret)
 246 {
 247     if (ret == RET13_1) globalVariable13_1 |= 32;
 248 }
 249
 250 void call14_1()
 251 {
 252     globalVariable14_1 = 1;
 253 }
 254
 255 void call15_1()
 256 {
 257     globalVariable15_1++;
 258 }
 259
 260 void call15_2()
 261 {
 262     globalVariable15_2++;
 263 }
 264
 265 void call15_3()
 266 {
 267     globalVariable15_3++;
 268 }
 269
 270 int call17_1(int p1)
 271 {
 272      /* make sure the function uses lots of registers */
 273
 274      int a1, a2, a3, a4, a5, a6, a7;
 275
 276      a1 = p1;
 277      a2 = a1 + p1;
 278      a3 = a1 * a2;
 279      a4 = a3 / p1;
 280      a5 = a4 + p1;
 281      a6 = a5 + a1;
 282      a7 = a6 + p1;
 283      return a7;
 284 }
 285
 286 int call17_2(int p1)
 287 {
 288      /* make sure the function uses lots of registers */
 289
 290      int a1, a2, a3, a4, a5, a6, a7;
 291
 292      a1 = p1;
 293      a2 = a1 + p1;
 294      a3 = a1 * a2;
 295      a4 = a3 / p1;
 296      a5 = a4 + p1;
 297      a6 = a5 + a1;
 298      a7 = a6 + p1;
 299      globalVariable17_2 = RAN17_1;
 300      return a7;
 301 }
 302
 303 void call19_1()
 304 {
 305     globalVariable19_1 = MAGIC19_1;
 306 }
 307
 308
 309 //
 310 // This is a series of nearly empty functions to attach code to
 311 //
 312 void func1_1() { dprintf("func1_1 () called\n"); }
 313 void func2_1() { dprintf("func2_1 () called\n"); }
 314 void func3_1() { dprintf("func3_1 () called\n"); }
 315 void func4_1() { dprintf("func4_1 () called\n"); }
 316 void func5_1() { dprintf("func5_1 () called\n"); }
 317 void func6_1() { dprintf("func7_1 () called\n"); }
 318 void func7_1() { dprintf("func7_1 () called\n"); }
 319
 320 void func8_1(int p1, int p2, int p3, int p4, int p5, int p6, int p7,
 321              int p8, int p9, int p10)
 322 {
 323     dprintf("func8_1 (...) called\n");
 324     if ((p1 == 1) && (p2 == 2) && (p3 == 3) && (p4 == 4) && (p5 == 5) &&
 325         (p6 == 6) && (p7 == 7) && (p8 == 8) && (p9 == 9) && (p10 == 10))  {
 326         printf("Passed test #8 (preserve registers - expr)\n");
 327     } else {
 328         printf("**Failed** test #8 (preserve registers - expr )\n");
 329         if (p1 != 1)  printf("    parameter #1 is %d not 1\n", p1);
 330         if (p2 != 2)  printf("    parameter #2 is %d not 2\n", p2);
 331         if (p3 != 3)  printf("    parameter #3 is %d not 3\n", p3);
 332         if (p4 != 4)  printf("    parameter #4 is %d not 4\n", p4);
 333         if (p5 != 5)  printf("    parameter #5 is %d not 5\n", p5);
 334         if (p6 != 6)  printf("    parameter #6 is %d not 6\n", p6);
 335         if (p7 != 7)  printf("    parameter #7 is %d not 7\n", p7);
 336         if (p8 != 8)  printf("    parameter #8 is %d not 8\n", p8);
 337         if (p9 != 9)  printf("    parameter #9 is %d not 9\n", p9);
 338         if (p10 != 10)  printf("    parameter #10 is %d not 10\n", p10);
 339     }
 340 }
 341
 342 void func9_1(int p1, int p2, int p3, int p4, int p5, int p6, int p7,
 343              int p8, int p9, int p10)
 344 {
 345     dprintf("func9_1 (...) called\n");
 346     if ((p1 == 1) && (p2 == 2) && (p3 == 3) && (p4 == 4) && (p5 == 5) &&
 347         (p6 == 6) && (p7 == 7) && (p8 == 8) && (p9 == 9) && (p10 == 10))  {
 348         printf("Passed test #9 (preserve registers - funcCall)\n");
 349     } else {
 350         printf("**Failed** test #9 (preserve registers - funcCall )\n");
 351         if (p1 != 1)  printf("    parameter #1 is %d not 1\n", p1);
 352         if (p2 != 2)  printf("    parameter #2 is %d not 2\n", p2);
 353         if (p3 != 3)  printf("    parameter #3 is %d not 3\n", p3);
 354         if (p4 != 4)  printf("    parameter #4 is %d not 4\n", p4);
 355         if (p5 != 5)  printf("    parameter #5 is %d not 5\n", p5);
 356         if (p6 != 6)  printf("    parameter #6 is %d not 6\n", p6);
 357         if (p7 != 7)  printf("    parameter #7 is %d not 7\n", p7);
 358         if (p8 != 8)  printf("    parameter #8 is %d not 8\n", p8);
 359         if (p9 != 9)  printf("    parameter #9 is %d not 9\n", p9);
 360         if (p10 != 10)  printf("    parameter #10 is %d not 10\n", p10);
 361     }
 362 }
 363
 364 void func10_1()
 365 {
 366     if ((globalVariable10_1 == 1) && (globalVariable10_2 == 1) &&
 367         (globalVariable10_3 == 1) && (globalVariable10_4 == 3)) {
 368         printf("Passed test #10 (insert snippet order)\n");
 369     } else {
 370         printf("** Failed test #10 (insert snippet order)\n");
 371         if (!globalVariable10_1)
 372             printf("    call10_1 was not called first\n");
 373         if (!globalVariable10_2)
 374             printf("    call10_2 was not called second\n");
 375         if (!globalVariable10_3)
 376             printf("    call10_3 was not called third\n");
 377     }
 378 }
 379
 380 void func11_2() {
 381     globalVariable11_1 = 2;
 382 }
 383
 384 void func11_1()
 385 {
 386     globalVariable11_1 = 1;
 387     func11_2();
 388     globalVariable11_1 = 3;
 389 }
 390
 391 void func12_2()
 392 {
 393 }
 394
 395 void func12_1()
 396 {
 397     func12_2();
 398     stop_process();
 399     func12_2();
 400     if (globalVariable12_1 == 1) {
 401         printf("Passed test #12 (insert/remove and malloc/free)\n");
 402     } else {
 403         printf("**Failed test #12 (insert/remove and malloc/free)\n");
 404     }
 405 }
 406
 407 int func13_2()
 408 {
 409     return(RET13_1);
 410 }
 411
 412 void func13_1(int p1, int p2, int p3, int p4, int p5)
 413 {
 414     func13_2();
 415
 416     if ((p1 == 131) && (p2 == 132) && (p3 == 133) &&
 417         (p4 == 134) && (p5 == 135) && (globalVariable13_1 == 63)) {
 418         printf("Passed test #13 (paramExpr,retExpr,nullExpr)\n");
 419     } else {
 420         printf("**Failed test #13 (paramExpr,retExpr,nullExpr)\n");
 421         if (p1 != 131) printf("  parameter 1 is %d, not 131\n", p1);
 422         if (p2 != 132) printf("  parameter 2 is %d, not 132\n", p2);
 423         if (p3 != 133) printf("  parameter 3 is %d, not 133\n", p3);
 424         if (p4 != 134) printf("  parameter 4 is %d, not 134\n", p4);
 425         if (p5 != 135) printf("  parameter 5 is %d, not 135\n", p5);
 426         if (!(globalVariable13_1 & 1)) printf("    passed param a1 wrong\n");
 427         if (!(globalVariable13_1 & 2)) printf("    passed param a2 wrong\n");
 428         if (!(globalVariable13_1 & 4)) printf("    passed param a3 wrong\n");
 429         if (!(globalVariable13_1 & 8)) printf("    passed param a4 wrong\n");
 430         if (!(globalVariable13_1 & 16)) printf("    passed param a5 wrong\n");
 431         if (!(globalVariable13_1 & 32)) printf("    return value wrong\n");
 432     }
 433 }
 434
 435
 436 void func14_2()
 437 {
 438     globalVariable14_1 = 2;
 439 }
 440
 441 void func14_3()
 442 {
 443     globalVariable14_2 = 1;
 444 }
 445
 446 void func14_1()
 447 {
 448     kludge = 1; // Here so that the following function call isn't the first
 449                 // instruction
 450
 451     func14_2();
 452     func14_3();
 453
 454     if (globalVariable14_1 == 1 && globalVariable14_2 == 0) {
 455         printf("Passed test #14 (replace/remove function call)\n");
 456     } else {
 457         printf("**Failed test #14 (replace/remove function call)\n");
 458         if (globalVariable14_1 != 1)
 459             printf("    call to func14_2() was not replaced\n");
 460         if (globalVariable14_2 != 0)
 461             printf("    call to func14_3() was not removed\n");
 462     }
 463 }
 464
 465
 466 void check15result(char *varname, int value, int expected,
 467                    char *errstr, int *failed)
 468 {
 469     if (value != expected) {
 470         if (!*failed)
 471             printf("**failed test #15 (setMutationsActive)\n");
 472         *failed = TRUE;
 473
 474         printf("    %s = %d %s\n", varname, value, errstr);
 475     }
 476 }
 477
 478
 479 void func15_2()
 480 {
 481 }
 482
 483 void func15_3()
 484 {
 485     globalVariable15_3 = 100;
 486 }
 487
 488 void func15_4()
 489 {
 490     kludge = 1; // Here so that the following function call isn't the first
 491                 // instruction
 492
 493     func15_3();
 494 }
 495
 496
 497 void func15_1()
 498 {
 499     int failed = FALSE;
 500
 501     func15_2();
 502     check15result("globalVariable15_1", globalVariable15_1, 1,
 503                   "after first call to instrumented function", &failed);
 504
 505 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
 506     // Test a function that makes a system call (is a special case on Sparc)
 507     access(".", R_OK);
 508     check15result("globalVariable15_2", globalVariable15_2, 2,
 509                   "after first call to instrumented function", &failed);
 510 #endif
 511
 512     func15_4();
 513     check15result("globalVariable15_3", globalVariable15_3, 1,
 514                   "after first call to instrumented function", &failed);
 515
 516     /***********************************************************/
 517
 518     stop_process();
 519
 520     func15_2();
 521     check15result("globalVariable15_1", globalVariable15_1, 1,
 522                   "after second call to instrumented function", &failed);
 523
 524 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
 525     access(".", R_OK);
 526     check15result("globalVariable15_2", globalVariable15_2, 2,
 527                   "after second call to instrumented function", &failed);
 528 #endif
 529
 530     func15_4();
 531     check15result("globalVariable15_3", globalVariable15_3, 100,
 532                   "after second call to instrumented function", &failed);
 533
 534     /***********************************************************/
 535
 536     stop_process();
 537
 538     func15_2();
 539     check15result("globalVariable15_1", globalVariable15_1, 2,
 540                   "after third call to instrumented function", &failed);
 541
 542 #if defined(sparc_sun_sunos4_1_3) || defined(sparc_sun_solaris2_4)
 543     access(".", R_OK);
 544     check15result("globalVariable15_2", globalVariable15_2, 4,
 545                   "after third call to instrumented function", &failed);
 546 #endif
 547
 548     func15_4();
 549     check15result("globalVariable15_3", globalVariable15_3, 101,
 550                   "after third call to instrumented function", &failed);
 551
 552     if (!failed) {
 553         printf("Passed test #15 (setMutationsActive)\n");
 554     }
 555 }
 556
 557
 558 void func16_2() { dprintf("func16_2 () called\n"); }
 559 void func16_3() { dprintf("func16_3 () called\n"); }
 560
 561 void func16_1()
 562 {
 563     int failed = 0;
 564
 565     func16_2();
 566     if (globalVariable16_1 != 1 || globalVariable16_2 != 0) {
 567         printf("**Failed test #16 (if-else)\n");
 568         if (globalVariable16_1 != 1)
 569             printf("    True clause of first if should have been executed but was not.\n");
 570         if (globalVariable16_2 != 0)
 571             printf("    False clause of first if should not have been executed but was.\n");
 572         failed = 1;
 573     }
 574
 575     func16_3();
 576     if (globalVariable16_3 != 0 || globalVariable16_4 != 1) {
 577         printf("**Failed test #16 (if-else)\n");
 578         if (globalVariable16_3 != 1)
 579             printf("    True clause of second if should not have been executed but was.\n");
 580         if (globalVariable16_4 != 0)
 581             printf("    False clause of second if should have been executed but was not.\n");
 582         failed = 1;
 583     }
 584
 585     if (!failed)
 586         printf("Passed test #16 (if-else)\n");
 587 }
 588
 589
 590 int func17_1()
 591 {
 592     return RET17_1;
 593 }
 594
 595 int func17_3()
 596 {
 597     return RET17_2;
 598 }
 599
 600 void func17_2()
 601 {
 602     globalVariable17_1 = func17_3();
 603     return;
 604 }
 605
 606 void func18_1()
 607 {
 608     if (globalVariable18_1 == 17) {
 609         printf("Passed test #18 (read/write a variable in the mutatee)\n");
 610     } else {
 611         printf("**Failed test #18 (read/write a variable in the mutatee)\n");
 612         if (globalVariable18_1 == 42)
 613             printf("    globalVariable18_1 still contains 42 (probably it was not written to)\n");
 614         else
 615             printf("    globalVariable18_1 contained %d, not 17 as expected\n",
 616                     globalVariable18_1);
 617     }
 618 }
 619
 620 void func19_1()
 621 {
 622     stop_process();
 623
 624     if (globalVariable19_1 == MAGIC19_1) {
 625         printf("Passed test #19 (oneTimeCode)\n");
 626     } else {
 627         printf("**Failed test #19 (oneTimeCode)\n");
 628         printf("    globalVariable19_1 contained %d, not %d as expected\n",
 629                 globalVariable19_1, MAGIC19_1);
 630     }
 631 }
 632
 633 void fail7Print(int tCase, int fCase, char *op)
 634 {
 635     if (tCase != 72)
 636         printf(" operator %s was not true when it should be\n", op);
 637     if (fCase != 71)
 638         printf(" operator %s was not false when it should be\n", op);
 639 }
 640
 641 void main(int argc, char *argv[])
 642 {
 643     int i;
 644     int ret17_1;
 645     int useAttach = FALSE;
 646
 647     for (i=1; i < argc; i++) {
 648         if (!strcmp(argv[i], "-verbose")) {
 649             debugPrint = 1;
 650         } else if (!strcmp(argv[i], "-attach")) {
 651             useAttach = TRUE;
 652         } else {
 653             fprintf(stderr, "Usage: test1 [-attach] [-verbose]\n");
 654             exit(-1);
 655         }
 656     }
 657
 658     if (useAttach) {
 659         printf("Waiting for mutator to attach...\n");
 660         while (!checkIfAttached()) ;
 661         printf("Mutator attached.  Mutatee continuing.\n");
 662     }
 663
 664     // Test #1
 665     dprintf("Value of globalVariable1_1 is %d.\n", globalVariable1_1);
 666     func1_1();
 667     dprintf("Value of globalVariable1_1 is now %d.\n", globalVariable1_1);
 668
 669     if (globalVariable1_1 == 11)
 670         printf("\nPassed test #1 (zero arg function call)\n");
 671     else
 672         printf("\n**Failed** test #1 (zero arg function call)\n");
 673
 674     // Test #2
 675     func2_1();
 676
 677     // Test #3
 678     func3_1();
 679
 680     // Test #4
 681     func4_1();
 682     if (globalVariable4_1 == 41) {
 683         printf("**Failed** test #4 (sequence)\n");
 684         printf("    none of the items were executed\n");
 685     } else if (globalVariable4_1 == 42) {
 686         printf("**Failed** test #4 (sequence)\n");
 687         printf("    first item was the last (or only) one to execute\n");
 688     } else if (globalVariable4_1 == 43) {
 689         printf("Passed test #4 (sequence)\n");
 690     }
 691
 692     // test #5
 693     func5_1();
 694     if ((globalVariable5_1 == 51) && (globalVariable5_2 == 53)) {
 695         printf("Passed test #5 (if w.o. else)\n");
 696     } else {
 697         printf("**Failed** test #5 (if w.o. else)\n");
 698         if (globalVariable5_1 != 51) {
 699             printf("    condition executed for false\n");
 700         }
 701         if (globalVariable5_2 != 53) {
 702             printf("    condition not executed for true\n");
 703         }
 704     }
 705
 706     func6_1();
 707     if ((globalVariable6_1 == 60+2) && (globalVariable6_2 == 64-1) &&
 708         (globalVariable6_3 == 66/3) && (globalVariable6_4 == 67/3) &&
 709         (globalVariable6_5 == 6 * 5) && (globalVariable6_6 == 3)) {
 710         printf("Passed test #6 (arithmetic operators)\n");
 711     } else {
 712         printf("**Failed** test #6 (arithmetic operators)\n");
 713         if (globalVariable6_1 != 60+2)
 714             printf("    addition error 60+2 got %d\n", globalVariable6_1);
 715         if (globalVariable6_2 != 64-1)
 716             printf("    subtraction error 64-1 got %d\n", globalVariable6_2);
 717         if (globalVariable6_3 != 66/3)
 718             printf("    division error 66/3 got %d\n", globalVariable6_3);
 719         if (globalVariable6_4 != 67/3)
 720             printf("    division error 67/3 got %d\n", globalVariable6_4);
 721         if (globalVariable6_5 != 6 * 5)
 722             printf("    mult error 6*5 got %d\n", globalVariable6_5);
 723         if (globalVariable6_6 != 3)
 724             printf("    mod error 10,3 got %d\n", globalVariable6_6);
 725     }
 726
 727     func7_1();
 728     if ((globalVariable7_1 == 72) && (globalVariable7_2 == 71) &&
 729         (globalVariable7_3 == 72) && (globalVariable7_4 == 71) &&
 730         (globalVariable7_5 == 72) && (globalVariable7_6 == 71) &&
 731         (globalVariable7_7 == 72) && (globalVariable7_8 == 71) &&
 732         (globalVariable7_9 == 72) && (globalVariable7_10 == 71) &&
 733         (globalVariable7_11 == 72) && (globalVariable7_12 == 71) &&
 734         (globalVariable7_13 == 72) && (globalVariable7_14 == 71) &&
 735         (globalVariable7_15 == 72) && (globalVariable7_16 == 71)) {
 736         printf("Passed test #7 (relational operators)\n");
 737     } else {
 738         printf("**Failed** test #7 (relational operators)\n");
 739         fail7Print(globalVariable7_1, globalVariable7_2, "BPatch_lt");
 740         fail7Print(globalVariable7_3, globalVariable7_4, "BPatch_eq");
 741         fail7Print(globalVariable7_5, globalVariable7_6, "BPatch_gt");
 742         fail7Print(globalVariable7_7, globalVariable7_8, "BPatch_le");
 743         fail7Print(globalVariable7_9, globalVariable7_10, "BPatch_ne");
 744         fail7Print(globalVariable7_11, globalVariable7_12, "BPatch_ge");
 745         fail7Print(globalVariable7_13, globalVariable7_14, "BPatch_and");
 746         fail7Print(globalVariable7_15, globalVariable7_16, "BPatch_or");
 747     }
 748
 749     func8_1(1,2,3,4,5,6,7,8,9,10);
 750
 751     func9_1(1,2,3,4,5,6,7,8,9,10);
 752
 753     func10_1();
 754
 755     func11_1();
 756
 757     func12_1();
 758
 759     func13_1(131,132,133,134,135);
 760
 761     func14_1();
 762
 763     func15_1();
 764
 765     func16_1();
 766
 767     ret17_1 = func17_1();
 768     func17_2();
 769
 770     if ((ret17_1 != RET17_1) ||
 771         (globalVariable17_1 != RET17_2) ||
 772         (globalVariable17_2 != RAN17_1)) {
 773         printf("**Failed** test case #17 (return values from func calls)\n");
 774         if (ret17_1 != RET17_1) {
 775             printf("  return value was %d, not %d\n", ret17_1, RET17_1);
 776         }
 777         if (globalVariable17_1 != RET17_2) {
 778             printf("  return value was %d, not %d\n",
 779                 globalVariable17_1, RET17_2);
 780         }
 781         if (globalVariable17_2 != RAN17_1) {
 782             printf("  function call17_2 was not inserted\n");
 783         }
 784     } else {
 785         printf("Passed test #17 (return values from func calls)\n");
 786     }
 787
 788     func18_1();
 789
 790     func19_1();
 791
 792     exit(0);
 793 }