Update copyright to LGPL on all files
[dyninst.git] / testsuite / src / dyninst / test1_20_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 int test1_20_func2(int *int_val, double *double_val);
38 void test1_20_call1();
39
40 /* Global variables accessed by the mutator.  These must have globally unique
41  * names.
42  */
43
44 /* Internally used function prototypes.  These should be declared with the
45  * keyword static so they don't interfere with other mutatees in the group.
46  */
47
48 static int eq_doubles(double a, double b);
49
50 /* Global variables used internally by the mutatee.  These should be declared
51  * with the keyword static so they don't interfere with other mutatees in the
52  * group.
53  */
54
55 #define TEST20_A 3
56 #define TEST20_B 4.3
57 #define TEST20_C 7
58 #define TEST20_D 6.4
59 #define TEST20_TIMES 41
60
61 static volatile int ta = TEST20_A;
62 static volatile double tb = TEST20_B;
63 static volatile int tc = TEST20_C;
64 static volatile double td = TEST20_D;
65 static int test20_iter = 50;
66
67 #define TEST20_ANSWER 1088896211
68
69 static int globalVariable20_1 = (int)0xdeadbeef;
70 static double globalVariable20_2 = 0.0;
71
72 /* Function definitions follow */
73
74 /*
75  * Test #20 - instrumentation at arbitrary points
76  */
77
78 int test1_20_mutatee() 
79 {
80   int retval;
81   int ret = 0;
82   int int_val = 0;
83   double double_val = 0.0;
84
85   ret = test1_20_func2(&int_val, &double_val);
86
87   if (globalVariable20_1 == (TEST20_A * TEST20_TIMES) &&
88       eq_doubles(globalVariable20_2, (TEST20_B * (double)TEST20_TIMES)) &&
89       int_val == (TEST20_C * TEST20_TIMES) &&
90       eq_doubles(double_val, (TEST20_D * (double)TEST20_TIMES)) &&
91       ret == TEST20_ANSWER) {
92     logerror("Passed test #20 (instrument arbitrary points)\n");
93     test_passes(testname);
94     retval = 0; /* Test passed */
95   } 
96   else 
97   {
98     logerror("**Failed test #20 (instrument arbitrary points)\n");
99     if (globalVariable20_1 != (TEST20_A * TEST20_TIMES))
100       logerror("    globalVariable20_1 contained %d, not %d as expected\n",
101                globalVariable20_1, TEST20_A * TEST20_TIMES);
102     if (!eq_doubles(globalVariable20_2, (TEST20_B * (double)TEST20_TIMES)))
103       logerror("    globalVariable20_2 contained %g, not %g as expected\n",
104                globalVariable20_2, TEST20_B * (double)TEST20_TIMES);
105     if (int_val != (TEST20_C * TEST20_TIMES))
106       logerror("    int_val contained %d, not %d as expected\n",
107                int_val, TEST20_C * TEST20_TIMES);
108     if (!eq_doubles(double_val, (TEST20_D * (double)TEST20_TIMES)))
109       logerror("    double_val contained %g, not %g as expected\n",
110                double_val, TEST20_D * (double)TEST20_TIMES);
111     if (ret != TEST20_ANSWER)
112       logerror("    ret contained %d, not %d as expected\n",
113                ret, TEST20_ANSWER);
114     retval = -1; /* Test failed */
115   }
116   return retval;
117 }
118
119 int test1_20_func2(int *int_val, double *double_val) {
120     int i, ret = 1;
121     *int_val = tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+
122                (tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+
123                (tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+
124                (tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc+(tc
125                ))))))))))))))))))))))))))))))))))))))));
126
127     *double_val = td+(td+(td+(td+(td+(td+(td+(td+(td+(td+
128                   (td+(td+(td+(td+(td+(td+(td+(td+(td+(td+
129                   (td+(td+(td+(td+(td+(td+(td+(td+(td+(td+
130                   (td+(td+(td+(td+(td+(td+(td+(td+(td+(td+(td
131                   ))))))))))))))))))))))))))))))))))))))));
132     for (i = 0; i < test20_iter; i++) {
133         ret *= 3;
134         if (i % 2 == 1) {
135             ret *= 5;
136         } else if (i < 10) {
137             ret *= 7;
138         } else if (i > 20) {
139             ret *= 11;
140         }
141     }
142
143     return ret;
144 }
145
146 /* This function appears to be unused */
147 int func20_3()
148 {
149     static int n = 1;
150
151     return n++;
152 }
153
154 void test1_20_call1() 
155 {
156         if (debugPrint)
157                 fprintf(stderr, "%s[%d]:  welcome to test1_20_call1\n", __FILE__, __LINE__);
158     globalVariable20_1 = ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+
159                          (ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+
160                          (ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+
161                          (ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta+(ta
162                          ))))))))))))))))))))))))))))))))))))))));
163
164     globalVariable20_2 = tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+
165                          (tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+
166                          (tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+
167                          (tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb+(tb
168                          ))))))))))))))))))))))))))))))))))))))));
169 }
170
171 /*
172  * Determine if two doubles are close to being equal (for our purposes, that
173  * means to ten decimal places).
174  */
175 int eq_doubles(double a, double b) {
176     double diff = a - b;
177
178     if (diff < 0) diff = -diff;
179
180     if (diff < 0.00000000001) return 1;
181     else return 0;
182 }