1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.math;
19
20 import java.io.ByteArrayInputStream;
21 import java.io.ByteArrayOutputStream;
22 import java.io.IOException;
23 import java.io.ObjectInputStream;
24 import java.io.ObjectOutputStream;
25
26 import junit.framework.Assert;
27 import junit.framework.AssertionFailedError;
28
29 import org.apache.commons.math.complex.Complex;
30 import org.apache.commons.math.complex.ComplexFormat;
31
32
33
34
35 public class TestUtils {
36
37
38
39 private TestUtils() {
40 super();
41 }
42
43
44
45
46
47 public static void assertEquals(double expected, double actual, double delta) {
48 assertEquals(null, expected, actual, delta);
49 }
50
51
52
53
54
55 public static void assertEquals(String msg, double expected, double actual, double delta) {
56
57 if(Double.isNaN(expected)){
58 Assert.assertTrue("" + actual + " is not NaN.",
59 Double.isNaN(actual));
60 } else {
61 Assert.assertEquals(msg, expected, actual, delta);
62 }
63 }
64
65
66
67
68
69 public static void assertSame(double expected, double actual) {
70 assertEquals(expected, actual, 0);
71 }
72
73
74
75
76
77 public static void assertSame(Complex expected, Complex actual) {
78 assertSame(expected.getReal(), actual.getReal());
79 assertSame(expected.getImaginary(), actual.getImaginary());
80 }
81
82
83
84
85
86 public static void assertEquals(Complex expected, Complex actual, double delta) {
87 assertEquals(expected.getReal(), actual.getReal(), delta);
88 assertEquals(expected.getImaginary(), actual.getImaginary(), delta);
89 }
90
91
92
93
94 public static void assertEquals(double a[], double b[], double tolerance) {
95 Assert.assertEquals(a.length, b.length);
96 for (int i = 0; i < a.length; i++) {
97 Assert.assertEquals(a[i], b[i], tolerance);
98 }
99 }
100
101
102
103
104
105
106
107
108 public static Object serializeAndRecover(Object o) {
109 try {
110
111 ByteArrayOutputStream bos = new ByteArrayOutputStream();
112 ObjectOutputStream so = new ObjectOutputStream(bos);
113 so.writeObject(o);
114
115
116 ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
117 ObjectInputStream si = new ObjectInputStream(bis);
118 return si.readObject();
119 } catch (IOException ioe) {
120 return null;
121 } catch (ClassNotFoundException cnfe) {
122 return null;
123 }
124 }
125
126
127
128
129
130
131
132 public static void checkSerializedEquality(Object object) {
133 Object object2 = serializeAndRecover(object);
134 Assert.assertEquals("Equals check", object, object2);
135 Assert.assertEquals("HashCode check", object.hashCode(), object2.hashCode());
136 }
137
138
139
140
141
142
143
144
145
146
147 public static void assertRelativelyEquals(double expected, double actual,
148 double relativeError) {
149 assertRelativelyEquals(null, expected, actual, relativeError);
150 }
151
152
153
154
155
156
157
158
159
160
161
162 public static void assertRelativelyEquals(String msg, double expected,
163 double actual, double relativeError) {
164 if (Double.isNaN(expected)) {
165 Assert.assertTrue(msg, Double.isNaN(actual));
166 } else if (Double.isNaN(actual)) {
167 Assert.assertTrue(msg, Double.isNaN(expected));
168 } else if (Double.isInfinite(actual) || Double.isInfinite(expected)) {
169 Assert.assertEquals(expected, actual, relativeError);
170 } else if (expected == 0.0) {
171 Assert.assertEquals(msg, actual, expected, relativeError);
172 } else {
173 double x = Math.abs((expected - actual) / expected);
174 Assert.assertEquals(msg, 0.0, x, relativeError);
175 }
176 }
177
178
179
180
181
182
183
184
185
186 public static void assertContains(String msg, Complex[] values,
187 Complex z, double epsilon) {
188 int i = 0;
189 boolean found = false;
190 while (!found && i < values.length) {
191 try {
192 assertEquals(values[i], z, epsilon);
193 found = true;
194 } catch (AssertionFailedError er) {
195
196 }
197 i++;
198 }
199 if (!found) {
200 Assert.fail(msg +
201 " Unable to find " + ComplexFormat.formatComplex(z));
202 }
203 }
204
205
206
207
208
209
210
211
212 public static void assertContains(Complex[] values,
213 Complex z, double epsilon) {
214 assertContains(null, values, z, epsilon);
215 }
216
217
218
219
220
221
222
223
224
225 public static void assertContains(String msg, double[] values,
226 double x, double epsilon) {
227 int i = 0;
228 boolean found = false;
229 while (!found && i < values.length) {
230 try {
231 assertEquals(values[i], x, epsilon);
232 found = true;
233 } catch (AssertionFailedError er) {
234
235 }
236 i++;
237 }
238 if (!found) {
239 Assert.fail(msg + " Unable to find" + x);
240 }
241 }
242
243
244
245
246
247
248
249
250 public static void assertContains(double[] values, double x,
251 double epsilon) {
252 assertContains(null, values, x, epsilon);
253 }
254
255 }