Coverage Report

Coverage Report - org.apache.maven.surefire.assertion.SurefireAssert

Classes in this File

Line Coverage

Branch Coverage

Complexity

SurefireAssert

0/107

0/58

1.725

 package org.apache.maven.surefire.assertion;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you 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.
  */
 
 public class SurefireAssert
 {
     private SurefireAssert()
     {
         // No touchy.
     }
 
     public static void fail()
     {
         throw new SurefireAssertionFailedException();
     }
 
     public static void fail( String message )
     {
         if ( message == null )
         {
             throw new NullPointerException( "message is null" );
         }
         throw new SurefireAssertionFailedException( message );
     }
 
     public static void fail( String message, Throwable cause )
     {
         if ( message == null )
         {
             throw new NullPointerException( "message is null" );
         }
 
         if ( cause == null )
         {
             throw new NullPointerException( "cause is null" );
         }
 
         throw new SurefireAssertionFailedException( message, cause );
     }
 
     public static void fail( Throwable cause )
     {
         if ( cause == null )
         {
             throw new NullPointerException( "cause is null" );
         }
 
         throw new SurefireAssertionFailedException( cause );
     }
 
     // ----------------------------------------------------------------------
     // JUnit type assertions
     // ----------------------------------------------------------------------
 
     public static void assertTrue( String message, boolean condition )
     {
         if ( !condition )
         {
             if ( message != null )
             {
                 fail( message );
             }
             else
             {
                 fail();
             }
         }
     }
 
     public static void assertTrue( boolean condition )
     {
         assertTrue( null, condition );
     }
 
     public static void assertFalse( String message, boolean condition )
     {
         assertTrue( message, !condition );
     }
 
     public static void assertFalse( boolean condition )
     {
         assertFalse( null, condition );
     }
 
     public static void assertEquals( String message, Object expected, Object actual )
     {
         if ( expected != null || actual != null )
         {
             if ( expected == null || !expected.equals( actual ) )
             {
                 failNotEquals( message, expected, actual );
             }
         }
     }
 
     public static void assertEquals( Object expected, Object actual )
     {
         assertEquals( null, expected, actual );
     }
 
     public static void assertEquals( String message, String expected, String actual )
     {
         if ( expected != null || actual != null )
         {
             if ( expected == null || !expected.equals( actual ) )
             {
                 throw new SurefireComparisonFailureException( message, expected, actual );
             }
         }
     }
 
     public static void assertEquals( String expected, String actual )
     {
         assertEquals( null, expected, actual );
     }
 
     public static void assertEquals( String message, double expected, double actual, double delta )
     {
         // handle infinity specially since subtracting to infinite values gives NaN and the
         // the following test fails
         if ( Double.isInfinite( expected ) )
         {
             if ( !Double.isInfinite( actual ) )
             {
                 failNotEquals( message, new Double( expected ), new Double( actual ) );
             }
         }
         else if ( !( Math.abs( expected - actual ) <= delta ) ) // Because comparison with NaN always returns false
         {
             failNotEquals( message, new Double( expected ), new Double( actual ) );
         }
     }
 
     public static void assertEquals( double expected, double actual, double delta )
     {
         assertEquals( null, expected, actual, delta );
     }
 
     public static void assertEquals( String message, float expected, float actual, float delta )
     {
         // handle infinity specially since subtracting to infinite values gives NaN and the
         // the following test fails
         if ( Float.isInfinite( expected ) )
         {
             if ( !Float.isInfinite( actual ) )
             {
                 failNotEquals( message, new Float( expected ), new Float( actual ) );
             }
 
         }
         else if ( !( Math.abs( expected - actual ) <= delta ) )
         {
             failNotEquals( message, new Float( expected ), new Float( actual ) );
         }
     }
 
     public static void assertEquals( float expected, float actual, float delta )
     {
         assertEquals( null, expected, actual, delta );
     }
 
     public static void assertEquals( String message, long expected, long actual )
     {
         assertEquals( message, new Long( expected ), new Long( actual ) );
     }
 
     public static void assertEquals( long expected, long actual )
     {
         assertEquals( null, expected, actual );
     }
 
     public static void assertEquals( String message, boolean expected, boolean actual )
     {
         assertEquals( message, expected ? Boolean.TRUE : Boolean.FALSE, actual ? Boolean.TRUE : Boolean.FALSE );
     }
 
     public static void assertEquals( boolean expected, boolean actual )
     {
         assertEquals( null, expected, actual );
     }
 
     public static void assertEquals( String message, byte expected, byte actual )
     {
         assertEquals( message, new Byte( expected ), new Byte( actual ) );
     }
 
     public static void assertEquals( byte expected, byte actual )
     {
         assertEquals( null, expected, actual );
     }
 
     public static void assertEquals( String message, char expected, char actual )
     {
         assertEquals( message, new Character( expected ), new Character( actual ) );
     }
 
     public static void assertEquals( char expected, char actual )
     {
         assertEquals( null, expected, actual );
     }
 
     public static void assertEquals( String message, short expected, short actual )
     {
         assertEquals( message, new Short( expected ), new Short( actual ) );
     }
 
     public static void assertEquals( short expected, short actual )
     {
         assertEquals( null, expected, actual );
     }
 
     public static void assertEquals( String message, int expected, int actual )
     {
         assertEquals( message, new Integer( expected ), new Integer( actual ) );
     }
 
     public static void assertEquals( int expected, int actual )
     {
         assertEquals( null, expected, actual );
     }
 
     public static void assertNotNull( Object object )
     {
         assertNotNull( null, object );
     }
 
     public static void assertNotNull( String message, Object object )
     {
         assertTrue( message, object != null );
     }
 
     public static void assertNull( Object object )
     {
         assertNull( null, object );
     }
 
     public static void assertNull( String message, Object object )
     {
         assertTrue( message, object == null );
     }
 
     public static void assertSame( String message, Object expected, Object actual )
     {
         //noinspection ObjectEquality
         if ( expected != actual )
         {
             failNotSame( message, expected, actual );
         }
     }
 
     public static void assertSame( Object expected, Object actual )
     {
         assertSame( null, expected, actual );
     }
 
     public static void assertNotSame( String message, Object expected, Object actual )
     {
         //noinspection ObjectEquality
         if ( expected == actual )
         {
             failSame( message );
         }
     }
 
     public static void assertNotSame( Object expected, Object actual )
     {
         assertNotSame( null, expected, actual );
     }
 
     private static void failSame( String message )
     {
         String formatted = "";
 
         if ( message != null )
         {
             formatted = message + " ";
         }
 
         // TODO! i18n
         fail( formatted + "expected not same" );
     }
 
     private static void failNotSame( String message, Object expected, Object actual )
     {
         String formatted = "";
 
         if ( message != null )
         {
             formatted = message + " ";
         }
 
         // TODO! i18n
         fail( formatted + "expected same:<" + expected + "> was not:<" + actual + ">" );
     }
 
     private static void failNotEquals( String message, Object expected, Object actual )
     {
         fail( ComparisonTool.formatMismatch( message, expected, actual ) );
     }
 }

1		package org.apache.maven.surefire.assertion;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		public class SurefireAssert
23		{
24		private SurefireAssert()
25	0	{
26		// No touchy.
27	0	}
28
29		public static void fail()
30		{
31	0	throw new SurefireAssertionFailedException();
32		}
33
34		public static void fail( String message )
35		{
36	0	if ( message == null )
37		{
38	0	throw new NullPointerException( "message is null" );
39		}
40	0	throw new SurefireAssertionFailedException( message );
41		}
42
43		public static void fail( String message, Throwable cause )
44		{
45	0	if ( message == null )
46		{
47	0	throw new NullPointerException( "message is null" );
48		}
49
50	0	if ( cause == null )
51		{
52	0	throw new NullPointerException( "cause is null" );
53		}
54
55	0	throw new SurefireAssertionFailedException( message, cause );
56		}
57
58		public static void fail( Throwable cause )
59		{
60	0	if ( cause == null )
61		{
62	0	throw new NullPointerException( "cause is null" );
63		}
64
65	0	throw new SurefireAssertionFailedException( cause );
66		}
67
68		// ----------------------------------------------------------------------
69		// JUnit type assertions
70		// ----------------------------------------------------------------------
71
72		public static void assertTrue( String message, boolean condition )
73		{
74	0	if ( !condition )
75		{
76	0	if ( message != null )
77		{
78	0	fail( message );
79		}
80		else
81		{
82	0	fail();
83		}
84		}
85	0	}
86
87		public static void assertTrue( boolean condition )
88		{
89	0	assertTrue( null, condition );
90	0	}
91
92		public static void assertFalse( String message, boolean condition )
93		{
94	0	assertTrue( message, !condition );
95	0	}
96
97		public static void assertFalse( boolean condition )
98		{
99	0	assertFalse( null, condition );
100	0	}
101
102		public static void assertEquals( String message, Object expected, Object actual )
103		{
104	0	if ( expected != null \|\| actual != null )
105		{
106	0	if ( expected == null \|\| !expected.equals( actual ) )
107		{
108	0	failNotEquals( message, expected, actual );
109		}
110		}
111	0	}
112
113		public static void assertEquals( Object expected, Object actual )
114		{
115	0	assertEquals( null, expected, actual );
116	0	}
117
118		public static void assertEquals( String message, String expected, String actual )
119		{
120	0	if ( expected != null \|\| actual != null )
121		{
122	0	if ( expected == null \|\| !expected.equals( actual ) )
123		{
124	0	throw new SurefireComparisonFailureException( message, expected, actual );
125		}
126		}
127	0	}
128
129		public static void assertEquals( String expected, String actual )
130		{
131	0	assertEquals( null, expected, actual );
132	0	}
133
134		public static void assertEquals( String message, double expected, double actual, double delta )
135		{
136		// handle infinity specially since subtracting to infinite values gives NaN and the
137		// the following test fails
138	0	if ( Double.isInfinite( expected ) )
139		{
140	0	if ( !Double.isInfinite( actual ) )
141		{
142	0	failNotEquals( message, new Double( expected ), new Double( actual ) );
143		}
144		}
145	0	else if ( !( Math.abs( expected - actual ) <= delta ) ) // Because comparison with NaN always returns false
146		{
147	0	failNotEquals( message, new Double( expected ), new Double( actual ) );
148		}
149	0	}
150
151		public static void assertEquals( double expected, double actual, double delta )
152		{
153	0	assertEquals( null, expected, actual, delta );
154	0	}
155
156		public static void assertEquals( String message, float expected, float actual, float delta )
157		{
158		// handle infinity specially since subtracting to infinite values gives NaN and the
159		// the following test fails
160	0	if ( Float.isInfinite( expected ) )
161		{
162	0	if ( !Float.isInfinite( actual ) )
163		{
164	0	failNotEquals( message, new Float( expected ), new Float( actual ) );
165		}
166
167		}
168	0	else if ( !( Math.abs( expected - actual ) <= delta ) )
169		{
170	0	failNotEquals( message, new Float( expected ), new Float( actual ) );
171		}
172	0	}
173
174		public static void assertEquals( float expected, float actual, float delta )
175		{
176	0	assertEquals( null, expected, actual, delta );
177	0	}
178
179		public static void assertEquals( String message, long expected, long actual )
180		{
181	0	assertEquals( message, new Long( expected ), new Long( actual ) );
182	0	}
183
184		public static void assertEquals( long expected, long actual )
185		{
186	0	assertEquals( null, expected, actual );
187	0	}
188
189		public static void assertEquals( String message, boolean expected, boolean actual )
190		{
191	0	assertEquals( message, expected ? Boolean.TRUE : Boolean.FALSE, actual ? Boolean.TRUE : Boolean.FALSE );
192	0	}
193
194		public static void assertEquals( boolean expected, boolean actual )
195		{
196	0	assertEquals( null, expected, actual );
197	0	}
198
199		public static void assertEquals( String message, byte expected, byte actual )
200		{
201	0	assertEquals( message, new Byte( expected ), new Byte( actual ) );
202	0	}
203
204		public static void assertEquals( byte expected, byte actual )
205		{
206	0	assertEquals( null, expected, actual );
207	0	}
208
209		public static void assertEquals( String message, char expected, char actual )
210		{
211	0	assertEquals( message, new Character( expected ), new Character( actual ) );
212	0	}
213
214		public static void assertEquals( char expected, char actual )
215		{
216	0	assertEquals( null, expected, actual );
217	0	}
218
219		public static void assertEquals( String message, short expected, short actual )
220		{
221	0	assertEquals( message, new Short( expected ), new Short( actual ) );
222	0	}
223
224		public static void assertEquals( short expected, short actual )
225		{
226	0	assertEquals( null, expected, actual );
227	0	}
228
229		public static void assertEquals( String message, int expected, int actual )
230		{
231	0	assertEquals( message, new Integer( expected ), new Integer( actual ) );
232	0	}
233
234		public static void assertEquals( int expected, int actual )
235		{
236	0	assertEquals( null, expected, actual );
237	0	}
238
239		public static void assertNotNull( Object object )
240		{
241	0	assertNotNull( null, object );
242	0	}
243
244		public static void assertNotNull( String message, Object object )
245		{
246	0	assertTrue( message, object != null );
247	0	}
248
249		public static void assertNull( Object object )
250		{
251	0	assertNull( null, object );
252	0	}
253
254		public static void assertNull( String message, Object object )
255		{
256	0	assertTrue( message, object == null );
257	0	}
258
259		public static void assertSame( String message, Object expected, Object actual )
260		{
261		//noinspection ObjectEquality
262	0	if ( expected != actual )
263		{
264	0	failNotSame( message, expected, actual );
265		}
266	0	}
267
268		public static void assertSame( Object expected, Object actual )
269		{
270	0	assertSame( null, expected, actual );
271	0	}
272
273		public static void assertNotSame( String message, Object expected, Object actual )
274		{
275		//noinspection ObjectEquality
276	0	if ( expected == actual )
277		{
278	0	failSame( message );
279		}
280	0	}
281
282		public static void assertNotSame( Object expected, Object actual )
283		{
284	0	assertNotSame( null, expected, actual );
285	0	}
286
287		private static void failSame( String message )
288		{
289	0	String formatted = "";
290
291	0	if ( message != null )
292		{
293	0	formatted = message + " ";
294		}
295
296		// TODO! i18n
297	0	fail( formatted + "expected not same" );
298	0	}
299
300		private static void failNotSame( String message, Object expected, Object actual )
301		{
302	0	String formatted = "";
303
304	0	if ( message != null )
305		{
306	0	formatted = message + " ";
307		}
308
309		// TODO! i18n
310	0	fail( formatted + "expected same:<" + expected + "> was not:<" + actual + ">" );
311	0	}
312
313		private static void failNotEquals( String message, Object expected, Object actual )
314		{
315	0	fail( ComparisonTool.formatMismatch( message, expected, actual ) );
316	0	}
317		}