Thread: [Japi-cvs] SF.net SVN: japi:[696] libs/util/trunk/src

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 696
          http://japi.svn.sourceforge.net/japi/?rev=696&view=rev
Author:   christianhujer
Date:     2008-10-07 23:24:28 +0000 (Tue, 07 Oct 2008)

Log Message:
-----------
Fixed code conventions issues.
Added new tests.

Modified Paths:
--------------
    libs/util/trunk/src/prj/net/sf/japi/util/Arrays2.java
    libs/util/trunk/src/prj/net/sf/japi/util/filter/file/AbstractFileFilter.java
    libs/util/trunk/src/prj/net/sf/japi/util/filter/file/EndingFileFilter.java
    libs/util/trunk/src/prj/net/sf/japi/util/filter/file/Factory.java
    libs/util/trunk/src/prj/net/sf/japi/util/filter/file/FilenameFileFilter.java
    libs/util/trunk/src/tst/test/net/sf/japi/util/Arrays2Test.java

Added Paths:
-----------
    libs/util/trunk/src/tst/test/net/sf/japi/util/EnumerationIteratorTest.java

Modified: libs/util/trunk/src/prj/net/sf/japi/util/Arrays2.java
===================================================================

--- libs/util/trunk/src/prj/net/sf/japi/util/Arrays2.java	2008-10-07 23:20:54 UTC (rev 695)
+++ libs/util/trunk/src/prj/net/sf/japi/util/Arrays2.java	2008-10-07 23:24:28 UTC (rev 696)
@@ -278,8 +278,8 @@
         return n;
     } // eventually add filters for primitive types and provide corresponding methods
 
-    /** Searches the specified array of ints for the specified value using the binary search algorithm.
-     * The array <strong>must</strong> be sorted (as by the <tt>sort</tt> method, above) prior to making this call.
+    /** Searches the specified array region of ints for the specified value using the binary search algorithm.
+     * The array region <strong>must</strong> be sorted (as by the <tt>sort</tt> method, above) prior to making this call.
      * If it is not sorted, the results are undefined (even a runtime exception might occur).
      * If the array contains multiple elements with the specified value, there is no guarantee which one will be found.
      * @param a    the array to be searched.

Modified: libs/util/trunk/src/prj/net/sf/japi/util/filter/file/AbstractFileFilter.java
===================================================================
--- libs/util/trunk/src/prj/net/sf/japi/util/filter/file/AbstractFileFilter.java	2008-10-07 23:20:54 UTC (rev 695)
+++ libs/util/trunk/src/prj/net/sf/japi/util/filter/file/AbstractFileFilter.java	2008-10-07 23:24:28 UTC (rev 696)
@@ -19,7 +19,7 @@
 
 package net.sf.japi.util.filter.file;
 
-/** A FileFilter that combines several File filtering classes and interfaces.
+/** The AbstractFileFilter is a combination of a normal {@link java.io.FileFilter}, {@link javax.swing.filechooser.FileFilter} and {@link net.sf.japi.util.filter.file.FileFilter}.
  * @author <a href="mailto:ch...@ri...">Christian Hujer</a>
  */
 @SuppressWarnings({"EmptyClass"})

Modified: libs/util/trunk/src/prj/net/sf/japi/util/filter/file/EndingFileFilter.java
===================================================================
--- libs/util/trunk/src/prj/net/sf/japi/util/filter/file/EndingFileFilter.java	2008-10-07 23:20:54 UTC (rev 695)
+++ libs/util/trunk/src/prj/net/sf/japi/util/filter/file/EndingFileFilter.java	2008-10-07 23:24:28 UTC (rev 696)
@@ -28,10 +28,10 @@
  */
 public class EndingFileFilter extends AbstractFileFilter {
 
-    /** Wether to accept directories. */
+    /** Whether to accept directories. */
     private final boolean acceptDirectories;
 
-    /** Wether to negate the endings. */
+    /** Whether to negate the endings. */
     private final boolean negate;
 
     /** The description text. */

Modified: libs/util/trunk/src/prj/net/sf/japi/util/filter/file/Factory.java
===================================================================
--- libs/util/trunk/src/prj/net/sf/japi/util/filter/file/Factory.java	2008-10-07 23:20:54 UTC (rev 695)
+++ libs/util/trunk/src/prj/net/sf/japi/util/filter/file/Factory.java	2008-10-07 23:24:28 UTC (rev 696)
@@ -57,7 +57,7 @@
 
         /** {@inheritDoc} */
         @Override public boolean accept(final File pathname) {
-            // XXX workaround bug in IntelliJ IDEA
+            // XXX:christianhujer:workaround bug in IntelliJ IDEA
             //noinspection RedundantCast
             return !((java.io.FileFilter) filter).accept(pathname);
         }
@@ -68,7 +68,7 @@
                     + (filter instanceof javax.swing.filechooser.FileFilter
                             ? ((javax.swing.filechooser.FileFilter) filter).getDescription()
                             : filter.toString())
-                    + ')'; // TODO: I18N/L10N
+                    + ')'; // TODO:christianhujer:I18N/L10N
         }
 
     } // class NotFileFilter

Modified: libs/util/trunk/src/prj/net/sf/japi/util/filter/file/FilenameFileFilter.java
===================================================================
--- libs/util/trunk/src/prj/net/sf/japi/util/filter/file/FilenameFileFilter.java	2008-10-07 23:20:54 UTC (rev 695)
+++ libs/util/trunk/src/prj/net/sf/japi/util/filter/file/FilenameFileFilter.java	2008-10-07 23:24:28 UTC (rev 696)
@@ -27,10 +27,10 @@
  */
 public final class FilenameFileFilter extends AbstractFileFilter {
 
-    /** Wether to accept directories. */
+    /** Whether to accept directories. */
     private final boolean acceptDirectories;
 
-    /** Wether to negate the names. */
+    /** Whether to negate the names. */
     private final boolean negate;
 
     /** The description text. */

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-10-07 23:20:54 UTC (rev 695)
+++ libs/util/trunk/src/tst/test/net/sf/japi/util/Arrays2Test.java	2008-10-07 23:24:28 UTC (rev 696)
@@ -23,6 +23,7 @@
 import java.util.Arrays;
 import junit.framework.TestCase;
 import net.sf.japi.util.Arrays2;
+import net.sf.japi.util.filter.Filter;
 import org.junit.Test;
 
 /** Test for {@link Arrays2}.
@@ -30,9 +31,9 @@
  */
 public class Arrays2Test extends TestCase {
 
-    /** Test case for Arrays2#concat(double[]...). */
+    /** Test case for {@link Arrays2#concat(byte[]...)}. */
     @Test
-    public void testConcat() {
+    public void testConcatByte() {
         final byte[] data1Orig = {1, 2, 3};
         final byte[] data2Orig = {4, 5, 6, 7};
         final byte[] data1Copy = data1Orig.clone();
@@ -44,4 +45,160 @@
         assertTrue("Concatenation must correctly concatenate", Arrays.equals(concatExpected, concatResult));
     }
 
+    /** Test case for {@link Arrays2#concat(short[]...)}. */
+    @Test
+    public void testConcatShort() {
+        final short[] data1Orig = {1, 2, 3};
+        final short[] data2Orig = {4, 5, 6, 7};
+        final short[] data1Copy = data1Orig.clone();
+        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));
+    }
+
+    /** Test case for {@link Arrays2#concat(int[]...)}. */
+    @Test
+    public void testConcatInt() {
+        final int[] data1Orig = {1, 2, 3};
+        final int[] data2Orig = {4, 5, 6, 7};
+        final int[] data1Copy = data1Orig.clone();
+        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));
+    }
+
+    /** Test case for {@link Arrays2#concat(long[]...)}. */
+    @Test
+    public void testConcatLong() {
+        final long[] data1Orig = {1, 2, 3};
+        final long[] data2Orig = {4, 5, 6, 7};
+        final long[] data1Copy = data1Orig.clone();
+        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));
+    }
+
+    /** Test case for {@link Arrays2#concat(float[]...)}. */
+    @Test
+    public void testConcatFloat() {
+        final float[] data1Orig = {1, 2, 3};
+        final float[] data2Orig = {4, 5, 6, 7};
+        final float[] data1Copy = data1Orig.clone();
+        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));
+    }
+
+    /** Test case for {@link Arrays2#concat(double[]...)}. */
+    @Test
+    public void testConcatDouble() {
+        final double[] data1Orig = {1, 2, 3};
+        final double[] data2Orig = {4, 5, 6, 7};
+        final double[] data1Copy = data1Orig.clone();
+        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));
+    }
+
+    /** Test case for {@link Arrays2#concat(char[]...)}. */
+    @Test
+    public void testConcatChar() {
+        final char[] data1Orig = {1, 2, 3};
+        final char[] data2Orig = {4, 5, 6, 7};
+        final char[] data1Copy = data1Orig.clone();
+        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));
+    }
+
+    /** Test case for {@link Arrays2#concat(boolean[]...)}. */
+    @Test
+    public void testConcatBoolean() {
+        final boolean[] data1Orig = {true, false, true};
+        final boolean[] data2Orig = {false, true, false, false};
+        final boolean[] data1Copy = data1Orig.clone();
+        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));
+    }
+
+    /** Test case for {@link Arrays2#concat(Object[][])}. */
+    @Test
+    public void testConcatObject() {
+        final String[] data1Orig = {"1", "2", "3"};
+        final String[] data2Orig = {"4", "5", "6", "7"};
+        final String[] data1Copy = data1Orig.clone();
+        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));
+    }
+
+    /** Test case for {@link Arrays2#filter(Filter, Object[])}. */
+    @Test
+    public void testFilter() {
+        final String[] dataOrig = {"foo1", "foo2", "bar1", "foo3", "bar2", "bar3", "bar4"};
+        final String[] dataCopy = dataOrig.clone();
+        final Filter<String> filter = new Filter<String>() {
+            public boolean accept(final String o) {
+                return o.startsWith("foo");
+            }
+        };
+        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));
+    }
+
+    /** Test case for {@link Arrays2#count(Filter, Object[])}. */
+    @Test
+    public void testCount() {
+        final String[] dataOrig = {"foo1", "foo2", "bar1", "foo3", "bar2", "bar3", "bar4"};
+        final String[] dataCopy = dataOrig.clone();
+        final Filter<String> filter = new Filter<String>() {
+            public boolean accept(final String o) {
+                return o.startsWith("foo");
+            }
+        };
+        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);
+    }
+
+    /** 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));
+    }
+
 } // class Arrays2Test

Copied: libs/util/trunk/src/tst/test/net/sf/japi/util/EnumerationIteratorTest.java (from rev 635, historic/trunk/src/test/net/sf/japi/util/EnumerationIteratorTest.java)
===================================================================
--- libs/util/trunk/src/tst/test/net/sf/japi/util/EnumerationIteratorTest.java	                        (rev 0)
+++ libs/util/trunk/src/tst/test/net/sf/japi/util/EnumerationIteratorTest.java	2008-10-07 23:24:28 UTC (rev 696)
@@ -0,0 +1,92 @@
+/*
+ * JAPI - (Yet another (hopefully) useful) Java API
+ *
+ * Copyright (C) 2006 Christian Hujer
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+package test.net.sf.japi.util;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.NoSuchElementException;
+import net.sf.japi.util.EnumerationIterator;
+import org.junit.Assert;
+import org.junit.Test;
+
+/** Test class for {@link EnumerationIterator}.
+ * @author <a href="mailto:ch...@it...">Christian Hujer</a>
+ */
+public class EnumerationIteratorTest {
+
+    /** Test case for {@link EnumerationIterator#iterator()}. */
+    @Test
+    public void testIterator() throws Exception {
+        EnumerationIterator<?> oUT = new EnumerationIterator<String>(Collections.enumeration(Arrays.asList("foo", "bar")));
+        Assert.assertNotNull("Even empty enumerations must generate an iterator instance.", oUT.iterator());
+        oUT = new EnumerationIterator<Object>(Collections.enumeration(Arrays.asList()));
+        Assert.assertNotNull("Even empty enumerations must generate an iterator instance.", oUT.iterator());
+    }
+
+    /** Test case for {@link EnumerationIterator#hasNext()}. */
+    @Test public void testHasNext() throws Exception {
+        EnumerationIterator<?> oUT = new EnumerationIterator<Object>(Collections.enumeration(Arrays.asList()));
+        Assert.assertFalse("hasNext() on empty enumeration must instantly return false.", oUT.hasNext());
+        oUT = new EnumerationIterator<String>(Collections.enumeration(Arrays.asList("foo", "bar")));
+        Assert.assertTrue("hasNext() on nonempty enumeration must first return true.", oUT.hasNext());
+    }
+
+    /** Test case for {@link EnumerationIterator#next()}. */
+    @Test public void testNext() throws Exception {
+        EnumerationIterator<?> oUT = new EnumerationIterator<Object>(Collections.enumeration(Arrays.asList()));
+        try {
+            oUT.next();
+            Assert.fail("next() on empty enumeration must instantly throw NoSuchElementException.");
+        } catch (final NoSuchElementException e) {
+            /* Expected exception. */
+        }
+        oUT = new EnumerationIterator<String>(Collections.enumeration(Arrays.asList("foo", "bar")));
+        oUT.next();
+        oUT.next();
+        try {
+            oUT.next();
+            Assert.fail("next() on two elements enumeration must throw NoSuchElementException on third invocation.");
+        } catch (final NoSuchElementException e) {
+            /* Expected exception. */
+        }
+    }
+
+    /** Test case for {@link EnumerationIterator#remove()}. */
+    @Test public void testRemove() throws Exception {
+        EnumerationIterator<?> oUT = new EnumerationIterator<Object>(Collections.enumeration(Arrays.asList()));
+        try {
+            oUT.remove();
+            Assert.fail("remove() on empty enumeration must instantly throw UnsupportedOperationException.");
+        } catch (final UnsupportedOperationException e) {
+            /* Expected exception. */
+        }
+        oUT = new EnumerationIterator<String>(Collections.enumeration(Arrays.asList("foo", "bar")));
+        try {
+            oUT.next();
+            oUT.remove();
+            Assert.fail("remove() must throw UnsupportedOperationException.");
+        } catch (final UnsupportedOperationException e) {
+            /* Expected exception. */
+        }
+    }
+
+} // class EnumerationIteratorTest


Property changes on: libs/util/trunk/src/tst/test/net/sf/japi/util/EnumerationIteratorTest.java
___________________________________________________________________
Added: svn:mime-type
   + text/plain
Added: svn:eol-style
   + LF


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




Thread: [Japi-cvs] SF.net SVN: japi:[696] libs/util/trunk/src

japi-cvs