Coverage Report - net.sf.ezmorph.test.ArrayAssertions
 
Classes in this File Line Coverage Branch Coverage Complexity
ArrayAssertions
95%
587/617
90%
465/518
4.789
 
 1   
 /*
 2   
  * Copyright 2006-2007 the original author or authors.
 3   
  *
 4   
  * Licensed under the Apache License, Version 2.0 (the "License");
 5   
  * you may not use this file except in compliance with the License.
 6   
  * You may obtain a copy of the License at
 7   
  *
 8   
  *      http://www.apache.org/licenses/LICENSE-2.0
 9   
  *
 10   
  * Unless required by applicable law or agreed to in writing, software
 11   
  * distributed under the License is distributed on an "AS IS" BASIS,
 12   
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13   
  * See the License for the specific language governing permissions and
 14   
  * limitations under the License.
 15   
  */
 16   
 
 17   
 package net.sf.ezmorph.test;
 18   
 
 19   
 import java.util.List;
 20   
 
 21   
 import junit.framework.Assert;
 22   
 
 23   
 /**
 24   
  * Provides assertions on arrays (primitive and objects).<br>
 25   
  * All methods support multiple dimensional arrays.
 26   
  *
 27   
  * @author Andres Almiray <aalmiray@users.sourceforge.net>
 28   
  */
 29   
 public class ArrayAssertions extends Assert
 30   
 {
 31   
    /**
 32   
     * Asserts that two boolean[] are equal.<br>
 33   
     *
 34   
     * @param expecteds
 35   
     * @param actuals
 36   
     */
 37   
    public static void assertEquals( boolean[] expecteds, boolean[] actuals )
 38   
    {
 39  28 
       assertEquals( null, expecteds, actuals );
 40  16 
    }
 41   
 
 42   
    /**
 43   
     * Asserts that a boolean[] is equal to an Object[] (presumably an Boolean[])
 44   
     *
 45   
     * @param expecteds
 46   
     * @param actuals
 47   
     */
 48   
    public static void assertEquals( boolean[] expecteds, Object[] actuals )
 49   
    {
 50  20 
       assertEquals( null, expecteds, actuals );
 51  8 
    }
 52   
 
 53   
    /**
 54   
     * Asserts that two byte[] are equal.<br>
 55   
     *
 56   
     * @param expecteds
 57   
     * @param actuals
 58   
     */
 59   
    public static void assertEquals( byte[] expecteds, byte[] actuals )
 60   
    {
 61  28 
       assertEquals( null, expecteds, actuals );
 62  16 
    }
 63   
 
 64   
    /**
 65   
     * Asserts that a byte[] is equal to an Object[] (presumably an Byte[])
 66   
     *
 67   
     * @param expecteds
 68   
     * @param actuals
 69   
     */
 70   
    public static void assertEquals( byte[] expecteds, Object[] actuals )
 71   
    {
 72  16 
       assertEquals( null, expecteds, actuals );
 73  4 
    }
 74   
 
 75   
    /**
 76   
     * Asserts that two char[] are equal.<br>
 77   
     *
 78   
     * @param expecteds
 79   
     * @param actuals
 80   
     */
 81   
    public static void assertEquals( char[] expecteds, char[] actuals )
 82   
    {
 83  28 
       assertEquals( null, expecteds, actuals );
 84  16 
    }
 85   
 
 86   
    /**
 87   
     * Asserts that a char[] is equal to an Object[] (presumably an Character[])
 88   
     *
 89   
     * @param expecteds
 90   
     * @param actuals
 91   
     */
 92   
    public static void assertEquals( char[] expecteds, Object[] actuals )
 93   
    {
 94  16 
       assertEquals( null, expecteds, actuals );
 95  4 
    }
 96   
 
 97   
    /**
 98   
     * Asserts that two double[] are equal.<br>
 99   
     *
 100   
     * @param expecteds
 101   
     * @param actuals
 102   
     */
 103   
    public static void assertEquals( double[] expecteds, double[] actuals )
 104   
    {
 105  28 
       assertEquals( null, expecteds, actuals );
 106  16 
    }
 107   
 
 108   
    /**
 109   
     * Asserts that a double[] is equal to an Object[] (presumably an Double[])
 110   
     *
 111   
     * @param expecteds
 112   
     * @param actuals
 113   
     */
 114   
    public static void assertEquals( double[] expecteds, Object[] actuals )
 115   
    {
 116  16 
       assertEquals( null, expecteds, actuals );
 117  4 
    }
 118   
 
 119   
    /**
 120   
     * Asserts that two float[] are equal.<br>
 121   
     *
 122   
     * @param expecteds
 123   
     * @param actuals
 124   
     */
 125   
    public static void assertEquals( float[] expecteds, float[] actuals )
 126   
    {
 127  28 
       assertEquals( null, expecteds, actuals );
 128  16 
    }
 129   
 
 130   
    /**
 131   
     * Asserts that a float[] is equal to an Object[] (presumably an Float[])
 132   
     *
 133   
     * @param expecteds
 134   
     * @param actuals
 135   
     */
 136   
    public static void assertEquals( float[] expecteds, Object[] actuals )
 137   
    {
 138  16 
       assertEquals( null, expecteds, actuals );
 139  4 
    }
 140   
 
 141   
    /**
 142   
     * Asserts that two int[] are equal.<br>
 143   
     *
 144   
     * @param expecteds
 145   
     * @param actuals
 146   
     */
 147   
    public static void assertEquals( int[] expecteds, int[] actuals )
 148   
    {
 149  32 
       assertEquals( null, expecteds, actuals );
 150  20 
    }
 151   
 
 152   
    /**
 153   
     * Asserts that a int[] is equal to an Object[] (presumably an Integer[])
 154   
     *
 155   
     * @param expecteds
 156   
     * @param actuals
 157   
     */
 158   
    public static void assertEquals( int[] expecteds, Object[] actuals )
 159   
    {
 160  16 
       assertEquals( null, expecteds, actuals );
 161  4 
    }
 162   
 
 163   
    /**
 164   
     * Asserts that two Lists are equal.<br>
 165   
     *
 166   
     * @param expecteds
 167   
     * @param actuals
 168   
     */
 169   
    public static void assertEquals( List expecteds, List actuals )
 170   
    {
 171  16 
       assertEquals( null, expecteds, actuals );
 172  16 
    }
 173   
 
 174   
    /**
 175   
     * Asserts that two long[] are equal.<br>
 176   
     *
 177   
     * @param expecteds
 178   
     * @param actuals
 179   
     */
 180   
    public static void assertEquals( long[] expecteds, long[] actuals )
 181   
    {
 182  28 
       assertEquals( null, expecteds, actuals );
 183  16 
    }
 184   
 
 185   
    /**
 186   
     * Asserts that a long[] is equal to an Object[] (presumably an Long[])
 187   
     *
 188   
     * @param expecteds
 189   
     * @param actuals
 190   
     */
 191   
    public static void assertEquals( long[] expecteds, Object[] actuals )
 192   
    {
 193  16 
       assertEquals( null, expecteds, actuals );
 194  4 
    }
 195   
 
 196   
    /**
 197   
     * Asserts that two objects are equal. If they are not an
 198   
     * AssertionFailedError is thrown.
 199   
     *
 200   
     * @param expecteds
 201   
     * @param actuals
 202   
     */
 203   
    public static void assertEquals( Object expected, Object actual )
 204   
    {
 205  228 
       assertEquals( null, expected, actual );
 206  196 
    }
 207   
 
 208   
    /**
 209   
     * Asserts that Object[] (presumably an Boolean[]) is equal to an boolean[].
 210   
     *
 211   
     * @param expecteds
 212   
     * @param actuals
 213   
     */
 214   
    public static void assertEquals( Object[] expecteds, boolean[] actuals )
 215   
    {
 216  16 
       assertEquals( null, expecteds, actuals );
 217  4 
    }
 218   
 
 219   
    /**
 220   
     * Asserts that Object[] (presumably an Byte[]) is equal to an byte[].
 221   
     *
 222   
     * @param expecteds
 223   
     * @param actuals
 224   
     */
 225   
    public static void assertEquals( Object[] expecteds, byte[] actuals )
 226   
    {
 227  16 
       assertEquals( null, expecteds, actuals );
 228  4 
    }
 229   
 
 230   
    /**
 231   
     * Asserts that Object[] (presumably an Character[]) is equal to an char[].
 232   
     *
 233   
     * @param expecteds
 234   
     * @param actuals
 235   
     */
 236   
    public static void assertEquals( Object[] expecteds, char[] actuals )
 237   
    {
 238  16 
       assertEquals( null, expecteds, actuals );
 239  4 
    }
 240   
 
 241   
    /**
 242   
     * Asserts that Object[] (presumably an Double[]) is equal to an double[].
 243   
     *
 244   
     * @param expecteds
 245   
     * @param actuals
 246   
     */
 247   
    public static void assertEquals( Object[] expecteds, double[] actuals )
 248   
    {
 249  16 
       assertEquals( null, expecteds, actuals );
 250  4 
    }
 251   
 
 252   
    /**
 253   
     * Asserts that Object[] (presumably an Float[]) is equal to an float[].
 254   
     *
 255   
     * @param expecteds
 256   
     * @param actuals
 257   
     */
 258   
    public static void assertEquals( Object[] expecteds, float[] actuals )
 259   
    {
 260  16 
       assertEquals( null, expecteds, actuals );
 261  4 
    }
 262   
 
 263   
    /**
 264   
     * Asserts that Object[] (presumably an Integer[]) is equal to an int[].
 265   
     *
 266   
     * @param expecteds
 267   
     * @param actuals
 268   
     */
 269   
    public static void assertEquals( Object[] expecteds, int[] actuals )
 270   
    {
 271  16 
       assertEquals( null, expecteds, actuals );
 272  4 
    }
 273   
 
 274   
    /**
 275   
     * Asserts that Object[] (presumably an Long[]) is equal to an long[].
 276   
     *
 277   
     * @param expecteds
 278   
     * @param actuals
 279   
     */
 280   
    public static void assertEquals( Object[] expecteds, long[] actuals )
 281   
    {
 282  16 
       assertEquals( null, expecteds, actuals );
 283  4 
    }
 284   
 
 285   
    /**
 286   
     * Asserts that two Object[] are equal.<br>
 287   
     *
 288   
     * @param expecteds
 289   
     * @param actuals
 290   
     */
 291   
    public static void assertEquals( Object[] expecteds, Object[] actuals )
 292   
    {
 293  516 
       assertEquals( null, expecteds, actuals );
 294  496 
    }
 295   
 
 296   
    /**
 297   
     * Asserts that Object[] (presumably an Short[]) is equal to an short[].
 298   
     *
 299   
     * @param expecteds
 300   
     * @param actuals
 301   
     */
 302   
    public static void assertEquals( Object[] expecteds, short[] actuals )
 303   
    {
 304  16 
       assertEquals( null, expecteds, actuals );
 305  4 
    }
 306   
 
 307   
    /**
 308   
     * Asserts that a short[] is equal to an Object[] (presumably an Short[])
 309   
     *
 310   
     * @param expecteds
 311   
     * @param actuals
 312   
     */
 313   
    public static void assertEquals( short[] expecteds, Object[] actuals )
 314   
    {
 315  16 
       assertEquals( null, expecteds, actuals );
 316  4 
    }
 317   
 
 318   
    /**
 319   
     * Asserts that two short[] are equal.<br>
 320   
     *
 321   
     * @param expecteds
 322   
     * @param actuals
 323   
     */
 324   
    public static void assertEquals( short[] expecteds, short[] actuals )
 325   
    {
 326  28 
       assertEquals( null, expecteds, actuals );
 327  16 
    }
 328   
 
 329   
    /**
 330   
     * Asserts that two boolean[] are equal.<br>
 331   
     *
 332   
     * @param message
 333   
     * @param expecteds
 334   
     * @param actuals
 335   
     */
 336   
    public static void assertEquals( String message, boolean[] expecteds, boolean[] actuals )
 337   
    {
 338  72 
       if( expecteds == actuals ){
 339  28 
          return;
 340   
       }
 341  44 
       String header = message == null ? "" : message + ": ";
 342  44 
       if( expecteds == null ){
 343  4 
          fail( header + "expected array was null" );
 344   
       }
 345  40 
       if( actuals == null ){
 346  4 
          fail( header + "actual array was null" );
 347   
       }
 348  36 
       if( actuals.length != expecteds.length ){
 349  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 350  3 
                + " actual.length=" + actuals.length );
 351   
       }
 352   
 
 353  116 
       for( int i = 0; i < expecteds.length; i++ ){
 354  147 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 355  63 
                actuals[i] );
 356   
       }
 357  32 
    }
 358   
 
 359   
    /**
 360   
     * Asserts that a boolean[] is equal to an Object[] (presumably an Boolean[])
 361   
     *
 362   
     * @param message
 363   
     * @param expecteds
 364   
     * @param actuals
 365   
     */
 366   
    public static void assertEquals( String message, boolean[] expecteds, Object[] actuals )
 367   
    {
 368  60 
       String header = message == null ? "" : message + ": ";
 369  60 
       if( expecteds == null ){
 370  4 
          fail( header + "expected array was null" );
 371   
       }
 372  56 
       if( actuals == null ){
 373  4 
          fail( header + "actual array was null" );
 374   
       }
 375  52 
       if( actuals.length != expecteds.length ){
 376  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 377  3 
                + " actual.length=" + actuals.length );
 378   
       }
 379   
 
 380  128 
       for( int i = 0; i < expecteds.length; i++ ){
 381  140 
          assertEquals( header + "arrays first differed at element [" + i + "];", new Boolean(
 382  60 
                expecteds[i] ), actuals[i] );
 383   
       }
 384  48 
    }
 385   
 
 386   
    /**
 387   
     * Asserts that two byte[] are equal.<br>
 388   
     *
 389   
     * @param message
 390   
     * @param expecteds
 391   
     * @param actuals
 392   
     */
 393   
    public static void assertEquals( String message, byte[] expecteds, byte[] actuals )
 394   
    {
 395  72 
       if( expecteds == actuals ){
 396  28 
          return;
 397   
       }
 398  44 
       String header = message == null ? "" : message + ": ";
 399  44 
       if( expecteds == null ){
 400  4 
          fail( header + "expected array was null" );
 401   
       }
 402  40 
       if( actuals == null ){
 403  4 
          fail( header + "actual array was null" );
 404   
       }
 405  36 
       if( actuals.length != expecteds.length ){
 406  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 407  3 
                + " actual.length=" + actuals.length );
 408   
       }
 409   
 
 410  104 
       for( int i = 0; i < expecteds.length; i++ ){
 411  126 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 412  54 
                actuals[i] );
 413   
       }
 414  32 
    }
 415   
 
 416   
    /**
 417   
     * Asserts that a byte[] is equal to an Object[] (presumably an Byte[])
 418   
     *
 419   
     * @param message
 420   
     * @param expecteds
 421   
     * @param actuals
 422   
     */
 423   
    public static void assertEquals( String message, byte[] expecteds, Object[] actuals )
 424   
    {
 425  32 
       String header = message == null ? "" : message + ": ";
 426  32 
       if( expecteds == null ){
 427  4 
          fail( header + "expected array was null" );
 428   
       }
 429  28 
       if( actuals == null ){
 430  4 
          fail( header + "actual array was null" );
 431   
       }
 432  24 
       if( actuals.length != expecteds.length ){
 433  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 434  3 
                + " actual.length=" + actuals.length );
 435   
       }
 436   
 
 437  60 
       for( int i = 0; i < expecteds.length; i++ ){
 438  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", new Byte(
 439  30 
                expecteds[i] ), actuals[i] );
 440   
       }
 441  20 
    }
 442   
 
 443   
    /**
 444   
     * Asserts that two char[] are equal.<br>
 445   
     *
 446   
     * @param message
 447   
     * @param expecteds
 448   
     * @param actuals
 449   
     */
 450   
    public static void assertEquals( String message, char[] expecteds, char[] actuals )
 451   
    {
 452  72 
       if( expecteds == actuals ){
 453  28 
          return;
 454   
       }
 455  44 
       String header = message == null ? "" : message + ": ";
 456  44 
       if( expecteds == null ){
 457  4 
          fail( header + "expected array was null" );
 458   
       }
 459  40 
       if( actuals == null ){
 460  4 
          fail( header + "actual array was null" );
 461   
       }
 462  36 
       if( actuals.length != expecteds.length ){
 463  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 464  3 
                + " actual.length=" + actuals.length );
 465   
       }
 466   
 
 467  104 
       for( int i = 0; i < expecteds.length; i++ ){
 468  126 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 469  54 
                actuals[i] );
 470   
       }
 471  32 
    }
 472   
 
 473   
    /**
 474   
     * Asserts that a char[] is equal to an Object[] (presumably an Character[])
 475   
     *
 476   
     * @param message
 477   
     * @param expecteds
 478   
     * @param actuals
 479   
     */
 480   
    public static void assertEquals( String message, char[] expecteds, Object[] actuals )
 481   
    {
 482  32 
       String header = message == null ? "" : message + ": ";
 483  32 
       if( expecteds == null ){
 484  4 
          fail( header + "expected array was null" );
 485   
       }
 486  28 
       if( actuals == null ){
 487  4 
          fail( header + "actual array was null" );
 488   
       }
 489  24 
       if( actuals.length != expecteds.length ){
 490  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 491  3 
                + " actual.length=" + actuals.length );
 492   
       }
 493   
 
 494  60 
       for( int i = 0; i < expecteds.length; i++ ){
 495  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", new Character(
 496  30 
                expecteds[i] ), actuals[i] );
 497   
       }
 498  20 
    }
 499   
 
 500   
    /**
 501   
     * Asserts that two double[] are equal.<br>
 502   
     *
 503   
     * @param message
 504   
     * @param expecteds
 505   
     * @param actuals
 506   
     */
 507   
    public static void assertEquals( String message, double[] expecteds, double[] actuals )
 508   
    {
 509  72 
       if( expecteds == actuals ){
 510  28 
          return;
 511   
       }
 512  44 
       String header = message == null ? "" : message + ": ";
 513  44 
       if( expecteds == null ){
 514  4 
          fail( header + "expected array was null" );
 515   
       }
 516  40 
       if( actuals == null ){
 517  4 
          fail( header + "actual array was null" );
 518   
       }
 519  36 
       if( actuals.length != expecteds.length ){
 520  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 521  3 
                + " actual.length=" + actuals.length );
 522   
       }
 523   
 
 524  104 
       for( int i = 0; i < expecteds.length; i++ ){
 525  126 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 526  54 
                actuals[i], 0d );
 527   
       }
 528  32 
    }
 529   
 
 530   
    /**
 531   
     * Asserts that a double[] is equal to an Object[] (presumably an Double[])
 532   
     *
 533   
     * @param message
 534   
     * @param expecteds
 535   
     * @param actuals
 536   
     */
 537   
    public static void assertEquals( String message, double[] expecteds, Object[] actuals )
 538   
    {
 539  32 
       String header = message == null ? "" : message + ": ";
 540  32 
       if( expecteds == null ){
 541  4 
          fail( header + "expected array was null" );
 542   
       }
 543  28 
       if( actuals == null ){
 544  4 
          fail( header + "actual array was null" );
 545   
       }
 546  24 
       if( actuals.length != expecteds.length ){
 547  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 548  3 
                + " actual.length=" + actuals.length );
 549   
       }
 550   
 
 551  60 
       for( int i = 0; i < expecteds.length; i++ ){
 552  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", new Double(
 553  30 
                expecteds[i] ), actuals[i] );
 554   
       }
 555  20 
    }
 556   
 
 557   
    /**
 558   
     * Asserts that two float[] are equal.<br>
 559   
     *
 560   
     * @param message
 561   
     * @param expecteds
 562   
     * @param actuals
 563   
     */
 564   
    public static void assertEquals( String message, float[] expecteds, float[] actuals )
 565   
    {
 566  72 
       if( expecteds == actuals ){
 567  28 
          return;
 568   
       }
 569  44 
       String header = message == null ? "" : message + ": ";
 570  44 
       if( expecteds == null ){
 571  4 
          fail( header + "expected array was null" );
 572   
       }
 573  40 
       if( actuals == null ){
 574  4 
          fail( header + "actual array was null" );
 575   
       }
 576  36 
       if( actuals.length != expecteds.length ){
 577  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 578  3 
                + " actual.length=" + actuals.length );
 579   
       }
 580   
 
 581  104 
       for( int i = 0; i < expecteds.length; i++ ){
 582  126 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 583  54 
                actuals[i], 0f );
 584   
       }
 585  32 
    }
 586   
 
 587   
    /**
 588   
     * Asserts that a float[] is equal to an Object[] (presumably an Float[])
 589   
     *
 590   
     * @param message
 591   
     * @param expecteds
 592   
     * @param actuals
 593   
     */
 594   
    public static void assertEquals( String message, float[] expecteds, Object[] actuals )
 595   
    {
 596  32 
       String header = message == null ? "" : message + ": ";
 597  32 
       if( expecteds == null ){
 598  4 
          fail( header + "expected array was null" );
 599   
       }
 600  28 
       if( actuals == null ){
 601  4 
          fail( header + "actual array was null" );
 602   
       }
 603  24 
       if( actuals.length != expecteds.length ){
 604  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 605  3 
                + " actual.length=" + actuals.length );
 606   
       }
 607   
 
 608  60 
       for( int i = 0; i < expecteds.length; i++ ){
 609  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", new Float(
 610  30 
                expecteds[i] ), actuals[i] );
 611   
       }
 612  20 
    }
 613   
 
 614   
    /**
 615   
     * Asserts that two int[] are equal.<br>
 616   
     *
 617   
     * @param message
 618   
     * @param expecteds
 619   
     * @param actuals
 620   
     */
 621   
    public static void assertEquals( String message, int[] expecteds, int[] actuals )
 622   
    {
 623  76 
       if( expecteds == actuals ){
 624  28 
          return;
 625   
       }
 626  48 
       String header = message == null ? "" : message + ": ";
 627  48 
       if( expecteds == null ){
 628  4 
          fail( header + "expected array was null" );
 629   
       }
 630  44 
       if( actuals == null ){
 631  4 
          fail( header + "actual array was null" );
 632   
       }
 633  40 
       if( actuals.length != expecteds.length ){
 634  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 635  3 
                + " actual.length=" + actuals.length );
 636   
       }
 637   
 
 638  120 
       for( int i = 0; i < expecteds.length; i++ ){
 639  147 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 640  63 
                actuals[i] );
 641   
       }
 642  36 
    }
 643   
 
 644   
    /**
 645   
     * Asserts that a int[] is equal to an Object[] (presumably an Integer[])
 646   
     *
 647   
     * @param message
 648   
     * @param expecteds
 649   
     * @param actuals
 650   
     */
 651   
    public static void assertEquals( String message, int[] expecteds, Object[] actuals )
 652   
    {
 653  32 
       String header = message == null ? "" : message + ": ";
 654  32 
       if( expecteds == null ){
 655  4 
          fail( header + "expected array was null" );
 656   
       }
 657  28 
       if( actuals == null ){
 658  4 
          fail( header + "actual array was null" );
 659   
       }
 660  24 
       if( actuals.length != expecteds.length ){
 661  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 662  3 
                + " actual.length=" + actuals.length );
 663   
       }
 664   
 
 665  60 
       for( int i = 0; i < expecteds.length; i++ ){
 666  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", new Integer(
 667  30 
                expecteds[i] ), actuals[i] );
 668   
       }
 669  20 
    }
 670   
 
 671   
    /**
 672   
     * Asserts that two Lists are equal.<br>
 673   
     *
 674   
     * @param message
 675   
     * @param expecteds
 676   
     * @param actuals
 677   
     */
 678   
    public static void assertEquals( String message, List expecteds, List actuals )
 679   
    {
 680  16 
       String header = message == null ? "" : message + ": ";
 681  16 
       if( expecteds == null ){
 682  0 
          fail( header + "expected list was null" );
 683   
       }
 684  16 
       if( actuals == null ){
 685  0 
          fail( header + "actual list was null" );
 686   
       }
 687  16 
       if( expecteds == actuals || expecteds.equals( actuals ) ){
 688  16 
          return;
 689   
       }
 690  0 
       if( actuals.size() != expecteds.size() ){
 691  0 
          fail( header + "list sizes differed, expected.size()=" + expecteds.size()
 692  0 
                + " actual.size()=" + actuals.size() );
 693   
       }
 694   
 
 695  0 
       int max = expecteds.size();
 696  0 
       for( int i = 0; i < max; i++ ){
 697  0 
          Object o1 = expecteds.get( i );
 698  0 
          Object o2 = actuals.get( i );
 699   
 
 700   
          // handle nulls
 701  0 
          if( o1 == null ){
 702  0 
             if( o2 == null ){
 703  0 
                return;
 704   
             }else{
 705  0 
                fail( header + "lists first differed at element [" + i + "];" );
 706   
             }
 707   
          }else{
 708  0 
             if( o2 == null ){
 709  0 
                fail( header + "lists first differed at element [" + i + "];" );
 710   
             }
 711   
          }
 712   
 
 713  0 
          if( o1.getClass()
 714  0 
                .isArray() && o2.getClass()
 715  0 
                .isArray() ){
 716  0 
             Object[] expected = (Object[]) o1;
 717  0 
             Object[] actual = (Object[]) o2;
 718  0 
             assertEquals( header + "lists first differed at element " + i + ";", expected, actual );
 719  8 
          }else if( List.class.isAssignableFrom( o1.getClass() )
 720  0 
                && List.class.isAssignableFrom( o2.getClass() ) ){
 721  0 
             assertEquals( header + "lists first differed at element [" + i + "];", (List) o1,
 722  0 
                   (List) o2 );
 723   
          }else{
 724  0 
             assertEquals( header + "lists first differed at element [" + i + "];", o1, o2 );
 725   
          }
 726   
       }
 727  0 
    }
 728   
 
 729   
    /**
 730   
     * Asserts that two long[] are equal.<br>
 731   
     *
 732   
     * @param message
 733   
     * @param expecteds
 734   
     * @param actuals
 735   
     */
 736   
    public static void assertEquals( String message, long[] expecteds, long[] actuals )
 737   
    {
 738  72 
       if( expecteds == actuals ){
 739  28 
          return;
 740   
       }
 741  44 
       String header = message == null ? "" : message + ": ";
 742  44 
       if( expecteds == null ){
 743  4 
          fail( header + "expected array was null" );
 744   
       }
 745  40 
       if( actuals == null ){
 746  4 
          fail( header + "actual array was null" );
 747   
       }
 748  36 
       if( actuals.length != expecteds.length ){
 749  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 750  3 
                + " actual.length=" + actuals.length );
 751   
       }
 752   
 
 753  104 
       for( int i = 0; i < expecteds.length; i++ ){
 754  126 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 755  54 
                actuals[i] );
 756   
       }
 757  32 
    }
 758   
 
 759   
    /**
 760   
     * Asserts that a long[] is equal to an Object[] (presumably an Long[])
 761   
     *
 762   
     * @param message
 763   
     * @param expecteds
 764   
     * @param actuals
 765   
     */
 766   
    public static void assertEquals( String message, long[] expecteds, Object[] actuals )
 767   
    {
 768  32 
       String header = message == null ? "" : message + ": ";
 769  32 
       if( expecteds == null ){
 770  4 
          fail( header + "expected array was null" );
 771   
       }
 772  28 
       if( actuals == null ){
 773  4 
          fail( header + "actual array was null" );
 774   
       }
 775  24 
       if( actuals.length != expecteds.length ){
 776  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 777  3 
                + " actual.length=" + actuals.length );
 778   
       }
 779   
 
 780  60 
       for( int i = 0; i < expecteds.length; i++ ){
 781  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", new Long(
 782  30 
                expecteds[i] ), actuals[i] );
 783   
       }
 784  20 
    }
 785   
 
 786   
    /**
 787   
     * Asserts that two objects are equal. If they are not an
 788   
     * AssertionFailedError is thrown with the given message. *
 789   
     *
 790   
     * @param message
 791   
     * @param expecteds
 792   
     * @param actuals
 793   
     */
 794   
    public static void assertEquals( String message, Object expected, Object actual )
 795   
    {
 796  1424 
       if( expected == null && actual == null )
 797  4 
          return;
 798  1420 
       if( expected != null && expected.equals( actual ) )
 799  1196 
          return;
 800  224 
       Class expectedClass = expected.getClass();
 801  224 
       Class actualClass = actual.getClass();
 802  224 
       if( expectedClass.isArray() && actualClass.isArray() ){
 803  224 
          Class expectedInnerType = expectedClass.getComponentType();
 804  224 
          Class actualInnerType = actualClass.getComponentType();
 805  224 
          if( expectedInnerType.isPrimitive() ){
 806  224 
             assertExpectedPrimitiveArrays( message, expected, actual, expectedInnerType,
 807  96 
                   actualInnerType );
 808  96 
          }else if( actualInnerType.isPrimitive() ){
 809  112 
             assertActualPrimitiveArrays( message, expected, actual, expectedInnerType,
 810  48 
                   actualInnerType );
 811   
          }else{
 812  32 
             assertEquals( message, (Object[]) expected, (Object[]) actual );
 813   
          }
 814  48 
       }else{
 815  0 
          failNotEquals( message, expected, actual );
 816   
       }
 817  192 
    }
 818   
 
 819   
    /**
 820   
     * Asserts that Object[] (presumably an Boolean[]) is equal to an boolean[].
 821   
     *
 822   
     * @param message
 823   
     * @param expecteds
 824   
     * @param actuals
 825   
     */
 826   
    public static void assertEquals( String message, Object[] expecteds, boolean[] actuals )
 827   
    {
 828  32 
       String header = message == null ? "" : message + ": ";
 829  32 
       if( expecteds == null ){
 830  4 
          fail( header + "expected array was null" );
 831   
       }
 832  28 
       if( actuals == null ){
 833  4 
          fail( header + "actual array was null" );
 834   
       }
 835  24 
       if( actuals.length != expecteds.length ){
 836  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 837  3 
                + " actual.length=" + actuals.length );
 838   
       }
 839   
 
 840  60 
       for( int i = 0; i < expecteds.length; i++ ){
 841  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 842  30 
                new Boolean( actuals[i] ) );
 843   
       }
 844  20 
    }
 845   
 
 846   
    /**
 847   
     * Asserts that Object[] (presumably an Byte[]) is equal to an byte[].
 848   
     *
 849   
     * @param message
 850   
     * @param expecteds
 851   
     * @param actuals
 852   
     */
 853   
    public static void assertEquals( String message, Object[] expecteds, byte[] actuals )
 854   
    {
 855  32 
       String header = message == null ? "" : message + ": ";
 856  32 
       if( expecteds == null ){
 857  4 
          fail( header + "expected array was null" );
 858   
       }
 859  28 
       if( actuals == null ){
 860  4 
          fail( header + "actual array was null" );
 861   
       }
 862  24 
       if( actuals.length != expecteds.length ){
 863  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 864  3 
                + " actual.length=" + actuals.length );
 865   
       }
 866   
 
 867  60 
       for( int i = 0; i < expecteds.length; i++ ){
 868  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 869  30 
                new Byte( actuals[i] ) );
 870   
       }
 871  20 
    }
 872   
 
 873   
    /**
 874   
     * Asserts that Object[] (presumably an Character[]) is equal to an char[].
 875   
     *
 876   
     * @param message
 877   
     * @param expecteds
 878   
     * @param actuals
 879   
     */
 880   
    public static void assertEquals( String message, Object[] expecteds, char[] actuals )
 881   
    {
 882  32 
       String header = message == null ? "" : message + ": ";
 883  32 
       if( expecteds == null ){
 884  4 
          fail( header + "expected array was null" );
 885   
       }
 886  28 
       if( actuals == null ){
 887  4 
          fail( header + "actual array was null" );
 888   
       }
 889  24 
       if( actuals.length != expecteds.length ){
 890  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 891  3 
                + " actual.length=" + actuals.length );
 892   
       }
 893   
 
 894  60 
       for( int i = 0; i < expecteds.length; i++ ){
 895  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 896  30 
                new Character( actuals[i] ) );
 897   
       }
 898  20 
    }
 899   
 
 900   
    /**
 901   
     * Asserts that Object[] (presumably an Double[]) is equal to an double[].
 902   
     *
 903   
     * @param message
 904   
     * @param expecteds
 905   
     * @param actuals
 906   
     */
 907   
    public static void assertEquals( String message, Object[] expecteds, double[] actuals )
 908   
    {
 909  32 
       String header = message == null ? "" : message + ": ";
 910  32 
       if( expecteds == null ){
 911  4 
          fail( header + "expected array was null" );
 912   
       }
 913  28 
       if( actuals == null ){
 914  4 
          fail( header + "actual array was null" );
 915   
       }
 916  24 
       if( actuals.length != expecteds.length ){
 917  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 918  3 
                + " actual.length=" + actuals.length );
 919   
       }
 920   
 
 921  60 
       for( int i = 0; i < expecteds.length; i++ ){
 922  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 923  30 
                new Double( actuals[i] ) );
 924   
       }
 925  20 
    }
 926   
 
 927   
    /**
 928   
     * Asserts that Object[] (presumably an Float[]) is equal to an float[].
 929   
     *
 930   
     * @param message
 931   
     * @param expecteds
 932   
     * @param actuals
 933   
     */
 934   
    public static void assertEquals( String message, Object[] expecteds, float[] actuals )
 935   
    {
 936  32 
       String header = message == null ? "" : message + ": ";
 937  32 
       if( expecteds == null ){
 938  4 
          fail( header + "expected array was null" );
 939   
       }
 940  28 
       if( actuals == null ){
 941  4 
          fail( header + "actual array was null" );
 942   
       }
 943  24 
       if( actuals.length != expecteds.length ){
 944  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 945  3 
                + " actual.length=" + actuals.length );
 946   
       }
 947   
 
 948  60 
       for( int i = 0; i < expecteds.length; i++ ){
 949  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 950  30 
                new Float( actuals[i] ) );
 951   
       }
 952  20 
    }
 953   
 
 954   
    /**
 955   
     * Asserts that Object[] (presumably an Integer[]) is equal to an int[].
 956   
     *
 957   
     * @param message
 958   
     * @param expecteds
 959   
     * @param actuals
 960   
     */
 961   
    public static void assertEquals( String message, Object[] expecteds, int[] actuals )
 962   
    {
 963  32 
       String header = message == null ? "" : message + ": ";
 964  32 
       if( expecteds == null ){
 965  4 
          fail( header + "expected array was null" );
 966   
       }
 967  28 
       if( actuals == null ){
 968  4 
          fail( header + "actual array was null" );
 969   
       }
 970  24 
       if( actuals.length != expecteds.length ){
 971  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 972  3 
                + " actual.length=" + actuals.length );
 973   
       }
 974   
 
 975  60 
       for( int i = 0; i < expecteds.length; i++ ){
 976  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 977  30 
                new Integer( actuals[i] ) );
 978   
       }
 979  20 
    }
 980   
 
 981   
    /**
 982   
     * Asserts that Object[] (presumably an Long[]) is equal to an long[].
 983   
     *
 984   
     * @param message
 985   
     * @param expecteds
 986   
     * @param actuals
 987   
     */
 988   
    public static void assertEquals( String message, Object[] expecteds, long[] actuals )
 989   
    {
 990  32 
       String header = message == null ? "" : message + ": ";
 991  32 
       if( expecteds == null ){
 992  4 
          fail( header + "expected array was null" );
 993   
       }
 994  28 
       if( actuals == null ){
 995  4 
          fail( header + "actual array was null" );
 996   
       }
 997  24 
       if( actuals.length != expecteds.length ){
 998  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 999  3 
                + " actual.length=" + actuals.length );
 1000   
       }
 1001   
 
 1002  60 
       for( int i = 0; i < expecteds.length; i++ ){
 1003  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 1004  30 
                new Long( actuals[i] ) );
 1005   
       }
 1006  20 
    }
 1007   
 
 1008   
    /**
 1009   
     * Asserts that two Object[] are equal.<br>
 1010   
     *
 1011   
     * @param message
 1012   
     * @param expecteds
 1013   
     * @param actuals
 1014   
     */
 1015   
    public static void assertEquals( String message, Object[] expecteds, Object[] actuals )
 1016   
    {
 1017  828 
       if( expecteds == actuals ){
 1018  56 
          return;
 1019   
       }
 1020  772 
       String header = message == null ? "" : message + ": ";
 1021  772 
       if( expecteds == null ){
 1022  4 
          fail( header + "expected array was null" );
 1023   
       }
 1024  768 
       if( actuals == null ){
 1025  4 
          fail( header + "actual array was null" );
 1026   
       }
 1027  764 
       if( actuals.length != expecteds.length ){
 1028  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 1029  3 
                + " actual.length=" + actuals.length );
 1030   
       }
 1031   
 
 1032  2028 
       for( int i = 0; i < expecteds.length; i++ ){
 1033  1360 
          Object o1 = expecteds[i];
 1034  1360 
          Object o2 = actuals[i];
 1035   
 
 1036  1360 
          if( o1 == null ){
 1037  88 
             if( o2 == null ){
 1038  84 
                return;
 1039   
             }else{
 1040  4 
                fail( header + "arrays first differed at element [" + i + "];" );
 1041   
             }
 1042   
          }else{
 1043  1272 
             if( o2 == null ){
 1044  4 
                fail( header + "arrays first differed at element [" + i + "];" );
 1045   
             }
 1046   
          }
 1047   
 
 1048  1268 
          if( o1.getClass()
 1049  951 
                .isArray() && o2.getClass()
 1050  564 
                .isArray() ){
 1051  1316 
             Class type1 = o1.getClass()
 1052  564 
                   .getComponentType();
 1053  1316 
             Class type2 = o2.getClass()
 1054  564 
                   .getComponentType();
 1055  752 
             if( type1.isPrimitive() ){
 1056  408 
                if( type1 == Boolean.TYPE ){
 1057  72 
                   if( type2 == Boolean.TYPE ){
 1058  70 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1059  30 
                            (boolean[]) o1, (boolean[]) o2 );
 1060   
                   }else{
 1061  56 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1062  24 
                            (boolean[]) o1, (Object[]) o2 );
 1063   
                   }
 1064  336 
                }else if( type1 == Byte.TYPE ){
 1065  48 
                   if( type2 == Byte.TYPE ){
 1066  70 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1067  30 
                            (byte[]) o1, (byte[]) o2 );
 1068   
                   }else{
 1069  14 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1070  6 
                            (byte[]) o1, (Object[]) o2 );
 1071   
                   }
 1072  288 
                }else if( type1 == Short.TYPE ){
 1073  48 
                   if( type2 == Short.TYPE ){
 1074  70 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1075  30 
                            (short[]) o1, (short[]) o2 );
 1076   
                   }else{
 1077  14 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1078  6 
                            (short[]) o1, (Object[]) o2 );
 1079   
                   }
 1080  240 
                }else if( type1 == Integer.TYPE ){
 1081  48 
                   if( type2 == Integer.TYPE ){
 1082  70 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1083  30 
                            (int[]) o1, (int[]) o2 );
 1084   
                   }else{
 1085  14 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1086  6 
                            (int[]) o1, (Object[]) o2 );
 1087   
                   }
 1088  192 
                }else if( type1 == Long.TYPE ){
 1089  48 
                   if( type2 == Long.TYPE ){
 1090  70 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1091  30 
                            (long[]) o1, (long[]) o2 );
 1092   
                   }else{
 1093  14 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1094  6 
                            (long[]) o1, (Object[]) o2 );
 1095   
                   }
 1096  144 
                }else if( type1 == Float.TYPE ){
 1097  48 
                   if( type2 == Float.TYPE ){
 1098  70 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1099  30 
                            (float[]) o1, (float[]) o2 );
 1100   
                   }else{
 1101  14 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1102  6 
                            (float[]) o1, (Object[]) o2 );
 1103   
                   }
 1104  96 
                }else if( type1 == Double.TYPE ){
 1105  48 
                   if( type2 == Double.TYPE ){
 1106  70 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1107  30 
                            (double[]) o1, (double[]) o2 );
 1108   
                   }else{
 1109  14 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1110  6 
                            (double[]) o1, (Object[]) o2 );
 1111   
                   }
 1112  48 
                }else if( type1 == Character.TYPE ){
 1113  48 
                   if( type2 == Character.TYPE ){
 1114  70 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1115  30 
                            (char[]) o1, (char[]) o2 );
 1116   
                   }else{
 1117  14 
                      assertEquals( header + "arrays first differed at element " + i + ";",
 1118  6 
                            (char[]) o1, (Object[]) o2 );
 1119   
                   }
 1120   
                }
 1121  344 
             }else if( type2.isPrimitive() ){
 1122  64 
                if( type2 == Boolean.TYPE ){
 1123  14 
                   assertEquals( header + "arrays first differed at element " + i + ";",
 1124  6 
                         (Object[]) o1, (boolean[]) o2 );
 1125  56 
                }else if( type2 == Byte.TYPE ){
 1126  14 
                   assertEquals( header + "arrays first differed at element " + i + ";",
 1127  6 
                         (Object[]) o1, (byte[]) o2 );
 1128  48 
                }else if( type2 == Short.TYPE ){
 1129  14 
                   assertEquals( header + "arrays first differed at element " + i + ";",
 1130  6 
                         (Object[]) o1, (short[]) o2 );
 1131  40 
                }else if( type2 == Integer.TYPE ){
 1132  14 
                   assertEquals( header + "arrays first differed at element " + i + ";",
 1133  6 
                         (Object[]) o1, (int[]) o2 );
 1134  32 
                }else if( type2 == Long.TYPE ){
 1135  14 
                   assertEquals( header + "arrays first differed at element " + i + ";",
 1136  6 
                         (Object[]) o1, (long[]) o2 );
 1137  24 
                }else if( type2 == Float.TYPE ){
 1138  14 
                   assertEquals( header + "arrays first differed at element " + i + ";",
 1139  6 
                         (Object[]) o1, (float[]) o2 );
 1140  16 
                }else if( type2 == Double.TYPE ){
 1141  14 
                   assertEquals( header + "arrays first differed at element " + i + ";",
 1142  6 
                         (Object[]) o1, (double[]) o2 );
 1143  8 
                }else if( type2 == Character.TYPE ){
 1144  14 
                   assertEquals( header + "arrays first differed at element " + i + ";",
 1145  6 
                         (Object[]) o1, (char[]) o2 );
 1146   
                }
 1147   
             }else{
 1148  280 
                Object[] expected = (Object[]) o1;
 1149  280 
                Object[] actual = (Object[]) o2;
 1150  490 
                assertEquals( header + "arrays first differed at element " + i + ";", expected,
 1151  210 
                      actual );
 1152   
             }
 1153  188 
          }else{
 1154  516 
             assertEquals( header + "arrays first differed at element [" + i + "];", o1, o2 );
 1155   
          }
 1156   
       }
 1157  668 
    }
 1158   
 
 1159   
    /**
 1160   
     * Asserts that Object[] (presumably an Short[]) is equal to a short[].
 1161   
     *
 1162   
     * @param message
 1163   
     * @param expecteds
 1164   
     * @param actuals
 1165   
     */
 1166   
    public static void assertEquals( String message, Object[] expecteds, short[] actuals )
 1167   
    {
 1168  32 
       String header = message == null ? "" : message + ": ";
 1169  32 
       if( expecteds == null ){
 1170  4 
          fail( header + "expected array was null" );
 1171   
       }
 1172  28 
       if( actuals == null ){
 1173  4 
          fail( header + "actual array was null" );
 1174   
       }
 1175  24 
       if( actuals.length != expecteds.length ){
 1176  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 1177  3 
                + " actual.length=" + actuals.length );
 1178   
       }
 1179   
 
 1180  60 
       for( int i = 0; i < expecteds.length; i++ ){
 1181  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 1182  30 
                new Short( actuals[i] ) );
 1183   
       }
 1184  20 
    }
 1185   
 
 1186   
    /**
 1187   
     * Asserts that a short[] is equal to an Object[] (presumably an Short[])
 1188   
     *
 1189   
     * @param message
 1190   
     * @param expecteds
 1191   
     * @param actuals
 1192   
     */
 1193   
    public static void assertEquals( String message, short[] expecteds, Object[] actuals )
 1194   
    {
 1195  32 
       String header = message == null ? "" : message + ": ";
 1196  32 
       if( expecteds == null ){
 1197  4 
          fail( header + "expected array was null" );
 1198   
       }
 1199  28 
       if( actuals == null ){
 1200  4 
          fail( header + "actual array was null" );
 1201   
       }
 1202  24 
       if( actuals.length != expecteds.length ){
 1203  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 1204  3 
                + " actual.length=" + actuals.length );
 1205   
       }
 1206   
 
 1207  60 
       for( int i = 0; i < expecteds.length; i++ ){
 1208  70 
          assertEquals( header + "arrays first differed at element [" + i + "];", new Short(
 1209  30 
                expecteds[i] ), actuals[i] );
 1210   
       }
 1211  20 
    }
 1212   
 
 1213   
    /**
 1214   
     * Asserts that two short[] are equal.<br>
 1215   
     *
 1216   
     * @param message
 1217   
     * @param expecteds
 1218   
     * @param actuals
 1219   
     */
 1220   
    public static void assertEquals( String message, short[] expecteds, short[] actuals )
 1221   
    {
 1222  72 
       if( expecteds == actuals ){
 1223  28 
          return;
 1224   
       }
 1225  44 
       String header = message == null ? "" : message + ": ";
 1226  44 
       if( expecteds == null ){
 1227  4 
          fail( header + "expected array was null" );
 1228   
       }
 1229  40 
       if( actuals == null ){
 1230  4 
          fail( header + "actual array was null" );
 1231   
       }
 1232  36 
       if( actuals.length != expecteds.length ){
 1233  7 
          fail( header + "array lengths differed, expected.length=" + expecteds.length
 1234  3 
                + " actual.length=" + actuals.length );
 1235   
       }
 1236   
 
 1237  104 
       for( int i = 0; i < expecteds.length; i++ ){
 1238  126 
          assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
 1239  54 
                actuals[i] );
 1240   
       }
 1241  32 
    }
 1242   
 
 1243   
    private static void assertActualPrimitiveArrays( String message, Object expected, Object actual,
 1244   
          Class expectedInnerType, Class actualInnerType )
 1245   
    {
 1246  64 
       if( Boolean.TYPE.isAssignableFrom( actualInnerType ) ){
 1247  8 
          if( Boolean.class.isAssignableFrom( expectedInnerType ) ){
 1248  4 
             assertEquals( message, (Boolean[]) expected, (boolean[]) actual );
 1249   
          }else{
 1250  4 
             assertEquals( message, (Object[]) expected, (boolean[]) actual );
 1251   
          }
 1252  56 
       }else if( Byte.TYPE.isAssignableFrom( actualInnerType ) ){
 1253  8 
          if( Byte.class.isAssignableFrom( expectedInnerType ) ){
 1254  4 
             assertEquals( message, (Byte[]) expected, (byte[]) actual );
 1255   
          }else{
 1256  4 
             assertEquals( message, (Object[]) expected, (byte[]) actual );
 1257   
          }
 1258  48 
       }else if( Short.TYPE.isAssignableFrom( actualInnerType ) ){
 1259  8 
          if( Short.class.isAssignableFrom( expectedInnerType ) ){
 1260  4 
             assertEquals( message, (Short[]) expected, (short[]) actual );
 1261   
          }else{
 1262  4 
             assertEquals( message, (Object[]) expected, (short[]) actual );
 1263   
          }
 1264  40 
       }else if( Integer.TYPE.isAssignableFrom( actualInnerType ) ){
 1265  8 
          if( Integer.class.isAssignableFrom( expectedInnerType ) ){
 1266  4 
             assertEquals( message, (Integer[]) expected, (int[]) actual );
 1267   
          }else{
 1268  4 
             assertEquals( message, (Object[]) expected, (int[]) actual );
 1269   
          }
 1270  32 
       }else if( Long.TYPE.isAssignableFrom( actualInnerType ) ){
 1271  8 
          if( Long.class.isAssignableFrom( expectedInnerType ) ){
 1272  4 
             assertEquals( message, (Long[]) expected, (long[]) actual );
 1273   
          }else{
 1274  4 
             assertEquals( message, (Object[]) expected, (long[]) actual );
 1275   
          }
 1276  24 
       }else if( Float.TYPE.isAssignableFrom( actualInnerType ) ){
 1277  8 
          if( Float.class.isAssignableFrom( expectedInnerType ) ){
 1278  4 
             assertEquals( message, (Float[]) expected, (float[]) actual );
 1279   
          }else{
 1280  4 
             assertEquals( message, (Object[]) expected, (float[]) actual );
 1281   
          }
 1282  16 
       }else if( Double.TYPE.isAssignableFrom( actualInnerType ) ){
 1283  8 
          if( Double.class.isAssignableFrom( expectedInnerType ) ){
 1284  4 
             assertEquals( message, (Double[]) expected, (double[]) actual );
 1285   
          }else{
 1286  4 
             assertEquals( message, (Object[]) expected, (double[]) actual );
 1287   
          }
 1288  8 
       }else if( Character.TYPE.isAssignableFrom( actualInnerType ) ){
 1289  8 
          if( Character.class.isAssignableFrom( expectedInnerType ) ){
 1290  4 
             assertEquals( message, (Character[]) expected, (char[]) actual );
 1291   
          }else{
 1292  4 
             assertEquals( message, (Object[]) expected, (char[]) actual );
 1293   
          }
 1294   
       }
 1295  64 
    }
 1296   
 
 1297   
    private static void assertExpectedPrimitiveArrays( String message, Object expected,
 1298   
          Object actual, Class expectedInnerType, Class actualInnerType )
 1299   
    {
 1300  128 
       if( Boolean.TYPE.isAssignableFrom( expectedInnerType ) ){
 1301  16 
          if( Boolean.TYPE.isAssignableFrom( actualInnerType ) ){
 1302  4 
             assertEquals( message, (boolean[]) expected, (boolean[]) actual );
 1303  12 
          }else if( Boolean.class.isAssignableFrom( actualInnerType ) ){
 1304  4 
             assertEquals( message, (boolean[]) expected, (Boolean[]) actual );
 1305  8 
          }else if( !actualInnerType.isPrimitive() ){
 1306  4 
             assertEquals( message, (boolean[]) expected, (Object[]) actual );
 1307   
          }else{
 1308  4 
             failNotEquals( message, expected, actual );
 1309   
          }
 1310  112 
       }else if( Byte.TYPE.isAssignableFrom( expectedInnerType ) ){
 1311  16 
          if( Byte.TYPE.isAssignableFrom( actualInnerType ) ){
 1312  4 
             assertEquals( message, (byte[]) expected, (byte[]) actual );
 1313  12 
          }else if( Byte.class.isAssignableFrom( actualInnerType ) ){
 1314  4 
             assertEquals( message, (byte[]) expected, (Byte[]) actual );
 1315  8 
          }else if( !actualInnerType.isPrimitive() ){
 1316  4 
             assertEquals( message, (byte[]) expected, (Object[]) actual );
 1317   
          }else{
 1318  4 
             failNotEquals( message, expected, actual );
 1319   
          }
 1320  96 
       }else if( Short.TYPE.isAssignableFrom( expectedInnerType ) ){
 1321  16 
          if( Short.TYPE.isAssignableFrom( actualInnerType ) ){
 1322  4 
             assertEquals( message, (short[]) expected, (short[]) actual );
 1323  12 
          }else if( Short.class.isAssignableFrom( actualInnerType ) ){
 1324  4 
             assertEquals( message, (short[]) expected, (Short[]) actual );
 1325  8 
          }else if( !actualInnerType.isPrimitive() ){
 1326  4 
             assertEquals( message, (short[]) expected, (Object[]) actual );
 1327   
          }else{
 1328  4 
             failNotEquals( message, expected, actual );
 1329   
          }
 1330  80 
       }else if( Integer.TYPE.isAssignableFrom( expectedInnerType ) ){
 1331  16 
          if( Integer.TYPE.isAssignableFrom( actualInnerType ) ){
 1332  4 
             assertEquals( message, (int[]) expected, (int[]) actual );
 1333  12 
          }else if( Integer.class.isAssignableFrom( actualInnerType ) ){
 1334  4 
             assertEquals( message, (int[]) expected, (Integer[]) actual );
 1335  8 
          }else if( !actualInnerType.isPrimitive() ){
 1336  4 
             assertEquals( message, (int[]) expected, (Object[]) actual );
 1337   
          }else{
 1338  4 
             failNotEquals( message, expected, actual );
 1339   
          }
 1340  64 
       }else if( Long.TYPE.isAssignableFrom( expectedInnerType ) ){
 1341  16 
          if( Long.TYPE.isAssignableFrom( actualInnerType ) ){
 1342  4 
             assertEquals( message, (long[]) expected, (long[]) actual );
 1343  12 
          }else if( Long.class.isAssignableFrom( actualInnerType ) ){
 1344  4 
             assertEquals( message, (long[]) expected, (Long[]) actual );
 1345  8 
          }else if( !actualInnerType.isPrimitive() ){
 1346  4 
             assertEquals( message, (long[]) expected, (Object[]) actual );
 1347   
          }else{
 1348  4 
             failNotEquals( message, expected, actual );
 1349   
          }
 1350  48 
       }else if( Float.TYPE.isAssignableFrom( expectedInnerType ) ){
 1351  16 
          if( Float.TYPE.isAssignableFrom( actualInnerType ) ){
 1352  4 
             assertEquals( message, (float[]) expected, (float[]) actual );
 1353  12 
          }else if( Float.class.isAssignableFrom( actualInnerType ) ){
 1354  4 
             assertEquals( message, (float[]) expected, (Float[]) actual );
 1355  8 
          }else if( !actualInnerType.isPrimitive() ){
 1356  4 
             assertEquals( message, (float[]) expected, (Object[]) actual );
 1357   
          }else{
 1358  4 
             failNotEquals( message, expected, actual );
 1359   
          }
 1360  32 
       }else if( Double.TYPE.isAssignableFrom( expectedInnerType ) ){
 1361  16 
          if( Double.TYPE.isAssignableFrom( actualInnerType ) ){
 1362  4 
             assertEquals( message, (double[]) expected, (double[]) actual );
 1363  12 
          }else if( Double.class.isAssignableFrom( actualInnerType ) ){
 1364  4 
             assertEquals( message, (double[]) expected, (Double[]) actual );
 1365  8 
          }else if( !actualInnerType.isPrimitive() ){
 1366  4 
             assertEquals( message, (double[]) expected, (Object[]) actual );
 1367   
          }else{
 1368  4 
             failNotEquals( message, expected, actual );
 1369   
          }
 1370  16 
       }else if( Character.TYPE.isAssignableFrom( expectedInnerType ) ){
 1371  16 
          if( Character.TYPE.isAssignableFrom( actualInnerType ) ){
 1372  4 
             assertEquals( message, (char[]) expected, (char[]) actual );
 1373  12 
          }else if( Character.class.isAssignableFrom( actualInnerType ) ){
 1374  4 
             assertEquals( message, (char[]) expected, (Character[]) actual );
 1375  8 
          }else if( !actualInnerType.isPrimitive() ){
 1376  4 
             assertEquals( message, (char[]) expected, (Object[]) actual );
 1377   
          }else{
 1378  4 
             failNotEquals( message, expected, actual );
 1379   
          }
 1380   
       }
 1381  96 
    }
 1382   
 
 1383  0 
    private ArrayAssertions()
 1384  0 
    {
 1385   
 
 1386  0 
    }
 1387   
 }
Report generated by Cobertura 1.9 on 12/8/08 8:54 PM.