arrayassertions.java

来自「iBATIS似乎已远离众说纷纭的OR框架之列」· Java 代码 · 共 1,107 行 · 第 1/3 页

               new Byte( actuals[i] ) );
      }
   }

   /**
    * Asserts that Object[] (presumably an Character[]) is equal to a char[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, Object[] expecteds, char[] 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 + "];", expecteds[i],
               new Character( actuals[i] ) );
      }
   }

   /**
    * Asserts that Object[] (presumably an Double[]) is equal to a double[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, Object[] expecteds, double[] 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 + "];", expecteds[i],
               new Double( actuals[i] ) );
      }
   }

   /**
    * Asserts that Object[] (presumably an Float[]) is equal to a float[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, Object[] expecteds, float[] 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 + "];", expecteds[i],
               new Float( actuals[i] ) );
      }
   }

   /**
    * Asserts that Object[] (presumably an Integer[]) is equal to a int[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, Object[] expecteds, int[] 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 + "];", expecteds[i],
               new Integer( actuals[i] ) );
      }
   }

   /**
    * Asserts that Object[] (presumably an Long[]) is equal to a long[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, Object[] expecteds, long[] 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 + "];", expecteds[i],
               new Long( actuals[i] ) );
      }
   }

   /**
    * Asserts that two Object[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, Object[] expecteds, Object[] 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++ ){
         Object o1 = expecteds[i];
         Object o2 = actuals[i];

         if( o1 == null ){
            if( o2 == null ){
               return;
            }else{
               fail( header + "arrays first differed at element [" + i + "];" );
            }
         }else{
            if( o2 == null ){
               fail( header + "arrays first differed at element [" + i + "];" );
            }
         }

         if( o1.getClass()
               .isArray() && o2.getClass()
               .isArray() ){
            Class type1 = o1.getClass()
                  .getComponentType();
            Class type2 = o2.getClass()
                  .getComponentType();
            if( type1.isPrimitive() ){
               if( type1 == Boolean.TYPE ){
                  if( type2 == Boolean.TYPE ){
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (boolean[]) o1, (boolean[]) o2 );
                  }else{
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (boolean[]) o1, (Object[]) o2 );
                  }
               }else if( type1 == Byte.TYPE ){
                  if( type2 == Byte.TYPE ){
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (byte[]) o1, (byte[]) o2 );
                  }else{
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (byte[]) o1, (Object[]) o2 );
                  }
               }else if( type1 == Short.TYPE ){
                  if( type2 == Short.TYPE ){
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (short[]) o1, (short[]) o2 );
                  }else{
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (short[]) o1, (Object[]) o2 );
                  }
               }else if( type1 == Integer.TYPE ){
                  if( type2 == Integer.TYPE ){
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (int[]) o1, (int[]) o2 );
                  }else{
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (int[]) o1, (Object[]) o2 );
                  }
               }else if( type1 == Long.TYPE ){
                  if( type2 == Long.TYPE ){
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (long[]) o1, (long[]) o2 );
                  }else{
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (long[]) o1, (Object[]) o2 );
                  }
               }else if( type1 == Float.TYPE ){
                  if( type2 == Float.TYPE ){
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (float[]) o1, (float[]) o2 );
                  }else{
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (float[]) o1, (Object[]) o2 );
                  }
               }else if( type1 == Double.TYPE ){
                  if( type2 == Double.TYPE ){
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (double[]) o1, (double[]) o2 );
                  }else{
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (double[]) o1, (Object[]) o2 );
                  }
               }else if( type1 == Character.TYPE ){
                  if( type2 == Character.TYPE ){
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (char[]) o1, (char[]) o2 );
                  }else{
                     assertEquals( header + "arrays first differed at element " + i + ";",
                           (char[]) o1, (Object[]) o2 );
                  }
               }
            }else if( type2.isPrimitive() ){
               if( type2 == Boolean.TYPE ){
                  assertEquals( header + "arrays first differed at element " + i + ";",
                        (Object[]) o1, (boolean[]) o2 );
               }else if( type2 == Byte.TYPE ){
                  assertEquals( header + "arrays first differed at element " + i + ";",
                        (Object[]) o1, (byte[]) o2 );
               }else if( type2 == Short.TYPE ){
                  assertEquals( header + "arrays first differed at element " + i + ";",
                        (Object[]) o1, (short[]) o2 );
               }else if( type2 == Integer.TYPE ){
                  assertEquals( header + "arrays first differed at element " + i + ";",
                        (Object[]) o1, (int[]) o2 );
               }else if( type2 == Long.TYPE ){
                  assertEquals( header + "arrays first differed at element " + i + ";",
                        (Object[]) o1, (long[]) o2 );
               }else if( type2 == Float.TYPE ){
                  assertEquals( header + "arrays first differed at element " + i + ";",
                        (Object[]) o1, (float[]) o2 );
               }else if( type2 == Double.TYPE ){
                  assertEquals( header + "arrays first differed at element " + i + ";",
                        (Object[]) o1, (double[]) o2 );
               }else if( type2 == Character.TYPE ){
                  assertEquals( header + "arrays first differed at element " + i + ";",
                        (Object[]) o1, (char[]) o2 );
               }
            }else{
               Object[] expected = (Object[]) o1;
               Object[] actual = (Object[]) o2;
               assertEquals( header + "arrays first differed at element " + i + ";", expected,
                     actual );
            }
         }else{
            assertEquals( header + "arrays first differed at element [" + i + "];", o1, o2 );
         }
      }
   }

   /**
    * Asserts that Object[] (presumably an Short[]) is equal to a short[].
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, Object[] expecteds, short[] 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 + "];", expecteds[i],
               new Short( actuals[i] ) );
      }
   }

   /**
    * Asserts that a short[] is equal to and Object[] (presumably an Short[])
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, short[] 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 Short(
               expecteds[i] ), actuals[i] );
      }
   }

   /**
    * Asserts that two short[] are equal.<br>
    *
    * @param expecteds
    * @param actuals
    */
   public static void assertEquals( String message, short[] expecteds, short[] 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] );
      }
   }

   private ArrayAssertions(){

   }
}