1   /*
2    ORG Usurper is a random value object generator library 
3    Copyright (C) 2007  Pierre-Antoine Grégoire
4    
5    This library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9    
10   This library is distributed in the hope that it will be useful,
11   but WITHOUT ANY WARRANTY; without even the implied warranty of
12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13   Lesser General Public License for more details.
14   
15   You should have received a copy of the GNU Lesser General Public
16   License along with this library; if not, write to the Free Software
17   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18   */
19  
20  package org.org.usurper;
21  
22  import java.math.BigInteger;
23  import java.sql.Timestamp;
24  import java.util.Date;
25  import java.util.Iterator;
26  import java.util.List;
27  import java.util.Random;
28  import java.util.Set;
29  
30  import junit.framework.TestCase;
31  
32  import org.org.usurper.TestCommons.NullPropertyException;
33  import org.org.usurper.dummydomain.DummyVO;
34  import org.org.usurper.dummydomain.DummyVOWithArrays;
35  import org.org.usurper.dummydomain.DummyVOWithCollections;
36  import org.org.usurper.dummydomain.DummyVOWithEnum;
37  import org.org.usurper.dummydomain.DummyVOWithVOArrays;
38  import org.org.usurper.dummydomain.DummyVOWithVOCollections;
39  import org.org.usurper.dummydomain.DummyWithChildVO;
40  import org.org.usurper.dummydomain.FcknVO;
41  import org.org.usurper.dummydomain.IDummyVO;
42  import org.org.usurper.dummydomain.IImmutableDummyVO;
43  import org.org.usurper.dummydomain.ImmutableDummyVO;
44  import org.org.usurper.dummydomain.ImmutableDummyVOWithEnum;
45  import org.org.usurper.dummydomain.ImmutableDummyWithChildVO;
46  import org.org.usurper.dummydomain.ImmutableDummyWithChildVOArray;
47  import org.org.usurper.dummydomain.ImmutableDummyWithChildVOCollections;
48  import org.org.usurper.dummydomain.PartiallyImmutableDummyVO;
49  import org.org.usurper.dummydomain.SonOfDummyWithChildVO;
50  import org.org.usurper.dummydomain.SonOfSonOfDummyWithChildVO;
51  import org.org.usurper.dummydomain.TelescopicConstructorDummyVO;
52  import org.org.usurper.handlers.additional.ListOfValuesSpecificPropertyHandler;
53  import org.org.usurper.handlers.additional.ValueObjectPropertyTypeHandler;
54  import org.org.usurper.handlers.basic.AbstractPropertyTypeHandler;
55  import org.org.usurper.handlers.basic.AbstractSpecificPropertyHandler;
56  import org.org.usurper.handlers.exceptions.NoHandlerDefinedException;
57  import org.org.usurper.model.HandledBeanProperty;
58  import org.org.usurper.model.HandledConstructorArg;
59  import org.org.usurper.model.PropertyTypeDefinition;
60  import org.org.usurper.model.SpecificPropertyDefinition;
61  import org.org.usurper.setup.UsurperGeneratorSetup;
62  import org.org.usurper.setup.constants.OnMissingHandlers;
63  
64  /**
65   * @author pagregoire
66   */
67  public class UsurperGeneratorTest extends TestCase {
68  
69      /**
70       * @see junit.framework.TestCase#setUp()
71       */
72      @Override
73      protected void setUp() throws Exception {
74          super.setUp();
75  
76      }
77  
78      public void testGenerateObject() {
79          // CREATE USURPER GENERATOR
80          UsurperGenerator<DummyVO> dummyVOUsurper = new UsurperGenerator<DummyVO>(DummyVO.class);
81  
82          // GENERATE USURPER
83          DummyVO object = dummyVOUsurper.generateUsurper();
84  
85          // VALIDATE RESULTING OBJECT
86          try {
87              TestCommons.auditVO(object);
88          } catch (NullPropertyException e) {
89              fail(e.getMessage());
90          }
91      }
92  
93      public void testGenerateImmutableObject() {
94          // PREPARE USURPER GENERATOR SETUP
95          UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
96          usurperGeneratorSetup.registerPropertyTypeHandler(new AbstractPropertyTypeHandler(new PropertyTypeDefinition(String.class)) {
97  
98              public Object handle(HandledBeanProperty handledBeanProperty) {
99                  return TestCommons.HANDLED_STRING;
100             }
101 
102             public Object handle(HandledConstructorArg handledConstructorArg) {
103                 return TestCommons.HANDLED_STRING;
104             }
105 
106         });
107 
108         // CREATE USURPER GENERATOR
109         UsurperGenerator<ImmutableDummyVO> immutableDummyVOUsurper = new UsurperGenerator<ImmutableDummyVO>(ImmutableDummyVO.class, usurperGeneratorSetup);
110 
111         // GENERATE USURPER
112         IImmutableDummyVO object = immutableDummyVOUsurper.generateUsurper();
113         assertEquals("The shortest constructor should be used.", ImmutableDummyVO.SHORT_CONTRUCTOR, object.getStringField());
114 
115         // VALIDATE RESULTING OBJECT
116         try {
117             TestCommons.auditVO(object);
118         } catch (NullPropertyException e) {
119             fail(e.getMessage());
120         }
121     }
122 
123     public void testGenerateImmutableWithChildObject() {
124         // PREPARE USURPER GENERATOR SETUP
125         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
126         usurperGeneratorSetup.registerPropertyTypeHandler(new ValueObjectPropertyTypeHandler(DummyWithChildVO.class, SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class));
127 
128         // CREATE USURPER GENERATOR
129         UsurperGenerator<ImmutableDummyWithChildVO> immutableDummyWithChildVOUsurper = new UsurperGenerator<ImmutableDummyWithChildVO>(ImmutableDummyWithChildVO.class, usurperGeneratorSetup);
130 
131         // GENERATE USURPER
132         ImmutableDummyWithChildVO object = immutableDummyWithChildVOUsurper.generateUsurper();
133 
134         // VALIDATE RESULTING OBJECT
135         try {
136             TestCommons.auditVO(object);
137         } catch (NullPropertyException e) {
138             fail(e.getMessage());
139         }
140     }
141 
142     public void testGenerateImmutableWithChildObjectArray() {
143         // PREPARE USURPER GENERATOR SETUP
144         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
145         usurperGeneratorSetup.registerPropertyTypeHandler(new ValueObjectPropertyTypeHandler(DummyWithChildVO.class, SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class));
146 
147         // CREATE USURPER GENERATOR
148         UsurperGenerator<ImmutableDummyWithChildVOArray> immutableDummyWithChildVOArrayUsurper = new UsurperGenerator<ImmutableDummyWithChildVOArray>(ImmutableDummyWithChildVOArray.class, usurperGeneratorSetup);
149 
150         // GENERATE USURPER
151         ImmutableDummyWithChildVOArray object = immutableDummyWithChildVOArrayUsurper.generateUsurper();
152 
153         // VALIDATE RESULTING OBJECT
154         try {
155             TestCommons.auditVO(object);
156         } catch (NullPropertyException e) {
157             fail(e.getMessage());
158         }
159     }
160 
161     public void testGenerateImmutableWithChildObjectCollections() {
162         // PREPARE USURPER GENERATOR SETUP
163         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
164         usurperGeneratorSetup.registerPropertyTypeHandler(new ValueObjectPropertyTypeHandler(DummyWithChildVO.class, SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class));
165 
166         // CREATE USURPER GENERATOR
167         UsurperGenerator<ImmutableDummyWithChildVOCollections> immutableDummyWithChildVOCollectionsUsurper = new UsurperGenerator<ImmutableDummyWithChildVOCollections>(ImmutableDummyWithChildVOCollections.class, usurperGeneratorSetup);
168 
169         // GENERATE USURPER
170         ImmutableDummyWithChildVOCollections object = immutableDummyWithChildVOCollectionsUsurper.generateUsurper();
171 
172         // VALIDATE RESULTING OBJECT
173         try {
174             TestCommons.auditVO(object);
175         } catch (NullPropertyException e) {
176             fail(e.getMessage());
177         }
178     }
179 
180     public void testGenerateImmutableObjectWithChosenConstructor() {
181         // PREPARE USURPER GENERATOR SETUP
182         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
183         usurperGeneratorSetup.registerPropertyTypeHandler(new AbstractPropertyTypeHandler(String.class) {
184 
185             public Object handle(HandledBeanProperty handledBeanProperty) {
186                 return TestCommons.HANDLED_STRING;
187             }
188 
189             public Object handle(HandledConstructorArg handledConstructorArg) {
190                 return TestCommons.HANDLED_STRING;
191             }
192 
193         });
194 
195         // CREATE USURPER GENERATOR
196         UsurperGenerator<ImmutableDummyVO> immutableDummyVOUsurper = new UsurperGenerator<ImmutableDummyVO>(ImmutableDummyVO.class, usurperGeneratorSetup);
197         immutableDummyVOUsurper.useConstructor(Integer.class, Float.class, Double.class, String.class, Date.class, Long.class, Short.class, Boolean.class, int.class, short.class, long.class, boolean.class, byte.class, char.class, float.class, double.class, Timestamp.class, java.sql.Date.class);
198 
199         // GENERATE USURPER
200         IImmutableDummyVO object = immutableDummyVOUsurper.generateUsurper();
201         assertNotSame("The shortest constructor should not be used.", ImmutableDummyVO.SHORT_CONTRUCTOR, object.getStringField());
202         assertEquals("The longest constructor should be used.", TestCommons.HANDLED_STRING, object.getStringField());
203 
204         // VALIDATE RESULTING OBJECT
205         try {
206             TestCommons.auditVO(object);
207         } catch (NullPropertyException e) {
208             fail(e.getMessage());
209         }
210     }
211 
212     public void testGeneratePartiallyImmutableObject() {
213         // CREATE USURPER GENERATOR
214         UsurperGenerator<PartiallyImmutableDummyVO> partiallyImmutableDummyVOUsurper = new UsurperGenerator<PartiallyImmutableDummyVO>(PartiallyImmutableDummyVO.class);
215 
216         // GENERATE USURPER
217         PartiallyImmutableDummyVO object = partiallyImmutableDummyVOUsurper.generateUsurper();
218 
219         // VALIDATE RESULTING OBJECT
220         try {
221             TestCommons.auditVO(object);
222         } catch (NullPropertyException e) {
223             fail(e.getMessage());
224         }
225     }
226 
227     public void testBestConstructorSelection() {
228         // CREATE USURPER GENERATOR
229         UsurperGenerator<TelescopicConstructorDummyVO> usurperGenerator = new UsurperGenerator<TelescopicConstructorDummyVO>(TelescopicConstructorDummyVO.class);
230 
231         // GENERATE USURPER
232         TelescopicConstructorDummyVO object = usurperGenerator.generateUsurper();
233 
234         // VALIDATE RESULTING OBJECT
235         // THE SHORTEST CONSTRUCTOR WITH HANDLERS AVAILABLE FOR ALL ARGUMENTS SHOULD BE CHOSEN.
236         assertNull(object.getInputStream());
237         assertNotNull(object.getInteger());
238         assertNotNull(object.getString());
239     }
240 
241     public void testGenerateObjectWithInterface() {
242         // CREATE USURPER GENERATOR
243         UsurperGenerator<IDummyVO> dummyVOUsurper = new UsurperGenerator<IDummyVO>(DummyVO.class);
244 
245         // GENERATE USURPER
246         IDummyVO object = dummyVOUsurper.generateUsurper();
247 
248         // VALIDATE RESULTING OBJECT
249         try {
250             TestCommons.auditVO(object);
251         } catch (NullPropertyException e) {
252             fail(e.getMessage());
253         }
254     }
255 
256     public void testGenerateImmutableObjectWithInterface() {
257         // CREATE USURPER GENERATOR
258         UsurperGenerator<IImmutableDummyVO> immutableDummyVOUsurper = new UsurperGenerator<IImmutableDummyVO>(ImmutableDummyVO.class);
259 
260         // GENERATE USURPER
261         IImmutableDummyVO object = immutableDummyVOUsurper.generateUsurper();
262 
263         // VALIDATE RESULTING OBJECT
264         try {
265             TestCommons.auditVO(object);
266         } catch (NullPropertyException e) {
267             fail(e.getMessage());
268         }
269     }
270 
271     public void testGenerateObjectWithEnum() {
272         // CREATE USURPER GENERATOR
273         UsurperGenerator<DummyVOWithEnum> dummyVOUsurper = new UsurperGenerator<DummyVOWithEnum>(DummyVOWithEnum.class);
274 
275         // GENERATE USURPER
276         DummyVOWithEnum object = dummyVOUsurper.generateUsurper();
277 
278         // VALIDATE RESULTING OBJECT
279         try {
280             TestCommons.auditVO(object);
281         } catch (NullPropertyException e) {
282             fail(e.getMessage());
283         }
284     }
285 
286     public void testGenerateImmutableObjectWithEnum() {
287         // CREATE USURPER GENERATOR
288         UsurperGenerator<ImmutableDummyVOWithEnum> immutableDummyVOUsurper = new UsurperGenerator<ImmutableDummyVOWithEnum>(ImmutableDummyVOWithEnum.class);
289 
290         // GENERATE USURPER
291         ImmutableDummyVOWithEnum object = immutableDummyVOUsurper.generateUsurper();
292 
293         // VALIDATE RESULTING OBJECT
294         try {
295             TestCommons.auditVO(object);
296         } catch (NullPropertyException e) {
297             fail(e.getMessage());
298         }
299     }
300 
301     public void testGenerateObjectWithChilds() {
302         // PREPARE USURPER GENERATOR SETUP
303         ValueObjectPropertyTypeHandler valueObjectFieldTypeHandler = new ValueObjectPropertyTypeHandler(SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class);
304         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
305         usurperGeneratorSetup.registerPropertyTypeHandler(valueObjectFieldTypeHandler);
306 
307         // CREATE USURPER GENERATOR
308         UsurperGenerator<DummyWithChildVO> dummyVOUsurper = new UsurperGenerator<DummyWithChildVO>(DummyWithChildVO.class, usurperGeneratorSetup);
309 
310         // GENERATE USURPER
311         DummyWithChildVO object = dummyVOUsurper.generateUsurper();
312 
313         // VALIDATE RESULTING OBJECT
314         try {
315             TestCommons.auditVO(object);
316         } catch (NullPropertyException e) {
317             fail(e.getMessage());
318         }
319     }
320 
321     public void testGenerateObjectWithCollectionChilds() {
322         // CREATE USURPER GENERATOR
323         UsurperGenerator<DummyVOWithCollections> dummyVOUsurper = new UsurperGenerator<DummyVOWithCollections>(DummyVOWithCollections.class);
324 
325         // GENERATE USURPER
326         DummyVOWithCollections object = dummyVOUsurper.generateUsurper();
327 
328         // VALIDATE RESULTING OBJECT
329         try {
330             TestCommons.auditVO(object);
331         } catch (NullPropertyException e) {
332             fail(e.getMessage());
333         }
334     }
335 
336     public void testGenerateObjectWithVOCollectionChilds() {
337         // PREPARE USURPER GENERATOR SETUP
338         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
339         usurperGeneratorSetup.registerPropertyTypeHandler(new ValueObjectPropertyTypeHandler(SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class));
340 
341         // CREATE USURPER GENERATOR
342         UsurperGenerator<DummyVOWithVOCollections> dummyVOUsurper = new UsurperGenerator<DummyVOWithVOCollections>(DummyVOWithVOCollections.class, usurperGeneratorSetup);
343 
344         // GENERATE USURPER
345         DummyVOWithVOCollections object = dummyVOUsurper.generateUsurper();
346 
347         // VALIDATE RESULTING OBJECT
348         try {
349             TestCommons.auditVO(object);
350         } catch (NullPropertyException e) {
351             fail(e.getMessage());
352         }
353     }
354 
355     public void testGenerateObjectWithArrayChilds() {
356         // CREATE USURPER GENERATOR
357         UsurperGenerator<DummyVOWithArrays> dummyVOUsurper = new UsurperGenerator<DummyVOWithArrays>(DummyVOWithArrays.class);
358 
359         // GENERATE USURPER
360         DummyVOWithArrays object = dummyVOUsurper.generateUsurper();
361 
362         // VALIDATE RESULTING OBJECT
363         try {
364             TestCommons.auditVO(object);
365         } catch (NullPropertyException e) {
366             fail(e.getMessage());
367         }
368     }
369 
370     public void testGenerateObjectWithVOArrayChilds() {
371         // PREPARE USURPER GENERATOR SETUP
372         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
373         usurperGeneratorSetup.registerPropertyTypeHandler(new ValueObjectPropertyTypeHandler(SonOfDummyWithChildVO.class, SonOfSonOfDummyWithChildVO.class));
374 
375         // CREATE USURPER GENERATOR
376         UsurperGenerator<DummyVOWithVOArrays> dummyVOUsurper = new UsurperGenerator<DummyVOWithVOArrays>(DummyVOWithVOArrays.class, usurperGeneratorSetup);
377 
378         // GENERATE USURPER
379         DummyVOWithVOArrays object = dummyVOUsurper.generateUsurper();
380 
381         // VALIDATE RESULTING OBJECT
382         try {
383             TestCommons.auditVO(object);
384         } catch (NullPropertyException e) {
385             fail(e.getMessage());
386         }
387     }
388 
389     public void testGenerateObjectWithNoHandlerForProperty() {
390         // CREATE USURPER GENERATOR
391         UsurperGenerator<FcknVO> fcknVOUsurper = new UsurperGenerator<FcknVO>(FcknVO.class);
392 
393         // TRY TO GENERATE USURPER WITH AN UNHANDLED TYPE : BigInteger
394         try {
395             @SuppressWarnings("unused")
396             FcknVO object = fcknVOUsurper.generateUsurper();
397             fail("a NoHandlerDefinedException should be thrown.");
398         } catch (Exception e) {
399             assertTrue("the thrown exception should be a " + NoHandlerDefinedException.class.getName(), e instanceof NoHandlerDefinedException);
400         }
401 
402         // PREPARE USURPER GENERATOR SETUP
403         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
404         usurperGeneratorSetup.onMissingHandlers(OnMissingHandlers.SKIP);
405 
406         // TRY TO GENERATE USURPER WITH AN UNHANDLED TYPE : BigInteger
407         // BUT WITH UNDEFINEDHANDLERS IGNORED
408         fcknVOUsurper.replaceSetup(usurperGeneratorSetup);
409         try {
410             @SuppressWarnings("unused")
411             FcknVO object = fcknVOUsurper.generateUsurper();
412 
413             // VALIDATE RESULTING OBJECT (should fail as the unhandled property
414             // is null)
415             try {
416                 TestCommons.auditVO(object);
417                 fail("unhandled property should be null");
418             } catch (Exception e) {
419                 assertTrue("the thrown exception should be a " + NullPropertyException.class.getName(), e instanceof NullPropertyException);
420             }
421         } catch (NoHandlerDefinedException e) {
422             fail("NoHandlerDefinedException should not be thrown.");
423         }
424     }
425 
426     public void testGenerateObjectWithListOfValuesSpecificPropertyHandler() {
427         // PREPARE USURPER GENERATOR SETUP
428         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
429         usurperGeneratorSetup.registerSpecificPropertyHandler(new ListOfValuesSpecificPropertyHandler(new SpecificPropertyDefinition(FcknVO.class, "bigIntField"), TestCommons.BIG_INTEGER_VALUES_LIST));
430         usurperGeneratorSetup.registerSpecificPropertyHandler(new ListOfValuesSpecificPropertyHandler(new SpecificPropertyDefinition(FcknVO.class, "bigIntField2"), TestCommons.BIG_INTEGER_VALUES_LIST));
431 
432         // CREATE USURPER GENERATOR
433         UsurperGenerator<FcknVO> fcknVOUsurper = new UsurperGenerator<FcknVO>(FcknVO.class, usurperGeneratorSetup);
434 
435         // GENERATE USURPER
436         List<FcknVO> collection = fcknVOUsurper.generateUsurperList(6);
437 
438         Iterator<BigInteger> it = TestCommons.BIG_INTEGER_VALUES_LIST.iterator();
439         // VALIDATE RESULTING OBJECT
440         for (FcknVO fcknVO : collection) {
441             try {
442                 TestCommons.auditVO(fcknVO);
443             } catch (NullPropertyException e) {
444                 fail(e.getMessage());
445             }
446             if (!it.hasNext()) {
447                 it = TestCommons.BIG_INTEGER_VALUES_LIST.iterator();
448             }
449             BigInteger nextValue = it.next();
450             assertEquals("the specificFieldHandler should put the <" + nextValue + "> value for the <bigIntField> field", nextValue, fcknVO.getBigIntField());
451             assertEquals("the specificFieldHandler should put the <" + nextValue + "> value for the <bigIntField2> field", nextValue, fcknVO.getBigIntField2());
452         }
453     }
454 
455     public void testGenerateObjectWithSpecificPropertyHandler() {
456         // PREPARE USURPER GENERATOR SETUP
457         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
458         usurperGeneratorSetup.registerSpecificPropertyHandler(new AbstractSpecificPropertyHandler(new SpecificPropertyDefinition(FcknVO.class, "bigIntField")) {
459             public Object handle(HandledBeanProperty handledBeanProperty) {
460                 return TestCommons.BIG_INTEGER_VALUE;
461             }
462 
463             public Object handle(HandledConstructorArg handledConstructorArg) {
464                 return TestCommons.BIG_INTEGER_VALUE;
465             }
466         });
467         usurperGeneratorSetup.registerSpecificPropertyHandler(new AbstractSpecificPropertyHandler(new SpecificPropertyDefinition(FcknVO.class, "bigIntField2")) {
468             public Object handle(HandledBeanProperty handledBeanProperty) {
469                 return TestCommons.BIG_INTEGER_VALUE;
470             }
471 
472             public Object handle(HandledConstructorArg handledConstructorArg) {
473                 return TestCommons.BIG_INTEGER_VALUE;
474             }
475         });
476 
477         // CREATE USURPER GENERATOR
478         UsurperGenerator<FcknVO> fcknVOUsurper = new UsurperGenerator<FcknVO>(FcknVO.class, usurperGeneratorSetup);
479 
480         // GENERATE USURPER
481         FcknVO object = fcknVOUsurper.generateUsurper();
482 
483         // VALIDATE RESULTING OBJECT
484         assertEquals("the specificFieldHandler should put a default value for the field", TestCommons.BIG_INTEGER_VALUE, ((FcknVO) object).getBigIntField());
485         assertEquals("the specificFieldHandler should put a default value for the field", TestCommons.BIG_INTEGER_VALUE, ((FcknVO) object).getBigIntField2());
486         try {
487             TestCommons.auditVO(object);
488         } catch (NullPropertyException e) {
489             fail(e.getMessage());
490         }
491     }
492 
493     public void testGenerateObjectWithPropertyTypeHandler() {
494         // PREPARE USURPER GENERATOR SETUP
495         UsurperGeneratorSetup usurperGeneratorSetup = new UsurperGeneratorSetup();
496         usurperGeneratorSetup.registerPropertyTypeHandler(new AbstractPropertyTypeHandler(BigInteger.class) {
497             public Object handle(HandledBeanProperty handledBeanProperty) {
498                 return new BigInteger(24, new Random());
499             }
500 
501             public Object handle(HandledConstructorArg handledConstructorArg) {
502                 return new BigInteger(24, new Random());
503             }
504         });
505 
506         // CREATE USURPER GENERATOR
507         UsurperGenerator<FcknVO> fcknVOUsurper = new UsurperGenerator<FcknVO>(FcknVO.class, usurperGeneratorSetup);
508 
509         // GENERATE USURPER
510         FcknVO object3 = fcknVOUsurper.generateUsurper();
511 
512         // VALIDATE RESULTING OBJECT
513         try {
514             TestCommons.auditVO(object3);
515         } catch (NullPropertyException e) {
516             fail(e.getMessage());
517         }
518     }
519 
520     public void testGenerateCollection() {
521         // CREATE USURPER GENERATOR
522         UsurperGenerator<DummyVO> dummyVOUsurper = new UsurperGenerator<DummyVO>(DummyVO.class);
523 
524         int collectionSize = 2;
525 
526         // GENERATE USURPER LIST
527 
528         List<DummyVO> list = dummyVOUsurper.generateUsurperList(collectionSize);
529 
530         // VALIDATE RESULTING OBJECT
531         assertEquals("the generated list's size should be " + collectionSize, list.size(), collectionSize);
532         for (DummyVO dummyVO : list) {
533             try {
534                 TestCommons.auditVO(dummyVO);
535             } catch (NullPropertyException e) {
536                 fail(e.getMessage());
537             }
538         }
539 
540         // GENERATE USURPER SET
541         Set<DummyVO> set = dummyVOUsurper.generateUsurperSet(collectionSize);
542 
543         // VALIDATE RESULTING OBJECT
544         assertEquals("the generated list's size should be " + collectionSize, set.size(), collectionSize);
545         for (DummyVO dummyVO : set) {
546             try {
547                 TestCommons.auditVO(dummyVO);
548             } catch (NullPropertyException e) {
549                 fail(e.getMessage());
550             }
551         }
552     }
553 }