Added BPatch_thread::oneTimeCode, BPatch_thread::loadLibrary, and other
[dyninst.git] / 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 }