Update copyright to LGPL on all files
[dyninst.git] / testsuite / src / dyninst / test1_6_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_6_func2();
38 int test1_6_func1();
39
40 /* Global variables accessed by the mutator.  These must have globally unique
41  * names.
42  */
43
44 volatile int test1_6_globalVariable1 = (int)0xdeadbeef;
45 volatile int test1_6_globalVariable2 = (int)0xdeadbeef;
46 volatile int test1_6_globalVariable3 = (int)0xdeadbeef;
47 volatile int test1_6_globalVariable4 = (int)0xdeadbeef;
48 volatile int test1_6_globalVariable5 = (int)0xdeadbeef;
49 volatile int test1_6_globalVariable6 = (int)0xdeadbeef;
50 volatile int test1_6_globalVariable1a = (int)0xdeadbeef;
51 volatile int test1_6_globalVariable2a = (int)0xdeadbeef;
52 volatile int test1_6_globalVariable3a = (int)0xdeadbeef;
53 volatile int test1_6_globalVariable4a = (int)0xdeadbeef;
54 volatile int test1_6_globalVariable5a = (int)0xdeadbeef;
55 volatile int test1_6_globalVariable6a = (int)0xdeadbeef;
56
57 volatile int test1_6_constVar0 = 0;
58 volatile int test1_6_constVar1 = 1;
59 volatile int test1_6_constVar2 = 2;
60 volatile int test1_6_constVar3 = 3;
61 volatile int test1_6_constVar4 = 4;
62 volatile int test1_6_constVar5 = 5;
63 volatile int test1_6_constVar6 = 6;
64 volatile int test1_6_constVar7 = 7;
65 volatile int test1_6_constVar9 = 9;
66 volatile int test1_6_constVar10 = 10;
67 volatile int test1_6_constVar60 = 60;
68 volatile int test1_6_constVar64 = 64;
69 volatile int test1_6_constVar66 = 66;
70 volatile int test1_6_constVar67 = 67;
71
72 /* Internally used function prototypes.  These should be declared with the
73  * keyword static so they don't interfere with other mutatees in the group.
74  */
75
76 /* Global variables used internally by the mutatee.  These should be declared
77  * with the keyword static so they don't interfere with other mutatees in the
78  * group.
79  */
80
81 /* Function definitions follow */
82
83 int test1_6_func1() {
84   int retval;
85   test1_6_func2();
86   if ((test1_6_globalVariable1 == 60+2) && (test1_6_globalVariable2 == 64-1) &&
87       (test1_6_globalVariable3 == 66/3) && (test1_6_globalVariable4 == 67/3) &&
88       (test1_6_globalVariable5 == 6 * 5) && (test1_6_globalVariable6 == 3) &&
89       (test1_6_globalVariable1a == 60+2) && (test1_6_globalVariable2a == 64-1) &&
90       (test1_6_globalVariable3a == 66/3) && (test1_6_globalVariable4a == 67/3) &&
91       (test1_6_globalVariable5a == 6 * 5) && (test1_6_globalVariable6a == 3)) {
92     logerror("Passed test #6 (arithmetic operators)\n");
93     retval = 0; /* Test passed */
94   } else {
95     logerror("**Failed** test #6 (arithmetic operators)\n");
96     if (test1_6_globalVariable1 != 60+2)
97       logerror("    addition error (const) 60+2 got %d\n", test1_6_globalVariable1);
98     if (test1_6_globalVariable2 != 64-1)
99       logerror("    subtraction error (const) 64-1 got %d\n", test1_6_globalVariable2);
100     if (test1_6_globalVariable3 != 66/3)
101       logerror("    division error (const) 66/3 got %d\n", test1_6_globalVariable3);
102     if (test1_6_globalVariable4 != 67/3)
103       logerror("    division error (const) 67/3 got %d\n", test1_6_globalVariable4);
104     if (test1_6_globalVariable5 != 6 * 5)
105       logerror("    mult error 6*5 (const) got %d\n", test1_6_globalVariable5);
106     if (test1_6_globalVariable6 != 3)
107       logerror("    comma error 10,3 (const) got %d\n", test1_6_globalVariable6);
108     if (test1_6_globalVariable1a != 60+2)
109       logerror("    addition error 60+2 (var) got %d\n", test1_6_globalVariable1a);
110     if (test1_6_globalVariable2a != 64-1)
111       logerror("    subtraction error 64-1 (var) got %d\n", test1_6_globalVariable2a);
112     if (test1_6_globalVariable3a != 66/3)
113       logerror("    division error 66/3 (var) got %d\n", test1_6_globalVariable3a);
114     if (test1_6_globalVariable4a != 67/3)
115       logerror("    division error 67/3 (var) got %d\n", test1_6_globalVariable4a);
116     if (test1_6_globalVariable5a != 6 * 5)
117       logerror("    mult error 6*5 (var) got %d\n", test1_6_globalVariable5a);
118     if (test1_6_globalVariable6a != 3)
119       logerror("    comma error 10,3 (var) got %d\n", test1_6_globalVariable6a);
120     retval = -1; /* Test failed */
121   }
122   return retval;
123 }
124
125 /*
126  * Start of Test #6 - arithmetic operators
127  *      Verify arithmetic operators:
128  *              constant integer addition
129  *              constant integer subtraction
130  *              constant integer divide (using large constants)
131  *              constant integer divide (small consts)
132  *              constant integer multiply
133  *              constant comma operator
134  *              variable integer addition
135  *              variable integer subtraction
136  *              variable integer divide (using large constants)
137  *              variable integer divide (small consts)
138  *              variable integer multiply
139  *              variable comma operator
140  *
141  *      constant - use constant expressions
142  *      variable - use variables in the expressions
143  *
144  */
145 int test1_6_mutatee() {
146   if (test1_6_func1()) {
147     return -1; /* Test failed */
148   } else {
149     test_passes(testname);
150     return 0; /* Test passed */
151   }
152 }
153
154 void test1_6_func2() {
155   dprintf("test1_6_func2 () called\n");
156 }