1   /*
2    * Copyright 2002-2009 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.json;
18  
19  import java.util.List;
20  
21  import net.sf.ezmorph.test.ArrayAssertions;
22  import net.sf.json.test.JSONAssert;
23  
24  /**
25   * @author Andres Almiray <aalmiray@users.sourceforge.net>
26   */
27  public class Assertions extends JSONAssert {
28     public static void assertEquals( List expecteds, List actuals ) {
29        assertEquals( null, expecteds, actuals );
30     }
31  
32     public static void assertEquals( Object expected, Object actual ) {
33        assertEquals( null, expected, actual );
34     }
35  
36     public static void assertEquals( String message, List expecteds, List actuals ) {
37        String header = message == null ? "" : message + ": ";
38        if( expecteds == null ){
39           fail( header + "expected list was null" );
40        }
41        if( actuals == null ){
42           fail( header + "actual list was null" );
43        }
44        if( expecteds == actuals || expecteds.equals( actuals ) ){
45           return;
46        }
47        if( actuals.size() != expecteds.size() ){
48           fail( header + "list sizes differed, expected.size()=" + expecteds.size()
49                 + " actual.size()=" + actuals.size() );
50        }
51  
52        int max = expecteds.size();
53        for( int i = 0; i < max; i++ ){
54           Object o1 = expecteds.get( i );
55           Object o2 = actuals.get( i );
56  
57           // handle nulls
58           if( o1 == null ){
59              if( o2 == null ){
60                 return;
61              }else{
62                 fail( header + "lists first differed at element [" + i + "];" );
63              }
64           }else{
65              if( o2 == null ){
66                 fail( header + "lists first differed at element [" + i + "];" );
67              }
68           }
69  
70           if( o1.getClass()
71                 .isArray() && o2.getClass()
72                 .isArray() ){
73              Object[] expected = (Object[]) o1;
74              Object[] actual = (Object[]) o2;
75              assertEquals( header + "lists first differed at element " + i + ";", expected, actual );
76           }else if( List.class.isAssignableFrom( o1.getClass() )
77                 && List.class.isAssignableFrom( o2.getClass() ) ){
78              assertEquals( header + "lists first differed at element [" + i + "];", (List) o1,
79                    (List) o2 );
80           }else{
81              if( o1 instanceof String && o2 instanceof JSONFunction ){
82                 assertEquals( header + "lists first differed at element [" + i + "];", (String) o1,
83                       (JSONFunction) o2 );
84              }else if( o1 instanceof JSONFunction && o2 instanceof String ){
85                 assertEquals( header + "lists first differed at element [" + i + "];",
86                       (JSONFunction) o1, (String) o2 );
87              }else if( o1 instanceof JSONObject && o2 instanceof JSONObject ){
88                 assertEquals( header + "lists first differed at element [" + i + "];",
89                       (JSONObject) o1, (JSONObject) o2 );
90              }else if( o1 instanceof JSONArray && o2 instanceof JSONArray ){
91                 assertEquals( header + "lists first differed at element [" + i + "];",
92                       (JSONArray) o1, (JSONArray) o2 );
93              }else if( o1 instanceof JSONFunction && o2 instanceof JSONFunction ){
94                 assertEquals( header + "lists first differed at element [" + i + "];",
95                       (JSONFunction) o1, (JSONFunction) o2 );
96              }else{
97                 assertEquals( header + "lists first differed at element [" + i + "];", o1, o2 );
98              }
99           }
100       }
101    }
102 
103    public static void assertEquals( String message, Object expected, Object actual ) {
104       if( expected == null && actual == null )
105          return;
106       if( expected != null && expected.equals( actual ) )
107          return;
108       Class expectedClass = expected.getClass();
109       Class actualClass = actual.getClass();
110       if( expectedClass.isArray() && actualClass.isArray() ){
111          Class expectedInnerType = expectedClass.getComponentType();
112          Class actualInnerType = actualClass.getComponentType();
113          if( expectedInnerType.isPrimitive() ){
114             assertExpectedPrimitiveArrays( message, expected, actual, expectedInnerType,
115                   actualInnerType );
116          }else if( actualInnerType.isPrimitive() ){
117             assertActualPrimitiveArrays( message, expected, actual, expectedInnerType,
118                   actualInnerType );
119          }else{
120             ArrayAssertions.assertEquals( message, (Object[]) expected, (Object[]) actual );
121          }
122       }else{
123          failNotEquals( message, expected, actual );
124       }
125    }
126 
127    private static void assertActualPrimitiveArrays( String message, Object expected, Object actual,
128          Class expectedInnerType, Class actualInnerType ) {
129       if( Boolean.TYPE.isAssignableFrom( actualInnerType ) ){
130          if( Boolean.TYPE.isAssignableFrom( expectedInnerType ) ){
131             ArrayAssertions.assertEquals( message, (boolean[]) expected, (boolean[]) actual );
132          }else if( Boolean.class.isAssignableFrom( expectedInnerType ) ){
133             ArrayAssertions.assertEquals( message, (Boolean[]) expected, (boolean[]) actual );
134          }else if( !expectedInnerType.isPrimitive() ){
135             ArrayAssertions.assertEquals( message, (Object[]) expected, (boolean[]) actual );
136          }else{
137             failNotEquals( message, expected, actual );
138          }
139       }else if( Byte.TYPE.isAssignableFrom( actualInnerType ) ){
140          if( Byte.TYPE.isAssignableFrom( expectedInnerType ) ){
141             ArrayAssertions.assertEquals( message, (byte[]) expected, (byte[]) actual );
142          }else if( Byte.class.isAssignableFrom( expectedInnerType ) ){
143             ArrayAssertions.assertEquals( message, (Byte[]) expected, (byte[]) actual );
144          }else if( !expectedInnerType.isPrimitive() ){
145             ArrayAssertions.assertEquals( message, (Object[]) expected, (byte[]) actual );
146          }else{
147             failNotEquals( message, expected, actual );
148          }
149       }else if( Short.TYPE.isAssignableFrom( actualInnerType ) ){
150          if( Short.TYPE.isAssignableFrom( expectedInnerType ) ){
151             ArrayAssertions.assertEquals( message, (short[]) expected, (short[]) actual );
152          }else if( Short.class.isAssignableFrom( expectedInnerType ) ){
153             ArrayAssertions.assertEquals( message, (Short[]) expected, (short[]) actual );
154          }else if( !expectedInnerType.isPrimitive() ){
155             ArrayAssertions.assertEquals( message, (Object[]) expected, (short[]) actual );
156          }else{
157             failNotEquals( message, expected, actual );
158          }
159       }else if( Integer.TYPE.isAssignableFrom( actualInnerType ) ){
160          if( Integer.TYPE.isAssignableFrom( expectedInnerType ) ){
161             ArrayAssertions.assertEquals( message, (int[]) expected, (int[]) actual );
162          }else if( Integer.class.isAssignableFrom( expectedInnerType ) ){
163             ArrayAssertions.assertEquals( message, (Integer[]) expected, (int[]) actual );
164          }else if( !expectedInnerType.isPrimitive() ){
165             ArrayAssertions.assertEquals( message, (Object[]) expected, (int[]) actual );
166          }else{
167             failNotEquals( message, expected, actual );
168          }
169       }else if( Long.TYPE.isAssignableFrom( actualInnerType ) ){
170          if( Long.TYPE.isAssignableFrom( expectedInnerType ) ){
171             ArrayAssertions.assertEquals( message, (long[]) expected, (long[]) actual );
172          }else if( Long.class.isAssignableFrom( expectedInnerType ) ){
173             ArrayAssertions.assertEquals( message, (Long[]) expected, (long[]) actual );
174          }else if( !expectedInnerType.isPrimitive() ){
175             ArrayAssertions.assertEquals( message, (Object[]) expected, (long[]) actual );
176          }else{
177             failNotEquals( message, expected, actual );
178          }
179       }else if( Float.TYPE.isAssignableFrom( actualInnerType ) ){
180          if( Float.TYPE.isAssignableFrom( expectedInnerType ) ){
181             ArrayAssertions.assertEquals( message, (float[]) expected, (float[]) actual );
182          }else if( Float.class.isAssignableFrom( expectedInnerType ) ){
183             ArrayAssertions.assertEquals( message, (Float[]) expected, (float[]) actual );
184          }else if( !expectedInnerType.isPrimitive() ){
185             ArrayAssertions.assertEquals( message, (Object[]) expected, (float[]) actual );
186          }else{
187             failNotEquals( message, expected, actual );
188          }
189       }else if( Double.TYPE.isAssignableFrom( actualInnerType ) ){
190          if( Double.TYPE.isAssignableFrom( expectedInnerType ) ){
191             ArrayAssertions.assertEquals( message, (double[]) expected, (double[]) actual );
192          }else if( Double.class.isAssignableFrom( expectedInnerType ) ){
193             ArrayAssertions.assertEquals( message, (Double[]) expected, (double[]) actual );
194          }else if( !expectedInnerType.isPrimitive() ){
195             ArrayAssertions.assertEquals( message, (Object[]) expected, (double[]) actual );
196          }else{
197             failNotEquals( message, expected, actual );
198          }
199       }else if( Character.TYPE.isAssignableFrom( actualInnerType ) ){
200          if( Character.TYPE.isAssignableFrom( expectedInnerType ) ){
201             ArrayAssertions.assertEquals( message, (char[]) expected, (char[]) actual );
202          }else if( Character.class.isAssignableFrom( expectedInnerType ) ){
203             ArrayAssertions.assertEquals( message, (Character[]) expected, (char[]) actual );
204          }else if( !expectedInnerType.isPrimitive() ){
205             ArrayAssertions.assertEquals( message, (Object[]) expected, (char[]) actual );
206          }else{
207             failNotEquals( message, expected, actual );
208          }
209       }
210    }
211 
212    private static void assertExpectedPrimitiveArrays( String message, Object expected,
213          Object actual, Class expectedInnerType, Class actualInnerType ) {
214       if( Boolean.TYPE.isAssignableFrom( expectedInnerType ) ){
215          if( Boolean.TYPE.isAssignableFrom( actualInnerType ) ){
216             ArrayAssertions.assertEquals( message, (boolean[]) expected, (boolean[]) actual );
217          }else if( Boolean.class.isAssignableFrom( actualInnerType ) ){
218             ArrayAssertions.assertEquals( message, (boolean[]) expected, (Boolean[]) actual );
219          }else if( !actualInnerType.isPrimitive() ){
220             ArrayAssertions.assertEquals( message, (boolean[]) expected, (Object[]) actual );
221          }else{
222             failNotEquals( message, expected, actual );
223          }
224       }else if( Byte.TYPE.isAssignableFrom( expectedInnerType ) ){
225          if( Byte.TYPE.isAssignableFrom( actualInnerType ) ){
226             ArrayAssertions.assertEquals( message, (byte[]) expected, (byte[]) actual );
227          }else if( Byte.class.isAssignableFrom( actualInnerType ) ){
228             ArrayAssertions.assertEquals( message, (byte[]) expected, (Byte[]) actual );
229          }else if( !actualInnerType.isPrimitive() ){
230             ArrayAssertions.assertEquals( message, (byte[]) expected, (Object[]) actual );
231          }else{
232             failNotEquals( message, expected, actual );
233          }
234       }else if( Short.TYPE.isAssignableFrom( expectedInnerType ) ){
235          if( Short.TYPE.isAssignableFrom( actualInnerType ) ){
236             ArrayAssertions.assertEquals( message, (short[]) expected, (short[]) actual );
237          }else if( Short.class.isAssignableFrom( actualInnerType ) ){
238             ArrayAssertions.assertEquals( message, (short[]) expected, (Short[]) actual );
239          }else if( !actualInnerType.isPrimitive() ){
240             ArrayAssertions.assertEquals( message, (short[]) expected, (Object[]) actual );
241          }else{
242             failNotEquals( message, expected, actual );
243          }
244       }else if( Integer.TYPE.isAssignableFrom( expectedInnerType ) ){
245          if( Integer.TYPE.isAssignableFrom( actualInnerType ) ){
246             ArrayAssertions.assertEquals( message, (int[]) expected, (int[]) actual );
247          }else if( Integer.class.isAssignableFrom( actualInnerType ) ){
248             ArrayAssertions.assertEquals( message, (int[]) expected, (Integer[]) actual );
249          }else if( !actualInnerType.isPrimitive() ){
250             ArrayAssertions.assertEquals( message, (int[]) expected, (Object[]) actual );
251          }else{
252             failNotEquals( message, expected, actual );
253          }
254       }else if( Long.TYPE.isAssignableFrom( expectedInnerType ) ){
255          if( Long.TYPE.isAssignableFrom( actualInnerType ) ){
256             ArrayAssertions.assertEquals( message, (long[]) expected, (long[]) actual );
257          }else if( Long.class.isAssignableFrom( actualInnerType ) ){
258             ArrayAssertions.assertEquals( message, (long[]) expected, (Long[]) actual );
259          }else if( !actualInnerType.isPrimitive() ){
260             ArrayAssertions.assertEquals( message, (long[]) expected, (Object[]) actual );
261          }else{
262             failNotEquals( message, expected, actual );
263          }
264       }else if( Float.TYPE.isAssignableFrom( expectedInnerType ) ){
265          if( Float.TYPE.isAssignableFrom( actualInnerType ) ){
266             ArrayAssertions.assertEquals( message, (float[]) expected, (float[]) actual );
267          }else if( Float.class.isAssignableFrom( actualInnerType ) ){
268             ArrayAssertions.assertEquals( message, (float[]) expected, (Float[]) actual );
269          }else if( !actualInnerType.isPrimitive() ){
270             ArrayAssertions.assertEquals( message, (float[]) expected, (Object[]) actual );
271          }else{
272             failNotEquals( message, expected, actual );
273          }
274       }else if( Double.TYPE.isAssignableFrom( expectedInnerType ) ){
275          if( Double.TYPE.isAssignableFrom( actualInnerType ) ){
276             ArrayAssertions.assertEquals( message, (double[]) expected, (double[]) actual );
277          }else if( Double.class.isAssignableFrom( actualInnerType ) ){
278             ArrayAssertions.assertEquals( message, (double[]) expected, (Double[]) actual );
279          }else if( !actualInnerType.isPrimitive() ){
280             ArrayAssertions.assertEquals( message, (double[]) expected, (Object[]) actual );
281          }else{
282             failNotEquals( message, expected, actual );
283          }
284       }else if( Character.TYPE.isAssignableFrom( expectedInnerType ) ){
285          if( Character.TYPE.isAssignableFrom( actualInnerType ) ){
286             ArrayAssertions.assertEquals( message, (char[]) expected, (char[]) actual );
287          }else if( Character.class.isAssignableFrom( actualInnerType ) ){
288             ArrayAssertions.assertEquals( message, (char[]) expected, (Character[]) actual );
289          }else if( !actualInnerType.isPrimitive() ){
290             ArrayAssertions.assertEquals( message, (char[]) expected, (Object[]) actual );
291          }else{
292             failNotEquals( message, expected, actual );
293          }
294       }
295    }
296 }