1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
|
/*
* ************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: Assurance.java,v $
* $Revision: 1.1.2.1 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
* ***********************************************************************
*/
package complexlib;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
*
* @author ll93751
*
* I have removed the assure(...) functions from ComplexTestCase due to the fact now I can
* use the functions every where and don't need to be a ComplexTestCase any longer.
*/
public class Assurance
{
public static final boolean CONTINUE = true;
/** State of the current test method **/
protected boolean state = true;
/** The message if the test did fail **/
protected String message = null;
/**
* Assure that s is true.
* This function generates "Assure failed." as standard message.
* @param s The condition that should be true.
*/
protected void assure(boolean s) {
assure("Assure failed.", s, false);
}
/**
* Assure that s is true.
* The given message will be only evaluated, if s is false.
* @param msg The message that is evaluated.
* @param s The condition that should be true.
*/
protected void assure(String msg, boolean s) {
assure(msg, s, false);
}
/**
* Assure that two boolean values are equal
* @param expected specifies the expected boolean value
* @param actual specifies the actual boolean value
*/
protected void assureEquals( boolean expected, boolean actual ) {
assureEquals( "Equality test failed", new Boolean( expected ), new Boolean( actual ), false );
}
/**
* Assure that two boolean values are equal
* @param message the message to print when the equality test fails
* @param expected specifies the expected boolean value
* @param actual specifies the actual boolean value
*/
protected void assureEquals( String message, boolean expected, boolean actual ) {
assureEquals( message, new Boolean( expected ), new Boolean( actual ), false );
}
/**
* Assure that two byte values are equal
* @param expected specifies the expected byte value
* @param actual specifies the actual byte value
*/
protected void assureEquals( byte expected, byte actual ) {
assureEquals( "Equality test failed", new Byte( expected ), new Byte( actual ), false );
}
/**
* Assure that two byte values are equal
* @param message the message to print when the equality test fails
* @param expected specifies the expected byte value
* @param actual specifies the actual byte value
*/
protected void assureEquals( String message, byte expected, byte actual ) {
assureEquals( message, new Byte( expected ), new Byte( actual ), false );
}
/**
* Assure that two double values are equal
* @param expected specifies the expected double value
* @param actual specifies the actual double value
*/
protected void assureEquals( double expected, double actual ) {
assureEquals( "Equality test failed", new Double( expected ), new Double( actual ), false );
}
/**
* Assure that two double values are equal
* @param message the message to print when the equality test fails
* @param expected specifies the expected double value
* @param actual specifies the actual double value
*/
protected void assureEquals( String message, double expected, double actual ) {
assureEquals( message, new Double( expected ), new Double( actual ), false );
}
/**
* Assure that two float values are equal
* @param expected specifies the expected float value
* @param actual specifies the actual float value
*/
protected void assureEquals( float expected, float actual ) {
assureEquals( "Equality test failed", new Float( expected ), new Float( actual ), false );
}
/**
* Assure that two float values are equal
* @param message the message to print when the equality test fails
* @param expected specifies the expected float value
* @param actual specifies the actual float value
*/
protected void assureEquals( String message, float expected, float actual ) {
assureEquals( message, new Float( expected ), new Float( actual ), false );
}
/**
* Assure that two short values are equal
* @param expected specifies the expected short value
* @param actual specifies the actual short value
*/
protected void assureEquals( short expected, short actual ) {
assureEquals( "Equality test failed", new Short( expected ), new Short( actual ), false );
}
/**
* Assure that two short values are equal
* @param message the message to print when the equality test fails
* @param expected specifies the expected short value
* @param actual specifies the actual short value
*/
protected void assureEquals( String message, short expected, short actual ) {
assureEquals( message, new Short( expected ), new Short( actual ), false );
}
/**
* Assure that two int values are equal
* @param expected specifies the expected int value
* @param actual specifies the actual int value
*/
protected void assureEquals( int expected, int actual ) {
assureEquals( "Equality test failed", new Integer( expected ), new Integer( actual ), false );
}
/**
* Assure that two int values are equal
* @param message the message to print when the equality test fails
* @param expected specifies the expected int value
* @param actual specifies the actual int value
*/
protected void assureEquals( String message, int expected, int actual ) {
assureEquals( message, new Integer( expected ), new Integer( actual ), false );
}
/**
* Assure that two long values are equal
* @param expected specifies the expected long value
* @param actual specifies the actual long value
*/
protected void assureEquals( long expected, long actual ) {
assureEquals( "Equality test failed", new Long( expected ), new Long( actual ), false );
}
/**
* Assure that two long values are equal
* @param message the message to print when the equality test fails
* @param expected specifies the expected long value
* @param actual specifies the actual long value
*/
protected void assureEquals( String message, long expected, long actual ) {
assureEquals( message, new Long( expected ), new Long( actual ), false );
}
/**
* Assure that two string values are equal
* @param expected specifies the expected string value
* @param actual specifies the actual string value
*/
protected void assureEquals( String expected, String actual ) {
assureEquals( "Equality test failed", expected, actual, false );
}
/**
* Assure that two string values are equal
* @param message the message to print when the equality test fails
* @param expected specifies the expected string value
* @param actual specifies the actual string value
*/
protected void assureEquals( String message, String expected, String actual ) {
assureEquals( message, expected, actual, false );
}
/**
* Assure that two object are equal
* @param expected specifies the expected object value
* @param actual specifies the actual object value
*/
protected void assureEquals( Object expected, Object actual ) {
assureEquals( "Equality test failed", expected, actual, false );
}
/**
* Assure that two objects are equal
* @param message the message to print when the equality test fails
* @param expected specifies the expected object value
* @param actual specifies the actual object value
*/
protected void assureEquals( String message, Object expected, Object actual ) {
assureEquals( message, expected, actual, false );
}
/** invokes a given method on a given object, and assures a certain exception is caught
* @param _message is the message to print when the check fails
* @param _object is the object to invoke the method on
* @param _methodName is the name of the method to invoke
* @param _methodArgs are the arguments to pass to the method.
* @param _argClasses are the classes to assume for the arguments of the methods
* @param _expectedExceptionClass is the class of the exception to be caught. If this is null,
* it means that <em>no</em> exception must be throw by invoking the method.
*/
protected void assureException( final String _message, final Object _object, final String _methodName,
final Class[] _argClasses, final Object[] _methodArgs, final Class _expectedExceptionClass )
{
Class objectClass = _object.getClass();
boolean noExceptionAllowed = ( _expectedExceptionClass == null );
boolean caughtExpected = noExceptionAllowed ? true : false;
try
{
Method method = objectClass.getMethod( _methodName, _argClasses );
method.invoke(_object, _methodArgs );
}
catch ( InvocationTargetException e )
{
caughtExpected = noExceptionAllowed
? false
: ( e.getTargetException().getClass().equals( _expectedExceptionClass ) );
}
catch( Exception e )
{
caughtExpected = false;
}
assure( _message, caughtExpected );
}
/** invokes a given method on a given object, and assures a certain exception is caught
* @param _message is the message to print when the check fails
* @param _object is the object to invoke the method on
* @param _methodName is the name of the method to invoke
* @param _methodArgs are the arguments to pass to the method. Those implicitly define
* the classes of the arguments of the method which is called.
* @param _expectedExceptionClass is the class of the exception to be caught. If this is null,
* it means that <em>no</em> exception must be throw by invoking the method.
*/
protected void assureException( final String _message, final Object _object, final String _methodName,
final Object[] _methodArgs, final Class _expectedExceptionClass )
{
Class[] argClasses = new Class[ _methodArgs.length ];
for ( int i=0; i<_methodArgs.length; ++i )
argClasses[i] = _methodArgs[i].getClass();
assureException( _message, _object, _methodName, argClasses, _methodArgs, _expectedExceptionClass );
}
/** invokes a given method on a given object, and assures a certain exception is caught
* @param _object is the object to invoke the method on
* @param _methodName is the name of the method to invoke
* @param _methodArgs are the arguments to pass to the method. Those implicitly define
* the classes of the arguments of the method which is called.
* @param _expectedExceptionClass is the class of the exception to be caught. If this is null,
* it means that <em>no</em> exception must be throw by invoking the method.
*/
protected void assureException( final Object _object, final String _methodName, final Object[] _methodArgs,
final Class _expectedExceptionClass )
{
assureException(
"did not catch the expected exception (" +
( ( _expectedExceptionClass == null ) ? "none" : _expectedExceptionClass.getName() ) +
") while calling " + _object.getClass().getName() + "." + _methodName,
_object, _methodName, _methodArgs, _expectedExceptionClass );
}
/** invokes a given method on a given object, and assures a certain exception is caught
* @param _object is the object to invoke the method on
* @param _methodName is the name of the method to invoke
* @param _methodArgs are the arguments to pass to the method
* @param _argClasses are the classes to assume for the arguments of the methods
* @param _expectedExceptionClass is the class of the exception to be caught. If this is null,
* it means that <em>no</em> exception must be throw by invoking the method.
*/
protected void assureException( final Object _object, final String _methodName, final Class[] _argClasses,
final Object[] _methodArgs, final Class _expectedExceptionClass )
{
assureException(
"did not catch the expected exception (" +
( ( _expectedExceptionClass == null ) ? "none" : _expectedExceptionClass.getName() ) +
") while calling " + _object.getClass().getName() + "." + _methodName,
_object, _methodName, _argClasses, _methodArgs, _expectedExceptionClass );
}
/**
* Mark the currently executed method as failed.
* This function generates "Test did fail." as standard message.
*/
protected void failed() {
assure("Test did fail.", false, false);
}
/**
* Mark the currently executed method as failed.
* with the given message.
* @param msg The message of the failure.
*/
protected void failed(String msg) {
assure(msg, false, false);
}
/**
* Assure that s is true.
* The given message will be only evaluated, if s is false.
* Normally, assure() leaves the current test method, and the next one
* is executed. With the parameter 'cont' set to true, the current test
* method will continue.<br>
* The current method will of course marked as failed.
* @param msg The message that is evaluated.
* @param s The condition that should be true.
* @param cont Continue with test method, even if s is false.
*/
protected void assure(String msg, boolean s, boolean cont) {
state &= s;
if (!s) {
message += msg + "\r\n";
// log.println(msg);
if (!cont) {
throw new AssureException(msg);
}
}
}
protected void assureEquals( String message, Object expected, Object actual, boolean cont ) {
assure( message + " (expected: " + expected.toString() + ", actual: " + actual.toString() + ")",
expected.equals( actual ), cont );
}
/**
* Mark the currently executed method as failed.
* with the given message.
* The given message will be only evaluated, if s is false.
* With the parameter 'cont' set to true, the current test
* method will continue.<br>
* The current method will of course marked as failed.
* @param msg The message that is evaluated.
* @param cont Continue with test method, even if s is false.
*/
protected void failed(String msg, boolean cont) {
assure(msg, false, cont);
}
/**
* @deprecated
*/
// protected void addResult(String message, boolean state) {
// String msg = message + " - " + state;
// this.state &= state;
// this.message += msg + "\r\n";
// log.println(msg);
// }
public class AssureException extends RuntimeException {
public AssureException(String msg) {
super(msg);
}
}
}
|