arrayassertions.java

iBATIS似乎已远离众说纷纭的OR框架之列

/*
 * Copyright 2006 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package net.sf.ezmorph.test;

import junit.framework.Assert;

/**
 * Provides assertions on arrays (primitive and objects).<br>
 * All methods support multiple dimensional arrays.
 *
 * @author Andres Almiray <[e-mail]>
 */
public class ArrayAssertions extends Assert
{
   /**
    * Asserts that two boolean[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( boolean[] expecteds, boolean[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that a boolean[] is equal to and Object[] (presumably an
    * Boolean[])
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( boolean[] expecteds, Object[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that two byte[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( byte[] expecteds, byte[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that a byte[] is equal to and Object[] (presumably an Byte[])
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( byte[] expecteds, Object[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that two char[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( char[] expecteds, char[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that a char[] is equal to and Object[] (presumably an Character[])
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( char[] expecteds, Object[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that two double[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( double[] expecteds, double[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that a double[] is equal to and Object[] (presumably an Double[])
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( double[] expecteds, Object[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that two float[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( float[] expecteds, float[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that a float[] is equal to and Object[] (presumably an Float[])
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( float[] expecteds, Object[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that two int[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( int[] expecteds, int[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that a int[] is equal to and Object[] (presumably an Integer[])
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( int[] expecteds, Object[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that two long[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( long[] expecteds, long[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that a long[] is equal to and Object[] (presumably an Long[])
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( long[] expecteds, Object[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that Object[] (presumably an Boolean[]) is equal to a boolean[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( Object[] expecteds, boolean[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that Object[] (presumably an Byte[]) is equal to a byte[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( Object[] expecteds, byte[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that Object[] (presumably an Character[]) is equal to a char[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( Object[] expecteds, char[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that Object[] (presumably an Double[]) is equal to a double[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( Object[] expecteds, double[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that Object[] (presumably an Float[]) is equal to a float[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( Object[] expecteds, float[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that Object[] (presumably an Integer[]) is equal to a int[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( Object[] expecteds, int[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that Object[] (presumably an Long[]) is equal to a long[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( Object[] expecteds, long[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that two Object[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( Object[] expecteds, Object[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that Object[] (presumably an Short[]) is equal to a short[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( Object[] expecteds, short[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that a short[] is equal to and Object[] (presumably an Short[])
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( short[] expecteds, Object[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that two short[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( short[] expecteds, short[] actuals )
   {
      assertEquals( null, expecteds, actuals );
   }

   /**
    * Asserts that two boolean[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, boolean[] expecteds, boolean[] actuals )
   {
      if( expecteds == actuals ){
         return;
      }
      String header = message == null ? "" : message + ": ";
      if( expecteds == null ){
         fail( header + "expected array was null" );
      }
      if( actuals == null ){
         fail( header + "actual array was null" );
      }
      if( actuals.length != expecteds.length ){
         fail( header + "array lengths differed, expected.length=" + expecteds.length
               + " actual.length=" + actuals.length );
      }

      for( int i = 0; i < expecteds.length; i++ ){
         assertEquals( header + "arrays first differed at element [" + i + "];", expecteds[i],
               actuals[i] );
      }
   }

   /**
    * Asserts that a boolean[] is equal to and Object[] (presumably an
    * Boolean[])
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, boolean[] expecteds, Object[] actuals )
   {
      String header = message == null ? "" : message + ": ";
      if( expecteds == null ){
         fail( header + "expected array was null" );
      }
      if( actuals == null ){
         fail( header + "actual array was null" );
      }
      if( actuals.length != expecteds.length ){
         fail( header + "array lengths differed, expected.length=" + expecteds.length
               + " actual.length=" + actuals.length );
      }

      for( int i = 0; i < expecteds.length; i++ ){
         assertEquals( header + "arrays first differed at element [" + i + "];",
               new Boolean( expecteds[i] ), actuals[i] );
      }
   }

   /**
    * Asserts that two byte[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, byte[] expecteds, byte[] actuals )
   {
      if( expecteds == actuals ){