Update copyright to LGPL on all files
[dyninst.git] / testsuite / src / dyninst / test1_24_mutatee.c
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 #include "mutatee_util.h"
32
33 /* Externally accessed function prototypes.  These must have globally unique
34  * names.  I suggest following the pattern <testname>_<function>
35  */
36
37 void test1_24_call1();
38
39 /* Global variables accessed by the mutator.  These must have globally unique
40  * names.
41  */
42
43 int test1_24_globalVariable1[100];
44 int test1_24_globalVariable2 = 53;
45 int test1_24_globalVariable3;
46 int test1_24_globalVariable4 = 83;
47 int test1_24_globalVariable5;
48
49 /* to hold values from local array */
50 int test1_24_globalVariable6;
51 int test1_24_globalVariable7;
52
53 /* for 2-d arrays - array is not square and we avoid using diagonal elements
54  *    to make sure we test address computation
55  */
56 int test1_24_globalVariable8[10][15];
57 int test1_24_globalVariable9;
58
59 /* Internally used function prototypes.  These should be declared with the
60  * keyword static so they don't interfere with other mutatees in the group.
61  */
62
63 static void verifyValue24(const char *name, int *a, int index, int value);
64 static void verifyScalarValue24(const char *name, int a, int value);
65 static void call24_2();
66 static int verifyValue(const char *name, int *a, int index, int value,
67                         const char *tst, const char *tn);
68
69 /* Global variables used internally by the mutatee.  These should be declared
70  * with the keyword static so they don't interfere with other mutatees in the
71  * group.
72  */
73
74 static int dummy;
75 static int foo;
76
77 static int test_failed = FALSE;
78
79 /* Function definitions follow */
80
81 /*
82  * Test #24 - arrary variables
83  */
84 int test1_24_mutatee() {
85     int i, j;
86     int retval;
87
88 #if !defined(sparc_sun_solaris2_4_test) \
89  && !defined(rs6000_ibm_aix4_1_test) \
90  && !defined(alpha_dec_osf4_0_test) \
91  && !defined(i386_unknown_linux2_0_test) \
92  && !defined(x86_64_unknown_linux2_4_test) /* Blind duplication - Ray */ \
93  && !defined(i386_unknown_solaris2_5_test) \
94  && !defined(i386_unknown_nt4_0_test) \
95  && !defined(ia64_unknown_linux2_4_test) \
96  && !defined(os_linux_test) /* Use OS #define instead of platform - Greg */
97
98     logerror("Skipped test #24 (array variables)\n");
99     logerror("\t- not implemented on this platform\n");
100     test_passes(testname); /* Test "passes" */
101     retval = 0;
102 #else
103
104     /* passedTest[24] = TRUE; */
105
106
107     for (i=0; i < 100; i++) test1_24_globalVariable1[i] = 2400000;
108     test1_24_globalVariable1[79] = 2400003;
109     test1_24_globalVariable1[83] = 2400004;
110
111     for (i=0; i < 10; i++) {
112         for (j=0; j < 15; j++) {
113             test1_24_globalVariable8[i][j] = 2400010;
114         }
115     }
116     test1_24_globalVariable8[7][9] = 2400012;
117
118     /* inst code we put into this function:
119      *  At Call:
120      *     test1_24_globalVariable1[1] = 2400001
121      *     test1_24_globalVariable1[test1_24_globalVariable2] = 2400002
122      *     test1_24_globalVariable3 = test1_24_globalVariable1[79]
123      *     test1_24_globalVariable5 = test1_24_globalVariable1[test1_24_globalVariable4]
124      *     localVariable24_1[1] = 2400001
125      *     localVariable24_1[test1_24_globalVariable2] = 2400002
126      *     test1_24_globalVariable8[2][3] = 2400011
127      *     test1_24_globalVariable6 = localVariable24_1[79]
128      *     test1_24_globalVariable7 = localVariable24_1[test1_24_globalVariable4]
129      */
130     test1_24_call1();
131
132     for (i=0; i < 100; i++) {
133         if (i == 1) {
134             /* 1st element should be modified by the snippet (constant index) */
135             verifyValue24("test1_24_globalVariable1", test1_24_globalVariable1, 1, 2400001);
136         } else if (i == 53) {
137             /* 53rd element should be modified by the snippet (variable index) */
138             verifyValue24("test1_24_globalVariable1", test1_24_globalVariable1, 53, 2400002);
139         } else if (i == 79) {
140             /* 79th element was modified by us  */
141             verifyValue24("test1_24_globalVariable1", test1_24_globalVariable1, 79, 2400003);
142         } else if (i == 83) {
143             /* 83rd element was modified by us  */
144             verifyValue24("test1_24_globalVariable1", test1_24_globalVariable1, 83, 2400004);
145         } else if (test1_24_globalVariable1[i] != 2400000) {
146             /* rest should still be the original value */
147             verifyValue24("test1_24_globalVariable1", test1_24_globalVariable1, i, 2400000);
148         }
149     }
150
151     verifyScalarValue24("test1_24_globalVariable3", test1_24_globalVariable3, 2400003);
152     verifyScalarValue24("test1_24_globalVariable5", test1_24_globalVariable5, 2400004);
153
154     /* now for the two elements read from the local variable */
155     verifyScalarValue24("test1_24_globalVariable6", test1_24_globalVariable6, 2400007);
156     verifyScalarValue24("test1_24_globalVariable7", test1_24_globalVariable7, 2400008);
157
158     /* verify 2-d element use */
159     verifyScalarValue24("test1_24_globalVariable8[2][3]", test1_24_globalVariable8[2][3],
160          2400011);
161     verifyScalarValue24("test1_24_globalVariable9", test1_24_globalVariable9, 2400012);
162
163     if (!test_failed) {
164       logerror("Passed test #24 (array variables)\n");
165       test_passes(testname);
166       retval = 0; /* Test passed */
167     } else {
168       retval = -1; /* Test failed */
169     }
170
171 #endif
172     return retval;
173 }
174
175 void verifyValue24(const char *name, int *a, int index, int value) {
176   if (!verifyValue(name, a, index, value, "test1_24", "array variables")) {
177     test_failed = TRUE;
178   }
179 }
180
181 void verifyScalarValue24(const char *name, int a, int value) {
182   if (!verifyScalarValue(name, a, value, "test1_24", "array variables")) {
183     test_failed = TRUE;
184   }
185 }
186
187 /*
188  * Verify that a passed array has the correct value in the passed element.
189  *
190  */
191 int verifyValue(const char *name, int *a, int index, int value,
192                  const char *tst, const char *tn)
193 {
194     if (a[index] != value) {
195         if (!test_failed) {
196           logerror("**Failed** test %s (%s)\n", tst, tn);
197         }
198         logerror("  %s[%d] = %d, not %d\n", 
199                 name, index, a[index], value);
200         return FALSE;
201     } else {
202       return TRUE;
203     }
204 }
205
206 void call24_2() {
207 }
208
209 void test1_24_call1() {
210 #ifdef sparc_sun_solaris2_4_test
211   unsigned i=0; /* hack to prevent g++'s optimizer making func uninstr'uble */
212 #else
213   unsigned i;
214 #endif
215
216     int localVariable24_1[100];
217
218     for (i=0; i < 100; i++) localVariable24_1[i] = 2400000;
219
220     localVariable24_1[79] = 2400007;
221     localVariable24_1[83] = 2400008;
222
223     call24_2();
224
225     verifyValue24("localVariable24_1", localVariable24_1, 1, 2400005);
226     verifyValue24("localVariable24_1", localVariable24_1, 53, 2400006);
227 }