1 /*
2  * JTiger Unit Testing Framework for J2SE 1.5
3  * Copyright (C) 2005 Tony Morris
4  *
5  * This software is licenced under the
6  * Common Public Licence version 1.0
7  * http://www.opensource.org/licenses/cpl1.0.php
8  *
9  * You received a copy of this licence with this software.
10  */
11 package org.jtiger.report.xml;
12 
13 import static org.jtiger.framework.SequenceFactory.newSequence;
14 import java.util.Arrays;
15 import org.jtiger.DummyFixture1;
16 import org.jtiger.DummyFixture2;
17 import org.jtiger.DummyFixture3;
18 import org.jtiger.DummyFixture4;
19 import org.jtiger.DummyFixture5;
20 import org.jtiger.assertion.ObjectFactory;
21 import org.jtiger.framework.Category;
22 import org.jtiger.framework.Fixture;
23 import org.jtiger.framework.FixturesRunner;
24 import org.jtiger.framework.FixturesRunnerConfig;
25 import org.jtiger.framework.RunnerException;
26 import org.jtiger.framework.Test;
27 import static org.jtiger.assertion.Reflection.assertHasDeclaredField;
28 import static org.jtiger.assertion.Serialization.assertSerializes;
29 import static org.jtiger.assertion.Basic.assertEqual;
30 import static org.jtiger.assertion.Basic.assertSame;
31 import static org.jtiger.framework.FixturesRunnerFactory.newFixturesRunner;
32 import static org.jtiger.framework.FixturesRunnerConfigFactory.newFixturesRunnerConfig;
33 import static org.jtiger.assertion.ObjectFactoryContract.assertObjectFactoryFillsContract;
34 import static org.jtiger.assertion.HashCodeMethodContract.assertHashCodeMethodFillsContract;
35 import static org.jtiger.assertion.EqualsMethodContract.assertEqualsMethodFillsContract;
36 
37 @Fixture(value = "TestResultBeanImpl", description = "Performs Unit Tests on org.jtiger.report.xml.TestResultBeanImpl")
38 @Category("org.jtiger.report.xml.TestResultBeanImpl")
39 public final class TestTestResultBeanImpl
40 {
TestTestResultBeanImpl()41     public TestTestResultBeanImpl()
42     {
43 
44     }
45 
46     @Test
constructors()47     public void constructors() throws RunnerException
48     {
49         assertEqual(0, new FixtureResultsBeanImpl().getFixtureResults().length);
50         final FixturesRunner runner = newFixturesRunner();
51         final FixturesRunnerConfig config = newFixturesRunnerConfig(
52                 newSequence(new Class<?>[]{DummyFixture1.class, DummyFixture2.class, DummyFixture3.class, DummyFixture4.class, DummyFixture5.class}), null, null, false);
53 
54         final org.jtiger.framework.FixtureResults results = runner.run(config);
55 
56         assertEqual(5, results.size());
57         assertEqual(12, results.get(0).size());
58     }
59 
60     @Test
accessors()61     public void accessors()
62     {
63         final TestResultBean bean = new TestResultBeanImpl();
64         final String[] categories = new String[]{"x", "y"};
65         final Long elapsedTime = 7L;
66         final Throwable exception = new IllegalArgumentException();
67         final Class<?> fixtureClass = getClass();
68         final String fixtureDescription = "fixture description";
69         final String fixtureName = "fixture name";
70         final String message = "message";
71         final String testDescription = "test description";
72         final String testMethodName = "testMethodName";
73         final String testName = "test name";
74         final String testResult = "Success";
75 
76         bean.setCategories(categories);
77         bean.setElapsedTime(elapsedTime);
78         bean.setException(exception);
79         bean.setFixtureClass(fixtureClass);
80         bean.setFixtureDescription(fixtureDescription);
81         bean.setFixtureName(fixtureName);
82         bean.setMessage(message);
83         bean.setTestDescription(testDescription);
84         bean.setTestMethodName(testMethodName);
85         bean.setTestName(testName);
86         bean.setTestResult(testResult);
87 
88         assertEqual(new String[]{"x", "y"}, bean.getCategories());
89         assertEqual(7L, bean.getElapsedTime());
90         assertEqual(exception, bean.getException());
91         assertSame(getClass(), bean.getFixtureClass());
92         assertEqual("fixture description", bean.getFixtureDescription());
93         assertEqual("fixture name", bean.getFixtureName());
94         assertEqual("message", bean.getMessage());
95         assertEqual("test description", bean.getTestDescription());
96         assertEqual("testMethodName", bean.getTestMethodName());
97         assertEqual("test name", bean.getTestName());
98         assertEqual("Success", bean.getTestResult());
99     }
100 
101     @Test
serialization()102     public void serialization()
103     {
104         final TestResultBean bean = new TestResultBeanImpl();
105         final String[] categories = new String[]{"x", "y"};
106         final Long elapsedTime = 7L;
107         final Throwable exception = new IllegalArgumentException();
108         final Class<?> fixtureClass = getClass();
109         final String fixtureDescription = "fixture description";
110         final String fixtureName = "fixture name";
111         final String message = "message";
112         final String testDescription = "test description";
113         final String testMethodName = "testMethodName";
114         final String testName = "test name";
115         final String testResult = "Success";
116 
117         bean.setCategories(categories);
118         bean.setElapsedTime(elapsedTime);
119         bean.setException(exception);
120         bean.setFixtureClass(fixtureClass);
121         bean.setFixtureDescription(fixtureDescription);
122         bean.setFixtureName(fixtureName);
123         bean.setMessage(message);
124         bean.setTestDescription(testDescription);
125         bean.setTestMethodName(testMethodName);
126         bean.setTestName(testName);
127         bean.setTestResult(testResult);
128 
129         assertSerializes(bean);
130         assertHasDeclaredField(bean.getClass(), "serialVersionUID");
131     }
132 
133     @Test
testToString()134     public void testToString()
135     {
136         final TestResultBean bean = new TestResultBeanImpl();
137         final String[] categories = new String[]{"x", "y"};
138         final Long elapsedTime = 7L;
139         final Throwable exception = new IllegalArgumentException();
140         final Class<?> fixtureClass = getClass();
141         final String fixtureDescription = "fixture description";
142         final String fixtureName = "fixture name";
143         final String message = "message";
144         final String testDescription = "test description";
145         final String testMethodName = "testMethodName";
146         final String testName = "test name";
147         final String testResult = "Success";
148 
149         bean.setCategories(categories);
150         bean.setElapsedTime(elapsedTime);
151         bean.setException(exception);
152         bean.setFixtureClass(fixtureClass);
153         bean.setFixtureDescription(fixtureDescription);
154         bean.setFixtureName(fixtureName);
155         bean.setMessage(message);
156         bean.setTestDescription(testDescription);
157         bean.setTestMethodName(testMethodName);
158         bean.setTestName(testName);
159         bean.setTestResult(testResult);
160 
161         final String s = "[" + testResult + "][" + message + "][" + exception + "][" + elapsedTime + "][" +
162                 Arrays.toString(categories) + "][" + testName + "][" + testDescription + "][" +
163                 testMethodName + "][" + fixtureName + "][" + fixtureDescription + "][" + fixtureClass + "]";
164 
165         assertEqual(s, bean.toString());
166     }
167 
168     @Test
equalsHashCode1()169     public void equalsHashCode1()
170     {
171         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
172         {
173             private final Throwable exception = new IllegalArgumentException();
174 
175             public TestResultBean newInstanceX()
176             {
177                 final TestResultBean bean1 = new TestResultBeanImpl();
178                 final String[] categories = new String[]{"x", "y"};
179                 final Long elapsedTime = 7L;
180                 final Throwable exception = this.exception;
181                 final Class<?> fixtureClass = getClass();
182                 final String fixtureDescription = "fixture description";
183                 final String fixtureName = "fixture name";
184                 final String message = "message";
185                 final String testDescription = "test description";
186                 final String testMethodName = "testMethodName";
187                 final String testName = "test name";
188                 final String testResult = "Success";
189 
190                 bean1.setCategories(categories);
191                 bean1.setElapsedTime(elapsedTime);
192                 bean1.setException(exception);
193                 bean1.setFixtureClass(fixtureClass);
194                 bean1.setFixtureDescription(fixtureDescription);
195                 bean1.setFixtureName(fixtureName);
196                 bean1.setMessage(message);
197                 bean1.setTestDescription(testDescription);
198                 bean1.setTestMethodName(testMethodName);
199                 bean1.setTestName(testName);
200                 bean1.setTestResult(testResult);
201                 return bean1;
202             }
203 
204             public TestResultBean newInstanceY()
205             {
206                 final TestResultBean bean1 = new TestResultBeanImpl();
207                 final String[] categories = new String[]{"y", "x"};
208                 final Long elapsedTime = 7L;
209                 final Throwable exception = this.exception;
210                 final Class<?> fixtureClass = getClass();
211                 final String fixtureDescription = "fixture description";
212                 final String fixtureName = "fixture name";
213                 final String message = "message";
214                 final String testDescription = "test description";
215                 final String testMethodName = "testMethodName";
216                 final String testName = "test name";
217                 final String testResult = "Success";
218 
219                 bean1.setCategories(categories);
220                 bean1.setElapsedTime(elapsedTime);
221                 bean1.setException(exception);
222                 bean1.setFixtureClass(fixtureClass);
223                 bean1.setFixtureDescription(fixtureDescription);
224                 bean1.setFixtureName(fixtureName);
225                 bean1.setMessage(message);
226                 bean1.setTestDescription(testDescription);
227                 bean1.setTestMethodName(testMethodName);
228                 bean1.setTestName(testName);
229                 bean1.setTestResult(testResult);
230                 return bean1;
231             }
232         };
233 
234         assertObjectFactoryFillsContract(factory);
235         assertHashCodeMethodFillsContract(factory);
236         assertEqualsMethodFillsContract(factory);
237     }
238 
239     @Test
equalsHashCode2()240     public void equalsHashCode2()
241     {
242         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
243         {
244             private final Throwable exception = new IllegalArgumentException();
245 
246             public TestResultBean newInstanceX()
247             {
248                 final TestResultBean bean1 = new TestResultBeanImpl();
249                 final String[] categories = new String[]{"x", "y"};
250                 final Long elapsedTime = 7L;
251                 final Throwable exception = this.exception;
252                 final Class<?> fixtureClass = getClass();
253                 final String fixtureDescription = "fixture description";
254                 final String fixtureName = "fixture name";
255                 final String message = "message";
256                 final String testDescription = "test description";
257                 final String testMethodName = "testMethodName";
258                 final String testName = "test name";
259                 final String testResult = "Success";
260 
261                 bean1.setCategories(categories);
262                 bean1.setElapsedTime(elapsedTime);
263                 bean1.setException(exception);
264                 bean1.setFixtureClass(fixtureClass);
265                 bean1.setFixtureDescription(fixtureDescription);
266                 bean1.setFixtureName(fixtureName);
267                 bean1.setMessage(message);
268                 bean1.setTestDescription(testDescription);
269                 bean1.setTestMethodName(testMethodName);
270                 bean1.setTestName(testName);
271                 bean1.setTestResult(testResult);
272                 return bean1;
273             }
274 
275             public TestResultBean newInstanceY()
276             {
277                 final TestResultBean bean1 = new TestResultBeanImpl();
278                 final String[] categories = new String[]{"x", "y"};
279                 final Long elapsedTime = 8L;
280                 final Throwable exception = this.exception;
281                 final Class<?> fixtureClass = getClass();
282                 final String fixtureDescription = "fixture description";
283                 final String fixtureName = "fixture name";
284                 final String message = "message";
285                 final String testDescription = "test description";
286                 final String testMethodName = "testMethodName";
287                 final String testName = "test name";
288                 final String testResult = "Success";
289 
290                 bean1.setCategories(categories);
291                 bean1.setElapsedTime(elapsedTime);
292                 bean1.setException(exception);
293                 bean1.setFixtureClass(fixtureClass);
294                 bean1.setFixtureDescription(fixtureDescription);
295                 bean1.setFixtureName(fixtureName);
296                 bean1.setMessage(message);
297                 bean1.setTestDescription(testDescription);
298                 bean1.setTestMethodName(testMethodName);
299                 bean1.setTestName(testName);
300                 bean1.setTestResult(testResult);
301                 return bean1;
302             }
303         };
304 
305         assertObjectFactoryFillsContract(factory);
306         assertHashCodeMethodFillsContract(factory);
307         assertEqualsMethodFillsContract(factory);
308     }
309 
310     @Test
equalsHashCode3()311     public void equalsHashCode3()
312     {
313         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
314         {
315             private final Throwable exception = new IllegalArgumentException();
316 
317             public TestResultBean newInstanceX()
318             {
319                 final TestResultBean bean1 = new TestResultBeanImpl();
320                 final String[] categories = new String[]{"x", "y"};
321                 final Long elapsedTime = 7L;
322                 final Throwable exception = this.exception;
323                 final Class<?> fixtureClass = getClass();
324                 final String fixtureDescription = "fixture description";
325                 final String fixtureName = "fixture name";
326                 final String message = "message";
327                 final String testDescription = "test description";
328                 final String testMethodName = "testMethodName";
329                 final String testName = "test name";
330                 final String testResult = "Success";
331 
332                 bean1.setCategories(categories);
333                 bean1.setElapsedTime(elapsedTime);
334                 bean1.setException(exception);
335                 bean1.setFixtureClass(fixtureClass);
336                 bean1.setFixtureDescription(fixtureDescription);
337                 bean1.setFixtureName(fixtureName);
338                 bean1.setMessage(message);
339                 bean1.setTestDescription(testDescription);
340                 bean1.setTestMethodName(testMethodName);
341                 bean1.setTestName(testName);
342                 bean1.setTestResult(testResult);
343                 return bean1;
344             }
345 
346             public TestResultBean newInstanceY()
347             {
348                 final TestResultBean bean1 = new TestResultBeanImpl();
349                 final String[] categories = new String[]{"x", "y"};
350                 final Long elapsedTime = 7L;
351                 final Throwable exception = null;
352                 final Class<?> fixtureClass = getClass();
353                 final String fixtureDescription = "fixture description";
354                 final String fixtureName = "fixture name";
355                 final String message = "message";
356                 final String testDescription = "test description";
357                 final String testMethodName = "testMethodName";
358                 final String testName = "test name";
359                 final String testResult = "Success";
360 
361                 bean1.setCategories(categories);
362                 bean1.setElapsedTime(elapsedTime);
363                 bean1.setException(exception);
364                 bean1.setFixtureClass(fixtureClass);
365                 bean1.setFixtureDescription(fixtureDescription);
366                 bean1.setFixtureName(fixtureName);
367                 bean1.setMessage(message);
368                 bean1.setTestDescription(testDescription);
369                 bean1.setTestMethodName(testMethodName);
370                 bean1.setTestName(testName);
371                 bean1.setTestResult(testResult);
372                 return bean1;
373             }
374         };
375 
376         assertObjectFactoryFillsContract(factory);
377         assertHashCodeMethodFillsContract(factory);
378         assertEqualsMethodFillsContract(factory);
379     }
380 
381     @Test
equalsHashCode4()382     public void equalsHashCode4()
383     {
384         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
385         {
386             private final Throwable exception = new IllegalArgumentException();
387 
388             public TestResultBean newInstanceX()
389             {
390                 final TestResultBean bean1 = new TestResultBeanImpl();
391                 final String[] categories = new String[]{"x", "y"};
392                 final Long elapsedTime = 7L;
393                 final Throwable exception = this.exception;
394                 final Class<?> fixtureClass = getClass();
395                 final String fixtureDescription = "fixture description";
396                 final String fixtureName = "fixture name";
397                 final String message = "message";
398                 final String testDescription = "test description";
399                 final String testMethodName = "testMethodName";
400                 final String testName = "test name";
401                 final String testResult = "Success";
402 
403                 bean1.setCategories(categories);
404                 bean1.setElapsedTime(elapsedTime);
405                 bean1.setException(exception);
406                 bean1.setFixtureClass(fixtureClass);
407                 bean1.setFixtureDescription(fixtureDescription);
408                 bean1.setFixtureName(fixtureName);
409                 bean1.setMessage(message);
410                 bean1.setTestDescription(testDescription);
411                 bean1.setTestMethodName(testMethodName);
412                 bean1.setTestName(testName);
413                 bean1.setTestResult(testResult);
414                 return bean1;
415             }
416 
417             public TestResultBean newInstanceY()
418             {
419                 final TestResultBean bean1 = new TestResultBeanImpl();
420                 final String[] categories = new String[]{"x", "y"};
421                 final Long elapsedTime = 7L;
422                 final Throwable exception = this.exception;
423                 final Class<?> fixtureClass = String.class;
424                 final String fixtureDescription = "fixture description";
425                 final String fixtureName = "fixture name";
426                 final String message = "message";
427                 final String testDescription = "test description";
428                 final String testMethodName = "testMethodName";
429                 final String testName = "test name";
430                 final String testResult = "Success";
431 
432                 bean1.setCategories(categories);
433                 bean1.setElapsedTime(elapsedTime);
434                 bean1.setException(exception);
435                 bean1.setFixtureClass(fixtureClass);
436                 bean1.setFixtureDescription(fixtureDescription);
437                 bean1.setFixtureName(fixtureName);
438                 bean1.setMessage(message);
439                 bean1.setTestDescription(testDescription);
440                 bean1.setTestMethodName(testMethodName);
441                 bean1.setTestName(testName);
442                 bean1.setTestResult(testResult);
443                 return bean1;
444             }
445         };
446 
447         assertObjectFactoryFillsContract(factory);
448         assertHashCodeMethodFillsContract(factory);
449         assertEqualsMethodFillsContract(factory);
450     }
451 
452     @Test
equalsHashCode5()453     public void equalsHashCode5()
454     {
455         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
456         {
457             private final Throwable exception = new IllegalArgumentException();
458 
459             public TestResultBean newInstanceX()
460             {
461                 final TestResultBean bean1 = new TestResultBeanImpl();
462                 final String[] categories = new String[]{"x", "y"};
463                 final Long elapsedTime = 7L;
464                 final Throwable exception = this.exception;
465                 final Class<?> fixtureClass = getClass();
466                 final String fixtureDescription = "fixture description";
467                 final String fixtureName = "fixture name";
468                 final String message = "message";
469                 final String testDescription = "test description";
470                 final String testMethodName = "testMethodName";
471                 final String testName = "test name";
472                 final String testResult = "Success";
473 
474                 bean1.setCategories(categories);
475                 bean1.setElapsedTime(elapsedTime);
476                 bean1.setException(exception);
477                 bean1.setFixtureClass(fixtureClass);
478                 bean1.setFixtureDescription(fixtureDescription);
479                 bean1.setFixtureName(fixtureName);
480                 bean1.setMessage(message);
481                 bean1.setTestDescription(testDescription);
482                 bean1.setTestMethodName(testMethodName);
483                 bean1.setTestName(testName);
484                 bean1.setTestResult(testResult);
485                 return bean1;
486             }
487 
488             public TestResultBean newInstanceY()
489             {
490                 final TestResultBean bean1 = new TestResultBeanImpl();
491                 final String[] categories = new String[]{"x", "y"};
492                 final Long elapsedTime = 7L;
493                 final Throwable exception = this.exception;
494                 final Class<?> fixtureClass = getClass();
495                 final String fixtureDescription = "fixture description x";
496                 final String fixtureName = "fixture name";
497                 final String message = "message";
498                 final String testDescription = "test description";
499                 final String testMethodName = "testMethodName";
500                 final String testName = "test name";
501                 final String testResult = "Success";
502 
503                 bean1.setCategories(categories);
504                 bean1.setElapsedTime(elapsedTime);
505                 bean1.setException(exception);
506                 bean1.setFixtureClass(fixtureClass);
507                 bean1.setFixtureDescription(fixtureDescription);
508                 bean1.setFixtureName(fixtureName);
509                 bean1.setMessage(message);
510                 bean1.setTestDescription(testDescription);
511                 bean1.setTestMethodName(testMethodName);
512                 bean1.setTestName(testName);
513                 bean1.setTestResult(testResult);
514                 return bean1;
515             }
516         };
517 
518         assertObjectFactoryFillsContract(factory);
519         assertHashCodeMethodFillsContract(factory);
520         assertEqualsMethodFillsContract(factory);
521     }
522 
523     @Test
equalsHashCode6()524     public void equalsHashCode6()
525     {
526         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
527         {
528             private final Throwable exception = new IllegalArgumentException();
529 
530             public TestResultBean newInstanceX()
531             {
532                 final TestResultBean bean1 = new TestResultBeanImpl();
533                 final String[] categories = new String[]{"x", "y"};
534                 final Long elapsedTime = 7L;
535                 final Throwable exception = this.exception;
536                 final Class<?> fixtureClass = getClass();
537                 final String fixtureDescription = "fixture description";
538                 final String fixtureName = "fixture name";
539                 final String message = "message";
540                 final String testDescription = "test description";
541                 final String testMethodName = "testMethodName";
542                 final String testName = "test name";
543                 final String testResult = "Success";
544 
545                 bean1.setCategories(categories);
546                 bean1.setElapsedTime(elapsedTime);
547                 bean1.setException(exception);
548                 bean1.setFixtureClass(fixtureClass);
549                 bean1.setFixtureDescription(fixtureDescription);
550                 bean1.setFixtureName(fixtureName);
551                 bean1.setMessage(message);
552                 bean1.setTestDescription(testDescription);
553                 bean1.setTestMethodName(testMethodName);
554                 bean1.setTestName(testName);
555                 bean1.setTestResult(testResult);
556                 return bean1;
557             }
558 
559             public TestResultBean newInstanceY()
560             {
561                 final TestResultBean bean1 = new TestResultBeanImpl();
562                 final String[] categories = new String[]{"x", "y"};
563                 final Long elapsedTime = 7L;
564                 final Throwable exception = this.exception;
565                 final Class<?> fixtureClass = getClass();
566                 final String fixtureDescription = "fixture description";
567                 final String fixtureName = "fixture name x";
568                 final String message = "message";
569                 final String testDescription = "test description";
570                 final String testMethodName = "testMethodName";
571                 final String testName = "test name";
572                 final String testResult = "Success";
573 
574                 bean1.setCategories(categories);
575                 bean1.setElapsedTime(elapsedTime);
576                 bean1.setException(exception);
577                 bean1.setFixtureClass(fixtureClass);
578                 bean1.setFixtureDescription(fixtureDescription);
579                 bean1.setFixtureName(fixtureName);
580                 bean1.setMessage(message);
581                 bean1.setTestDescription(testDescription);
582                 bean1.setTestMethodName(testMethodName);
583                 bean1.setTestName(testName);
584                 bean1.setTestResult(testResult);
585                 return bean1;
586             }
587         };
588 
589         assertObjectFactoryFillsContract(factory);
590         assertHashCodeMethodFillsContract(factory);
591         assertEqualsMethodFillsContract(factory);
592     }
593 
594     @Test
equalsHashCode7()595     public void equalsHashCode7()
596     {
597         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
598         {
599             private final Throwable exception = new IllegalArgumentException();
600 
601             public TestResultBean newInstanceX()
602             {
603                 final TestResultBean bean1 = new TestResultBeanImpl();
604                 final String[] categories = new String[]{"x", "y"};
605                 final Long elapsedTime = 7L;
606                 final Throwable exception = this.exception;
607                 final Class<?> fixtureClass = getClass();
608                 final String fixtureDescription = "fixture description";
609                 final String fixtureName = "fixture name";
610                 final String message = "message";
611                 final String testDescription = "test description";
612                 final String testMethodName = "testMethodName";
613                 final String testName = "test name";
614                 final String testResult = "Success";
615 
616                 bean1.setCategories(categories);
617                 bean1.setElapsedTime(elapsedTime);
618                 bean1.setException(exception);
619                 bean1.setFixtureClass(fixtureClass);
620                 bean1.setFixtureDescription(fixtureDescription);
621                 bean1.setFixtureName(fixtureName);
622                 bean1.setMessage(message);
623                 bean1.setTestDescription(testDescription);
624                 bean1.setTestMethodName(testMethodName);
625                 bean1.setTestName(testName);
626                 bean1.setTestResult(testResult);
627                 return bean1;
628             }
629 
630             public TestResultBean newInstanceY()
631             {
632                 final TestResultBean bean1 = new TestResultBeanImpl();
633                 final String[] categories = new String[]{"x", "y"};
634                 final Long elapsedTime = 7L;
635                 final Throwable exception = this.exception;
636                 final Class<?> fixtureClass = getClass();
637                 final String fixtureDescription = "fixture description";
638                 final String fixtureName = "fixture name";
639                 final String message = "message x";
640                 final String testDescription = "test description";
641                 final String testMethodName = "testMethodName";
642                 final String testName = "test name";
643                 final String testResult = "Success";
644 
645                 bean1.setCategories(categories);
646                 bean1.setElapsedTime(elapsedTime);
647                 bean1.setException(exception);
648                 bean1.setFixtureClass(fixtureClass);
649                 bean1.setFixtureDescription(fixtureDescription);
650                 bean1.setFixtureName(fixtureName);
651                 bean1.setMessage(message);
652                 bean1.setTestDescription(testDescription);
653                 bean1.setTestMethodName(testMethodName);
654                 bean1.setTestName(testName);
655                 bean1.setTestResult(testResult);
656                 return bean1;
657             }
658         };
659 
660         assertObjectFactoryFillsContract(factory);
661         assertHashCodeMethodFillsContract(factory);
662         assertEqualsMethodFillsContract(factory);
663     }
664 
665     @Test
equalsHashCode8()666     public void equalsHashCode8()
667     {
668         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
669         {
670             private final Throwable exception = new IllegalArgumentException();
671 
672             public TestResultBean newInstanceX()
673             {
674                 final TestResultBean bean1 = new TestResultBeanImpl();
675                 final String[] categories = new String[]{"x", "y"};
676                 final Long elapsedTime = 7L;
677                 final Throwable exception = this.exception;
678                 final Class<?> fixtureClass = getClass();
679                 final String fixtureDescription = "fixture description";
680                 final String fixtureName = "fixture name";
681                 final String message = "message";
682                 final String testDescription = "test description";
683                 final String testMethodName = "testMethodName";
684                 final String testName = "test name";
685                 final String testResult = "Success";
686 
687                 bean1.setCategories(categories);
688                 bean1.setElapsedTime(elapsedTime);
689                 bean1.setException(exception);
690                 bean1.setFixtureClass(fixtureClass);
691                 bean1.setFixtureDescription(fixtureDescription);
692                 bean1.setFixtureName(fixtureName);
693                 bean1.setMessage(message);
694                 bean1.setTestDescription(testDescription);
695                 bean1.setTestMethodName(testMethodName);
696                 bean1.setTestName(testName);
697                 bean1.setTestResult(testResult);
698                 return bean1;
699             }
700 
701             public TestResultBean newInstanceY()
702             {
703                 final TestResultBean bean1 = new TestResultBeanImpl();
704                 final String[] categories = new String[]{"x", "y"};
705                 final Long elapsedTime = 7L;
706                 final Throwable exception = this.exception;
707                 final Class<?> fixtureClass = getClass();
708                 final String fixtureDescription = "fixture description";
709                 final String fixtureName = "fixture name";
710                 final String message = "message";
711                 final String testDescription = "test description x";
712                 final String testMethodName = "testMethodName";
713                 final String testName = "test name";
714                 final String testResult = "Success";
715 
716                 bean1.setCategories(categories);
717                 bean1.setElapsedTime(elapsedTime);
718                 bean1.setException(exception);
719                 bean1.setFixtureClass(fixtureClass);
720                 bean1.setFixtureDescription(fixtureDescription);
721                 bean1.setFixtureName(fixtureName);
722                 bean1.setMessage(message);
723                 bean1.setTestDescription(testDescription);
724                 bean1.setTestMethodName(testMethodName);
725                 bean1.setTestName(testName);
726                 bean1.setTestResult(testResult);
727                 return bean1;
728             }
729         };
730 
731         assertObjectFactoryFillsContract(factory);
732         assertHashCodeMethodFillsContract(factory);
733         assertEqualsMethodFillsContract(factory);
734     }
735 
736     @Test
equalsHashCode9()737     public void equalsHashCode9()
738     {
739         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
740         {
741             private final Throwable exception = new IllegalArgumentException();
742 
743             public TestResultBean newInstanceX()
744             {
745                 final TestResultBean bean1 = new TestResultBeanImpl();
746                 final String[] categories = new String[]{"x", "y"};
747                 final Long elapsedTime = 7L;
748                 final Throwable exception = this.exception;
749                 final Class<?> fixtureClass = getClass();
750                 final String fixtureDescription = "fixture description";
751                 final String fixtureName = "fixture name";
752                 final String message = "message";
753                 final String testDescription = "test description";
754                 final String testMethodName = "testMethodName";
755                 final String testName = "test name";
756                 final String testResult = "Success";
757 
758                 bean1.setCategories(categories);
759                 bean1.setElapsedTime(elapsedTime);
760                 bean1.setException(exception);
761                 bean1.setFixtureClass(fixtureClass);
762                 bean1.setFixtureDescription(fixtureDescription);
763                 bean1.setFixtureName(fixtureName);
764                 bean1.setMessage(message);
765                 bean1.setTestDescription(testDescription);
766                 bean1.setTestMethodName(testMethodName);
767                 bean1.setTestName(testName);
768                 bean1.setTestResult(testResult);
769                 return bean1;
770             }
771 
772             public TestResultBean newInstanceY()
773             {
774                 final TestResultBean bean1 = new TestResultBeanImpl();
775                 final String[] categories = new String[]{"x", "y"};
776                 final Long elapsedTime = 7L;
777                 final Throwable exception = this.exception;
778                 final Class<?> fixtureClass = getClass();
779                 final String fixtureDescription = "fixture description";
780                 final String fixtureName = "fixture name";
781                 final String message = "message";
782                 final String testDescription = "test description";
783                 final String testMethodName = "testMethodNameX";
784                 final String testName = "test name";
785                 final String testResult = "Success";
786 
787                 bean1.setCategories(categories);
788                 bean1.setElapsedTime(elapsedTime);
789                 bean1.setException(exception);
790                 bean1.setFixtureClass(fixtureClass);
791                 bean1.setFixtureDescription(fixtureDescription);
792                 bean1.setFixtureName(fixtureName);
793                 bean1.setMessage(message);
794                 bean1.setTestDescription(testDescription);
795                 bean1.setTestMethodName(testMethodName);
796                 bean1.setTestName(testName);
797                 bean1.setTestResult(testResult);
798                 return bean1;
799             }
800         };
801 
802         assertObjectFactoryFillsContract(factory);
803         assertHashCodeMethodFillsContract(factory);
804         assertEqualsMethodFillsContract(factory);
805     }
806 
807     @Test
equalsHashCode10()808     public void equalsHashCode10()
809     {
810         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
811         {
812             private final Throwable exception = new IllegalArgumentException();
813 
814             public TestResultBean newInstanceX()
815             {
816                 final TestResultBean bean1 = new TestResultBeanImpl();
817                 final String[] categories = new String[]{"x", "y"};
818                 final Long elapsedTime = 7L;
819                 final Throwable exception = this.exception;
820                 final Class<?> fixtureClass = getClass();
821                 final String fixtureDescription = "fixture description";
822                 final String fixtureName = "fixture name";
823                 final String message = "message";
824                 final String testDescription = "test description";
825                 final String testMethodName = "testMethodName";
826                 final String testName = "test name";
827                 final String testResult = "Success";
828 
829                 bean1.setCategories(categories);
830                 bean1.setElapsedTime(elapsedTime);
831                 bean1.setException(exception);
832                 bean1.setFixtureClass(fixtureClass);
833                 bean1.setFixtureDescription(fixtureDescription);
834                 bean1.setFixtureName(fixtureName);
835                 bean1.setMessage(message);
836                 bean1.setTestDescription(testDescription);
837                 bean1.setTestMethodName(testMethodName);
838                 bean1.setTestName(testName);
839                 bean1.setTestResult(testResult);
840                 return bean1;
841             }
842 
843             public TestResultBean newInstanceY()
844             {
845                 final TestResultBean bean1 = new TestResultBeanImpl();
846                 final String[] categories = new String[]{"x", "y"};
847                 final Long elapsedTime = 7L;
848                 final Throwable exception = this.exception;
849                 final Class<?> fixtureClass = getClass();
850                 final String fixtureDescription = "fixture description";
851                 final String fixtureName = "fixture name";
852                 final String message = "message";
853                 final String testDescription = "test description";
854                 final String testMethodName = "testMethodName";
855                 final String testName = "test name x";
856                 final String testResult = "Success";
857 
858                 bean1.setCategories(categories);
859                 bean1.setElapsedTime(elapsedTime);
860                 bean1.setException(exception);
861                 bean1.setFixtureClass(fixtureClass);
862                 bean1.setFixtureDescription(fixtureDescription);
863                 bean1.setFixtureName(fixtureName);
864                 bean1.setMessage(message);
865                 bean1.setTestDescription(testDescription);
866                 bean1.setTestMethodName(testMethodName);
867                 bean1.setTestName(testName);
868                 bean1.setTestResult(testResult);
869                 return bean1;
870             }
871         };
872 
873         assertObjectFactoryFillsContract(factory);
874         assertHashCodeMethodFillsContract(factory);
875         assertEqualsMethodFillsContract(factory);
876     }
877 
878     @Test
equalsHashCode11()879     public void equalsHashCode11()
880     {
881         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
882         {
883             private final Throwable exception = new IllegalArgumentException();
884 
885             public TestResultBean newInstanceX()
886             {
887                 final TestResultBean bean1 = new TestResultBeanImpl();
888                 final String[] categories = new String[]{"x", "y"};
889                 final Long elapsedTime = 7L;
890                 final Throwable exception = this.exception;
891                 final Class<?> fixtureClass = getClass();
892                 final String fixtureDescription = "fixture description";
893                 final String fixtureName = "fixture name";
894                 final String message = "message";
895                 final String testDescription = "test description";
896                 final String testMethodName = "testMethodName";
897                 final String testName = "test name";
898                 final String testResult = "Success";
899 
900                 bean1.setCategories(categories);
901                 bean1.setElapsedTime(elapsedTime);
902                 bean1.setException(exception);
903                 bean1.setFixtureClass(fixtureClass);
904                 bean1.setFixtureDescription(fixtureDescription);
905                 bean1.setFixtureName(fixtureName);
906                 bean1.setMessage(message);
907                 bean1.setTestDescription(testDescription);
908                 bean1.setTestMethodName(testMethodName);
909                 bean1.setTestName(testName);
910                 bean1.setTestResult(testResult);
911                 return bean1;
912             }
913 
914             public TestResultBean newInstanceY()
915             {
916                 final TestResultBean bean1 = new TestResultBeanImpl();
917                 final String[] categories = new String[]{"x", "y"};
918                 final Long elapsedTime = 7L;
919                 final Throwable exception = this.exception;
920                 final Class<?> fixtureClass = getClass();
921                 final String fixtureDescription = "fixture description";
922                 final String fixtureName = "fixture name";
923                 final String message = "message";
924                 final String testDescription = "test description";
925                 final String testMethodName = "testMethodName";
926                 final String testName = "test name";
927                 final String testResult = "Failure";
928 
929                 bean1.setCategories(categories);
930                 bean1.setElapsedTime(elapsedTime);
931                 bean1.setException(exception);
932                 bean1.setFixtureClass(fixtureClass);
933                 bean1.setFixtureDescription(fixtureDescription);
934                 bean1.setFixtureName(fixtureName);
935                 bean1.setMessage(message);
936                 bean1.setTestDescription(testDescription);
937                 bean1.setTestMethodName(testMethodName);
938                 bean1.setTestName(testName);
939                 bean1.setTestResult(testResult);
940                 return bean1;
941             }
942         };
943 
944         assertObjectFactoryFillsContract(factory);
945         assertHashCodeMethodFillsContract(factory);
946         assertEqualsMethodFillsContract(factory);
947     }
948 
949     @Test
equalsHashCode12()950     public void equalsHashCode12()
951     {
952         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
953         {
954             private final Throwable exception = new IllegalArgumentException();
955 
956             public TestResultBean newInstanceX()
957             {
958                 final TestResultBean bean1 = new TestResultBeanImpl();
959                 final String[] categories = new String[]{"x", "y"};
960                 final Long elapsedTime = 7L;
961                 final Throwable exception = this.exception;
962                 final Class<?> fixtureClass = getClass();
963                 final String fixtureDescription = "fixture description";
964                 final String fixtureName = "fixture name";
965                 final String message = "message";
966                 final String testDescription = "test description";
967                 final String testMethodName = "testMethodName";
968                 final String testName = "test name";
969                 final String testResult = "Success";
970 
971                 bean1.setCategories(categories);
972                 bean1.setElapsedTime(elapsedTime);
973                 bean1.setException(exception);
974                 bean1.setFixtureClass(fixtureClass);
975                 bean1.setFixtureDescription(fixtureDescription);
976                 bean1.setFixtureName(fixtureName);
977                 bean1.setMessage(message);
978                 bean1.setTestDescription(testDescription);
979                 bean1.setTestMethodName(testMethodName);
980                 bean1.setTestName(testName);
981                 bean1.setTestResult(testResult);
982                 return bean1;
983             }
984 
985             public TestResultBean newInstanceY()
986             {
987                 final TestResultBean bean1 = new TestResultBeanImpl();
988                 final String[] categories = null;
989                 final Long elapsedTime = 7L;
990                 final Throwable exception = this.exception;
991                 final Class<?> fixtureClass = getClass();
992                 final String fixtureDescription = "fixture description";
993                 final String fixtureName = "fixture name";
994                 final String message = "message";
995                 final String testDescription = "test description";
996                 final String testMethodName = "testMethodName";
997                 final String testName = "test name";
998                 final String testResult = "Success";
999 
1000                 bean1.setCategories(categories);
1001                 bean1.setElapsedTime(elapsedTime);
1002                 bean1.setException(exception);
1003                 bean1.setFixtureClass(fixtureClass);
1004                 bean1.setFixtureDescription(fixtureDescription);
1005                 bean1.setFixtureName(fixtureName);
1006                 bean1.setMessage(message);
1007                 bean1.setTestDescription(testDescription);
1008                 bean1.setTestMethodName(testMethodName);
1009                 bean1.setTestName(testName);
1010                 bean1.setTestResult(testResult);
1011                 return bean1;
1012             }
1013         };
1014 
1015         assertObjectFactoryFillsContract(factory);
1016         assertHashCodeMethodFillsContract(factory);
1017         assertEqualsMethodFillsContract(factory);
1018     }
1019 
1020     @Test
equalsHashCode13()1021     public void equalsHashCode13()
1022     {
1023         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
1024         {
1025             private final Throwable exception = new IllegalArgumentException();
1026 
1027             public TestResultBean newInstanceX()
1028             {
1029                 final TestResultBean bean1 = new TestResultBeanImpl();
1030                 final String[] categories = new String[]{"x", "y"};
1031                 final Long elapsedTime = 7L;
1032                 final Throwable exception = this.exception;
1033                 final Class<?> fixtureClass = getClass();
1034                 final String fixtureDescription = "fixture description";
1035                 final String fixtureName = "fixture name";
1036                 final String message = "message";
1037                 final String testDescription = "test description";
1038                 final String testMethodName = "testMethodName";
1039                 final String testName = "test name";
1040                 final String testResult = "Success";
1041 
1042                 bean1.setCategories(categories);
1043                 bean1.setElapsedTime(elapsedTime);
1044                 bean1.setException(exception);
1045                 bean1.setFixtureClass(fixtureClass);
1046                 bean1.setFixtureDescription(fixtureDescription);
1047                 bean1.setFixtureName(fixtureName);
1048                 bean1.setMessage(message);
1049                 bean1.setTestDescription(testDescription);
1050                 bean1.setTestMethodName(testMethodName);
1051                 bean1.setTestName(testName);
1052                 bean1.setTestResult(testResult);
1053                 return bean1;
1054             }
1055 
1056             public TestResultBean newInstanceY()
1057             {
1058                 final TestResultBean bean1 = new TestResultBeanImpl();
1059                 final String[] categories = new String[]{"x", "y"};
1060                 final Long elapsedTime = null;
1061                 final Throwable exception = this.exception;
1062                 final Class<?> fixtureClass = getClass();
1063                 final String fixtureDescription = "fixture description";
1064                 final String fixtureName = "fixture name";
1065                 final String message = "message";
1066                 final String testDescription = "test description";
1067                 final String testMethodName = "testMethodName";
1068                 final String testName = "test name";
1069                 final String testResult = "Success";
1070 
1071                 bean1.setCategories(categories);
1072                 bean1.setElapsedTime(elapsedTime);
1073                 bean1.setException(exception);
1074                 bean1.setFixtureClass(fixtureClass);
1075                 bean1.setFixtureDescription(fixtureDescription);
1076                 bean1.setFixtureName(fixtureName);
1077                 bean1.setMessage(message);
1078                 bean1.setTestDescription(testDescription);
1079                 bean1.setTestMethodName(testMethodName);
1080                 bean1.setTestName(testName);
1081                 bean1.setTestResult(testResult);
1082                 return bean1;
1083             }
1084         };
1085 
1086         assertObjectFactoryFillsContract(factory);
1087         assertHashCodeMethodFillsContract(factory);
1088         assertEqualsMethodFillsContract(factory);
1089     }
1090 
1091     @Test
equalsHashCode14()1092     public void equalsHashCode14()
1093     {
1094         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
1095         {
1096             private final Throwable exception = new IllegalArgumentException();
1097 
1098             public TestResultBean newInstanceX()
1099             {
1100                 final TestResultBean bean1 = new TestResultBeanImpl();
1101                 final String[] categories = new String[]{"x", "y"};
1102                 final Long elapsedTime = 7L;
1103                 final Throwable exception = this.exception;
1104                 final Class<?> fixtureClass = getClass();
1105                 final String fixtureDescription = "fixture description";
1106                 final String fixtureName = "fixture name";
1107                 final String message = "message";
1108                 final String testDescription = "test description";
1109                 final String testMethodName = "testMethodName";
1110                 final String testName = "test name";
1111                 final String testResult = "Success";
1112 
1113                 bean1.setCategories(categories);
1114                 bean1.setElapsedTime(elapsedTime);
1115                 bean1.setException(exception);
1116                 bean1.setFixtureClass(fixtureClass);
1117                 bean1.setFixtureDescription(fixtureDescription);
1118                 bean1.setFixtureName(fixtureName);
1119                 bean1.setMessage(message);
1120                 bean1.setTestDescription(testDescription);
1121                 bean1.setTestMethodName(testMethodName);
1122                 bean1.setTestName(testName);
1123                 bean1.setTestResult(testResult);
1124                 return bean1;
1125             }
1126 
1127             public TestResultBean newInstanceY()
1128             {
1129                 final TestResultBean bean1 = new TestResultBeanImpl();
1130                 final String[] categories = null;
1131                 final Long elapsedTime = 7L;
1132                 final Throwable exception = null;
1133                 final Class<?> fixtureClass = getClass();
1134                 final String fixtureDescription = "fixture description";
1135                 final String fixtureName = "fixture name";
1136                 final String message = "message";
1137                 final String testDescription = "test description";
1138                 final String testMethodName = "testMethodName";
1139                 final String testName = "test name";
1140                 final String testResult = "Success";
1141 
1142                 bean1.setCategories(categories);
1143                 bean1.setElapsedTime(elapsedTime);
1144                 bean1.setException(exception);
1145                 bean1.setFixtureClass(fixtureClass);
1146                 bean1.setFixtureDescription(fixtureDescription);
1147                 bean1.setFixtureName(fixtureName);
1148                 bean1.setMessage(message);
1149                 bean1.setTestDescription(testDescription);
1150                 bean1.setTestMethodName(testMethodName);
1151                 bean1.setTestName(testName);
1152                 bean1.setTestResult(testResult);
1153                 return bean1;
1154             }
1155         };
1156 
1157         assertObjectFactoryFillsContract(factory);
1158         assertHashCodeMethodFillsContract(factory);
1159         assertEqualsMethodFillsContract(factory);
1160     }
1161 
1162     @Test
equalsHashCode15()1163     public void equalsHashCode15()
1164     {
1165         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
1166         {
1167             private final Throwable exception = new IllegalArgumentException();
1168 
1169             public TestResultBean newInstanceX()
1170             {
1171                 final TestResultBean bean1 = new TestResultBeanImpl();
1172                 final String[] categories = new String[]{"x", "y"};
1173                 final Long elapsedTime = 7L;
1174                 final Throwable exception = this.exception;
1175                 final Class<?> fixtureClass = getClass();
1176                 final String fixtureDescription = "fixture description";
1177                 final String fixtureName = "fixture name";
1178                 final String message = "message";
1179                 final String testDescription = "test description";
1180                 final String testMethodName = "testMethodName";
1181                 final String testName = "test name";
1182                 final String testResult = "Success";
1183 
1184                 bean1.setCategories(categories);
1185                 bean1.setElapsedTime(elapsedTime);
1186                 bean1.setException(exception);
1187                 bean1.setFixtureClass(fixtureClass);
1188                 bean1.setFixtureDescription(fixtureDescription);
1189                 bean1.setFixtureName(fixtureName);
1190                 bean1.setMessage(message);
1191                 bean1.setTestDescription(testDescription);
1192                 bean1.setTestMethodName(testMethodName);
1193                 bean1.setTestName(testName);
1194                 bean1.setTestResult(testResult);
1195                 return bean1;
1196             }
1197 
1198             public TestResultBean newInstanceY()
1199             {
1200                 final TestResultBean bean1 = new TestResultBeanImpl();
1201                 final String[] categories = null;
1202                 final Long elapsedTime = 7L;
1203                 final Throwable exception = this.exception;
1204                 final Class<?> fixtureClass = null;
1205                 final String fixtureDescription = "fixture description";
1206                 final String fixtureName = "fixture name";
1207                 final String message = "message";
1208                 final String testDescription = "test description";
1209                 final String testMethodName = "testMethodName";
1210                 final String testName = "test name";
1211                 final String testResult = "Success";
1212 
1213                 bean1.setCategories(categories);
1214                 bean1.setElapsedTime(elapsedTime);
1215                 bean1.setException(exception);
1216                 bean1.setFixtureClass(fixtureClass);
1217                 bean1.setFixtureDescription(fixtureDescription);
1218                 bean1.setFixtureName(fixtureName);
1219                 bean1.setMessage(message);
1220                 bean1.setTestDescription(testDescription);
1221                 bean1.setTestMethodName(testMethodName);
1222                 bean1.setTestName(testName);
1223                 bean1.setTestResult(testResult);
1224                 return bean1;
1225             }
1226         };
1227 
1228         assertObjectFactoryFillsContract(factory);
1229         assertHashCodeMethodFillsContract(factory);
1230         assertEqualsMethodFillsContract(factory);
1231     }
1232 
1233     @Test
equalsHashCode16()1234     public void equalsHashCode16()
1235     {
1236         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
1237         {
1238             private final Throwable exception = new IllegalArgumentException();
1239 
1240             public TestResultBean newInstanceX()
1241             {
1242                 final TestResultBean bean1 = new TestResultBeanImpl();
1243                 final String[] categories = new String[]{"x", "y"};
1244                 final Long elapsedTime = 7L;
1245                 final Throwable exception = this.exception;
1246                 final Class<?> fixtureClass = getClass();
1247                 final String fixtureDescription = "fixture description";
1248                 final String fixtureName = "fixture name";
1249                 final String message = "message";
1250                 final String testDescription = "test description";
1251                 final String testMethodName = "testMethodName";
1252                 final String testName = "test name";
1253                 final String testResult = "Success";
1254 
1255                 bean1.setCategories(categories);
1256                 bean1.setElapsedTime(elapsedTime);
1257                 bean1.setException(exception);
1258                 bean1.setFixtureClass(fixtureClass);
1259                 bean1.setFixtureDescription(fixtureDescription);
1260                 bean1.setFixtureName(fixtureName);
1261                 bean1.setMessage(message);
1262                 bean1.setTestDescription(testDescription);
1263                 bean1.setTestMethodName(testMethodName);
1264                 bean1.setTestName(testName);
1265                 bean1.setTestResult(testResult);
1266                 return bean1;
1267             }
1268 
1269             public TestResultBean newInstanceY()
1270             {
1271                 final TestResultBean bean1 = new TestResultBeanImpl();
1272                 final String[] categories = null;
1273                 final Long elapsedTime = 7L;
1274                 final Throwable exception = this.exception;
1275                 final Class<?> fixtureClass = getClass();
1276                 final String fixtureDescription = null;
1277                 final String fixtureName = "fixture name";
1278                 final String message = "message";
1279                 final String testDescription = "test description";
1280                 final String testMethodName = "testMethodName";
1281                 final String testName = "test name";
1282                 final String testResult = "Success";
1283 
1284                 bean1.setCategories(categories);
1285                 bean1.setElapsedTime(elapsedTime);
1286                 bean1.setException(exception);
1287                 bean1.setFixtureClass(fixtureClass);
1288                 bean1.setFixtureDescription(fixtureDescription);
1289                 bean1.setFixtureName(fixtureName);
1290                 bean1.setMessage(message);
1291                 bean1.setTestDescription(testDescription);
1292                 bean1.setTestMethodName(testMethodName);
1293                 bean1.setTestName(testName);
1294                 bean1.setTestResult(testResult);
1295                 return bean1;
1296             }
1297         };
1298 
1299         assertObjectFactoryFillsContract(factory);
1300         assertHashCodeMethodFillsContract(factory);
1301         assertEqualsMethodFillsContract(factory);
1302     }
1303 
1304     @Test
equalsHashCode17()1305     public void equalsHashCode17()
1306     {
1307         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
1308         {
1309             private final Throwable exception = new IllegalArgumentException();
1310 
1311             public TestResultBean newInstanceX()
1312             {
1313                 final TestResultBean bean1 = new TestResultBeanImpl();
1314                 final String[] categories = new String[]{"x", "y"};
1315                 final Long elapsedTime = 7L;
1316                 final Throwable exception = this.exception;
1317                 final Class<?> fixtureClass = getClass();
1318                 final String fixtureDescription = "fixture description";
1319                 final String fixtureName = "fixture name";
1320                 final String message = "message";
1321                 final String testDescription = "test description";
1322                 final String testMethodName = "testMethodName";
1323                 final String testName = "test name";
1324                 final String testResult = "Success";
1325 
1326                 bean1.setCategories(categories);
1327                 bean1.setElapsedTime(elapsedTime);
1328                 bean1.setException(exception);
1329                 bean1.setFixtureClass(fixtureClass);
1330                 bean1.setFixtureDescription(fixtureDescription);
1331                 bean1.setFixtureName(fixtureName);
1332                 bean1.setMessage(message);
1333                 bean1.setTestDescription(testDescription);
1334                 bean1.setTestMethodName(testMethodName);
1335                 bean1.setTestName(testName);
1336                 bean1.setTestResult(testResult);
1337                 return bean1;
1338             }
1339 
1340             public TestResultBean newInstanceY()
1341             {
1342                 final TestResultBean bean1 = new TestResultBeanImpl();
1343                 final String[] categories = null;
1344                 final Long elapsedTime = 7L;
1345                 final Throwable exception = this.exception;
1346                 final Class<?> fixtureClass = getClass();
1347                 final String fixtureDescription = "fixture description";
1348                 final String fixtureName = null;
1349                 final String message = "message";
1350                 final String testDescription = "test description";
1351                 final String testMethodName = "testMethodName";
1352                 final String testName = "test name";
1353                 final String testResult = "Success";
1354 
1355                 bean1.setCategories(categories);
1356                 bean1.setElapsedTime(elapsedTime);
1357                 bean1.setException(exception);
1358                 bean1.setFixtureClass(fixtureClass);
1359                 bean1.setFixtureDescription(fixtureDescription);
1360                 bean1.setFixtureName(fixtureName);
1361                 bean1.setMessage(message);
1362                 bean1.setTestDescription(testDescription);
1363                 bean1.setTestMethodName(testMethodName);
1364                 bean1.setTestName(testName);
1365                 bean1.setTestResult(testResult);
1366                 return bean1;
1367             }
1368         };
1369 
1370         assertObjectFactoryFillsContract(factory);
1371         assertHashCodeMethodFillsContract(factory);
1372         assertEqualsMethodFillsContract(factory);
1373     }
1374 
1375     @Test
equalsHashCode18()1376     public void equalsHashCode18()
1377     {
1378         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
1379         {
1380             private final Throwable exception = new IllegalArgumentException();
1381 
1382             public TestResultBean newInstanceX()
1383             {
1384                 final TestResultBean bean1 = new TestResultBeanImpl();
1385                 final String[] categories = new String[]{"x", "y"};
1386                 final Long elapsedTime = 7L;
1387                 final Throwable exception = this.exception;
1388                 final Class<?> fixtureClass = getClass();
1389                 final String fixtureDescription = "fixture description";
1390                 final String fixtureName = "fixture name";
1391                 final String message = "message";
1392                 final String testDescription = "test description";
1393                 final String testMethodName = "testMethodName";
1394                 final String testName = "test name";
1395                 final String testResult = "Success";
1396 
1397                 bean1.setCategories(categories);
1398                 bean1.setElapsedTime(elapsedTime);
1399                 bean1.setException(exception);
1400                 bean1.setFixtureClass(fixtureClass);
1401                 bean1.setFixtureDescription(fixtureDescription);
1402                 bean1.setFixtureName(fixtureName);
1403                 bean1.setMessage(message);
1404                 bean1.setTestDescription(testDescription);
1405                 bean1.setTestMethodName(testMethodName);
1406                 bean1.setTestName(testName);
1407                 bean1.setTestResult(testResult);
1408                 return bean1;
1409             }
1410 
1411             public TestResultBean newInstanceY()
1412             {
1413                 final TestResultBean bean1 = new TestResultBeanImpl();
1414                 final String[] categories = null;
1415                 final Long elapsedTime = 7L;
1416                 final Throwable exception = this.exception;
1417                 final Class<?> fixtureClass = getClass();
1418                 final String fixtureDescription = "fixture description";
1419                 final String fixtureName = "fixture name";
1420                 final String message = null;
1421                 final String testDescription = "test description";
1422                 final String testMethodName = "testMethodName";
1423                 final String testName = "test name";
1424                 final String testResult = "Success";
1425 
1426                 bean1.setCategories(categories);
1427                 bean1.setElapsedTime(elapsedTime);
1428                 bean1.setException(exception);
1429                 bean1.setFixtureClass(fixtureClass);
1430                 bean1.setFixtureDescription(fixtureDescription);
1431                 bean1.setFixtureName(fixtureName);
1432                 bean1.setMessage(message);
1433                 bean1.setTestDescription(testDescription);
1434                 bean1.setTestMethodName(testMethodName);
1435                 bean1.setTestName(testName);
1436                 bean1.setTestResult(testResult);
1437                 return bean1;
1438             }
1439         };
1440 
1441         assertObjectFactoryFillsContract(factory);
1442         assertHashCodeMethodFillsContract(factory);
1443         assertEqualsMethodFillsContract(factory);
1444     }
1445 
1446     @Test
equalsHashCode19()1447     public void equalsHashCode19()
1448     {
1449         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
1450         {
1451             private final Throwable exception = new IllegalArgumentException();
1452 
1453             public TestResultBean newInstanceX()
1454             {
1455                 final TestResultBean bean1 = new TestResultBeanImpl();
1456                 final String[] categories = new String[]{"x", "y"};
1457                 final Long elapsedTime = 7L;
1458                 final Throwable exception = this.exception;
1459                 final Class<?> fixtureClass = getClass();
1460                 final String fixtureDescription = "fixture description";
1461                 final String fixtureName = "fixture name";
1462                 final String message = "message";
1463                 final String testDescription = "test description";
1464                 final String testMethodName = "testMethodName";
1465                 final String testName = "test name";
1466                 final String testResult = "Success";
1467 
1468                 bean1.setCategories(categories);
1469                 bean1.setElapsedTime(elapsedTime);
1470                 bean1.setException(exception);
1471                 bean1.setFixtureClass(fixtureClass);
1472                 bean1.setFixtureDescription(fixtureDescription);
1473                 bean1.setFixtureName(fixtureName);
1474                 bean1.setMessage(message);
1475                 bean1.setTestDescription(testDescription);
1476                 bean1.setTestMethodName(testMethodName);
1477                 bean1.setTestName(testName);
1478                 bean1.setTestResult(testResult);
1479                 return bean1;
1480             }
1481 
1482             public TestResultBean newInstanceY()
1483             {
1484                 final TestResultBean bean1 = new TestResultBeanImpl();
1485                 final String[] categories = null;
1486                 final Long elapsedTime = 7L;
1487                 final Throwable exception = this.exception;
1488                 final Class<?> fixtureClass = getClass();
1489                 final String fixtureDescription = "fixture description";
1490                 final String fixtureName = "fixture name";
1491                 final String message = "message";
1492                 final String testDescription = null;
1493                 final String testMethodName = "testMethodName";
1494                 final String testName = "test name";
1495                 final String testResult = "Success";
1496 
1497                 bean1.setCategories(categories);
1498                 bean1.setElapsedTime(elapsedTime);
1499                 bean1.setException(exception);
1500                 bean1.setFixtureClass(fixtureClass);
1501                 bean1.setFixtureDescription(fixtureDescription);
1502                 bean1.setFixtureName(fixtureName);
1503                 bean1.setMessage(message);
1504                 bean1.setTestDescription(testDescription);
1505                 bean1.setTestMethodName(testMethodName);
1506                 bean1.setTestName(testName);
1507                 bean1.setTestResult(testResult);
1508                 return bean1;
1509             }
1510         };
1511 
1512         assertObjectFactoryFillsContract(factory);
1513         assertHashCodeMethodFillsContract(factory);
1514         assertEqualsMethodFillsContract(factory);
1515     }
1516 
1517     @Test
equalsHashCode20()1518     public void equalsHashCode20()
1519     {
1520         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
1521         {
1522             private final Throwable exception = new IllegalArgumentException();
1523 
1524             public TestResultBean newInstanceX()
1525             {
1526                 final TestResultBean bean1 = new TestResultBeanImpl();
1527                 final String[] categories = new String[]{"x", "y"};
1528                 final Long elapsedTime = 7L;
1529                 final Throwable exception = this.exception;
1530                 final Class<?> fixtureClass = getClass();
1531                 final String fixtureDescription = "fixture description";
1532                 final String fixtureName = "fixture name";
1533                 final String message = "message";
1534                 final String testDescription = "test description";
1535                 final String testMethodName = "testMethodName";
1536                 final String testName = "test name";
1537                 final String testResult = "Success";
1538 
1539                 bean1.setCategories(categories);
1540                 bean1.setElapsedTime(elapsedTime);
1541                 bean1.setException(exception);
1542                 bean1.setFixtureClass(fixtureClass);
1543                 bean1.setFixtureDescription(fixtureDescription);
1544                 bean1.setFixtureName(fixtureName);
1545                 bean1.setMessage(message);
1546                 bean1.setTestDescription(testDescription);
1547                 bean1.setTestMethodName(testMethodName);
1548                 bean1.setTestName(testName);
1549                 bean1.setTestResult(testResult);
1550                 return bean1;
1551             }
1552 
1553             public TestResultBean newInstanceY()
1554             {
1555                 final TestResultBean bean1 = new TestResultBeanImpl();
1556                 final String[] categories = null;
1557                 final Long elapsedTime = 7L;
1558                 final Throwable exception = this.exception;
1559                 final Class<?> fixtureClass = getClass();
1560                 final String fixtureDescription = "fixture description";
1561                 final String fixtureName = "fixture name";
1562                 final String message = "message";
1563                 final String testDescription = "test description";
1564                 final String testMethodName = null;
1565                 final String testName = "test name";
1566                 final String testResult = "Success";
1567 
1568                 bean1.setCategories(categories);
1569                 bean1.setElapsedTime(elapsedTime);
1570                 bean1.setException(exception);
1571                 bean1.setFixtureClass(fixtureClass);
1572                 bean1.setFixtureDescription(fixtureDescription);
1573                 bean1.setFixtureName(fixtureName);
1574                 bean1.setMessage(message);
1575                 bean1.setTestDescription(testDescription);
1576                 bean1.setTestMethodName(testMethodName);
1577                 bean1.setTestName(testName);
1578                 bean1.setTestResult(testResult);
1579                 return bean1;
1580             }
1581         };
1582 
1583         assertObjectFactoryFillsContract(factory);
1584         assertHashCodeMethodFillsContract(factory);
1585         assertEqualsMethodFillsContract(factory);
1586     }
1587 
1588     @Test
equalsHashCode21()1589     public void equalsHashCode21()
1590     {
1591         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
1592         {
1593             private final Throwable exception = new IllegalArgumentException();
1594 
1595             public TestResultBean newInstanceX()
1596             {
1597                 final TestResultBean bean1 = new TestResultBeanImpl();
1598                 final String[] categories = new String[]{"x", "y"};
1599                 final Long elapsedTime = 7L;
1600                 final Throwable exception = this.exception;
1601                 final Class<?> fixtureClass = getClass();
1602                 final String fixtureDescription = "fixture description";
1603                 final String fixtureName = "fixture name";
1604                 final String message = "message";
1605                 final String testDescription = "test description";
1606                 final String testMethodName = "testMethodName";
1607                 final String testName = "test name";
1608                 final String testResult = "Success";
1609 
1610                 bean1.setCategories(categories);
1611                 bean1.setElapsedTime(elapsedTime);
1612                 bean1.setException(exception);
1613                 bean1.setFixtureClass(fixtureClass);
1614                 bean1.setFixtureDescription(fixtureDescription);
1615                 bean1.setFixtureName(fixtureName);
1616                 bean1.setMessage(message);
1617                 bean1.setTestDescription(testDescription);
1618                 bean1.setTestMethodName(testMethodName);
1619                 bean1.setTestName(testName);
1620                 bean1.setTestResult(testResult);
1621                 return bean1;
1622             }
1623 
1624             public TestResultBean newInstanceY()
1625             {
1626                 final TestResultBean bean1 = new TestResultBeanImpl();
1627                 final String[] categories = null;
1628                 final Long elapsedTime = 7L;
1629                 final Throwable exception = this.exception;
1630                 final Class<?> fixtureClass = getClass();
1631                 final String fixtureDescription = "fixture description";
1632                 final String fixtureName = "fixture name";
1633                 final String message = "message";
1634                 final String testDescription = "test description";
1635                 final String testMethodName = "testMethodName";
1636                 final String testName = null;
1637                 final String testResult = "Success";
1638 
1639                 bean1.setCategories(categories);
1640                 bean1.setElapsedTime(elapsedTime);
1641                 bean1.setException(exception);
1642                 bean1.setFixtureClass(fixtureClass);
1643                 bean1.setFixtureDescription(fixtureDescription);
1644                 bean1.setFixtureName(fixtureName);
1645                 bean1.setMessage(message);
1646                 bean1.setTestDescription(testDescription);
1647                 bean1.setTestMethodName(testMethodName);
1648                 bean1.setTestName(testName);
1649                 bean1.setTestResult(testResult);
1650                 return bean1;
1651             }
1652         };
1653 
1654         assertObjectFactoryFillsContract(factory);
1655         assertHashCodeMethodFillsContract(factory);
1656         assertEqualsMethodFillsContract(factory);
1657     }
1658 
1659     @Test
equalsHashCode22()1660     public void equalsHashCode22()
1661     {
1662         final ObjectFactory<TestResultBean> factory = new ObjectFactory<TestResultBean>()
1663         {
1664             private final Throwable exception = new IllegalArgumentException();
1665 
1666             public TestResultBean newInstanceX()
1667             {
1668                 final TestResultBean bean1 = new TestResultBeanImpl();
1669                 final String[] categories = new String[]{"x", "y"};
1670                 final Long elapsedTime = 7L;
1671                 final Throwable exception = this.exception;
1672                 final Class<?> fixtureClass = getClass();
1673                 final String fixtureDescription = "fixture description";
1674                 final String fixtureName = "fixture name";
1675                 final String message = "message";
1676                 final String testDescription = "test description";
1677                 final String testMethodName = "testMethodName";
1678                 final String testName = "test name";
1679                 final String testResult = "Success";
1680 
1681                 bean1.setCategories(categories);
1682                 bean1.setElapsedTime(elapsedTime);
1683                 bean1.setException(exception);
1684                 bean1.setFixtureClass(fixtureClass);
1685                 bean1.setFixtureDescription(fixtureDescription);
1686                 bean1.setFixtureName(fixtureName);
1687                 bean1.setMessage(message);
1688                 bean1.setTestDescription(testDescription);
1689                 bean1.setTestMethodName(testMethodName);
1690                 bean1.setTestName(testName);
1691                 bean1.setTestResult(testResult);
1692                 return bean1;
1693             }
1694 
1695             public TestResultBean newInstanceY()
1696             {
1697                 final TestResultBean bean1 = new TestResultBeanImpl();
1698                 final String[] categories = null;
1699                 final Long elapsedTime = 7L;
1700                 final Throwable exception = this.exception;
1701                 final Class<?> fixtureClass = getClass();
1702                 final String fixtureDescription = "fixture description";
1703                 final String fixtureName = "fixture name";
1704                 final String message = "message";
1705                 final String testDescription = "test description";
1706                 final String testMethodName = "testMethodName";
1707                 final String testName = "test name";
1708                 final String testResult = null;
1709 
1710                 bean1.setCategories(categories);
1711                 bean1.setElapsedTime(elapsedTime);
1712                 bean1.setException(exception);
1713                 bean1.setFixtureClass(fixtureClass);
1714                 bean1.setFixtureDescription(fixtureDescription);
1715                 bean1.setFixtureName(fixtureName);
1716                 bean1.setMessage(message);
1717                 bean1.setTestDescription(testDescription);
1718                 bean1.setTestMethodName(testMethodName);
1719                 bean1.setTestName(testName);
1720                 bean1.setTestResult(testResult);
1721                 return bean1;
1722             }
1723         };
1724 
1725         assertObjectFactoryFillsContract(factory);
1726         assertHashCodeMethodFillsContract(factory);
1727         assertEqualsMethodFillsContract(factory);
1728     }
1729 }
1730