dyninstAPI/tests/src/test1.mutatee.c

   1 /* Test application (Mutatee) */
   2
   3 /*
   4  * $Log: test1.mutatee.c,v $
   5  * Revision 1.2  1997/04/29 16:58:55  buck
   6  * Added features to dyninstAPI library, including the ability to delete
   7  * inserted snippets and the start of type checking.
   8  *
   9  * Revision 1.2  1997/04/09 17:20:54  buck
  10  * Added test for deleting snippets.
  11  *
  12  * Revision 1.1.1.1  1997/04/01 20:25:16  buck
  13  * Update Maryland repository with latest from Wisconsin.
  14  *
  15  * Revision 1.1  1997/03/18 19:45:22  buck
  16  * first commit of dyninst library.  Also includes:
  17  *      moving templates from paradynd to dyninstAPI
  18  *      converting showError into a function (in showerror.C)
  19  *      many ifdefs for BPATCH_LIBRARY in dyinstAPI/src.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <sys/types.h>
  25 #include <signal.h>
  26
  27 // control debug printf statements
  28 #define dprintf if (debugPrint) printf
  29 int debugPrint = 0;
  30
  31
  32 int globalVariable1_1 = 0;
  33 int globalVariable3_1 = 31;
  34 int globalVariable4_1 = 41;
  35 int globalVariable5_1 = 51;
  36 int globalVariable5_2 = 51;
  37
  38 int globalVariable6_1 = 0xdeadbeef;
  39 int globalVariable6_2 = 0xdeadbeef;
  40 int globalVariable6_3 = 0xdeadbeef;
  41 int globalVariable6_4 = 0xdeadbeef;
  42 int globalVariable6_5 = 0xdeadbeef;
  43 int globalVariable6_6 = 0xdeadbeef;
  44
  45 int globalVariable7_1 = 71, globalVariable7_2 = 71,
  46     globalVariable7_3 = 71, globalVariable7_4 = 71,
  47     globalVariable7_5 = 71, globalVariable7_6 = 71,
  48     globalVariable7_7 = 71, globalVariable7_8 = 71,
  49     globalVariable7_9 = 71, globalVariable7_10 = 71,
  50     globalVariable7_11 = 71, globalVariable7_12 = 71,
  51     globalVariable7_13 = 71, globalVariable7_14 = 71,
  52     globalVariable7_15 = 71, globalVariable7_16 = 71;
  53
  54
  55 int globalVariable8_1 = 1;
  56
  57 int globalVariable10_1 = 0, globalVariable10_2 = 0,
  58     globalVariable10_3 = 0, globalVariable10_4 = 0;
  59
  60 int globalVariable11_1 = 0, globalVariable11_2 = 0,
  61     globalVariable11_3 = 0, globalVariable11_4 = 0, globalVariable11_5 = 0;
  62
  63 int globalVariable12_1 = 0;
  64
  65 int globalVariable13_1 = 0;
  66
  67 void call1_1()
  68 {
  69     dprintf("call1() called - setting globalVariable1_1 = 11\n");
  70     globalVariable1_1 = 11;
  71 }
  72
  73 void call2_1(int arg1, int arg2, char *arg3)
  74 {
  75     if ((arg1 == 1) && (arg2 == 2) && (!strcmp(arg3, "testString2_1"))) {
  76         printf("Passed test #2 (three parameter function)\n");
  77     } else {
  78         printf("**Failed** test #2 (three parameter function)\n");
  79         if (arg1 != 1)
  80             printf("    arg1 = %d, should be 1\n", arg1);
  81         if (arg1 != 2)
  82             printf("    arg2 = %d, should be 2\n", arg2);
  83         if (strcmp(arg3, "testString2_1"))
  84             printf("    arg3 = %s, should be \"testString2_1\"\n", arg3);
  85     }
  86 }
  87
  88 void call3_1(int arg1, int arg2)
  89 {
  90     if ((arg1 == 31) && (arg2 == 32))  {
  91         printf("Passed test #3 (passing variables to functions)\n");
  92     } else {
  93         printf("**Failed** test #3 (passing variables to functions)\n");
  94         printf("    arg1 = %d, should be 31\n", arg1);
  95         printf("    arg2 = %d, should be 32\n", arg2);
  96     }
  97 }
  98
  99 int call9_1(int p1, int p2, int p3, int p4, int p5)
 100 {
 101     int x;
 102     x = (((p1 + p2) + (p3 + p4) + (p5)));
 103     if (x != (91 + 92 + 93 + 94 + 95 )) {
 104       printf("**Failed** test case #9 (preserve registers - funcCall)\n");
 105       if (p1 != 91) printf("    call9_1 parameter 1 is %d not 91\n", p1);
 106       if (p2 != 92) printf("    call9_1 parameter 2 is %d not 92\n", p2);
 107       if (p3 != 93) printf("    call9_1 parameter 2 is %d not 93\n", p3);
 108       if (p4 != 94) printf("    call9_1 parameter 4 is %d not 94\n", p4);
 109       if (p5 != 95) printf("    call9_1 parameter 5 is %d not 95\n", p5);
 110       exit(-1);
 111     }
 112     dprintf("inside call9_1\n");
 113     return x;
 114 }
 115
 116 void call10_1()
 117 {
 118     if (globalVariable10_4 == 0) {
 119         globalVariable10_4 = 1; // update marker of call order
 120         globalVariable10_1 = 1; // flag that this was called first
 121     }
 122 }
 123
 124
 125 void call10_2()
 126 {
 127     if (globalVariable10_4 == 1) {
 128         globalVariable10_4 = 2; // update marker of call order
 129         globalVariable10_2 = 1; // flag that this was called first
 130     }
 131 }
 132
 133 void call10_3()
 134 {
 135     if (globalVariable10_4 == 2) {
 136         globalVariable10_4 = 3; // update marker of call order
 137         globalVariable10_3 = 1; // flag that this was called first
 138     }
 139 }
 140
 141 void call11_1()
 142 {
 143     if (globalVariable11_1 == 0) globalVariable11_2 = 1;
 144 }
 145
 146 void call11_2()
 147 {
 148     if (globalVariable11_1 == 1) globalVariable11_3 = 1;
 149 }
 150
 151 void call11_3()
 152 {
 153     if (globalVariable11_1 == 2) globalVariable11_4 = 1;
 154 }
 155
 156 void call11_4()
 157 {
 158     if (globalVariable11_1 == 3) globalVariable11_5 = 1;
 159
 160     if (globalVariable11_2 && globalVariable11_3 &&
 161         globalVariable11_4 && globalVariable11_5) {
 162         printf("Passed test #11 (snippets at entry,exit,call)\n");
 163     } else {
 164         printf("**Failed test #11 (snippets at entry,exit,call)\n");
 165         if (!globalVariable11_2)
 166             printf("    entry snippet not called at the correct time\n");
 167         if (!globalVariable11_3)
 168             printf("    pre call snippet not called at the correct time\n");
 169         if (!globalVariable11_4)
 170             printf("    post call snippet not called at the correct time\n");
 171         if (!globalVariable11_5)
 172             printf("    exit snippet not called at the correct time\n");
 173     }
 174 }
 175
 176 void call12_1()
 177 {
 178     globalVariable12_1++;
 179 }
 180
 181 void call13_1(int a1, int a2, int a3, int a4, int a5)
 182 {
 183     if (a1 == 131) globalVariable13_1 |= 1;
 184     if (a2 == 132) globalVariable13_1 |= 2;
 185     if (a3 == 133) globalVariable13_1 |= 4;
 186     if (a4 == 134) globalVariable13_1 |= 8;
 187     if (a5 == 135) globalVariable13_1 |= 16;
 188     dprintf("a1 = %d\n", a1);
 189     dprintf("a2 = %d\n", a2);
 190     dprintf("a3 = %d\n", a3);
 191     dprintf("a4 = %d\n", a4);
 192     dprintf("a5 = %d\n", a5);
 193 }
 194
 195 //
 196 // This is a series of nearly empty functions to attach code to
 197 //
 198 void func1_1() { dprintf("func1_1 () called\n"); }
 199 void func2_1() { dprintf("func2_1 () called\n"); }
 200 void func3_1() { dprintf("func3_1 () called\n"); }
 201 void func4_1() { dprintf("func4_1 () called\n"); }
 202 void func5_1() { dprintf("func5_1 () called\n"); }
 203 void func6_1() { dprintf("func7_1 () called\n"); }
 204 void func7_1() { dprintf("func7_1 () called\n"); }
 205
 206 void func8_1(int p1, int p2, int p3, int p4, int p5, int p6, int p7,
 207              int p8, int p9, int p10)
 208 {
 209     dprintf("func8_1 (...) called\n");
 210     if ((p1 == 1) && (p2 == 2) && (p3 == 3) && (p4 == 4) && (p5 == 5) &&
 211         (p6 == 6) && (p7 == 7) && (p8 == 8) && (p9 == 9) && (p10 == 10))  {
 212         printf("Passed test #8 (preserve registers - expr)\n");
 213     } else {
 214         printf("**Failed** test #8 (preserve registers - expr )\n");
 215         if (p1 != 1)  printf("    parameter #1 is %d not 1\n", p1);
 216         if (p2 != 2)  printf("    parameter #2 is %d not 2\n", p2);
 217         if (p3 != 3)  printf("    parameter #3 is %d not 3\n", p3);
 218         if (p4 != 4)  printf("    parameter #4 is %d not 4\n", p4);
 219         if (p5 != 5)  printf("    parameter #5 is %d not 5\n", p5);
 220         if (p6 != 6)  printf("    parameter #6 is %d not 6\n", p6);
 221         if (p7 != 7)  printf("    parameter #7 is %d not 7\n", p7);
 222         if (p8 != 8)  printf("    parameter #8 is %d not 8\n", p8);
 223         if (p9 != 9)  printf("    parameter #9 is %d not 9\n", p9);
 224         if (p10 != 10)  printf("    parameter #10 is %d not 10\n", p10);
 225     }
 226 }
 227
 228 void func9_1(int p1, int p2, int p3, int p4, int p5, int p6, int p7,
 229              int p8, int p9, int p10)
 230 {
 231     dprintf("func9_1 (...) called\n");
 232     if ((p1 == 1) && (p2 == 2) && (p3 == 3) && (p4 == 4) && (p5 == 5) &&
 233         (p6 == 6) && (p7 == 7) && (p8 == 8) && (p9 == 9) && (p10 == 10))  {
 234         printf("Passed test #9 (preserve registers - funcCall)\n");
 235     } else {
 236         printf("**Failed** test #9 (preserve registers - funcCall )\n");
 237         if (p1 != 1)  printf("    parameter #1 is %d not 1\n", p1);
 238         if (p2 != 2)  printf("    parameter #2 is %d not 2\n", p2);
 239         if (p3 != 3)  printf("    parameter #3 is %d not 3\n", p3);
 240         if (p4 != 4)  printf("    parameter #4 is %d not 4\n", p4);
 241         if (p5 != 5)  printf("    parameter #5 is %d not 5\n", p5);
 242         if (p6 != 6)  printf("    parameter #6 is %d not 6\n", p6);
 243         if (p7 != 7)  printf("    parameter #7 is %d not 7\n", p7);
 244         if (p8 != 8)  printf("    parameter #8 is %d not 8\n", p8);
 245         if (p9 != 9)  printf("    parameter #9 is %d not 9\n", p9);
 246         if (p10 != 10)  printf("    parameter #10 is %d not 10\n", p10);
 247     }
 248 }
 249
 250 void func10_1()
 251 {
 252     if ((globalVariable10_1 == 1) && (globalVariable10_2 == 1) &&
 253         (globalVariable10_3 == 1) && (globalVariable10_4 == 3)) {
 254         printf("Passed test #10 (insert snippet order)\n");
 255     } else {
 256         printf("** Failed test #10 (insert snippet order)\n");
 257         if (!globalVariable10_1)
 258             printf("    call10_1 was not called first\n");
 259         if (!globalVariable10_2)
 260             printf("    call10_2 was not called second\n");
 261         if (!globalVariable10_3)
 262             printf("    call10_3 was not called third\n");
 263     }
 264 }
 265
 266 void func11_2() {
 267     globalVariable11_1 = 2;
 268 }
 269
 270 void func11_1()
 271 {
 272     globalVariable11_1 = 1;
 273     func11_2();
 274     globalVariable11_1 = 3;
 275 }
 276
 277 void func12_2()
 278 {
 279 }
 280
 281 void func12_1()
 282 {
 283     func12_2();
 284     kill(getpid(), SIGSTOP);
 285     func12_2();
 286     if (globalVariable12_1 == 1) {
 287         printf("Passed test #12 (insert/remove and malloc/free)\n");
 288     } else {
 289         printf("**Failed test #12 (insert/remove and malloc/free)\n");
 290     }
 291 }
 292
 293 void func13_1(int p1, int p2, int p3, int p4, int p5)
 294 {
 295     if ((p1 == 131) && (p2 == 132) && (p3 == 133) &&
 296         (p4 == 134) && (p5 == 135) && (globalVariable13_1 == 31)) {
 297         printf("Passed test #13 (paramExpr,nullExpr)\n");
 298     } else {
 299         printf("**Failed test #13 (paramExpr,nullExpr)\n");
 300         if (p1 != 131) printf("  parameter 1 is %d, not 131\n", p1);
 301         if (p2 != 132) printf("  parameter 2 is %d, not 132\n", p2);
 302         if (p3 != 133) printf("  parameter 3 is %d, not 133\n", p3);
 303         if (p4 != 134) printf("  parameter 4 is %d, not 134\n", p4);
 304         if (p5 != 135) printf("  parameter 5 is %d, not 135\n", p5);
 305         if (!(globalVariable13_1 & 1)) printf("    passed param a1 wrong\n");
 306         if (!(globalVariable13_1 & 2)) printf("    passed param a2 wrong\n");
 307         if (!(globalVariable13_1 & 4)) printf("    passed param a3 wrong\n");
 308         if (!(globalVariable13_1 & 8)) printf("    passed param a4 wrong\n");
 309         if (!(globalVariable13_1 & 16)) printf("    passed param a5 wrong\n");
 310     }
 311 }
 312
 313 void fail7Print(int tCase, int fCase, char *op)
 314 {
 315     if (tCase != 72)
 316         printf(" operator %s was not true when it should be\n", op);
 317     if (fCase != 71)
 318         printf(" operator %s was not false when it should be\n", op);
 319 }
 320
 321 void main(int argc, char *argv[])
 322 {
 323     if (argc == 2 && !strcmp(argv[1], "-verbose")) {
 324         debugPrint = 1;
 325     }
 326
 327     // Test #1
 328     dprintf("Value of globalVariable1_1 is %d.\n", globalVariable1_1);
 329     func1_1();
 330     dprintf("Value of globalVariable1_1 is now %d.\n", globalVariable1_1);
 331
 332     if (globalVariable1_1 == 11)
 333         printf("\nPassed test #1 (zero arg function call)\n");
 334     else
 335         printf("\n**Failed** test #1 (zero arg function call)\n");
 336
 337     // Test #2
 338     func2_1();
 339
 340     // Test #3
 341     func3_1();
 342
 343     // Test #4
 344     func4_1();
 345     if (globalVariable4_1 == 41) {
 346         printf("**Failed** test #4 (sequence)\n");
 347         printf("    none of the items were executed\n");
 348     } else if (globalVariable4_1 == 42) {
 349         printf("**Failed** test #4 (sequence)\n");
 350         printf("    first item was the last (or only) one to execute\n");
 351     } else if (globalVariable4_1 == 43) {
 352         printf("Passed test #4 (sequence)\n");
 353     }
 354
 355     // test #5
 356     func5_1();
 357     if ((globalVariable5_1 == 51) && (globalVariable5_2 == 53)) {
 358         printf("Passed test #5 (if w.o. else)\n");
 359     } else {
 360         printf("**Failed** test #5 (if w.o. else)\n");
 361         if (globalVariable5_1 != 51) {
 362             printf("    condition executed for false\n");
 363         }
 364         if (globalVariable5_2 != 53) {
 365             printf("    condition not executed for true\n");
 366         }
 367     }
 368
 369     func6_1();
 370     if ((globalVariable6_1 == 60+2) && (globalVariable6_2 == 64-1) &&
 371         (globalVariable6_3 == 66/3) && (globalVariable6_4 == 67/3) &&
 372         (globalVariable6_5 == 6 * 5) && (globalVariable6_6 == 3)) {
 373         printf("Passed test #6 (arithmetic operators)\n");
 374     } else {
 375         printf("**Failed** test #6 (arithmetic operators)\n");
 376         if (globalVariable6_1 != 60+2)
 377             printf("    addition error 60+2 got %d\n", globalVariable6_1);
 378         if (globalVariable6_2 != 64-1)
 379             printf("    subtraction error 64-1 got %d\n", globalVariable6_2);
 380         if (globalVariable6_3 != 66/3)
 381             printf("    division error 66/3 got %d\n", globalVariable6_3);
 382         if (globalVariable6_4 != 67/3)
 383             printf("    division error 67/3 got %d\n", globalVariable6_4);
 384         if (globalVariable6_5 != 6 * 5)
 385             printf("    mult error 6*5 got %d\n", globalVariable6_5);
 386         if (globalVariable6_6 != 3)
 387             printf("    mod error 10,3 got %d\n", globalVariable6_6);
 388     }
 389
 390     func7_1();
 391     if ((globalVariable7_1 == 72) && (globalVariable7_2 == 71) &&
 392         (globalVariable7_3 == 72) && (globalVariable7_4 == 71) &&
 393         (globalVariable7_5 == 72) && (globalVariable7_6 == 71) &&
 394         (globalVariable7_7 == 72) && (globalVariable7_8 == 71) &&
 395         (globalVariable7_9 == 72) && (globalVariable7_10 == 71) &&
 396         (globalVariable7_11 == 72) && (globalVariable7_12 == 71) &&
 397         (globalVariable7_13 == 72) && (globalVariable7_14 == 71) &&
 398         (globalVariable7_15 == 72) && (globalVariable7_16 == 71)) {
 399         printf("Passed test #7 (relational operators)\n");
 400     } else {
 401         printf("**Failed** test #7 (relational operators)\n");
 402         fail7Print(globalVariable7_1, globalVariable7_2, "BPatch_lt");
 403         fail7Print(globalVariable7_3, globalVariable7_4, "BPatch_eq");
 404         fail7Print(globalVariable7_5, globalVariable7_6, "BPatch_gt");
 405         fail7Print(globalVariable7_7, globalVariable7_8, "BPatch_le");
 406         fail7Print(globalVariable7_9, globalVariable7_10, "BPatch_ne");
 407         fail7Print(globalVariable7_11, globalVariable7_12, "BPatch_ge");
 408         fail7Print(globalVariable7_13, globalVariable7_14, "BPatch_and");
 409         fail7Print(globalVariable7_15, globalVariable7_16, "BPatch_or");
 410     }
 411
 412     func8_1(1,2,3,4,5,6,7,8,9,10);
 413
 414     func9_1(1,2,3,4,5,6,7,8,9,10);
 415
 416     func10_1();
 417
 418     func11_1();
 419
 420     func12_1();
 421
 422     func13_1(131,132,133,134,135);
 423
 424     exit(0);
 425 }