[Japi-cvs] SF.net SVN: japi:[696] libs/util/trunk/src
Status: Beta
Brought to you by:
christianhujer
Menu
▾
▴
[Japi-cvs] SF.net SVN: japi:[696] libs/util/trunk/src
|
From: <chr...@us...> - 2008-10-07 23:24:35
|
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.
|
