Rename newtestsuite to testsuite
[dyninst.git] / testsuite / src / dyninst / test1_24_mutatee.c
1 #include "mutatee_util.h"
2
3 /* Externally accessed function prototypes.  These must have globally unique
4  * names.  I suggest following the pattern <testname>_<function>
5  */
6
7 void test1_24_call1();
8
9 /* Global variables accessed by the mutator.  These must have globally unique
10  * names.
11  */
12
13 int test1_24_globalVariable1[100];
14 int test1_24_globalVariable2 = 53;
15 int test1_24_globalVariable3;
16 int test1_24_globalVariable4 = 83;
17 int test1_24_globalVariable5;
18
19 /* to hold values from local array */
20 int test1_24_globalVariable6;
21 int test1_24_globalVariable7;
22
23 /* for 2-d arrays - array is not square and we avoid using diagonal elements
24  *    to make sure we test address computation
25  */
26 int test1_24_globalVariable8[10][15];
27 int test1_24_globalVariable9;
28
29 /* Internally used function prototypes.  These should be declared with the
30  * keyword static so they don't interfere with other mutatees in the group.
31  */
32
33 static void verifyValue24(const char *name, int *a, int index, int value);
34 static void verifyScalarValue24(const char *name, int a, int value);
35 static void call24_2();
36 static int verifyValue(const char *name, int *a, int index, int value,
37                         const char *tst, const char *tn);
38
39 /* Global variables used internally by the mutatee.  These should be declared
40  * with the keyword static so they don't interfere with other mutatees in the
41  * group.
42  */
43
44 static int dummy;
45 static int foo;
46
47 static int test_failed = FALSE;
48
49 /* Function definitions follow */
50
51 /*
52  * Test #24 - arrary variables
53  */
54 int test1_24_mutatee() {
55     int i, j;
56     int retval;
57
58 #if !defined(sparc_sun_solaris2_4_test) \
59  && !defined(rs6000_ibm_aix4_1_test) \
60  && !defined(alpha_dec_osf4_0_test) \
61  && !defined(i386_unknown_linux2_0_test) \
62  && !defined(x86_64_unknown_linux2_4_test) /* Blind duplication - Ray */ \
63  && !defined(i386_unknown_solaris2_5_test) \
64  && !defined(i386_unknown_nt4_0_test) \
65  && !defined(ia64_unknown_linux2_4_test) \
66  && !defined(os_linux_test) /* Use OS #define instead of platform - Greg */
67
68     logerror("Skipped test #24 (array variables)\n");
69     logerror("\t- not implemented on this platform\n");
70     test_passes(testname); /* Test "passes" */
71     retval = 0;
72 #else
73
74     /* passedTest[24] = TRUE; */
75
76
77     for (i=0; i < 100; i++) test1_24_globalVariable1[i] = 2400000;
78     test1_24_globalVariable1[79] = 2400003;
79     test1_24_globalVariable1[83] = 2400004;
80
81     for (i=0; i < 10; i++) {
82         for (j=0; j < 15; j++) {
83             test1_24_globalVariable8[i][j] = 2400010;
84         }
85     }
86     test1_24_globalVariable8[7][9] = 2400012;
87
88     /* inst code we put into this function:
89      *  At Call:
90      *     test1_24_globalVariable1[1] = 2400001
91      *     test1_24_globalVariable1[test1_24_globalVariable2] = 2400002
92      *     test1_24_globalVariable3 = test1_24_globalVariable1[79]
93      *     test1_24_globalVariable5 = test1_24_globalVariable1[test1_24_globalVariable4]
94      *     localVariable24_1[1] = 2400001
95      *     localVariable24_1[test1_24_globalVariable2] = 2400002
96      *     test1_24_globalVariable8[2][3] = 2400011
97      *     test1_24_globalVariable6 = localVariable24_1[79]
98      *     test1_24_globalVariable7 = localVariable24_1[test1_24_globalVariable4]
99      */
100     test1_24_call1();
101
102     for (i=0; i < 100; i++) {
103         if (i == 1) {
104             /* 1st element should be modified by the snippet (constant index) */
105             verifyValue24("test1_24_globalVariable1", test1_24_globalVariable1, 1, 2400001);
106         } else if (i == 53) {
107             /* 53rd element should be modified by the snippet (variable index) */
108             verifyValue24("test1_24_globalVariable1", test1_24_globalVariable1, 53, 2400002);
109         } else if (i == 79) {
110             /* 79th element was modified by us  */
111             verifyValue24("test1_24_globalVariable1", test1_24_globalVariable1, 79, 2400003);
112         } else if (i == 83) {
113             /* 83rd element was modified by us  */
114             verifyValue24("test1_24_globalVariable1", test1_24_globalVariable1, 83, 2400004);
115         } else if (test1_24_globalVariable1[i] != 2400000) {
116             /* rest should still be the original value */
117             verifyValue24("test1_24_globalVariable1", test1_24_globalVariable1, i, 2400000);
118         }
119     }
120
121     verifyScalarValue24("test1_24_globalVariable3", test1_24_globalVariable3, 2400003);
122     verifyScalarValue24("test1_24_globalVariable5", test1_24_globalVariable5, 2400004);
123
124     /* now for the two elements read from the local variable */
125     verifyScalarValue24("test1_24_globalVariable6", test1_24_globalVariable6, 2400007);
126     verifyScalarValue24("test1_24_globalVariable7", test1_24_globalVariable7, 2400008);
127
128     /* verify 2-d element use */
129     verifyScalarValue24("test1_24_globalVariable8[2][3]", test1_24_globalVariable8[2][3],
130          2400011);
131     verifyScalarValue24("test1_24_globalVariable9", test1_24_globalVariable9, 2400012);
132
133     if (!test_failed) {
134       logerror("Passed test #24 (array variables)\n");
135       test_passes(testname);
136       retval = 0; /* Test passed */
137     } else {
138       retval = -1; /* Test failed */
139     }
140
141 #endif
142     return retval;
143 }
144
145 void verifyValue24(const char *name, int *a, int index, int value) {
146   if (!verifyValue(name, a, index, value, "test1_24", "array variables")) {
147     test_failed = TRUE;
148   }
149 }
150
151 void verifyScalarValue24(const char *name, int a, int value) {
152   if (!verifyScalarValue(name, a, value, "test1_24", "array variables")) {
153     test_failed = TRUE;
154   }
155 }
156
157 /*
158  * Verify that a passed array has the correct value in the passed element.
159  *
160  */
161 int verifyValue(const char *name, int *a, int index, int value,
162                  const char *tst, const char *tn)
163 {
164     if (a[index] != value) {
165         if (!test_failed) {
166           logerror("**Failed** test %s (%s)\n", tst, tn);
167         }
168         logerror("  %s[%d] = %d, not %d\n", 
169                 name, index, a[index], value);
170         return FALSE;
171     } else {
172       return TRUE;
173     }
174 }
175
176 void call24_2() {
177 }
178
179 void test1_24_call1() {
180 #ifdef sparc_sun_solaris2_4_test
181   unsigned i=0; /* hack to prevent g++'s optimizer making func uninstr'uble */
182 #else
183   unsigned i;
184 #endif
185
186     int localVariable24_1[100];
187
188     for (i=0; i < 100; i++) localVariable24_1[i] = 2400000;
189
190     localVariable24_1[79] = 2400007;
191     localVariable24_1[83] = 2400008;
192
193     call24_2();
194
195     verifyValue24("localVariable24_1", localVariable24_1, 1, 2400005);
196     verifyValue24("localVariable24_1", localVariable24_1, 53, 2400006);
197 }