1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package net.sf.ezmorph.object;
18
19 import java.math.BigDecimal;
20 import java.math.BigInteger;
21
22 import junit.framework.Test;
23 import junit.framework.TestSuite;
24 import junit.textui.TestRunner;
25 import net.sf.ezmorph.MorphException;
26 import net.sf.ezmorph.MorphUtils;
27 import net.sf.ezmorph.Morpher;
28
29
30
31
32 public class NumberMorpherTest extends AbstractObjectMorpherTestCase
33 {
34 public static void main( String[] args )
35 {
36 TestRunner.run( suite() );
37 }
38
39 public static Test suite()
40 {
41 TestSuite suite = new TestSuite( NumberMorpherTest.class );
42 suite.setName( "NumberMorpher Tests" );
43 return suite;
44 }
45
46 private NumberMorpher anotherMorpher;
47 private NumberMorpher anotherMorpherWithDefaultValue;
48 private NumberMorpher morpher;
49 private NumberMorpher morpherWithDefaultValue;
50
51 public NumberMorpherTest( String name )
52 {
53 super( name );
54 }
55
56
57
58 public void testBigDecimalConversion_Double()
59 {
60 morpher = new NumberMorpher( BigDecimal.class );
61 BigDecimal expected = new BigDecimal( Double.MIN_VALUE );
62 BigDecimal actual = (BigDecimal) morpher.morph( expected );
63 assertEquals( expected, actual );
64 }
65
66 public void testBigDecimalConversion_null()
67 {
68 morpher = new NumberMorpher( BigDecimal.class );
69 assertNull( morpher.morph( null ) );
70 }
71
72 public void testBigDecimalConversion_useDefault()
73 {
74 morpher = new NumberMorpher( BigDecimal.class );
75 BigDecimal expected = MorphUtils.BIGDECIMAL_ONE;
76 morpher.setDefaultValue( expected );
77 morpher.setUseDefault( true );
78 BigDecimal actual = (BigDecimal) morpher.morph( new Object() );
79 assertEquals( expected, actual );
80 }
81
82 public void testBigDecimalConversion_useDefault_null()
83 {
84 morpher = new NumberMorpher( BigDecimal.class, (BigDecimal) null );
85 assertNull( morpher.morph( null ) );
86 }
87
88 public void testBigIntegerConversion_Long()
89 {
90 morpher = new NumberMorpher( BigInteger.class );
91 BigInteger expected = BigInteger.valueOf( Long.MIN_VALUE );
92 BigInteger actual = (BigInteger) morpher.morph( expected );
93 assertEquals( expected, actual );
94 }
95
96 public void testBigIntegerConversion_null()
97 {
98 morpher = new NumberMorpher( BigInteger.class );
99 assertNull( morpher.morph( null ) );
100 }
101
102 public void testBigIntegerConversion_useDefault()
103 {
104 morpher = new NumberMorpher( BigInteger.class );
105 BigInteger expected = BigInteger.ONE;
106 morpher.setDefaultValue( expected );
107 morpher.setUseDefault( true );
108 BigInteger actual = (BigInteger) morpher.morph( new Object() );
109 assertEquals( expected, actual );
110 }
111
112 public void testBigIntegerConversion_useDefault_null()
113 {
114 morpher = new NumberMorpher( BigInteger.class, (BigInteger) null );
115 assertNull( morpher.morph( null ) );
116 }
117
118 public void testByteConversion_byte()
119 {
120 morpher = new NumberMorpher( Byte.TYPE );
121 Byte expected = new Byte( Byte.MIN_VALUE );
122 Byte actual = (Byte) morpher.morph( expected );
123 assertEquals( expected, actual );
124 }
125
126 public void testByteConversion_Byte()
127 {
128 morpher = new NumberMorpher( Byte.class );
129 Byte expected = new Byte( Byte.MIN_VALUE );
130 Byte actual = (Byte) morpher.morph( expected );
131 assertEquals( expected, actual );
132 }
133
134 public void testByteConversion_null()
135 {
136 morpher = new NumberMorpher( Byte.class );
137 assertNull( morpher.morph( null ) );
138 }
139
140 public void testByteConversion_String()
141 {
142 morpher = new NumberMorpher( Byte.class );
143 String expected = String.valueOf( Byte.MIN_VALUE );
144 Byte actual = (Byte) morpher.morph( expected );
145 assertEquals( expected, actual.toString() );
146 }
147
148 public void testByteConversion_useDefault()
149 {
150 Byte expected = new Byte( Byte.MIN_VALUE );
151 morpher = new NumberMorpher( Byte.class, expected );
152 Byte actual = (Byte) morpher.morph( new Object() );
153 assertEquals( expected, actual );
154 }
155
156 public void testByteConversion_useDefault_null()
157 {
158 morpher = new NumberMorpher( Byte.class, (Byte) null );
159 assertNull( morpher.morph( new Object() ) );
160 }
161
162 public void testDoubleConversion_double()
163 {
164 morpher = new NumberMorpher( Double.TYPE );
165 Double expected = new Double( Double.MIN_VALUE );
166 Double actual = (Double) morpher.morph( expected );
167 assertEquals( expected, actual );
168 }
169
170 public void testDoubleConversion_Double()
171 {
172 morpher = new NumberMorpher( Double.class );
173 Double expected = new Double( Double.MIN_VALUE );
174 Double actual = (Double) morpher.morph( expected );
175 assertEquals( expected, actual );
176 }
177
178 public void testDoubleConversion_null()
179 {
180 morpher = new NumberMorpher( Double.class );
181 assertNull( morpher.morph( null ) );
182 }
183
184 public void testDoubleConversion_String()
185 {
186 morpher = new NumberMorpher( Double.class );
187 String expected = String.valueOf( Double.MIN_VALUE );
188 Double actual = (Double) morpher.morph( expected );
189 assertEquals( expected, actual.toString() );
190 }
191
192 public void testDoubleConversion_useDefault()
193 {
194 morpher = new NumberMorpher( Double.class );
195 Double expected = new Double( Double.MIN_VALUE );
196 morpher.setDefaultValue( expected );
197 morpher.setUseDefault( true );
198 Double actual = (Double) morpher.morph( new Object() );
199 assertEquals( expected, actual );
200 }
201
202 public void testDoubleConversion_useDefault_null()
203 {
204 morpher = new NumberMorpher( Double.class, (Double) null );
205 assertNull( morpher.morph( new Object() ) );
206 }
207
208 public void testFloatConversion_float()
209 {
210 morpher = new NumberMorpher( Float.TYPE );
211 Float expected = new Float( Float.MIN_VALUE );
212 Float actual = (Float) morpher.morph( expected );
213 assertEquals( expected, actual );
214 }
215
216 public void testFloatConversion_Float()
217 {
218 morpher = new NumberMorpher( Float.class );
219 Float expected = new Float( Float.MIN_VALUE );
220 Float actual = (Float) morpher.morph( expected );
221 assertEquals( expected, actual );
222 }
223
224 public void testFloatConversion_null()
225 {
226 morpher = new NumberMorpher( Float.class );
227 assertNull( morpher.morph( null ) );
228 }
229
230 public void testFloatConversion_String()
231 {
232 morpher = new NumberMorpher( Float.class );
233 String expected = String.valueOf( Float.MIN_VALUE );
234 Float actual = (Float) morpher.morph( expected );
235 assertEquals( expected, actual.toString() );
236 }
237
238 public void testFloatConversion_useDefault()
239 {
240 morpher = new NumberMorpher( Float.class );
241 Float expected = new Float( Float.MIN_VALUE );
242 morpher.setDefaultValue( expected );
243 morpher.setUseDefault( true );
244 Float actual = (Float) morpher.morph( new Object() );
245 assertEquals( expected, actual );
246 }
247
248 public void testFloatConversion_useDefault_null()
249 {
250 morpher = new NumberMorpher( Float.class, (Float) null );
251 assertNull( morpher.morph( new Object() ) );
252 }
253
254 public void testIntegerConversion_int()
255 {
256 morpher = new NumberMorpher( Integer.TYPE );
257 Integer expected = new Integer( Integer.MIN_VALUE );
258 Integer actual = (Integer) morpher.morph( expected );
259 assertEquals( expected, actual );
260 }
261
262 public void testIntegerConversion_Integer()
263 {
264 morpher = new NumberMorpher( Integer.class );
265 Integer expected = new Integer( Integer.MIN_VALUE );
266 Integer actual = (Integer) morpher.morph( expected );
267 assertEquals( expected, actual );
268 }
269
270 public void testIntegerConversion_null()
271 {
272 morpher = new NumberMorpher( Integer.class );
273 assertNull( morpher.morph( null ) );
274 }
275
276 public void testIntegerConversion_String()
277 {
278 morpher = new NumberMorpher( Integer.class );
279 String expected = String.valueOf( Integer.MIN_VALUE );
280 Integer actual = (Integer) morpher.morph( expected );
281 assertEquals( expected, actual.toString() );
282 }
283
284 public void testIntegerConversion_useDefault()
285 {
286 morpher = new NumberMorpher( Integer.class );
287 Integer expected = new Integer( Integer.MIN_VALUE );
288 morpher.setDefaultValue( expected );
289 morpher.setUseDefault( true );
290 Integer actual = (Integer) morpher.morph( new Object() );
291 assertEquals( expected, actual );
292 }
293
294 public void testIntegerConversion_useDefault_null()
295 {
296 morpher = new NumberMorpher( Integer.class, (Integer) null );
297 assertNull( morpher.morph( new Object() ) );
298 }
299
300 public void testlongConversion_long()
301 {
302 morpher = new NumberMorpher( Long.TYPE );
303 Long expected = new Long( Long.MIN_VALUE );
304 Long actual = (Long) morpher.morph( expected );
305 assertEquals( expected, actual );
306 }
307
308 public void testLongConversion_Long()
309 {
310 morpher = new NumberMorpher( Long.class );
311 Long expected = new Long( Long.MIN_VALUE );
312 Long actual = (Long) morpher.morph( expected );
313 assertEquals( expected, actual );
314 }
315
316 public void testLongConversion_null()
317 {
318 morpher = new NumberMorpher( Long.class );
319 assertNull( morpher.morph( null ) );
320 }
321
322 public void testLongConversion_String()
323 {
324 morpher = new NumberMorpher( Long.class );
325 String expected = String.valueOf( Long.MIN_VALUE );
326 Long actual = (Long) morpher.morph( expected );
327 assertEquals( expected, actual.toString() );
328 }
329
330 public void testLongConversion_useDefault()
331 {
332 morpher = new NumberMorpher( Long.class );
333 Long expected = new Long( Long.MIN_VALUE );
334 morpher.setDefaultValue( expected );
335 morpher.setUseDefault( true );
336 Long actual = (Long) morpher.morph( new Object() );
337 assertEquals( expected, actual );
338 }
339
340 public void testLongConversion_useDefault_null()
341 {
342 morpher = new NumberMorpher( Long.class, (Long) null );
343 assertNull( morpher.morph( new Object() ) );
344 }
345
346 public void testNumbermorpher_incompatible_defaultValue()
347 {
348 try{
349 morpher = new NumberMorpher( Integer.class, new Double( 0 ) );
350 fail( "Should have thrown a ConversionException" );
351 }
352 catch( MorphException expected ){
353
354 }
355 }
356
357 public void testNumbermorpher_notSupported()
358 {
359 try{
360 morpher = new NumberMorpher( String.class );
361 fail( "Should have thrown a ConversionException" );
362 }
363 catch( MorphException expected ){
364
365 }
366 }
367
368 public void testNumbermorpher_notSupported_2()
369 {
370 try{
371 morpher = new NumberMorpher( String.class, new Integer( 0 ) );
372 fail( "Should have thrown a ConversionException" );
373 }
374 catch( MorphException expected ){
375
376 }
377 }
378
379 public void testNumbermorpher_unspecifiedClass()
380 {
381 try{
382 morpher = new NumberMorpher( null );
383 fail( "Should have thrown a ConversionException" );
384 }
385 catch( MorphException expected ){
386
387 }
388 }
389
390 public void testNumbermorpher_unspecifiedClass2()
391 {
392 try{
393 morpher = new NumberMorpher( null, new Integer( 0 ) );
394 fail( "Should have thrown a ConversionException" );
395 }
396 catch( MorphException expected ){
397
398 }
399 }
400
401 public void testShortConversion_null()
402 {
403 morpher = new NumberMorpher( Short.class );
404 assertNull( morpher.morph( null ) );
405 }
406
407 public void testShortConversion_short()
408 {
409 morpher = new NumberMorpher( Short.TYPE );
410 Short expected = new Short( Short.MIN_VALUE );
411 Short actual = (Short) morpher.morph( expected );
412 assertEquals( expected, actual );
413 }
414
415 public void testShortConversion_Short()
416 {
417 morpher = new NumberMorpher( Short.class );
418 Short expected = new Short( Short.MIN_VALUE );
419 Short actual = (Short) morpher.morph( expected );
420 assertEquals( expected, actual );
421 }
422
423 public void testShortConversion_String()
424 {
425 morpher = new NumberMorpher( Short.class );
426 String expected = String.valueOf( Short.MIN_VALUE );
427 Short actual = (Short) morpher.morph( expected );
428 assertEquals( expected, actual.toString() );
429 }
430
431 public void testShortConversion_useDefault()
432 {
433 morpher = new NumberMorpher( Short.class );
434 Short expected = new Short( Short.MIN_VALUE );
435 morpher.setDefaultValue( expected );
436 morpher.setUseDefault( true );
437 Short actual = (Short) morpher.morph( new Object() );
438 assertEquals( expected, actual );
439 }
440
441 public void testShortConversion_useDefault_null()
442 {
443 morpher = new NumberMorpher( Short.class, (Short) null );
444 assertNull( morpher.morph( new Object() ) );
445 }
446
447 protected Morpher getAnotherMorpher()
448 {
449 return anotherMorpher;
450 }
451
452 protected Morpher getAnotherMorpherWithDefaultValue()
453 {
454 return anotherMorpherWithDefaultValue;
455 }
456
457 protected Morpher getMorpher()
458 {
459 return morpher;
460 }
461
462 protected Morpher getMorpherWithDefaultValue()
463 {
464 return morpherWithDefaultValue;
465 }
466
467 protected void setUp() throws Exception
468 {
469 morpher = new NumberMorpher( Integer.class );
470 morpherWithDefaultValue = new NumberMorpher( Integer.class, new Integer( 0 ) );
471 anotherMorpher = new NumberMorpher( Integer.class );
472 anotherMorpherWithDefaultValue = new NumberMorpher( Integer.class, new Integer( 1 ) );
473 }
474 }