[Japi-cvs] SF.net SVN: japi:[768] libs/util/trunk/src/tst/test/net/sf/japi/util/ Arrays2Test.java

[<chr...@us...>]

Revision: 768
          http://japi.svn.sourceforge.net/japi/?rev=768&view=rev
Author:   christianhujer
Date:     2008-12-29 04:56:02 +0000 (Mon, 29 Dec 2008)

Log Message:
-----------
Unit Tests: Replaced mixture of JUnit 3 and JUnit 4 by pure JUnit 4 usage.

Modified Paths:
--------------
    libs/util/trunk/src/tst/test/net/sf/japi/util/Arrays2Test.java

Modified: libs/util/trunk/src/tst/test/net/sf/japi/util/Arrays2Test.java
===================================================================
--- libs/util/trunk/src/tst/test/net/sf/japi/util/Arrays2Test.java	2008-12-29 04:53:42 UTC (rev 767)
+++ libs/util/trunk/src/tst/test/net/sf/japi/util/Arrays2Test.java	2008-12-29 04:56:02 UTC (rev 768)
@@ -21,15 +21,15 @@
 package test.net.sf.japi.util;
 
 import java.util.Arrays;
-import junit.framework.TestCase;
 import net.sf.japi.util.Arrays2;
 import net.sf.japi.util.filter.Filter;
+import org.junit.Assert;
 import org.junit.Test;
 
 /** Test for {@link Arrays2}.
  * @author <a href="mailto:ch...@ri...">Christian Hujer</a>
  */
-public class Arrays2Test extends TestCase {
+public class Arrays2Test {
 
     /** Test case for {@link Arrays2#concat(byte[]...)}. */
     @Test
@@ -40,9 +40,9 @@
         final byte[] data2Copy = data2Orig.clone();
         final byte[] concatExpected = {1, 2, 3, 4, 5, 6, 7};
         final byte[] concatResult = Arrays2.concat(data1Copy, data2Copy);
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
-        assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
+        Assert.assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
     }
 
     /** Test case for {@link Arrays2#concat(short[]...)}. */
@@ -54,9 +54,9 @@
         final short[] data2Copy = data2Orig.clone();
         final short[] concatExpected = {1, 2, 3, 4, 5, 6, 7};
         final short[] concatResult = Arrays2.concat(data1Copy, data2Copy);
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
-        assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
+        Assert.assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
     }
 
     /** Test case for {@link Arrays2#concat(int[]...)}. */
@@ -68,9 +68,9 @@
         final int[] data2Copy = data2Orig.clone();
         final int[] concatExpected = {1, 2, 3, 4, 5, 6, 7};
         final int[] concatResult = Arrays2.concat(data1Copy, data2Copy);
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
-        assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
+        Assert.assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
     }
 
     /** Test case for {@link Arrays2#concat(long[]...)}. */
@@ -82,9 +82,9 @@
         final long[] data2Copy = data2Orig.clone();
         final long[] concatExpected = {1, 2, 3, 4, 5, 6, 7};
         final long[] concatResult = Arrays2.concat(data1Copy, data2Copy);
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
-        assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
+        Assert.assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
     }
 
     /** Test case for {@link Arrays2#concat(float[]...)}. */
@@ -96,9 +96,9 @@
         final float[] data2Copy = data2Orig.clone();
         final float[] concatExpected = {1, 2, 3, 4, 5, 6, 7};
         final float[] concatResult = Arrays2.concat(data1Copy, data2Copy);
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
-        assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
+        Assert.assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
     }
 
     /** Test case for {@link Arrays2#concat(double[]...)}. */
@@ -110,9 +110,9 @@
         final double[] data2Copy = data2Orig.clone();
         final double[] concatExpected = {1, 2, 3, 4, 5, 6, 7};
         final double[] concatResult = Arrays2.concat(data1Copy, data2Copy);
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
-        assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
+        Assert.assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
     }
 
     /** Test case for {@link Arrays2#concat(char[]...)}. */
@@ -124,9 +124,9 @@
         final char[] data2Copy = data2Orig.clone();
         final char[] concatExpected = {1, 2, 3, 4, 5, 6, 7};
         final char[] concatResult = Arrays2.concat(data1Copy, data2Copy);
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
-        assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
+        Assert.assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
     }
 
     /** Test case for {@link Arrays2#concat(boolean[]...)}. */
@@ -138,9 +138,9 @@
         final boolean[] data2Copy = data2Orig.clone();
         final boolean[] concatExpected = {true, false, true, false, true, false, false};
         final boolean[] concatResult = Arrays2.concat(data1Copy, data2Copy);
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
-        assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
+        Assert.assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
     }
 
     /** Test case for {@link Arrays2#concat(Object[][])}. */
@@ -152,9 +152,9 @@
         final String[] data2Copy = data2Orig.clone();
         final String[] concatExpected = {"1", "2", "3", "4", "5", "6", "7"};
         final String[] concatResult = Arrays2.concat(data1Copy, data2Copy);
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
-        assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
-        assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data1Orig, data1Copy));
+        Assert.assertTrue("Original arrays must be unmodified", Arrays.equals(data2Orig, data2Copy));
+        Assert.assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
     }
 
     /** Test case for {@link Arrays2#filter(Filter, Object[])}. */
@@ -169,8 +169,8 @@
         };
         final String[] expected = {"foo1", "foo2", "foo3"};
         final String[] actual = Arrays2.filter(filter, dataCopy);
-        assertTrue("Original array must be unmodified", Arrays.equals(dataOrig, dataCopy));
-        assertTrue("Filter must filter correctly.", Arrays.equals(expected, actual));
+        Assert.assertTrue("Original array must be unmodified", Arrays.equals(dataOrig, dataCopy));
+        Assert.assertTrue("Filter must filter correctly.", Arrays.equals(expected, actual));
     }
 
     /** Test case for {@link Arrays2#count(Filter, Object[])}. */
@@ -185,20 +185,20 @@
         };
         final int expected = 3;
         final int actual = Arrays2.count(filter, dataCopy);
-        assertTrue("Original array must be unmodified", Arrays.equals(dataOrig, dataCopy));
-        assertEquals("Count must count correctly.", expected, actual);
+        Assert.assertTrue("Original array must be unmodified", Arrays.equals(dataOrig, dataCopy));
+        Assert.assertEquals("Count must count correctly.", expected, actual);
     }
 
     /** Test case for {@link Arrays2#linearSearch(int, int[])}. */
     @Test
     public void testLinearSearch() {
         final int[] data = { 0, 1, 2, 3 };
-        assertEquals(-1, Arrays2.linearSearch(-1, data));
-        assertEquals(0, Arrays2.linearSearch(0, data));
-        assertEquals(1, Arrays2.linearSearch(1, data));
-        assertEquals(2, Arrays2.linearSearch(2, data));
-        assertEquals(3, Arrays2.linearSearch(3, data));
-        assertEquals(-1, Arrays2.linearSearch(4, data));
+        Assert.assertEquals(-1, Arrays2.linearSearch(-1, data));
+        Assert.assertEquals(0, Arrays2.linearSearch(0, data));
+        Assert.assertEquals(1, Arrays2.linearSearch(1, data));
+        Assert.assertEquals(2, Arrays2.linearSearch(2, data));
+        Assert.assertEquals(3, Arrays2.linearSearch(3, data));
+        Assert.assertEquals(-1, Arrays2.linearSearch(4, data));
     }
 
 } // class Arrays2Test


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.