Clover coverage report - Diasparsoft Toolkit - 0.22
Coverage timestamp: Tue Jun 8 2004 12:41:26 EDT
file stats: LOC: 326   Methods: 23
NCLOC: 237   Classes: 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
 
 Source file Conditionals Statements Methods TOTAL
ValueObjectEqualsTest.java 100% 98.8% 100% 99.1%
coverage coverage
 1   
 package com.diasparsoftware.util.junit;
 2   
 
 3   
 import java.util.*;
 4   
 
 5   
 import junit.framework.*;
 6   
 
 7   
 import org.apache.commons.collections.*;
 8   
 
 9   
 import com.diasparsoftware.java.util.*;
 10   
 
 11   
 public abstract class ValueObjectEqualsTest extends TestCase {
 12   
     private Object control;
 13   
     private Map differentObjects = new HashMap();
 14   
 
 15   
     private Object equalToControl;
 16   
     private Object equalToControl2;
 17   
 
 18   
     private static final int NUM_ITERATIONS = 20;
 19   
 
 20   
     /**
 21   
      * Creates the "control" instance of the class under test —
 22   
      * the object against which all the others are to be compared.
 23   
     */
 24   
     protected abstract Object createControlInstance() throws Exception;
 25   
 
 26   
     /**
 27   
      * Creates and returns an instance of the class under test that
 28   
      * differs from the control instance by having a different value
 29   
      * for the specified key property.
 30   
      */
 31   
     protected abstract Object createInstanceDiffersIn(String keyPropertyName)
 32   
         throws Exception;
 33   
 
 34   
     /**
 35   
      * The names of the key properties used to distinguish
 36   
      * unequal instances of this class.
 37   
      * 
 38   
      * @return
 39   
      */
 40   
     protected abstract List keyPropertyNames();
 41   
 
 42  176
     protected void setUp() throws Exception {
 43  176
         super.setUp();
 44   
 
 45  176
         control = createControlInstance();
 46  176
         equalToControl = createControlInstance();
 47  176
         equalToControl2 = createControlInstance();
 48   
 
 49  176
         CollectionUtil
 50   
             .forEachDo(keyPropertyNames(), new ExceptionalClosure() {
 51  528
             public Object execute(Object each) throws Exception {
 52  528
                 String eachName = (String) each;
 53  528
                 differentObjects.put(
 54   
                     each,
 55   
                     createInstanceDiffersIn(eachName));
 56  528
                 return null;
 57   
             }
 58   
         });
 59   
 
 60   
         // We want these assertions to yield errors, not failures.
 61  176
         try {
 62  176
             assertNotNull(
 63   
                 "createControlInstance() returned null",
 64   
                 control);
 65  176
             assertNotNull(
 66   
                 "2nd createControlInstance() returned null",
 67   
                 equalToControl);
 68  176
             assertNotNull(
 69   
                 "3rd createControlInstance() returned null",
 70   
                 equalToControl2);
 71   
 
 72  176
             eachDifferentObjectDo(new MapEntryClosure() {
 73  528
                 public void eachMapEntry(Object key, Object value) {
 74  528
                     assertNotNull(nameOf(key) + "returned null", value);
 75   
                 }
 76   
             });
 77   
 
 78  176
             Assert.assertNotSame(control, equalToControl);
 79  176
             Assert.assertNotSame(control, equalToControl2);
 80   
 
 81  176
             eachDifferentObjectDo(new MapEntryClosure() {
 82  528
                 public void eachMapEntry(Object key, Object value) {
 83  528
                     Assert.assertNotSame(
 84   
                         nameOf(key) + " same as control",
 85   
                         control,
 86   
                         value);
 87  528
                     Assert.assertNotSame(
 88   
                         nameOf(key) + " same as equalToControl",
 89   
                         equalToControl,
 90   
                         value);
 91  528
                     Assert.assertNotSame(
 92   
                         nameOf(key) + " same as equalToControl2",
 93   
                         equalToControl2,
 94   
                         value);
 95   
                 }
 96   
             });
 97   
 
 98  176
             Assert.assertNotSame(equalToControl, equalToControl2);
 99   
 
 100  176
             assertEquals(
 101   
                 "1st and 2nd equal instances of different classes",
 102   
                 control.getClass(),
 103   
                 equalToControl.getClass());
 104  176
             assertEquals(
 105   
                 "1st and 3rd equal instances of different classes",
 106   
                 control.getClass(),
 107   
                 equalToControl2.getClass());
 108   
 
 109  176
             eachDifferentObjectDo(new MapEntryClosure() {
 110  528
                 public void eachMapEntry(Object key, Object value) {
 111  528
                     assertEquals(
 112   
                         "control instance and "
 113   
                             + nameOf(key)
 114   
                             + " of different classes",
 115   
                         control.getClass(),
 116   
                         value.getClass());
 117   
 
 118   
                 }
 119   
             });
 120   
         }
 121   
         catch (AssertionFailedError ex) {
 122  0
             throw new IllegalArgumentException(ex.getMessage());
 123   
         }
 124   
     }
 125   
 
 126   
     /**
 127   
      * Tests whether <code>equals</code> holds up against a new
 128   
      * <code>Object</code> (should always be <code>false</code>).
 129   
      */
 130  462
     public final void testEqualsAgainstNewObject() {
 131  462
         final Object o = new Object();
 132   
 
 133  462
         assertNotEquals(o, control);
 134  462
         assertNotEquals(o, equalToControl);
 135  462
         assertNotEquals(o, equalToControl2);
 136   
 
 137  462
         eachDifferentObjectDo(new MapEntryClosure() {
 138  1386
             public void eachMapEntry(Object key, Object value) {
 139  1386
                 assertNotEquals(o, value);
 140   
             }
 141   
         });
 142   
     }
 143   
 
 144   
     /**
 145   
      * Tests whether <code>equals</code> holds up against <code>null</code>.
 146   
      */
 147  462
     public final void testEqualsAgainstNull() {
 148  462
         assertNotEquals("null vs. 1st", null, control);
 149  462
         assertNotEquals("null vs. 2nd", null, equalToControl);
 150  462
         assertNotEquals("null vs. 3rd", null, equalToControl2);
 151   
 
 152  462
         eachDifferentObjectDo(new MapEntryClosure() {
 153  1386
             public void eachMapEntry(Object key, Object value) {
 154  1386
                 assertNotEquals("null vs. " + nameOf(key), null, value);
 155   
             }
 156   
         });
 157   
     }
 158   
 
 159   
     /**
 160   
      * Tests whether <code>equals</code> holds up against objects that should
 161   
      * not compare equal.
 162   
      */
 163  462
     public final void testEqualsAgainstUnequalObjects() {
 164  462
         eachDifferentObjectDo(new MapEntryClosure() {
 165  1386
             public void eachMapEntry(Object key, Object value) {
 166  1386
                 assertNotEquals(
 167   
                     "1st vs. " + nameOf(key),
 168   
                     control,
 169   
                     value);
 170  1386
                 assertNotEquals(
 171   
                     "2nd vs. " + nameOf(key),
 172   
                     equalToControl,
 173   
                     value);
 174  1386
                 assertNotEquals(
 175   
                     "3rd vs. " + nameOf(key),
 176   
                     equalToControl2,
 177   
                     value);
 178   
 
 179  1386
                 assertNotEquals(
 180   
                     nameOf(key) + " vs. 1st",
 181   
                     value,
 182   
                     control);
 183  1386
                 assertNotEquals(
 184   
                     nameOf(key) + " vs. 2nd",
 185   
                     value,
 186   
                     equalToControl);
 187  1386
                 assertNotEquals(
 188   
                     nameOf(key) + " vs. 3rd",
 189   
                     value,
 190   
                     equalToControl2);
 191   
             }
 192   
         });
 193   
 
 194   
     }
 195   
 
 196   
     /**
 197   
      * Tests whether <code>equals</code> is <em>consistent</em>.
 198   
      */
 199  22
     public final void testEqualsIsConsistentAcrossInvocations() {
 200  22
         for (int i = 0; i < NUM_ITERATIONS; ++i) {
 201  440
             testEqualsAgainstNewObject();
 202  440
             testEqualsAgainstNull();
 203  440
             testEqualsAgainstUnequalObjects();
 204  440
             testEqualsIsReflexive();
 205  440
             testEqualsIsSymmetricAndTransitive();
 206   
         }
 207   
     }
 208   
 
 209   
     /**
 210   
      * Tests whether <code>equals</code> is <em>reflexive</em>.
 211   
      */
 212  462
     public final void testEqualsIsReflexive() {
 213  462
         assertEquals("1st equal instance", control, control);
 214  462
         assertEquals(
 215   
             "2nd equal instance",
 216   
             equalToControl,
 217   
             equalToControl);
 218  462
         assertEquals(
 219   
             "3rd equal instance",
 220   
             equalToControl2,
 221   
             equalToControl2);
 222   
 
 223  462
         eachDifferentObjectDo(new MapEntryClosure() {
 224  1386
             public void eachMapEntry(Object key, Object value) {
 225  1386
                 assertEquals(nameOf(key) + " instance", value, value);
 226   
             }
 227   
         });
 228   
     }
 229   
 
 230   
     /**
 231   
      * Tests whether <code>equals</code> is <em>symmetric</em> and
 232   
      * <em>transitive</em>.
 233   
      */
 234  462
     public final void testEqualsIsSymmetricAndTransitive() {
 235  462
         assertEquals("1st vs. 2nd", control, equalToControl);
 236  462
         assertEquals("2nd vs. 1st", equalToControl, control);
 237   
 
 238  462
         assertEquals("1st vs. 3rd", control, equalToControl2);
 239  462
         assertEquals("3rd vs. 1st", equalToControl2, control);
 240   
 
 241  462
         assertEquals("2nd vs. 3rd", equalToControl, equalToControl2);
 242  462
         assertEquals("3rd vs. 2nd", equalToControl2, equalToControl);
 243   
     }
 244   
 
 245   
     /**
 246   
      * Tests the <code>hashCode</code> contract.
 247   
      */
 248  22
     public final void testHashCodeContract() {
 249  22
         assertEquals(
 250   
             "1st vs. 2nd",
 251   
             control.hashCode(),
 252   
             equalToControl.hashCode());
 253  22
         assertEquals(
 254   
             "1st vs. 3rd",
 255   
             control.hashCode(),
 256   
             equalToControl2.hashCode());
 257  22
         assertEquals(
 258   
             "2nd vs. 3rd",
 259   
             equalToControl.hashCode(),
 260   
             equalToControl2.hashCode());
 261   
     }
 262   
 
 263   
     /**
 264   
      * Tests the consistency of <code>hashCode</code>.
 265   
      */
 266  22
     public final void testHashCodeIsConsistentAcrossInvocations() {
 267  22
         int eq1Hash = control.hashCode();
 268  22
         int eq2Hash = equalToControl.hashCode();
 269  22
         int eq3Hash = equalToControl2.hashCode();
 270   
 
 271  22
         final Map differentObjectsHashes = new HashMap();
 272   
 
 273  22
         eachDifferentObjectDo(new MapEntryClosure() {
 274  66
             public void eachMapEntry(Object key, Object value) {
 275  66
                 differentObjectsHashes.put(
 276   
                     key,
 277   
                     new Integer(value.hashCode()));
 278   
             }
 279   
         });
 280   
 
 281  22
         for (int i = 0; i < NUM_ITERATIONS; ++i) {
 282  440
             assertEquals(
 283   
                 "1st equal instance",
 284   
                 eq1Hash,
 285   
                 control.hashCode());
 286  440
             assertEquals(
 287   
                 "2nd equal instance",
 288   
                 eq2Hash,
 289   
                 equalToControl.hashCode());
 290  440
             assertEquals(
 291   
                 "3rd equal instance",
 292   
                 eq3Hash,
 293   
                 equalToControl2.hashCode());
 294   
 
 295  440
             eachDifferentObjectDo(new MapEntryClosure() {
 296  1320
                 public void eachMapEntry(Object key, Object value) {
 297  1320
                     assertEquals(
 298   
                         nameOf(key) + " instance",
 299   
                         ((Integer) differentObjectsHashes.get(key))
 300   
                             .intValue(),
 301   
                         value.hashCode());
 302   
                 }
 303   
             });
 304   
         }
 305   
     }
 306   
 
 307  2772
     protected static void assertNotEquals(Object lhs, Object rhs) {
 308  2772
         assertNotEquals(null, lhs, rhs);
 309   
     }
 310   
 
 311  13860
     protected static void assertNotEquals(
 312   
         String failureMessage,
 313   
         Object lhs,
 314   
         Object rhs) {
 315  13860
         if (lhs != null)
 316  11088
             assertFalse(failureMessage, lhs.equals(rhs));
 317   
     }
 318   
 
 319  2838
     private void eachDifferentObjectDo(Closure closure) {
 320  2838
         CollectionUtils.forAllDo(differentObjects.entrySet(), closure);
 321   
     }
 322   
 
 323  15048
     private final String nameOf(Object key) {
 324  15048
         return "objectDiffersBy('" + key + "')";
 325   
     }
 326   
 }