Coverage report

  %line %branch
net.sf.classifier4J.util.EqualsBuilder
3% 
16% 

 1  
 /* ====================================================================
 2  
  * The Apache Software License, Version 1.1
 3  
  *
 4  
  * Copyright (c) 2002-2003 The Apache Software Foundation.  All rights
 5  
  * reserved.
 6  
  *
 7  
  * Redistribution and use in source and binary forms, with or without
 8  
  * modification, are permitted provided that the following conditions
 9  
  * are met:
 10  
  *
 11  
  * 1. Redistributions of source code must retain the above copyright
 12  
  *    notice, this list of conditions and the following disclaimer.
 13  
  *
 14  
  * 2. Redistributions in binary form must reproduce the above copyright
 15  
  *    notice, this list of conditions and the following disclaimer in
 16  
  *    the documentation and/or other materials provided with the
 17  
  *    distribution.
 18  
  *
 19  
  * 3. The end-user documentation included with the redistribution, if
 20  
  *    any, must include the following acknowledgement:
 21  
  *       "This product includes software developed by the
 22  
  *        Apache Software Foundation (http://www.apache.org/)."
 23  
  *    Alternately, this acknowledgement may appear in the software itself,
 24  
  *    if and wherever such third-party acknowledgements normally appear.
 25  
  *
 26  
  * 4. The names "The Jakarta Project", "Commons", and "Apache Software
 27  
  *    Foundation" must not be used to endorse or promote products derived
 28  
  *    from this software without prior written permission. For written
 29  
  *    permission, please contact apache@apache.org.
 30  
  *
 31  
  * 5. Products derived from this software may not be called "Apache"
 32  
  *    nor may "Apache" appear in their names without prior written
 33  
  *    permission of the Apache Software Foundation.
 34  
  *
 35  
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 36  
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 37  
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 38  
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 39  
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 40  
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 41  
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 42  
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 43  
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 44  
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 45  
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 46  
  * SUCH DAMAGE.
 47  
  * ====================================================================
 48  
  *
 49  
  * This software consists of voluntary contributions made by many
 50  
  * individuals on behalf of the Apache Software Foundation.  For more
 51  
  * information on the Apache Software Foundation, please see
 52  
  * <http://www.apache.org/>.
 53  
  */
 54  
 package net.sf.classifier4J.util;
 55  
 
 56  
 import java.lang.reflect.AccessibleObject;
 57  
 import java.lang.reflect.Field;
 58  
 import java.lang.reflect.Modifier;
 59  
 
 60  
 /**
 61  
  * <p>Assists in implementing {@link Object#equals(Object)} methods.</p>
 62  
  *
 63  
  * <p>Originally from the Apache commons-lang package</p> 
 64  
  *
 65  
  * <p> This class provides methods to build a good equals method for any
 66  
  * class. It follows rules laid out in
 67  
  * <a href="http://java.sun.com/docs/books/effective/index.html">Effective Java</a>
 68  
  * , by Joshua Bloch. In particular the rule for comparing <code>doubles</code>,
 69  
  * <code>floats</code>, and arrays can be tricky. Also, making sure that
 70  
  * <code>equals()</code> and <code>hashCode()</code> are consistent can be
 71  
  * difficult.</p>
 72  
  *
 73  
  * <p>Two Objects that compare as equals must generate the same hash code,
 74  
  * but two Objects with the same hash code do not have to be equal.</p>
 75  
  *
 76  
  * <p>All relevant fields should be included in the calculation of equals.
 77  
  * Derived fields may be ignored. In particular, any field used in
 78  
  * generating a hash code must be used in the equals method, and vice
 79  
  * versa.</p>
 80  
  *
 81  
  * <p>Typical use for the code is as follows:</p>
 82  
  * <pre>
 83  
  * public boolean equals(Object o) {
 84  
  *   if ( !(o instanceof MyClass) ) {
 85  
  *    return false;
 86  
  *   }
 87  
  *  MyClass rhs = (MyClass) o;
 88  
  *  return new EqualsBuilder()
 89  
  *                 .appendSuper(super.equals(o))
 90  
  *                 .append(field1, rhs.field1)
 91  
  *                 .append(field2, rhs.field2)
 92  
  *                 .append(field3, rhs.field3)
 93  
  *                 .isEquals();
 94  
  *  }
 95  
  * </pre>
 96  
  *
 97  
  * <p> Alternatively, there is a method that uses reflection to determine
 98  
  * the fields to test. Because these fields are usually private, the method,
 99  
  * <code>reflectionEquals</code>, uses <code>AccessibleObject.setAccessible</code> to
 100  
  * change the visibility of the fields. This will fail under a security
 101  
  * manager, unless the appropriate permissions are set up correctly. It is
 102  
  * also slower than testing explicitly.</p>
 103  
  *
 104  
  * <p> A typical invocation for this method would look like:</p>
 105  
  * <pre>
 106  
  * public boolean equals(Object o) {
 107  
  *   return EqualsBuilder.reflectionEquals(this, o);
 108  
  * }
 109  
  * </pre>
 110  
  *
 111  
  * @author <a href="mailto:steve.downey@netfolio.com">Steve Downey</a>
 112  
  * @author Stephen Colebourne
 113  
  * @author Gary Gregory
 114  
  * @author Pete Gieser
 115  
  * @since 1.0
 116  
  * @version $Id: EqualsBuilder.java,v 1.1 2005/02/04 05:30:28 nicklothian Exp $
 117  
  */
 118  
 public class EqualsBuilder {
 119  
     /**
 120  
      * If the fields tested are equals.
 121  
      */
 122  
     private boolean isEquals;
 123  
 
 124  
     /**
 125  
      * <p>Constructor for EqualsBuilder.</p>
 126  
      *
 127  
      * <p>Starts off assuming that equals is <code>true</code>.</p>
 128  
      * @see java.lang.Object#equals
 129  
      */
 130  
     public EqualsBuilder() {
 131  2
         super();
 132  2
         isEquals = true;
 133  2
     }
 134  
 
 135  
     //-------------------------------------------------------------------------
 136  
 
 137  
     /**
 138  
      * <p>This method uses reflection to determine if the two <code>Object</code>s
 139  
      * are equal.</p>
 140  
      *
 141  
      * <p>It uses <code>AccessibleObject.setAccessible</code> to gain access to private
 142  
      * fields. This means that it will throw a security exception if run under
 143  
      * a security manager, if the permissions are not set up correctly. It is also
 144  
      * not as efficient as testing explicitly.</p>
 145  
      *
 146  
      * <p>Transient members will be not be tested, as they are likely derived
 147  
      * fields, and not part of the value of the Object.</p>
 148  
      *
 149  
      * <p>Static fields will not be tested. Superclass fields will be included.</p>
 150  
      *
 151  
      * @param lhs  <code>this</code> object
 152  
      * @param rhs  the other object
 153  
      * @return <code>true</code> if the two Objects have tested equals.
 154  
      */
 155  
     public static boolean reflectionEquals(Object lhs, Object rhs) {
 156  0
         return reflectionEquals(lhs, rhs, false, null);
 157  
     }
 158  
 
 159  
     /**
 160  
      * <p>This method uses reflection to determine if the two <code>Object</code>s
 161  
      * are equal.</p>
 162  
      *
 163  
      * <p>It uses <code>AccessibleObject.setAccessible</code> to gain access to private
 164  
      * fields. This means that it will throw a security exception if run under
 165  
      * a security manager, if the permissions are not set up correctly. It is also
 166  
      * not as efficient as testing explicitly.</p>
 167  
      *
 168  
      * <p>If the TestTransients parameter is set to <code>true</code>, transient
 169  
      * members will be tested, otherwise they are ignored, as they are likely
 170  
      * derived fields, and not part of the value of the <code>Object</code>.</p>
 171  
      *
 172  
      * <p>Static fields will not be tested. Superclass fields will be included.</p>
 173  
      *
 174  
      * @param lhs  <code>this</code> object
 175  
      * @param rhs  the other object
 176  
      * @param testTransients  whether to include transient fields
 177  
      * @return <code>true</code> if the two Objects have tested equals.
 178  
      */
 179  
     public static boolean reflectionEquals(Object lhs, Object rhs, class="keyword">boolean testTransients) {
 180  0
         return reflectionEquals(lhs, rhs, testTransients, null);
 181  
     }
 182  
 
 183  
     /**
 184  
      * <p>This method uses reflection to determine if the two <code>Object</code>s
 185  
      * are equal.</p>
 186  
      *
 187  
      * <p>It uses <code>AccessibleObject.setAccessible</code> to gain access to private
 188  
      * fields. This means that it will throw a security exception if run under
 189  
      * a security manager, if the permissions are not set up correctly. It is also
 190  
      * not as efficient as testing explicitly.</p>
 191  
      *
 192  
      * <p>If the testTransients parameter is set to <code>true</code>, transient
 193  
      * members will be tested, otherwise they are ignored, as they are likely
 194  
      * derived fields, and not part of the value of the <code>Object</code>.</p>
 195  
      *
 196  
      * <p>Static fields will not be included. Superclass fields will be appended
 197  
      * up to and including the specified superclass. A null superclass is treated
 198  
      * as java.lang.Object.</p>
 199  
      *
 200  
      * @param lhs  <code>this</code> object
 201  
      * @param rhs  the other object
 202  
      * @param testTransients  whether to include transient fields
 203  
      * @param reflectUpToClass  the superclass to reflect up to (inclusive),
 204  
      *  may be <code>null</code>
 205  
      * @return <code>true</code> if the two Objects have tested equals.
 206  
      * @since 2.0
 207  
      */
 208  
     public static boolean reflectionEquals(Object lhs, Object rhs, class="keyword">boolean testTransients, Class reflectUpToClass) {
 209  0
         if (lhs == rhs) {
 210  0
             return true;
 211  
         }
 212  0
         if (lhs == null || rhs == class="keyword">null) {
 213  0
             return false;
 214  
         }
 215  
         // Find the leaf class since there may be transients in the leaf 
 216  
         // class or in classes between the leaf and root.
 217  
         // If we are not testing transients or a subclass has no ivars, 
 218  
         // then a subclass can test equals to a superclass.
 219  0
         Class lhsClass = lhs.getClass();
 220  0
         Class rhsClass = rhs.getClass();
 221  
         Class testClass;
 222  0
         if (lhsClass.isInstance(rhs)) {
 223  0
             testClass = lhsClass;
 224  0
             if (!rhsClass.isInstance(lhs)) {
 225  
                 // rhsClass is a subclass of lhsClass
 226  0
                 testClass = rhsClass;
 227  
             }
 228  0
         } else if (rhsClass.isInstance(lhs)) {
 229  0
             testClass = rhsClass;
 230  0
             if (!lhsClass.isInstance(rhs)) {
 231  
                 // lhsClass is a subclass of rhsClass
 232  0
                 testClass = lhsClass;
 233  
             }
 234  
         } else {
 235  
             // The two classes are not related.
 236  0
             return false;
 237  
         }
 238  0
         EqualsBuilder equalsBuilder = new EqualsBuilder();
 239  
         try {
 240  0
             reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients);
 241  0
             while (testClass.getSuperclass() != null && testClass != reflectUpToClass) {
 242  0
                 testClass = testClass.getSuperclass();
 243  0
                 reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients);
 244  
             }
 245  0
         } catch (IllegalArgumentException e) {
 246  
             // In this case, we tried to test a subclass vs. a superclass and
 247  
             // the subclass has ivars or the ivars are transient and 
 248  
             // we are testing transients.
 249  
             // If a subclass has ivars that we are trying to test them, we get an
 250  
             // exception and we know that the objects are not equal.
 251  0
             return false;
 252  
         }
 253  0
         return equalsBuilder.isEquals();
 254  
     }
 255  
 
 256  
     /**
 257  
      * <p>Appends the fields and values defined by the given object of the
 258  
      * given Class.</p>
 259  
      * 
 260  
      * @param lhs  the left hand object
 261  
      * @param rhs  the right hand object
 262  
      * @param clazz  the class to append details of
 263  
      * @param builder  the builder to append to
 264  
      * @param useTransients  whether to test transient fields
 265  
      */
 266  
     private static void reflectionAppend(
 267  
         Object lhs,
 268  
         Object rhs,
 269  
         Class clazz,
 270  
         EqualsBuilder builder,
 271  
         boolean useTransients) {
 272  0
         Field[] fields = clazz.getDeclaredFields();
 273  0
         AccessibleObject.setAccessible(fields, true);
 274  0
         for (int i = 0; i < fields.length && builder.isEquals; i++) {
 275  0
             Field f = fields[i];
 276  0
             if ((f.getName().indexOf('$') == -1)
 277  
                 && (useTransients || !Modifier.isTransient(f.getModifiers()))
 278  
                 && (!Modifier.isStatic(f.getModifiers()))) {
 279  
                 try {
 280  0
                     builder.append(f.get(lhs), f.get(rhs));
 281  0
                 } catch (IllegalAccessException e) {
 282  
                     //this can't happen. Would get a Security exception instead
 283  
                     //throw a runtime exception in case the impossible happens.
 284  0
                     throw new InternalError("Unexpected IllegalAccessException");
 285  
                 }
 286  
             }
 287  
         }
 288  0
     }
 289  
 
 290  
     //-------------------------------------------------------------------------
 291  
 
 292  
     /**
 293  
      * <p>Adds the result of <code>super.equals()</code> to this builder.</p>
 294  
      *
 295  
      * @param superEquals  the result of calling <code>super.equals()</code>
 296  
      * @return EqualsBuilder - used to chain calls.
 297  
      * @since 2.0
 298  
      */
 299  
     public EqualsBuilder appendSuper(boolean superEquals) {
 300  0
         if (isEquals == false) {
 301  0
             return this;
 302  
         }
 303  0
         isEquals = superEquals;
 304  0
         return this;
 305  
     }
 306  
 
 307  
     //-------------------------------------------------------------------------
 308  
 
 309  
     /**
 310  
      * <p>Test if two <code>Object</code>s are equal using their
 311  
      * <code>equals</code> method.</p>
 312  
      *
 313  
      * @param lhs  the left hand object
 314  
      * @param rhs  the right hand object
 315  
      * @return EqualsBuilder - used to chain calls.
 316  
      */
 317  
     public EqualsBuilder append(Object lhs, Object rhs) {
 318  4
         if (isEquals == false) {
 319  0
             return this;
 320  
         }
 321  4
         if (lhs == rhs) {
 322  4
             return this;
 323  
         }
 324  0
         if (lhs == null || rhs == class="keyword">null) {
 325  0
             isEquals = false;
 326  0
             return this;
 327  
         }
 328  0
         Class lhsClass = lhs.getClass();
 329  0
         if (!lhsClass.isArray()) {
 330  
             //the simple case, not an array, just test the element
 331  0
             isEquals = lhs.equals(rhs);
 332  
         } else {
 333  
             //'Switch' on type of array, to dispatch to the correct handler
 334  
             // This handles multi dimensional arrays
 335  0
             if (lhs instanceof long[]) {
 336  0
                 append((long[]) lhs, (class="keyword">long[]) rhs);
 337  0
             } else if (lhs instanceof int[]) {
 338  0
                 append((int[]) lhs, (class="keyword">int[]) rhs);
 339  0
             } else if (lhs instanceof short[]) {
 340  0
                 append((short[]) lhs, (class="keyword">short[]) rhs);
 341  0
             } else if (lhs instanceof char[]) {
 342  0
                 append((char[]) lhs, (class="keyword">char[]) rhs);
 343  0
             } else if (lhs instanceof byte[]) {
 344  0
                 append((byte[]) lhs, (byte[]) rhs);
 345  0
             } else if (lhs instanceof double[]) {
 346  0
                 append((double[]) lhs, (class="keyword">double[]) rhs);
 347  0
             } else if (lhs instanceof float[]) {
 348  0
                 append((float[]) lhs, (class="keyword">float[]) rhs);
 349  0
             } else if (lhs instanceof boolean[]) {
 350  0
                 append((boolean[]) lhs, (class="keyword">boolean[]) rhs);
 351  
             } else {
 352  
                 // Not an array of primitives
 353  0
                 append((Object[]) lhs, (Object[]) rhs);
 354  
             }
 355  
         }
 356  0
         return this;
 357  
     }
 358  
 
 359  
     /**
 360  
      * <p>Test if two <code>long</code>s are equal.</p>
 361  
      *
 362  
      * @param lhs  the left hand <code>long</code>
 363  
      * @param rhs  the right hand <code>long</code>
 364  
      * @return EqualsBuilder - used to chain calls.
 365  
      */
 366  
     public EqualsBuilder append(long lhs, class="keyword">long rhs) {
 367  0
         if (isEquals == false) {
 368  0
             return this;
 369  
         }
 370  0
         isEquals = (lhs == rhs);
 371  0
         return this;
 372  
     }
 373  
 
 374  
     /**
 375  
      * <p>Test if two <code>int</code>s are equal.</p>
 376  
      *
 377  
      * @param lhs  the left hand <code>int</code>
 378  
      * @param rhs  the right hand <code>int</code>
 379  
      * @return EqualsBuilder - used to chain calls.
 380  
      */
 381  
     public EqualsBuilder append(int lhs, class="keyword">int rhs) {
 382  0
         if (isEquals == false) {
 383  0
             return this;
 384  
         }
 385  0
         isEquals = (lhs == rhs);
 386  0
         return this;
 387  
     }
 388  
 
 389  
     /**
 390  
      * <p>Test if two <code>short</code>s are equal.</p>
 391  
      *
 392  
      * @param lhs  the left hand <code>short</code>
 393  
      * @param rhs  the right hand <code>short</code>
 394  
      * @return EqualsBuilder - used to chain calls.
 395  
      */
 396  
     public EqualsBuilder append(short lhs, class="keyword">short rhs) {
 397  0
         if (isEquals == false) {
 398  0
             return this;
 399  
         }
 400  0
         isEquals = (lhs == rhs);
 401  0
         return this;
 402  
     }
 403  
 
 404  
     /**
 405  
      * <p>Test if two <code>char</code>s are equal.</p>
 406  
      *
 407  
      * @param lhs  the left hand <code>char</code>
 408  
      * @param rhs  the right hand <code>char</code>
 409  
      * @return EqualsBuilder - used to chain calls.
 410  
      */
 411  
     public EqualsBuilder append(char lhs, class="keyword">char rhs) {
 412  0
         if (isEquals == false) {
 413  0
             return this;
 414  
         }
 415  0
         isEquals = (lhs == rhs);
 416  0
         return this;
 417  
     }
 418  
 
 419  
     /**
 420  
      * <p>Test if two <code>byte</code>s are equal.</p>
 421  
      *
 422  
      * @param lhs  the left hand <code>byte</code>
 423  
      * @param rhs  the right hand <code>byte</code>
 424  
      * @return EqualsBuilder - used to chain calls.
 425  
      */
 426  
     public EqualsBuilder append(byte lhs, byte rhs) {
 427  0
         if (isEquals == false) {
 428  0
             return this;
 429  
         }
 430  0
         isEquals = (lhs == rhs);
 431  0
         return this;
 432  
     }
 433  
 
 434  
     /**
 435  
      * <p>Test if two <code>double</code>s are equal by testing that the
 436  
      * pattern of bits returned by <code>doubleToLong</code> are equal.</p>
 437  
      *
 438  
      * <p>This handles NaNs, Infinities, and <code>-0.0</code>.</p>
 439  
      *
 440  
      * <p>It is compatible with the hash code generated by
 441  
      * <code>HashCodeBuilder</code>.</p>
 442  
      *
 443  
      * @param lhs  the left hand <code>double</code>
 444  
      * @param rhs  the right hand <code>double</code>
 445  
      * @return EqualsBuilder - used to chain calls.
 446  
      */
 447  
     public EqualsBuilder append(double lhs, class="keyword">double rhs) {
 448  0
         if (isEquals == false) {
 449  0
             return this;
 450  
         }
 451  0
         return append(Double.doubleToLongBits(lhs), Double.doubleToLongBits(rhs));
 452  
     }
 453  
 
 454  
     /**
 455  
      * <p>Test if two <code>float</code>s are equal byt testing that the
 456  
      * pattern of bits returned by doubleToLong are equal.</p>
 457  
      *
 458  
      * <p>This handles NaNs, Infinities, and <code>-0.0</code>.</p>
 459  
      *
 460  
      * <p>It is compatible with the hash code generated by
 461  
      * <code>HashCodeBuilder</code>.</p>
 462  
      *
 463  
      * @param lhs  the left hand <code>float</code>
 464  
      * @param rhs  the right hand <code>float</code>
 465  
      * @return EqualsBuilder - used to chain calls.
 466  
      */
 467  
     public EqualsBuilder append(float lhs, class="keyword">float rhs) {
 468  0
         if (isEquals == false) {
 469  0
             return this;
 470  
         }
 471  0
         return append(Float.floatToIntBits(lhs), Float.floatToIntBits(rhs));
 472  
     }
 473  
 
 474  
     /**
 475  
      * <p>Test if two <code>booleans</code>s are equal.</p>
 476  
      *
 477  
      * @param lhs  the left hand <code>boolean</code>
 478  
      * @param rhs  the right hand <code>boolean</code>
 479  
      * @return EqualsBuilder - used to chain calls.
 480  
       */
 481  
     public EqualsBuilder append(boolean lhs, class="keyword">boolean rhs) {
 482  0
         if (isEquals == false) {
 483  0
             return this;
 484  
         }
 485  0
         isEquals = (lhs == rhs);
 486  0
         return this;
 487  
     }
 488  
 
 489  
     /**
 490  
      * <p>Performs a deep comparison of two <code>Object</code> arrays.</p>
 491  
      *
 492  
      * <p>This also will be called for the top level of
 493  
      * multi-dimensional, ragged, and multi-typed arrays.</p>
 494  
      *
 495  
      * @param lhs  the left hand <code>Object[]</code>
 496  
      * @param rhs  the right hand <code>Object[]</code>
 497  
      * @return EqualsBuilder - used to chain calls.
 498  
      */
 499  
     public EqualsBuilder append(Object[] lhs, Object[] rhs) {
 500  0
         if (isEquals == false) {
 501  0
             return this;
 502  
         }
 503  0
         if (lhs == rhs) {
 504  0
             return this;
 505  
         }
 506  0
         if (lhs == null || rhs == class="keyword">null) {
 507  0
             isEquals = false;
 508  0
             return this;
 509  
         }
 510  0
         if (lhs.length != rhs.length) {
 511  0
             isEquals = false;
 512  0
             return this;
 513  
         }
 514  0
         for (int i = 0; i < lhs.length && isEquals; ++i) {
 515  0
             Class lhsClass = lhs[i].getClass();
 516  0
             if (!lhsClass.isInstance(rhs[i])) {
 517  0
                 isEquals = false; //If the types don't match, not equal
 518  0
                 break;
 519  
             }
 520  0
             append(lhs[i], rhs[i]);
 521  
         }
 522  0
         return this;
 523  
     }
 524  
 
 525  
     /**
 526  
      * <p>Deep comparison of array of <code>long</code>. Length and all
 527  
      * values are compared.</p>
 528  
      *
 529  
      * <p>The method {@link #append(long, long)} is used.</p>
 530  
      *
 531  
      * @param lhs  the left hand <code>long[]</code>
 532  
      * @param rhs  the right hand <code>long[]</code>
 533  
      * @return EqualsBuilder - used to chain calls.
 534  
      */
 535  
     public EqualsBuilder append(long[] lhs, class="keyword">long[] rhs) {
 536  0
         if (isEquals == false) {
 537  0
             return this;
 538  
         }
 539  0
         if (lhs == rhs) {
 540  0
             return this;
 541  
         }
 542  0
         if (lhs == null || rhs == class="keyword">null) {
 543  0
             isEquals = false;
 544  0
             return this;
 545  
         }
 546  0
         if (lhs.length != rhs.length) {
 547  0
             isEquals = false;
 548  0
             return this;
 549  
         }
 550  0
         for (int i = 0; i < lhs.length && isEquals; ++i) {
 551  0
             append(lhs[i], rhs[i]);
 552  
         }
 553  0
         return this;
 554  
     }
 555  
 
 556  
     /**
 557  
      * <p>Deep comparison of array of <code>int</code>. Length and all
 558  
      * values are compared.</p>
 559  
      *
 560  
      * <p>The method {@link #append(int, int)} is used.</p>
 561  
      *
 562  
      * @param lhs  the left hand <code>int[]</code>
 563  
      * @param rhs  the right hand <code>int[]</code>
 564  
      * @return EqualsBuilder - used to chain calls.
 565  
      */
 566  
     public EqualsBuilder append(int[] lhs, class="keyword">int[] rhs) {
 567  0
         if (isEquals == false) {
 568  0
             return this;
 569  
         }
 570  0
         if (lhs == rhs) {
 571  0
             return this;
 572  
         }
 573  0
         if (lhs == null || rhs == class="keyword">null) {
 574  0
             isEquals = false;
 575  0
             return this;
 576  
         }
 577  0
         if (lhs.length != rhs.length) {
 578  0
             isEquals = false;
 579  0
             return this;
 580  
         }
 581  0
         for (int i = 0; i < lhs.length && isEquals; ++i) {
 582  0
             append(lhs[i], rhs[i]);
 583  
         }
 584  0
         return this;
 585  
     }
 586  
 
 587  
     /**
 588  
      * <p>Deep comparison of array of <code>short</code>. Length and all
 589  
      * values are compared.</p>
 590  
      *
 591  
      * <p>The method {@link #append(short, short)} is used.</p>
 592  
      *
 593  
      * @param lhs  the left hand <code>short[]</code>
 594  
      * @param rhs  the right hand <code>short[]</code>
 595  
      * @return EqualsBuilder - used to chain calls.
 596  
      */
 597  
     public EqualsBuilder append(short[] lhs, class="keyword">short[] rhs) {
 598  0
         if (isEquals == false) {
 599  0
             return this;
 600  
         }
 601  0
         if (lhs == rhs) {
 602  0
             return this;
 603  
         }
 604  0
         if (lhs == null || rhs == class="keyword">null) {
 605  0
             isEquals = false;
 606  0
             return this;
 607  
         }
 608  0
         if (lhs.length != rhs.length) {
 609  0
             isEquals = false;
 610  0
             return this;
 611  
         }
 612  0
         for (int i = 0; i < lhs.length && isEquals; ++i) {
 613  0
             append(lhs[i], rhs[i]);
 614  
         }
 615  0
         return this;
 616  
     }
 617  
 
 618  
     /**
 619  
      * <p>Deep comparison of array of <code>char</code>. Length and all
 620  
      * values are compared.</p>
 621  
      *
 622  
      * <p>The method {@link #append(char, char)} is used.</p>
 623  
      *
 624  
      * @param lhs  the left hand <code>char[]</code>
 625  
      * @param rhs  the right hand <code>char[]</code>
 626  
      * @return EqualsBuilder - used to chain calls.
 627  
      */
 628  
     public EqualsBuilder append(char[] lhs, class="keyword">char[] rhs) {
 629  0
         if (isEquals == false) {
 630  0
             return this;
 631  
         }
 632  0
         if (lhs == rhs) {
 633  0
             return this;
 634  
         }
 635  0
         if (lhs == null || rhs == class="keyword">null) {
 636  0
             isEquals = false;
 637  0
             return this;
 638  
         }
 639  0
         if (lhs.length != rhs.length) {
 640  0
             isEquals = false;
 641  0
             return this;
 642  
         }
 643  0
         for (int i = 0; i < lhs.length && isEquals; ++i) {
 644  0
             append(lhs[i], rhs[i]);
 645  
         }
 646  0
         return this;
 647  
     }
 648  
 
 649  
     /**
 650  
      * <p>Deep comparison of array of <code>byte</code>. Length and all
 651  
      * values are compared.</p>
 652  
      *
 653  
      * <p>The method {@link #append(byte, byte)} is used.</p>
 654  
      *
 655  
      * @param lhs  the left hand <code>byte[]</code>
 656  
      * @param rhs  the right hand <code>byte[]</code>
 657  
      * @return EqualsBuilder - used to chain calls.
 658  
      */
 659  
     public EqualsBuilder append(byte[] lhs, byte[] rhs) {
 660  0
         if (isEquals == false) {
 661  0
             return this;
 662  
         }
 663  0
         if (lhs == rhs) {
 664  0
             return this;
 665  
         }
 666  0
         if (lhs == null || rhs == class="keyword">null) {
 667  0
             isEquals = false;
 668  0
             return this;
 669  
         }
 670  0
         if (lhs.length != rhs.length) {
 671  0
             isEquals = false;
 672  0
             return this;
 673  
         }
 674  0
         for (int i = 0; i < lhs.length && isEquals; ++i) {
 675  0
             append(lhs[i], rhs[i]);
 676  
         }
 677  0
         return this;
 678  
     }
 679  
 
 680  
     /**
 681  
      * <p>Deep comparison of array of <code>double</code>. Length and all
 682  
      * values are compared.</p>
 683  
      *
 684  
      * <p>The method {@link #append(double, double)} is used.</p>
 685  
      *
 686  
      * @param lhs  the left hand <code>double[]</code>
 687  
      * @param rhs  the right hand <code>double[]</code>
 688  
      * @return EqualsBuilder - used to chain calls.
 689  
      */
 690  
     public EqualsBuilder append(double[] lhs, class="keyword">double[] rhs) {
 691  0
         if (isEquals == false) {
 692  0
             return this;
 693  
         }
 694  0
         if (lhs == rhs) {
 695  0
             return this;
 696  
         }
 697  0
         if (lhs == null || rhs == class="keyword">null) {
 698  0
             isEquals = false;
 699  0
             return this;
 700  
         }
 701  0
         if (lhs.length != rhs.length) {
 702  0
             isEquals = false;
 703  0
             return this;
 704  
         }
 705  0
         for (int i = 0; i < lhs.length && isEquals; ++i) {
 706  0
             append(lhs[i], rhs[i]);
 707  
         }
 708  0
         return this;
 709  
     }
 710  
 
 711  
     /**
 712  
      * <p>Deep comparison of array of <code>float</code>. Length and all
 713  
      * values are compared.</p>
 714  
      *
 715  
      * <p>The method {@link #append(float, float)} is used.</p>
 716  
      *
 717  
      * @param lhs  the left hand <code>float[]</code>
 718  
      * @param rhs  the right hand <code>float[]</code>
 719  
      * @return EqualsBuilder - used to chain calls.
 720  
      */
 721  
     public EqualsBuilder append(float[] lhs, class="keyword">float[] rhs) {
 722  0
         if (isEquals == false) {
 723  0
             return this;
 724  
         }
 725  0
         if (lhs == rhs) {
 726  0
             return this;
 727  
         }
 728  0
         if (lhs == null || rhs == class="keyword">null) {
 729  0
             isEquals = false;
 730  0
             return this;
 731  
         }
 732  0
         if (lhs.length != rhs.length) {
 733  0
             isEquals = false;
 734  0
             return this;
 735  
         }
 736  0
         for (int i = 0; i < lhs.length && isEquals; ++i) {
 737  0
             append(lhs[i], rhs[i]);
 738  
         }
 739  0
         return this;
 740  
     }
 741  
 
 742  
     /**
 743  
      * <p>Deep comparison of array of <code>boolean</code>. Length and all
 744  
      * values are compared.</p>
 745  
      *
 746  
      * <p>The method {@link #append(boolean, boolean)} is used.</p>
 747  
      *
 748  
      * @param lhs  the left hand <code>boolean[]</code>
 749  
      * @param rhs  the right hand <code>boolean[]</code>
 750  
      * @return EqualsBuilder - used to chain calls.
 751  
      */
 752  
     public EqualsBuilder append(boolean[] lhs, class="keyword">boolean[] rhs) {
 753  0
         if (isEquals == false) {
 754  0
             return this;
 755  
         }
 756  0
         if (lhs == rhs) {
 757  0
             return this;
 758  
         }
 759  0
         if (lhs == null || rhs == class="keyword">null) {
 760  0
             isEquals = false;
 761  0
             return this;
 762  
         }
 763  0
         if (lhs.length != rhs.length) {
 764  0
             isEquals = false;
 765  0
             return this;
 766  
         }
 767  0
         for (int i = 0; i < lhs.length && isEquals; ++i) {
 768  0
             append(lhs[i], rhs[i]);
 769  
         }
 770  0
         return this;
 771  
     }
 772  
 
 773  
     /**
 774  
      * <p>Return <code>true</code> if the fields that have been checked
 775  
      * are all equal.</p>
 776  
      *
 777  
      * @return boolean
 778  
      */
 779  
     public boolean isEquals() {
 780  2
         return isEquals;
 781  
     }
 782  
 
 783  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.