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 junit.framework.AssertionFailedError;
20  import junit.framework.Test;
21  import junit.framework.TestCase;
22  import junit.framework.TestSuite;
23  import junit.textui.TestRunner;
24  
25  /**
26   * @author Andres Almiray <aalmiray@users.sourceforge.net>
27   */
28  public class CharArrayAssertionsTest extends TestCase
29  {
30     public static void main( String[] args )
31     {
32        TestRunner.run( suite() );
33     }
34  
35     public static Test suite()
36     {
37        TestSuite suite = new TestSuite( CharArrayAssertionsTest.class );
38        suite.setName( "CharArrayAssertions Tests" );
39        return suite;
40     }
41  
42     public CharArrayAssertionsTest( String name )
43     {
44        super( name );
45     }
46  
47     // -----------------------------------------------------------------------
48  
49     public void testAssertEquals_char_char()
50     {
51        char[] expecteds = new char[] { 'A', 'B' };
52        char[] actuals = new char[] { 'A', 'B' };
53        ArrayAssertions.assertEquals( expecteds, actuals );
54     }
55  
56     public void testAssertEquals_char_char_actuals_is_null()
57     {
58        boolean errorThrown = false;
59        char[] expecteds = new char[] { 'A', 'B' };
60        try{
61           ArrayAssertions.assertEquals( expecteds, (char[]) null );
62        }
63        catch( AssertionFailedError expected ){
64           errorThrown = true;
65        }
66        assertTrue( "Expected a failure", errorThrown );
67     }
68  
69     public void testAssertEquals_char_char_different_length()
70     {
71        char[] expecteds = new char[] { 'A' };
72        char[] actuals = new char[] { 'A', 'B' };
73        boolean errorThrown = false;
74        try{
75           ArrayAssertions.assertEquals( expecteds, actuals );
76        }
77        catch( AssertionFailedError expected ){
78           errorThrown = true;
79        }
80        assertTrue( "Expected a failure", errorThrown );
81     }
82  
83     public void testAssertEquals_char_char_expecteds_is_null()
84     {
85        boolean errorThrown = false;
86        char[] actuals = new char[] { 'A', 'B' };
87        try{
88           ArrayAssertions.assertEquals( (char[]) null, actuals );
89        }
90        catch( AssertionFailedError expected ){
91           errorThrown = true;
92        }
93        assertTrue( "Expected a failure", errorThrown );
94     }
95  
96     public void testAssertEquals_char_Character()
97     {
98        char[] expecteds = new char[] { 'A', 'B' };
99        Character[] actuals = new Character[] { new Character( 'A' ), new Character( 'B' ) };
100       ArrayAssertions.assertEquals( expecteds, actuals );
101    }
102 
103    public void testAssertEquals_char_Character_actuals_is_null()
104    {
105       boolean errorThrown = false;
106       char[] expecteds = new char[] { 'A', 'B' };
107       try{
108          ArrayAssertions.assertEquals( expecteds, (Character[]) null );
109       }
110       catch( AssertionFailedError expected ){
111          errorThrown = true;
112       }
113       assertTrue( "Expected a failure", errorThrown );
114    }
115 
116    public void testAssertEquals_char_Character_different_length()
117    {
118       char[] expecteds = new char[] { 'A' };
119       Character[] actuals = new Character[] { new Character( 'A' ), new Character( 'B' ) };
120       boolean errorThrown = false;
121       try{
122          ArrayAssertions.assertEquals( expecteds, actuals );
123       }
124       catch( AssertionFailedError expected ){
125          errorThrown = true;
126       }
127       assertTrue( "Expected a failure", errorThrown );
128    }
129 
130    public void testAssertEquals_char_Character_expecteds_is_null()
131    {
132       boolean errorThrown = false;
133       Character[] actuals = new Character[] { new Character( 'A' ), new Character( 'B' ) };
134       try{
135          ArrayAssertions.assertEquals( (char[]) null, actuals );
136       }
137       catch( AssertionFailedError expected ){
138          errorThrown = true;
139       }
140       assertTrue( "Expected a failure", errorThrown );
141    }
142 
143    public void testAssertEquals_Character_char()
144    {
145       Character[] expecteds = new Character[] { new Character( 'A' ), new Character( 'B' ) };
146       char[] actuals = new char[] { 'A', 'B' };
147       ArrayAssertions.assertEquals( expecteds, actuals );
148    }
149 
150    public void testAssertEquals_Character_char_actuals_is_null()
151    {
152       boolean errorThrown = false;
153       Character[] expecteds = new Character[] { new Character( 'A' ), new Character( 'B' ) };
154       try{
155          ArrayAssertions.assertEquals( expecteds, (char[]) null );
156       }
157       catch( AssertionFailedError expected ){
158          errorThrown = true;
159       }
160       assertTrue( "Expected a failure", errorThrown );
161    }
162 
163    public void testAssertEquals_Character_char_different_length()
164    {
165       Character[] expecteds = new Character[] { new Character( 'A' ) };
166       char[] actuals = new char[] { 'A', 'B' };
167       boolean errorThrown = false;
168       try{
169          ArrayAssertions.assertEquals( expecteds, actuals );
170       }
171       catch( AssertionFailedError expected ){
172          errorThrown = true;
173       }
174       assertTrue( "Expected a failure", errorThrown );
175    }
176 
177    public void testAssertEquals_Character_char_expecteds_is_null()
178    {
179       boolean errorThrown = false;
180       char[] actuals = new char[] { 'A', 'B' };
181       try{
182          ArrayAssertions.assertEquals( (Character[]) null, actuals );
183       }
184       catch( AssertionFailedError expected ){
185          errorThrown = true;
186       }
187       assertTrue( "Expected a failure", errorThrown );
188    }
189 
190    public void testAssertEquals_Character_Character()
191    {
192       Character[] expecteds = new Character[] { new Character( 'A' ), new Character( 'B' ) };
193       Character[] actuals = new Character[] { new Character( 'A' ), new Character( 'B' ) };
194       ArrayAssertions.assertEquals( expecteds, actuals );
195    }
196 
197    public void testAssertEquals_multi_char_char()
198    {
199       char[][] expecteds = new char[][] { { 'A', 'B' }, { 'A', 'B' } };
200       char[][] actuals = new char[][] { { 'A', 'B' }, { 'A', 'B' } };
201       ArrayAssertions.assertEquals( expecteds, actuals );
202    }
203 
204    public void testAssertEquals_multi_char_Character()
205    {
206       char[][] expecteds = new char[][] { { 'A', 'B' }, { 'A', 'B' } };
207       Character[][] actuals = new Character[][] { { new Character( 'A' ), new Character( 'B' ) },
208             { new Character( 'A' ), new Character( 'B' ) } };
209       ArrayAssertions.assertEquals( expecteds, actuals );
210    }
211 
212    public void testAssertEquals_multi_Character_char()
213    {
214       Character[][] expecteds = new Character[][] { { new Character( 'A' ), new Character( 'B' ) },
215             { new Character( 'A' ), new Character( 'B' ) } };
216       char[][] actuals = new char[][] { { 'A', 'B' }, { 'A', 'B' } };
217       ArrayAssertions.assertEquals( expecteds, actuals );
218    }
219 
220    public void testAssertEquals_multi_Character_Character()
221    {
222       Character[][] expecteds = new Character[][] { { new Character( 'A' ), new Character( 'B' ) },
223             { new Character( 'A' ), new Character( 'B' ) } };
224       Character[][] actuals = new Character[][] { { new Character( 'A' ), new Character( 'B' ) },
225             { new Character( 'A' ), new Character( 'B' ) } };
226       ArrayAssertions.assertEquals( expecteds, actuals );
227    }
228 
229    public void testAssertEquals_OO_char_char()
230    {
231       Object expecteds = new char[] { 'A', 'B' };
232       Object actuals = new char[] { 'A', 'B' };
233       ArrayAssertions.assertEquals( expecteds, actuals );
234    }
235 
236    public void testAssertEquals_OO_char_Character()
237    {
238       Object expecteds = new char[] { 'A', 'B' };
239       Object actuals = new Character[] { new Character( 'A' ), new Character( 'B' ) };
240       ArrayAssertions.assertEquals( expecteds, actuals );
241    }
242 
243    public void testAssertEquals_OO_char_double()
244    {
245       boolean errorThrown = false;
246       Object expecteds = new char[] { 'A', 'B' };
247       Object actuals = new double[] { 1, 2 };
248       try{
249          ArrayAssertions.assertEquals( expecteds, actuals );
250       }
251       catch( AssertionFailedError expected ){
252          errorThrown = true;
253       }
254       assertTrue( "Expected a failure", errorThrown );
255    }
256 
257    public void testAssertEquals_OO_char_Object_array()
258    {
259       Object expecteds = new char[] { 'A', 'B' };
260       Object actuals = new Object[] { new Character( 'A' ), new Character( 'B' ) };
261       ArrayAssertions.assertEquals( expecteds, actuals );
262    }
263 
264    public void testAssertEquals_OO_Character_char()
265    {
266       Object expecteds = new Character[] { new Character( 'A' ), new Character( 'B' ) };
267       Object actuals = new char[] { 'A', 'B' };
268       ArrayAssertions.assertEquals( expecteds, actuals );
269    }
270 
271    public void testAssertEquals_OO_Object_array_char()
272    {
273       Object expecteds = new Object[] { new Character( 'A' ), new Character( 'B' ) };
274       Object actuals = new char[] { 'A', 'B' };
275       ArrayAssertions.assertEquals( expecteds, actuals );
276    }
277 
278    public void testAssertEquals_OO_Object_array_Object_array()
279    {
280       Object expecteds = new Object[] { new Character( 'A' ), new Character( 'B' ) };
281       Object actuals = new Object[] { new Character( 'A' ), new Character( 'B' ) };
282       ArrayAssertions.assertEquals( expecteds, actuals );
283    }
284 }