T deepCopy(T original) {
if (original == null) {
return null;
}
try {
final ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
final ObjectOutputStream oas = new ObjectOutputStream(baos);
oas.writeObject(original);
oas.flush();
// close is unnecessary
final ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
final ObjectInputStream ois = new ObjectInputStream(bais);
return (T) ois.readObject();
} catch (Throwable e) {
throw new RuntimeException("Deep copy failed", e);
}
}
/**
* Checks and answers if the two objects are both {@code null} or equal.
*
*
* Objects.equals(null, null) == true
* Objects.equals("Hi", "Hi") == true
* Objects.equals("Hi", null) == false
* Objects.equals(null, "Hi") == false
* Objects.equals("Hi", "Ho") == false
*
*
* @param o1 the first object to compare
* @param o2 the second object to compare
* @return boolean {@code true} if and only if
* both objects are {@code null} or equal according to
* {@link Object#equals(Object) equals} invoked on the
* first object
*/
public static boolean equals(Object o1, Object o2) {
return o1 == o2
|| o1 != null && o1.equals(o2);
}
}
jgoodies-common-1.4.0/src/main/java/com/jgoodies/common/base/Strings.java 0000644 0001750 0001750 00000022736 11730624762 025106 0 ustar tony tony /*
* Copyright (c) 2009-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.base;
/**
* Provides frequently used static null-safe String testing methods .
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*/
public class Strings {
protected Strings() {
// Override default constructor; prevents direct instantiation.
}
// String Validations ***************************************************
/**
* Checks if the given string is whitespace, empty ("") or {@code null}.
*
*
* Strings.isBlank(null) == true
* Strings.isBlank("") == true
* Strings.isBlank(" ") == true
* Strings.isBlank(" abc") == false
* Strings.isBlank("abc ") == false
* Strings.isBlank(" abc ") == false
*
*
* @param str the string to check, may be {@code null}
* @return {@code true} if the string is whitespace, empty
* or {@code null}
*
* @see #isEmpty(String)
*/
public static boolean isBlank(String str) {
int length;
if (str == null || (length = str.length()) == 0) {
return true;
}
for (int i = length - 1; i >= 0; i--) {
if (!Character.isWhitespace(str.charAt(i))) {
return false;
}
}
return true;
}
/**
* Checks if the given string is not empty (""),
* not {@code null} and not whitespace only.
*
*
* Strings.isNotBlank(null) == false
* Strings.isNotBlank("") == false
* Strings.isNotBlank(" ") == false
* Strings.isNotBlank(" abc") == true
* Strings.isNotBlank("abc ") == true
* Strings.isNotBlank(" abc ") == true
*
*
* @param str the string to check, may be {@code null}
* @return {@code true} if the string is not empty
* and not {@code null} and not whitespace only
*
* @see #isEmpty(String)
*/
public static boolean isNotBlank(String str) {
int length;
if (str == null || (length = str.length()) == 0) {
return false;
}
for (int i = length - 1; i >= 0; i--) {
if (!Character.isWhitespace(str.charAt(i))) {
return true;
}
}
return false;
}
/**
* Checks if the given string is empty ("") or {@code null}.
*
*
* Strings.isEmpty(null) == true
* Strings.isEmpty("") == true
* Strings.isEmpty(" ") == false
* Strings.isEmpty("Hi ") == false
*
*
* @param str the string to check, may be {@code null}
* @return {@code true} if the string is empty or {@code null}
*
* @see #isBlank(String)
*/
public static boolean isEmpty(String str) {
return str == null || str.length() == 0;
}
/**
* Checks if the given string is not empty ("")
* and not {@code null}.
*
*
* Strings.isNotEmpty(null) == false
* Strings.isNotEmpty("") == false
* Strings.isNotEmpty(" ") == true
* Strings.isNotEmpty("Hi") == true
* Strings.isNotEmpty("Hi ") == true
*
*
* @param str the string to check, may be {@code null}
* @return {@code true} if the string is not empty and not {@code null}
*
* @see #isBlank(String)
*/
public static boolean isNotEmpty(String str) {
return str != null && str.length() > 0;
}
/**
* Checks if the given string is {@code null}, empty (""),
* or the first and last characters are not whitespace.
*
*
* Strings.isTrimmed(null) == true
* Strings.isTrimmed("") == true
* Strings.isTrimmed(" ") == false
* Strings.isTrimmed("Hi") == true
* Strings.isTrimmed("Hi ") == false
* Strings.isTrimmed(" Hi") == false
*
*
* @param str the string to check, may be {@code null}
* @return {@code true} if the string is {@code null}, empty,
* or the first and last characters are not whitespace.
*
* @since 1.3
*/
public static boolean isTrimmed(String str) {
int length;
if (str == null || (length = str.length()) == 0) {
return true;
}
return !Character.isWhitespace(str.charAt(0))
&& !Character.isWhitespace(str.charAt(length-1));
}
/**
* Checks if {@code str} starts with the given prefix ignoring cases.
* {@code null} is handled safely; if both arguments are null, true
* is returned, false otherwise.
*
*
* Strings.startsWithIgnoreCase(null, null) == true
* Strings.startsWithIgnoreCase("a", null) == false
* Strings.startsWithIgnoreCase(null, "a") == false
* Strings.startsWithIgnoreCase("", "") == true
* Strings.startsWithIgnoreCase(" ", "") == true
* Strings.startsWithIgnoreCase("John", "J") == true
* Strings.startsWithIgnoreCase("John", "Jo") == true
* Strings.startsWithIgnoreCase("John", "Joh") == true
* Strings.startsWithIgnoreCase("John", "joh") == true
* Strings.startsWithIgnoreCase("john", "Joh") == true
* Strings.startsWithIgnoreCase("john", "joh") == true
* Strings.startsWithIgnoreCase("John", "John") == true
* Strings.startsWithIgnoreCase("John", "john") == true
* Strings.startsWithIgnoreCase("John", "Jonny") == false
*
*
* @param str the test string to check, may be null
* @param prefix the prefix to check for, may be null
* @return {@code true}, if the string starts with the prefix, ignoring cases,
* {@code false} otherwise
*
* @see String#startsWith(java.lang.String)
*/
public static boolean startsWithIgnoreCase(String str, String prefix) {
if (str == null) {
return prefix == null;
}
if (prefix == null) { // str is not null
return false;
}
return str.regionMatches(true, 0, prefix, 0, prefix.length());
}
/**
* Abbreviates the given string if it exceeds the given maximum length
* by replacing its center part with an ellipsis ('…').
* If the string is {@code null} or shorter than the limit,
* it is returned as is.
*
*
* Strings.abbreviateCenter(null, 3) == null
* Strings.abbreviateCenter("", 3) == ""
* Strings.abbreviateCenter(" ", 3) == " "
* Strings.abbreviateCenter("a", 3) == "a"
* Strings.abbreviateCenter("ab", 3) == "ab"
* Strings.abbreviateCenter("abc", 3) == "abc"
* Strings.abbreviateCenter("abcd", 3) == "a…d"
* Strings.abbreviateCenter("abcde", 3) == "a…e"
* Strings.abbreviateCenter("abcde", 4) == "ab…e"
* Strings.abbreviateCenter("abcdef", 4) == "ab…f"
* Strings.abbreviateCenter("abcdefg", 5) == "ab…fg"
*
*
* @param str the source string
* @param maxLength the maximum length of the result string
* @return {@code str} if its length is less than or equal to {@code maxLength},
* an abbreviated string with length {@code maxLength} where
* the center is replaced by an ellipsis
*/
public static String abbreviateCenter(String str, int maxLength) {
if (str == null) {
return null;
}
final int length = str.length();
if (length <= maxLength) {
return str;
}
int headLength = maxLength / 2;
int tailLength = maxLength - headLength - 1;
String head = str.substring(0, headLength);
String tail = str.substring(length - tailLength, length);
return head + "\u2026" + tail;
}
}
jgoodies-common-1.4.0/src/main/java/com/jgoodies/common/base/SystemUtils.java 0000644 0001750 0001750 00000022707 11754435356 025765 0 ustar tony tony /*
* Copyright (c) 2009-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.base;
import java.awt.HeadlessException;
import java.awt.Toolkit;
import java.util.logging.Logger;
/**
* Provides convenience behavior to determine the operating system
* and Java version.
*
* @author Karsten Lentzsch
* @version $Revision: 1.2 $
*/
public class SystemUtils {
// Internal Constants *****************************************************
/**
* The {@code os.name} System Property. Operating system name.
*
* Defaults to {@code null}, if the runtime does not have security
* access to read this property or the property does not exist.
*/
protected static final String OS_NAME = getSystemProperty("os.name");
/**
* The {@code os.version} System Property. Operating system version.
*
* Defaults to {@code null}, if the runtime does not have security
* access to read this property or the property does not exist.
*/
protected static final String OS_VERSION = getSystemProperty("os.version");
/**
* The {@code os.name} System Property. Operating system name.
*
* Defaults to {@code null}, if the runtime does not have security
* access to read this property or the property does not exist.
*/
protected static final String JAVA_VERSION = getSystemProperty("java.version");
// Requesting the OS and OS Version ***************************************
/**
* Is true if this is Linux.
*/
public static final boolean IS_OS_LINUX =
startsWith(OS_NAME, "Linux") || startsWith(OS_NAME, "LINUX");
/**
* True if this is the Mac OS.
*/
public static final boolean IS_OS_MAC =
startsWith(OS_NAME, "Mac OS");
/**
* True if this is Solaris.
*/
public static final boolean IS_OS_SOLARIS =
startsWith(OS_NAME, "Solaris");
/**
* True if this is Windows.
*/
public static final boolean IS_OS_WINDOWS =
startsWith(OS_NAME, "Windows");
/**
* True if this is Windows 98.
*/
public static final boolean IS_OS_WINDOWS_98 =
startsWith(OS_NAME, "Windows 9") && startsWith(OS_VERSION, "4.1");
/**
* True if this is Windows ME.
*/
public static final boolean IS_OS_WINDOWS_ME =
startsWith(OS_NAME, "Windows") && startsWith(OS_VERSION, "4.9");
/**
* True if this is Windows 2000.
*/
public static final boolean IS_OS_WINDOWS_2000 =
startsWith(OS_NAME, "Windows") && startsWith(OS_VERSION, "5.0");
/**
* True if this is Windows XP.
*/
public static final boolean IS_OS_WINDOWS_XP =
startsWith(OS_NAME, "Windows") && startsWith(OS_VERSION, "5.1");
/**
* True if this is Windows Vista or Server 2008.
*/
public static final boolean IS_OS_WINDOWS_VISTA =
startsWith(OS_NAME, "Windows") && startsWith(OS_VERSION, "6.0");
/**
* True if this is Windows 7.
*/
public static final boolean IS_OS_WINDOWS_7 =
startsWith(OS_NAME, "Windows") && startsWith(OS_VERSION, "6.1");
/**
* True if this is Windows 8.
*/
public static final boolean IS_OS_WINDOWS_8 =
startsWith(OS_NAME, "Windows") && startsWith(OS_VERSION, "6.2");
/**
* True if this is Windows Vista/Server 2008/7/2008 R2.
*/
public static final boolean IS_OS_WINDOWS_6_OR_LATER =
startsWith(OS_NAME, "Windows") && startsWith(OS_VERSION, "6.");
// Requesting the Java Version ********************************************
/**
* True if this is Java 6. We check for a prefix of 1.6.
*/
public static final boolean IS_JAVA_6 =
startsWith(JAVA_VERSION, "1.6");
/**
* True if this is Java 7. We check for a prefix of 1.7.
*/
public static final boolean IS_JAVA_7 =
startsWith(JAVA_VERSION, "1.7");
/**
* True if this is Java 7.x or later. We check that it's not 1.6.
*/
public static final boolean IS_JAVA_7_OR_LATER =
!IS_JAVA_6;
// Visual Properties ******************************************************
/**
* True since Java 6 update 10.
*
* @since 1.2
*/
public static final boolean HAS_MODERN_RASTERIZER = hasModernRasterizer();
/**
* True if the Windows XP Look&Feel is enabled.
*
* @since 1.2
*/
public static final boolean IS_LAF_WINDOWS_XP_ENABLED = isWindowsXPLafEnabled();
/**
* Is true if this environment's default toolkit reports a screen resolution
* below 120 dpi.
*
* @since 1.2
*/
public static final boolean IS_LOW_RESOLUTION = isLowResolution();
// Internal ***************************************************************
private static final String AWT_UTILITIES_CLASS_NAME =
"com.sun.awt.AWTUtilities";
protected SystemUtils() {
// Override default constructor; prevents instantiation.
}
/**
* Tries to look up the System property for the given key.
* In untrusted environments this may throw a SecurityException.
* In this case we catch the exception and answer an empty string.
*
* @param key the name of the system property
* @return the system property's String value, or {@code null} if there's
* no such value, or an empty String when
* a SecurityException has been caught
*/
protected static String getSystemProperty(String key) {
try {
return System.getProperty(key);
} catch (SecurityException e) {
Logger.getLogger(SystemUtils.class.getName()).warning(
"Can't access the System property " + key + ".");
return "";
}
}
protected static boolean startsWith(String str, String prefix) {
return str != null && str.startsWith(prefix);
}
/**
* Checks and answers whether this Java runtime has a modern rasterizer
* or not. More precisely this method aims to understand whether a good
* or poor rasterizer is used. Sun's Java runtime has improved its
* rasterizer in the 1.6 N series after build 12.
*
* @return {@code true} if the AWTUtilities class is available,
* {@code false} if this class is not in the class path.
*/
private static boolean hasModernRasterizer() {
try {
Class.forName(AWT_UTILITIES_CLASS_NAME);
return true;
} catch (ClassNotFoundException e) {
return false;
}
}
/**
* Checks and answers whether the Windows XP style is enabled.
* This method is intended to be called only if a Windows look&feel
* is about to be installed or already active in the UIManager.
* The XP style of the Windows look&feel is enabled by default on
* Windows XP platforms since the J2SE 1.4.2; it can be disabled either
* in the Windows desktop as well as in the Java runtime by setting
* a System property.
*
* First checks the platform, platform version and Java version. Then
* checks whether the desktop property win.xpstyle.themeActive
* is set or not.
*
* @return true if the Windows XP style is enabled
*/
private static boolean isWindowsXPLafEnabled() {
return IS_OS_WINDOWS
&& Boolean.TRUE.equals(Toolkit.getDefaultToolkit().
getDesktopProperty("win.xpstyle.themeActive"))
&& getSystemProperty("swing.noxp") == null;
}
private static boolean isLowResolution() {
try {
return Toolkit.getDefaultToolkit().getScreenResolution() < 120;
} catch (HeadlessException e) {
return true;
}
}
}
jgoodies-common-1.4.0/src/main/java/com/jgoodies/common/collect/ 0000755 0001750 0001750 00000000000 11731046166 023310 5 ustar tony tony jgoodies-common-1.4.0/src/main/java/com/jgoodies/common/collect/package.html 0000644 0001750 0001750 00000004113 11730624764 025575 0 ustar tony tony
Consists of classes that add ListModel features to List implementations.
jgoodies-common-1.4.0/src/main/java/com/jgoodies/common/collect/ObservableList.java 0000644 0001750 0001750 00000004562 11730624764 027107 0 ustar tony tony /*
* Copyright (c) 2002-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.collect;
import java.util.List;
import javax.swing.ListModel;
/**
* Combines the {@link List} and {@link ListModel} interfaces.
* Useful to specify a type that operates like a List and is published
* as a ListModel so it can be bound to user interface components
* such as {@code JList}, {@code JTable} and {@code JComboBox}.
*
* The JGoodies Common ships two predefined implementations:
* {@link ArrayListModel} and {@link LinkedListModel}.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*
* @param the type of the list elements
*/
public interface ObservableList extends List, ListModel {
// This interface just combines List and ListModel and
// doesn't add anything new.
}
jgoodies-common-1.4.0/src/main/java/com/jgoodies/common/collect/LinkedListModel.java 0000644 0001750 0001750 00000041465 11730624764 027215 0 ustar tony tony /*
* Copyright (c) 2002-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.collect;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import javax.swing.event.EventListenerList;
import javax.swing.event.ListDataEvent;
import javax.swing.event.ListDataListener;
/**
* Adds {@link javax.swing.ListModel} capabilities to its superclass.
* It allows to observe changes in the content and structure. Useful for
* Lists that are bound to list views such as JList, JComboBox and JTable.
*
* This class should be be final and it will be marked final in a future
* version, if its subclass in the JGoodies Binding has been removed.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*
* @see ObservableList
* @see ArrayListModel
*
* @param the type of the list elements
*/
public class LinkedListModel extends LinkedList implements ObservableList {
private static final long serialVersionUID = 5753378113505707237L;
// Instance Creation ******************************************************
/**
* Constructs an empty LinkedListModel.
*/
public LinkedListModel() {
// Just invoke the super constructor implicitly.
}
/**
* Constructs a LinkedListModel containing the elements of the specified
* collection, in the order they are returned by the collection's
* iterator.
*
* @param c the collection whose elements are to be placed into this list.
* @throws NullPointerException if {@code c} is {@code null}
*/
public LinkedListModel(Collection c) {
super(c);
}
// Overriding Superclass Behavior *****************************************
@Override
public final void add(int index, E element) {
super.add(index, element);
fireIntervalAdded(index, index);
}
@Override
public final boolean add(E e) {
int newIndex = size();
super.add(e);
fireIntervalAdded(newIndex, newIndex);
return true;
}
@Override
public final boolean addAll(int index, Collection c) {
boolean changed = super.addAll(index, c);
if (changed) {
int lastIndex = index + c.size() - 1;
fireIntervalAdded(index, lastIndex);
}
return changed;
}
/**
* Removes from this collection all of its elements that are contained in
* the specified collection (optional operation).
*
* This implementation iterates over this collection, checking each
* element returned by the iterator in turn to see if it's contained
* in the specified collection. If it's so contained, it's removed from
* this collection with the iterator's remove method.
*
* Note that this implementation will throw an
* UnsupportedOperationException if the iterator returned by the
* iterator method does not implement the remove method
* and this collection contains one or more elements in common with the
* specified collection.
*
* @param c elements to be removed from this collection.
* @return true if this collection changed as a result of the
* call.
* @throws UnsupportedOperationException if the removeAll method
* is not supported by this collection.
* @throws NullPointerException if the specified collection is null.
*
* @see #remove(Object)
* @see #contains(Object)
*/
@Override
public boolean removeAll(Collection c) {
boolean modified = false;
Iterator e = iterator();
while (e.hasNext()) {
if (c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
/**
* Retains only the elements in this collection that are contained in the
* specified collection (optional operation). In other words, removes
* from this collection all of its elements that are not contained in the
* specified collection.
*
* This implementation iterates over this collection, checking each
* element returned by the iterator in turn to see if it's contained
* in the specified collection. If it's not so contained, it's removed
* from this collection with the iterator's remove method.
*
* Note that this implementation will throw an
* UnsupportedOperationException if the iterator returned by the
* iterator method does not implement the remove method
* and this collection contains one or more elements not present in the
* specified collection.
*
* @param c elements to be retained in this collection.
* @return true if this collection changed as a result of the
* call.
* @throws UnsupportedOperationException if the retainAll method
* is not supported by this Collection.
* @throws NullPointerException if the specified collection is null.
*
* @see #remove(Object)
* @see #contains(Object)
*/
@Override
public boolean retainAll(Collection c) {
boolean modified = false;
Iterator e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
@Override
public final void addFirst(E e) {
super.addFirst(e);
fireIntervalAdded(0, 0);
}
@Override
public final void addLast(E e) {
int newIndex = size();
super.addLast(e);
fireIntervalAdded(newIndex, newIndex);
}
@Override
public final void clear() {
if (isEmpty()) {
return;
}
int oldLastIndex = size() - 1;
super.clear();
fireIntervalRemoved(0, oldLastIndex);
}
@Override
public final E remove(int index) {
E removedElement = super.remove(index);
fireIntervalRemoved(index, index);
return removedElement;
}
@Override
public final boolean remove(Object o) {
int index = indexOf(o);
if (index == -1) {
return false;
}
remove(index);
return true;
}
@Override
public final E removeFirst() {
E first = super.removeFirst();
fireIntervalRemoved(0, 0);
return first;
}
@Override
public final E removeLast() {
int lastIndex = size() - 1;
E last = super.removeLast();
fireIntervalRemoved(lastIndex, lastIndex);
return last;
}
@Override
protected final void removeRange(int fromIndex, int toIndex) {
super.removeRange(fromIndex, toIndex);
fireIntervalRemoved(fromIndex, toIndex - 1);
}
@Override
public final E set(int index, E element) {
E previousElement = super.set(index, element);
fireContentsChanged(index, index);
return previousElement;
}
@Override
public final ListIterator listIterator(int index) {
return new ReportingListIterator(super.listIterator(index));
}
// ListModel Field ********************************************************
/**
* Holds the registered ListDataListeners. The list that holds these
* listeners is initialized lazily in {@code #getEventListenerList}.
*
* @see #addListDataListener(ListDataListener)
* @see #removeListDataListener(ListDataListener)
*/
private EventListenerList listenerList;
// ListModel Implementation ***********************************************
@Override
public final void addListDataListener(ListDataListener l) {
getEventListenerList().add(ListDataListener.class, l);
}
@Override
public final void removeListDataListener(ListDataListener l) {
getEventListenerList().remove(ListDataListener.class, l);
}
@Override
public final E getElementAt(int index) {
return get(index);
}
@Override
public final int getSize() {
return size();
}
// Explicit Change Notification *******************************************
/**
* Notifies all registered {@code ListDataListeners} that the element
* at the specified index has changed. Useful if there's a content change
* without any structural change.
*
* This method must be called after the element of the list changes.
*
* @param index the index of the element that has changed
*
* @see EventListenerList
*/
public final void fireContentsChanged(int index) {
fireContentsChanged(index, index);
}
// ListModel Helper Code **************************************************
/**
* Returns an array of all the list data listeners
* registered on this {@code LinkedListModel}.
*
* @return all of this model's {@code ListDataListener}s,
* or an empty array if no list data listeners
* are currently registered
*
* @see #addListDataListener(ListDataListener)
* @see #removeListDataListener(ListDataListener)
*/
public final ListDataListener[] getListDataListeners() {
return getEventListenerList().getListeners(ListDataListener.class);
}
/**
* This method must be called after one or more elements
* of the list change. The changed elements
* are specified by the closed interval index0, index1 -- the end points
* are included. Note that index0 need not be less than or equal to index1.
*
* @param index0 one end of the new interval
* @param index1 the other end of the new interval
* @see EventListenerList
*/
private void fireContentsChanged(int index0, int index1) {
Object[] listeners = getEventListenerList().getListenerList();
ListDataEvent e = null;
for (int i = listeners.length - 2; i >= 0; i -= 2) {
if (listeners[i] == ListDataListener.class) {
if (e == null) {
e = new ListDataEvent(this,
ListDataEvent.CONTENTS_CHANGED, index0, index1);
}
((ListDataListener) listeners[i + 1]).contentsChanged(e);
}
}
}
/**
* This method must be called after one or more elements
* are added to the model. The new elements
* are specified by a closed interval index0, index1 -- the end points
* are included. Note that index0 need not be less than or equal to index1.
*
* @param index0 one end of the new interval
* @param index1 the other end of the new interval
* @see EventListenerList
*/
private void fireIntervalAdded(int index0, int index1) {
Object[] listeners = getEventListenerList().getListenerList();
ListDataEvent e = null;
for (int i = listeners.length - 2; i >= 0; i -= 2) {
if (listeners[i] == ListDataListener.class) {
if (e == null) {
e = new ListDataEvent(this, ListDataEvent.INTERVAL_ADDED, index0, index1);
}
((ListDataListener) listeners[i + 1]).intervalAdded(e);
}
}
}
/**
* This method must be called after one or more elements
* are removed from the model.
* {@code index0} and {@code index1} are the end points
* of the interval that's been removed. Note that {@code index0}
* need not be less than or equal to {@code index1}.
*
* @param index0 one end of the removed interval,
* including {@code index0}
* @param index1 the other end of the removed interval,
* including {@code index1}
* @see EventListenerList
*/
private void fireIntervalRemoved(int index0, int index1) {
Object[] listeners = getEventListenerList().getListenerList();
ListDataEvent e = null;
for (int i = listeners.length - 2; i >= 0; i -= 2) {
if (listeners[i] == ListDataListener.class) {
if (e == null) {
e = new ListDataEvent(this, ListDataEvent.INTERVAL_REMOVED, index0, index1);
}
((ListDataListener) listeners[i + 1]).intervalRemoved(e);
}
}
}
/**
* Lazily initializes and returns the event listener list used
* to notify registered listeners.
*
* @return the event listener list used to notify listeners
*/
private EventListenerList getEventListenerList() {
if (listenerList == null) {
listenerList = new EventListenerList();
}
return listenerList;
}
// Helper Class ***********************************************************
/**
* A ListIterator that fires ListDataEvents if elements are added or removed.
*/
private final class ReportingListIterator implements ListIterator {
/**
* Refers to the wrapped ListIterator that is used
* to forward all ListIterator methods to.
*/
private final ListIterator delegate;
/**
* Holds the object that was returned last by the underlying
* ListIteratur. Used to determine the index of the element removed.
*/
private int lastReturnedIndex;
ReportingListIterator(ListIterator delegate) {
this.delegate = delegate;
lastReturnedIndex = -1;
}
@Override
public boolean hasNext() {
return delegate.hasNext();
}
@Override
public E next() {
lastReturnedIndex = nextIndex();
return delegate.next();
}
@Override
public boolean hasPrevious() {
return delegate.hasPrevious();
}
@Override
public E previous() {
lastReturnedIndex = previousIndex();
return delegate.previous();
}
@Override
public int nextIndex() {
return delegate.nextIndex();
}
@Override
public int previousIndex() {
return delegate.previousIndex();
}
@Override
public void remove() {
int oldSize = size();
delegate.remove();
int newSize = size();
if (newSize < oldSize) {
LinkedListModel.this.fireIntervalRemoved(lastReturnedIndex, lastReturnedIndex);
}
}
@Override
public void set(E e) {
delegate.set(e);
LinkedListModel.this.fireContentsChanged(lastReturnedIndex);
}
@Override
public void add(E e) {
delegate.add(e);
int newIndex = previousIndex();
LinkedListModel.this.fireIntervalAdded(newIndex, newIndex);
lastReturnedIndex = -1;
}
}
}
jgoodies-common-1.4.0/src/main/java/com/jgoodies/common/collect/ArrayListModel.java 0000644 0001750 0001750 00000035105 11730624764 027057 0 ustar tony tony /*
* Copyright (c) 2002-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.collect;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import javax.swing.event.EventListenerList;
import javax.swing.event.ListDataEvent;
import javax.swing.event.ListDataListener;
/**
* Adds {@link javax.swing.ListModel} capabilities to its superclass.
* It allows to observe changes in the content and structure. Useful for
* Lists that are bound to list views such as JList, JComboBox and JTable.
*
* This class should be be final and it will be marked final in a future
* version, if its subclass in the JGoodies Binding has been removed.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*
* @see ObservableList
* @see LinkedListModel
*
* @param the type of the list elements
*/
public class ArrayListModel extends ArrayList implements ObservableList {
private static final long serialVersionUID = -6165677201152015546L;
// Instance Creation ******************************************************
/**
* Constructs an empty list with an initial capacity of ten.
*/
public ArrayListModel() {
this(10);
}
/**
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list.
* @throws IllegalArgumentException if the specified initial capacity
* is negative
*/
public ArrayListModel(int initialCapacity) {
super(initialCapacity);
}
/**
* Constructs a list containing the elements of the specified collection,
* in the order they are returned by the collection's iterator.
* The {@code ArrayListModel} instance has an initial capacity of
* 110% the size of the specified collection.
*
* @param c the collection whose elements are to be placed into this list.
* @throws NullPointerException if the specified collection is
* {@code null}
*/
public ArrayListModel(Collection c) {
super(c);
}
// Overriding Superclass Behavior *****************************************
@Override
public final void add(int index, E element) {
super.add(index, element);
fireIntervalAdded(index, index);
}
@Override
public final boolean add(E e) {
int newIndex = size();
super.add(e);
fireIntervalAdded(newIndex, newIndex);
return true;
}
@Override
public final boolean addAll(int index, Collection c) {
boolean changed = super.addAll(index, c);
if (changed) {
int lastIndex = index + c.size() - 1;
fireIntervalAdded(index, lastIndex);
}
return changed;
}
@Override
public final boolean addAll(Collection c) {
int firstIndex = size();
boolean changed = super.addAll(c);
if (changed) {
int lastIndex = firstIndex + c.size() - 1;
fireIntervalAdded(firstIndex, lastIndex);
}
return changed;
}
/**
* Removes from this collection all of its elements that are contained in
* the specified collection (optional operation).
*
* This implementation iterates over this collection, checking each
* element returned by the iterator in turn to see if it's contained
* in the specified collection. If it's so contained, it's removed from
* this collection with the iterator's remove method.
*
* Note that this implementation will throw an
* UnsupportedOperationException if the iterator returned by the
* iterator method does not implement the remove method
* and this collection contains one or more elements in common with the
* specified collection.
*
* @param c elements to be removed from this collection.
* @return true if this collection changed as a result of the
* call.
* @throws UnsupportedOperationException if the removeAll method
* is not supported by this collection.
* @throws NullPointerException if the specified collection is null.
*
* @see #remove(Object)
* @see #contains(Object)
*/
@Override
public boolean removeAll(Collection c) {
boolean modified = false;
Iterator e = iterator();
while (e.hasNext()) {
if (c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
/**
* Retains only the elements in this collection that are contained in the
* specified collection (optional operation). In other words, removes
* from this collection all of its elements that are not contained in the
* specified collection.
*
* This implementation iterates over this collection, checking each
* element returned by the iterator in turn to see if it's contained
* in the specified collection. If it's not so contained, it's removed
* from this collection with the iterator's remove method.
*
* Note that this implementation will throw an
* UnsupportedOperationException if the iterator returned by the
* iterator method does not implement the remove method
* and this collection contains one or more elements not present in the
* specified collection.
*
* @param c elements to be retained in this collection.
* @return true if this collection changed as a result of the
* call.
* @throws UnsupportedOperationException if the retainAll method
* is not supported by this Collection.
* @throws NullPointerException if the specified collection is null.
*
* @see #remove(Object)
* @see #contains(Object)
*/
@Override
public boolean retainAll(Collection c) {
boolean modified = false;
Iterator e = iterator();
while (e.hasNext()) {
if (!c.contains(e.next())) {
e.remove();
modified = true;
}
}
return modified;
}
@Override
public final void clear() {
if (isEmpty()) {
return;
}
int oldLastIndex = size() - 1;
super.clear();
fireIntervalRemoved(0, oldLastIndex);
}
@Override
public final E remove(int index) {
E removedElement = super.remove(index);
fireIntervalRemoved(index, index);
return removedElement;
}
@Override
public final boolean remove(Object o) {
int index = indexOf(o);
boolean contained = index != -1;
if (contained) {
remove(index);
}
return contained;
}
@Override
protected final void removeRange(int fromIndex, int toIndex) {
super.removeRange(fromIndex, toIndex);
fireIntervalRemoved(fromIndex, toIndex - 1);
}
@Override
public final E set(int index, E element) {
E previousElement = super.set(index, element);
fireContentsChanged(index, index);
return previousElement;
}
// ListModel Field ********************************************************
/**
* Holds the registered ListDataListeners. The list that holds these
* listeners is initialized lazily in {@code #getEventListenerList}.
*
* @see #addListDataListener(ListDataListener)
* @see #removeListDataListener(ListDataListener)
*/
private EventListenerList listenerList;
// ListModel Implementation ***********************************************
@Override
public final void addListDataListener(ListDataListener l) {
getEventListenerList().add(ListDataListener.class, l);
}
@Override
public final void removeListDataListener(ListDataListener l) {
getEventListenerList().remove(ListDataListener.class, l);
}
@Override
public final Object getElementAt(int index) {
return get(index);
}
@Override
public final int getSize() {
return size();
}
// Explicit Change Notification *******************************************
/**
* Notifies all registered {@code ListDataListeners} that the element
* at the specified index has changed. Useful if there's a content change
* without any structural change.
*
* This method must be called after the element of the list changes.
*
* @param index the index of the element that has changed
*
* @see EventListenerList
*/
public final void fireContentsChanged(int index) {
fireContentsChanged(index, index);
}
// ListModel Helper Code **************************************************
/**
* Returns an array of all the list data listeners
* registered on this {@code ArrayListModel}.
*
* @return all of this model's {@code ListDataListener}s,
* or an empty array if no list data listeners
* are currently registered
*
* @see #addListDataListener(ListDataListener)
* @see #removeListDataListener(ListDataListener)
*/
public final ListDataListener[] getListDataListeners() {
return getEventListenerList().getListeners(ListDataListener.class);
}
/**
* This method must be called after one or more elements
* of the list change. The changed elements
* are specified by the closed interval index0, index1 -- the end points
* are included. Note that index0 need not be less than or equal to index1.
*
* @param index0 one end of the new interval
* @param index1 the other end of the new interval
* @see EventListenerList
*/
private void fireContentsChanged(int index0, int index1) {
Object[] listeners = getEventListenerList().getListenerList();
ListDataEvent e = null;
for (int i = listeners.length - 2; i >= 0; i -= 2) {
if (listeners[i] == ListDataListener.class) {
if (e == null) {
e = new ListDataEvent(this,
ListDataEvent.CONTENTS_CHANGED, index0, index1);
}
((ListDataListener) listeners[i + 1]).contentsChanged(e);
}
}
}
/**
* This method must be called after one or more elements
* are added to the model. The new elements
* are specified by a closed interval index0, index1 -- the end points
* are included. Note that index0 need not be less than or equal to index1.
*
* @param index0 one end of the new interval
* @param index1 the other end of the new interval
* @see EventListenerList
*/
private void fireIntervalAdded(int index0, int index1) {
Object[] listeners = getEventListenerList().getListenerList();
ListDataEvent e = null;
for (int i = listeners.length - 2; i >= 0; i -= 2) {
if (listeners[i] == ListDataListener.class) {
if (e == null) {
e = new ListDataEvent(this, ListDataEvent.INTERVAL_ADDED, index0, index1);
}
((ListDataListener) listeners[i + 1]).intervalAdded(e);
}
}
}
/**
* This method must be called after one or more elements
* are removed from the model.
* {@code index0} and {@code index1} are the end points
* of the interval that's been removed. Note that {@code index0}
* need not be less than or equal to {@code index1}.
*
* @param index0 one end of the removed interval,
* including {@code index0}
* @param index1 the other end of the removed interval,
* including {@code index1}
* @see EventListenerList
*/
private void fireIntervalRemoved(int index0, int index1) {
Object[] listeners = getEventListenerList().getListenerList();
ListDataEvent e = null;
for (int i = listeners.length - 2; i >= 0; i -= 2) {
if (listeners[i] == ListDataListener.class) {
if (e == null) {
e = new ListDataEvent(this, ListDataEvent.INTERVAL_REMOVED, index0, index1);
}
((ListDataListener) listeners[i + 1]).intervalRemoved(e);
}
}
}
/**
* Lazily initializes and returns the event listener list used
* to notify registered listeners.
*
* @return the event listener list used to notify listeners
*/
private EventListenerList getEventListenerList() {
if (listenerList == null) {
listenerList = new EventListenerList();
}
return listenerList;
}
}
jgoodies-common-1.4.0/src/test/ 0000755 0001750 0001750 00000000000 12052274600 015115 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/ 0000755 0001750 0001750 00000000000 12052274610 016037 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/META-INF/ 0000755 0001750 0001750 00000000000 12003474132 017174 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/META-INF/MANIFEST.MF 0000644 0001750 0001750 00000000147 12003474130 020626 0 ustar tony tony Manifest-Version: 1.0
Ant-Version: Apache Ant 1.8.2
Created-By: 1.7.0_05-b05 (Oracle Corporation)
jgoodies-common-1.4.0/src/test/java/com/ 0000755 0001750 0001750 00000000000 11731046166 016623 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/com/jgoodies/ 0000755 0001750 0001750 00000000000 11731046166 020426 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/ 0000755 0001750 0001750 00000000000 11731046166 021716 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/swing/ 0000755 0001750 0001750 00000000000 11731046166 023045 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/swing/MnemonicUtilsTest.java 0000644 0001750 0001750 00000020533 11730624764 027346 0 ustar tony tony /*
* Copyright (c) 2009-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.swing;
import static org.junit.Assert.assertEquals;
import javax.swing.JLabel;
import org.junit.Test;
/**
* Tests the {@link MnemonicUtils} class.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*/
@SuppressWarnings("static-method")
public final class MnemonicUtilsTest {
@Test
public void htmlText() {
testMnemonic("abc&def", "abcdef", 'D', -1);
testMnemonic("a&bcdef", "a&bcdef", 0, -1);
testMnemonic("a&bc&def", "a&bcdef", 'D', -1);
}
@Test
public void mix() {
testMnemonic("Save", "Save", 0, -1);
testMnemonic("S&ave", "Save", 'A', 1);
testMnemonic("Save &as", "Save as", 'A', 5);
testMnemonic("Look&Feel", "LookFeel", 'F', 4);
testMnemonic("Look&&Feel", "Look&Feel", 0, -1);
testMnemonic("Look&&&Feel", "Look&Feel", 'F', 5);
testMnemonic("Look & Feel", "Look & Feel", 0, -1);
testMnemonic("Look & &Feel", "Look & Feel", 'F', 7);
testMnemonic("Look & Feel&", "Look & Feel&", 0, -1);
testMnemonic("Look & Feel& ", "Look & Feel& ", 0, -1);
testMnemonic("&&abc&&def&&g", "&abc&def&g", 0, -1);
testMnemonic("&&abc&&def&g", "&abc&defg", 'G', 8);
}
@Test
public void testLabelWithoutMnemonic() {
testMnemonic("", "", 0, -1);
testMnemonic(" ", " ", 0, -1);
testMnemonic(" ", " ", 0, -1);
testMnemonic(" ", " ", 0, -1);
testMnemonic("a", "a", 0, -1);
testMnemonic("a ", "a ", 0, -1);
testMnemonic(" a", " a", 0, -1);
testMnemonic(" a ", " a ", 0, -1);
testMnemonic("abcd", "abcd", 0, -1);
testMnemonic("abcd ", "abcd ", 0, -1);
}
@Test
public void testLabelWithSingleMnemonicMarker() {
testMnemonic("&x", "x", 'X', 0);
testMnemonic("a&x", "ax", 'X', 1);
testMnemonic("ab&x", "abx", 'X', 2);
testMnemonic("abc&x", "abcx", 'X', 3);
testMnemonic("abc&x ", "abcx ", 'X', 3);
testMnemonic("x&x", "xx", 'X', 1);
testMnemonic("xa&x", "xax", 'X', 2);
testMnemonic("xab&x", "xabx", 'X', 3);
testMnemonic("xabc&x", "xabcx", 'X', 4);
testMnemonic("xabc&x ", "xabcx ", 'X', 4);
testMnemonic("X&x", "Xx", 'X', 1);
testMnemonic("Xa&x", "Xax", 'X', 2);
testMnemonic("Xab&x", "Xabx", 'X', 3);
testMnemonic("Xabc&x", "Xabcx", 'X', 4);
testMnemonic("Xabc&x ", "Xabcx ", 'X', 4);
}
@Test
public void testLabelWithSingleQuotedMnemonicMarker() {
testMnemonic("&&", "&", 0, -1);
testMnemonic("a&&", "a&", 0, -1);
testMnemonic("ab&&", "ab&", 0, -1);
testMnemonic("abc&&", "abc&", 0, -1);
testMnemonic("abc&& ", "abc& ", 0, -1);
testMnemonic("abc&&a", "abc&a", 0, -1);
testMnemonic("abc&&ab", "abc&ab", 0, -1);
testMnemonic("abc&&ab ", "abc&ab ", 0, -1);
}
@Test
public void testLabelWithMultipleMnemonicMarkers() {
testMnemonic("&x&x", "x&x", 'X', 0);
testMnemonic("a&x&x", "ax&x", 'X', 1);
testMnemonic("ab&x&x", "abx&x", 'X', 2);
testMnemonic("abc&x&x", "abcx&x", 'X', 3);
testMnemonic("abc&x &x", "abcx &x", 'X', 3);
testMnemonic("x&x&x", "xx&x", 'X', 1);
testMnemonic("xa&x&x", "xax&x", 'X', 2);
testMnemonic("xab&x&x", "xabx&x", 'X', 3);
testMnemonic("xabc&x&x", "xabcx&x", 'X', 4);
testMnemonic("xabc&x &x", "xabcx &x",'X', 4);
testMnemonic("X&x&x", "Xx&x", 'X', 1);
testMnemonic("Xa&x&x", "Xax&x", 'X', 2);
testMnemonic("Xab&x&x", "Xabx&x", 'X', 3);
testMnemonic("Xabc&x&x", "Xabcx&x", 'X', 4);
testMnemonic("Xabc&x &x", "Xabcx &x",'X', 4);
}
@Test
public void testLabelWithQuotedMarkerBeforeMnemonic() {
testMnemonic("L&&F &choice", "L&F choice", 'C', 4);
testMnemonic("&&&x", "&x", 'X', 1);
testMnemonic("&&a&x", "&ax", 'X', 2);
testMnemonic("&&ab&x", "&abx", 'X', 3);
testMnemonic("&&abc&x", "&abcx", 'X', 4);
testMnemonic("&&abc&x ", "&abcx ", 'X', 4);
testMnemonic("&&x&x", "&xx", 'X', 2);
testMnemonic("&&xa&x", "&xax", 'X', 3);
testMnemonic("&&xab&x", "&xabx", 'X', 4);
testMnemonic("&&xabc&x", "&xabcx", 'X', 5);
testMnemonic("&&xabc&x ", "&xabcx ", 'X', 5);
testMnemonic("&&X&x", "&Xx", 'X', 2);
testMnemonic("X&&a&x", "X&ax", 'X', 3);
testMnemonic("X&&ab&x", "X&abx", 'X', 4);
testMnemonic("X&&abc&x", "X&abcx", 'X', 5);
testMnemonic("X&&abc&x ", "X&abcx ", 'X', 5);
}
@Test
public void testLabelWithQuotedMarkerAfterMnemonic() {
testMnemonic("&Look&&Feel choice", "Look&&Feel choice", 'L', 0);
testMnemonic("&x&&", "x&&", 'X', 0);
testMnemonic("a&x&&", "ax&&", 'X', 1);
testMnemonic("ab&x&&", "abx&&", 'X', 2);
testMnemonic("abc&x&&", "abcx&&", 'X', 3);
testMnemonic("abc&x &&", "abcx &&", 'X', 3);
testMnemonic("a&x&&b", "ax&&b", 'X', 1);
testMnemonic("a&xb&&c", "axb&&c", 'X', 1);
testMnemonic("a&xbc&&", "axbc&&", 'X', 1);
testMnemonic("a&xb&&c", "axb&&c", 'X', 1);
}
@Test
public void testLabelWithQuotedMarkersBeforeAndAfterMnemonic() {
testMnemonic("a&&b&&c&&d&x&&e&&f&&", "a&b&c&dx&&e&&f&&", 'X', 7);
testMnemonic("a&&b&&c&&d&x&&e&&f&&g", "a&b&c&dx&&e&&f&&g",'X', 7);
}
// Helper Code ************************************************************
private static void testMnemonic(String markedText,
String expectedPlainText,
int expectedMnemonic,
int expectedMnemonicIndex) {
JLabel label = new JLabel("");
MnemonicUtils.configure(label, markedText);
assertEquals("Text",
expectedPlainText,
label.getText());
assertEquals("Mnemonic",
expectedMnemonic,
label.getDisplayedMnemonic());
assertEquals("Mnemonic index",
expectedMnemonicIndex,
label.getDisplayedMnemonicIndex());
}
}
jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/format/ 0000755 0001750 0001750 00000000000 11731046166 023206 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/format/FormatTest.java 0000644 0001750 0001750 00000011422 11730624764 026146 0 ustar tony tony /*
* Copyright (c) 2009-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.format;
import static org.junit.Assert.assertEquals;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Date;
import org.junit.Assert;
import org.junit.Test;
/**
* Tests classes {@link EmptyDateFormat} and {@link EmptyNumberFormat}.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*/
public final class FormatTest {
@SuppressWarnings({"deprecation", "static-method"})
@Test
public void emptyDateFormat() {
Date day1 = new Date(1967, 11, 5);
Date day2 = new Date(2010, 4, 17);
DateFormat defaultFormat = DateFormat.getDateInstance();
DateFormat emptyFormat1 = new EmptyDateFormat(defaultFormat);
DateFormat emptyFormat2 = new EmptyDateFormat(defaultFormat, day2);
String formatted = defaultFormat.format(day1);
testParseDate("Empty", emptyFormat1, "", null);
testParseDate("Whitespace", emptyFormat1, " ", null);
testParseDate("Empty", emptyFormat2, "", day2);
testParseDate("Whitespace", emptyFormat2, " ", day2);
testParseDate("Day1 (raw)", defaultFormat, formatted, day1);
testParseDate("Day1 (wrapped)", emptyFormat1, formatted, day1);
testParseDate("Day1 (wrapped)", emptyFormat2, formatted, day1);
}
@SuppressWarnings("static-method")
@Test
public void emptyNumberFormat() {
Number number1 = Long.valueOf(42);
Number number2 = Double.valueOf(1.03d);
NumberFormat defaultFormat = NumberFormat.getInstance();
NumberFormat emptyFormat1 = new EmptyNumberFormat(defaultFormat);
NumberFormat emptyFormat2 = new EmptyNumberFormat(defaultFormat, number2);
String formatted = defaultFormat.format(number1);
testParseNumber("Empty", emptyFormat1, "", null);
testParseNumber("Whitespace", emptyFormat1, " ", null);
testParseNumber("Empty", emptyFormat2, "", number2);
testParseNumber("Whitespace", emptyFormat2, " ", number2);
testParseNumber("Number1 (raw)", defaultFormat, formatted, number1);
testParseNumber("Number1 (wrapped)", emptyFormat1, formatted, number1);
testParseNumber("Number1 (wrapped)", emptyFormat2, formatted, number1);
}
// Helper Code ************************************************************
private static void testParseDate(String message, DateFormat format, String source, Date expected) {
try {
Object actual = format.parse(source);
assertEquals(message, expected, actual);
} catch (ParseException e) {
Assert.fail(e.getLocalizedMessage());
}
}
private static void testParseNumber(String message, NumberFormat format, String source, Number expected) {
try {
Object actual = format.parse(source);
assertEquals(message, expected, actual);
} catch (ParseException e) {
Assert.fail(e.getLocalizedMessage());
}
}
}
jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/base/ 0000755 0001750 0001750 00000000000 11731046166 022630 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/base/SystemUtilsTest.java 0000644 0001750 0001750 00000004475 11730624764 026657 0 ustar tony tony /*
* Copyright (c) 2009-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.base;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;
import org.junit.Test;
/**
* Tests the {@link SystemUtils} class.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*/
@SuppressWarnings("static-method")
public final class SystemUtilsTest {
@Test
public void testJava6() {
assumeTrue(SystemUtils.IS_JAVA_6);
assertFalse(SystemUtils.IS_JAVA_7);
}
@Test
public void testJava7() {
assumeTrue(SystemUtils.IS_JAVA_7);
assertTrue(SystemUtils.IS_JAVA_7_OR_LATER);
assertFalse(SystemUtils.IS_JAVA_6);
}
}
jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/base/ObjectsTest.java 0000644 0001750 0001750 00000004361 11730624764 025735 0 ustar tony tony /*
* Copyright (c) 2009-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.base;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
/**
* Tests the {@link Objects} operations.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*/
public final class ObjectsTest {
@SuppressWarnings("static-method")
@Test
public void objectEquality() {
assertTrue(Objects.equals(null, null));
assertTrue(Objects.equals("Hi", "Hi"));
assertFalse(Objects.equals("Hi", null));
assertFalse(Objects.equals(null, "Hi"));
assertFalse(Objects.equals("Hi", "Ho"));
}
}
jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/base/PreconditionsTest.java 0000644 0001750 0001750 00000005421 11730624764 027162 0 ustar tony tony /*
* Copyright (c) 2009-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.base;
import org.junit.Test;
/**
* Tests the {@link Preconditions} class.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*/
@SuppressWarnings("static-method")
public final class PreconditionsTest {
@Test
public void checkValidArgument() {
int count = 1;
Preconditions.checkArgument(count > 0, "a message");
}
@Test(expected=IllegalArgumentException.class)
public void checkInvalidArgument() {
int count = 0;
Preconditions.checkArgument(count > 0, "a message");
}
@Test
public void checkNonNull() {
Preconditions.checkNotNull("Hello", "a message");
}
@Test(expected=NullPointerException.class)
public void checkNull() {
Preconditions.checkNotNull(null, "a message");
}
@Test
public void checkValidState() {
boolean locked = true;
Preconditions.checkArgument(locked, "a message");
}
@Test(expected=IllegalStateException.class)
public void checkInvalidState() {
boolean locked = false;
Preconditions.checkState(locked, "a message");
}
}
jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/base/StringsTest.java 0000644 0001750 0001750 00000014175 11730624764 026001 0 ustar tony tony /*
* Copyright (c) 2003-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.base;
import junit.framework.TestCase;
import org.junit.Assert;
import org.junit.Test;
/**
* A test case for class {@link Strings}.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*/
public final class StringsTest extends TestCase {
private static final String EMPTY = "";
private static final String BLANK = " ";
private static final String TEXT = "abc";
private static final String SPACE_TEXT = " abc";
private static final String TEXT_SPACE = "abc ";
private static final String SPACE_TEXT_SPACE = " abc ";
// String Tests ***********************************************************
@Test
public static void testIsBlank() {
assertTrue ("Null is blank", Strings.isBlank(null));
assertTrue ("EMPTY is blank", Strings.isBlank(EMPTY));
assertTrue ("BLANK is blank", Strings.isBlank(BLANK));
assertFalse("SPACE_TEXT is not blank", Strings.isBlank(SPACE_TEXT));
assertFalse("TEXT_SPACE is not blank", Strings.isBlank(TEXT_SPACE));
assertFalse("SPACE_TEXT_SPACE is not blank", Strings.isBlank(SPACE_TEXT_SPACE));
}
@Test
public static void testIsNotBlank() {
assertFalse("Null is not not-blank", Strings.isNotBlank(null));
assertFalse("EMPTY is not not-blank", Strings.isNotBlank(EMPTY));
assertFalse("BLANK is not not-blank", Strings.isNotBlank(BLANK));
assertTrue ("SPACE_TEXT is not-blank", Strings.isNotBlank(SPACE_TEXT));
assertTrue ("TEXT_SPACE is not-blank", Strings.isNotBlank(TEXT_SPACE));
assertTrue ("SPACE_TEXT_SPACE is not-blank", Strings.isNotBlank(SPACE_TEXT_SPACE));
}
@Test
public static void testIsEmpty() {
assertTrue ("Null is empty", Strings.isEmpty(null));
assertTrue ("EMPTY is empty", Strings.isEmpty(EMPTY));
assertFalse("BLANK is not empty", Strings.isEmpty(BLANK));
assertFalse("SPACE_TEXT is not blank", Strings.isEmpty(SPACE_TEXT));
assertFalse("TEXT_SPACE is not blank", Strings.isEmpty(TEXT_SPACE));
assertFalse("SPACE_TEXT_SPACE is not blank", Strings.isEmpty(SPACE_TEXT_SPACE));
}
@Test
public static void testIsNotEmpty() {
assertFalse("Null is not not-empty", Strings.isNotEmpty(null));
assertFalse("EMPTY is not not-empty", Strings.isNotEmpty(EMPTY));
assertTrue ("BLANK is not-empty", Strings.isNotEmpty(BLANK));
assertTrue ("SPACE_TEXT is not-empty", Strings.isNotEmpty(SPACE_TEXT));
assertTrue ("TEXT_SPACE is not-empty", Strings.isNotEmpty(TEXT_SPACE));
assertTrue ("SPACE_TEXT_SPACE is not-empty", Strings.isNotEmpty(SPACE_TEXT_SPACE));
}
@Test
public static void testIsTrimmed() {
assertTrue ("Null is trimmed", Strings.isTrimmed(null));
assertTrue ("EMPTY is trimmed", Strings.isTrimmed(EMPTY));
assertFalse("BLANK is not trimmed", Strings.isTrimmed(BLANK));
assertTrue ("TEXT is trimmed", Strings.isTrimmed(TEXT));
assertFalse("SPACE_TEXT is not trimmed", Strings.isTrimmed(SPACE_TEXT));
assertFalse("TEXT_SPACE is not trimmed", Strings.isTrimmed(TEXT_SPACE));
assertFalse("SPACE_TEXT_SPACE is not trimmed", Strings.isTrimmed(SPACE_TEXT_SPACE));
}
// Operations *********************************************************
@Test
public static void testAbbreviateCenter() {
final String empty = "";
final String blank = " ";
final String abc = "abc";
Assert.assertSame(null, Strings.abbreviateCenter(null, 3));
Assert.assertSame(empty, Strings.abbreviateCenter(empty, 3));
Assert.assertSame(blank, Strings.abbreviateCenter(blank, 3));
Assert.assertSame(abc, Strings.abbreviateCenter(abc, 3));
Assert.assertEquals("a\u2026d", Strings.abbreviateCenter("abcd", 3));
Assert.assertEquals("a\u2026e", Strings.abbreviateCenter("abcde", 3));
Assert.assertEquals("ab\u2026e", Strings.abbreviateCenter("abcde", 4));
Assert.assertEquals("ab\u2026f", Strings.abbreviateCenter("abcdef", 4));
Assert.assertEquals("ab\u2026fg", Strings.abbreviateCenter("abcdefg", 5));
}
}
jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/collect/ 0000755 0001750 0001750 00000000000 11731046166 023343 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/collect/ObservableListTest.java 0000644 0001750 0001750 00000113502 11730624764 027775 0 ustar tony tony /*
* Copyright (c) 2002-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.collect;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import javax.swing.event.ListDataEvent;
import javax.swing.event.ListDataListener;
import junit.framework.TestCase;
import org.junit.Test;
import com.jgoodies.common.test.event.ListDataReport;
/**
* A test case for classes {@link ArrayListModel} and {@link LinkedListModel}.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*/
@SuppressWarnings("static-method")
public final class ObservableListTest extends TestCase {
/**
* Tests the constructor that accepts a collection as initial content.
*/
@SuppressWarnings("unused")
@Test
public void testListConstructor() {
new ArrayListModel(createEmptyArrayListModel());
new LinkedListModel(createEmptyArrayListModel());
new ArrayListModel(createSingleElementArrayListModel());
new LinkedListModel(createSingleElementLinkedListModel());
new ArrayListModel(createFilledArrayListModel());
new LinkedListModel(createFilledLinkedListModel());
}
/**
* Tests a single add operation on different observable lists.
*/
@Test
public void testAdd() {
testAdd(createEmptyArrayListModel());
testAdd(createEmptyLinkedListModel());
testAdd(createSingleElementArrayListModel());
testAdd(createSingleElementLinkedListModel());
testAdd(createFilledArrayListModel());
testAdd(createFilledLinkedListModel());
}
/**
* Tests a single indexed add operation on different observable lists.
*/
@Test
public void testAddIndexed() {
testAddIndexed(createEmptyArrayListModel(), 0);
testAddIndexed(createEmptyLinkedListModel(), 0);
testAddIndexed(createSingleElementArrayListModel(), 0);
testAddIndexed(createSingleElementLinkedListModel(), 0);
testAddIndexed(createSingleElementArrayListModel(), 1);
testAddIndexed(createSingleElementLinkedListModel(), 1);
int size1 = createFilledArrayListModel().size();
for (int i = 0; i <= size1; i++) {
testAddIndexed(createFilledArrayListModel(), i);
}
int size2 = createFilledLinkedListModel().size();
for (int i = 0; i <= size2; i++) {
testAddIndexed(createFilledLinkedListModel(), i);
}
}
/**
* Tests a multiple add operation on different combinations of observable lists.
*/
@Test
public void testAddAll() {
testAddAll(createEmptyArrayListModel(), createEmptyArrayListModel());
testAddAll(createEmptyLinkedListModel(), createEmptyArrayListModel());
testAddAll(createEmptyArrayListModel(), createSingleElementArrayListModel());
testAddAll(createEmptyLinkedListModel(), createSingleElementArrayListModel());
testAddAll(createEmptyArrayListModel(), createFilledArrayListModel());
testAddAll(createEmptyLinkedListModel(), createFilledArrayListModel());
testAddAll(createSingleElementArrayListModel(), createEmptyArrayListModel());
testAddAll(createSingleElementLinkedListModel(), createEmptyArrayListModel());
testAddAll(createSingleElementArrayListModel(), createSingleElementArrayListModel());
testAddAll(createSingleElementLinkedListModel(), createSingleElementArrayListModel());
testAddAll(createSingleElementArrayListModel(), createFilledArrayListModel());
testAddAll(createSingleElementLinkedListModel(), createFilledArrayListModel());
testAddAll(createFilledArrayListModel(), createEmptyArrayListModel());
testAddAll(createFilledLinkedListModel(), createEmptyArrayListModel());
testAddAll(createFilledArrayListModel(), createSingleElementArrayListModel());
testAddAll(createFilledLinkedListModel(), createSingleElementArrayListModel());
testAddAll(createFilledArrayListModel(), createFilledArrayListModel());
testAddAll(createFilledLinkedListModel(), createFilledLinkedListModel());
}
/**
* Tests indexed multiple add operations on different combinations of
* observable lists.
*/
@Test
public void testAddAllIndexed() {
testAddAllIndexed(createEmptyArrayListModel(), createFilledArrayListModel(), 0);
testAddAllIndexed(createEmptyLinkedListModel(), createFilledArrayListModel(), 0);
testAddAllIndexed(createSingleElementArrayListModel(), createFilledArrayListModel(), 0);
testAddAllIndexed(createSingleElementLinkedListModel(), createFilledArrayListModel(), 0);
testAddAllIndexed(createSingleElementArrayListModel(), createFilledArrayListModel(), 1);
testAddAllIndexed(createSingleElementLinkedListModel(), createFilledArrayListModel(), 1);
int size1 = createFilledArrayListModel().size();
for (int i = 0; i <= size1; i++) {
testAddAllIndexed(createFilledArrayListModel(), createFilledArrayListModel(), i);
}
int size2 = createFilledLinkedListModel().size();
for (int i = 0; i <= size2; i++) {
testAddAllIndexed(createFilledLinkedListModel(), createFilledArrayListModel(), i);
}
}
/**
* Tests the #clear operation on different observable lists.
*/
@Test
public void testClear() {
testClear(createEmptyArrayListModel());
testClear(createEmptyLinkedListModel());
testClear(createSingleElementArrayListModel());
testClear(createSingleElementLinkedListModel());
testClear(createFilledArrayListModel());
testClear(createFilledLinkedListModel());
}
/**
* Tests the #remove(int) operation on different observable lists.
*/
@Test
public void testRemoveIndex() {
testRemoveIndex(createEmptyArrayListModel(), -1);
testRemoveIndex(createEmptyLinkedListModel(), -1);
testRemoveIndex(createEmptyArrayListModel(), 0);
testRemoveIndex(createEmptyLinkedListModel(), 0);
testRemoveIndex(createEmptyArrayListModel(), 1);
testRemoveIndex(createEmptyLinkedListModel(), 1);
testRemoveIndex(createSingleElementArrayListModel(), -1);
testRemoveIndex(createSingleElementLinkedListModel(), -1);
testRemoveIndex(createSingleElementArrayListModel(), 0);
testRemoveIndex(createSingleElementLinkedListModel(), 0);
testRemoveIndex(createSingleElementArrayListModel(), 1);
testRemoveIndex(createSingleElementLinkedListModel(), 1);
int size1 = createFilledArrayListModel().size();
for (int i = -1; i <= size1; i++) {
testRemoveIndex(createFilledArrayListModel(), i);
}
int size2 = createFilledLinkedListModel().size();
for (int i = -1; i <= size2; i++) {
testRemoveIndex(createFilledLinkedListModel(), i);
}
}
/**
* Tests the #remove(Object) operation on different observable lists.
*/
@Test
public void testRemoveObject() {
testRemoveObject(createEmptyArrayListModel(), -1);
testRemoveObject(createEmptyLinkedListModel(), -1);
testRemoveObject(createEmptyArrayListModel(), 0);
testRemoveObject(createEmptyLinkedListModel(), 0);
testRemoveObject(createEmptyArrayListModel(), 1);
testRemoveObject(createEmptyLinkedListModel(), 1);
testRemoveObject(createSingleElementArrayListModel(), -1);
testRemoveObject(createSingleElementLinkedListModel(), -1);
testRemoveObject(createSingleElementArrayListModel(), 0);
testRemoveObject(createSingleElementLinkedListModel(), 0);
testRemoveObject(createSingleElementArrayListModel(), 1);
testRemoveObject(createSingleElementLinkedListModel(), 1);
int size1 = createFilledArrayListModel().size();
for (int i = -1; i <= size1; i++) {
testRemoveObject(createFilledArrayListModel(), i);
}
int size2 = createFilledLinkedListModel().size();
for (int i = -1; i <= size2; i++) {
testRemoveObject(createFilledLinkedListModel(), i);
}
}
/**
* Tests #removeAll on different combinations of observable lists.
*/
@Test
public void testRemoveAll() {
testRemoveAll(createEmptyArrayListModel(), createEmptyArrayListModel());
testRemoveAll(createEmptyLinkedListModel(), createEmptyArrayListModel());
testRemoveAll(createEmptyArrayListModel(), createSingleElementArrayListModel());
testRemoveAll(createEmptyLinkedListModel(), createSingleElementArrayListModel());
testRemoveAll(createEmptyArrayListModel(), createFilledArrayListModel());
testRemoveAll(createEmptyLinkedListModel(), createFilledArrayListModel());
testRemoveAll(createSingleElementArrayListModel(), createEmptyArrayListModel());
testRemoveAll(createSingleElementLinkedListModel(), createEmptyArrayListModel());
testRemoveAll(createSingleElementArrayListModel(), createSingleElementArrayListModel());
testRemoveAll(createSingleElementLinkedListModel(), createSingleElementArrayListModel());
testRemoveAll(createSingleElementArrayListModel(), createFilledArrayListModel());
testRemoveAll(createSingleElementLinkedListModel(), createFilledArrayListModel());
testRemoveAll(createFilledArrayListModel(), createEmptyArrayListModel());
testRemoveAll(createFilledLinkedListModel(), createEmptyArrayListModel());
testRemoveAll(createFilledArrayListModel(), createSingleElementArrayListModel());
testRemoveAll(createFilledLinkedListModel(), createSingleElementArrayListModel());
testRemoveAll(createFilledArrayListModel(), createFilledArrayListModel());
testRemoveAll(createFilledLinkedListModel(), createFilledLinkedListModel());
}
/**
* Tests #retainAll on different combinations of observable lists.
*/
@Test
public void testRetainAll() {
testRetainAll(createEmptyArrayListModel(), createEmptyArrayListModel());
testRetainAll(createEmptyLinkedListModel(), createEmptyArrayListModel());
testRetainAll(createEmptyArrayListModel(), createSingleElementArrayListModel());
testRetainAll(createEmptyLinkedListModel(), createSingleElementArrayListModel());
testRetainAll(createEmptyArrayListModel(), createFilledArrayListModel());
testRetainAll(createEmptyLinkedListModel(), createFilledArrayListModel());
testRetainAll(createSingleElementArrayListModel(), createEmptyArrayListModel());
testRetainAll(createSingleElementLinkedListModel(), createEmptyArrayListModel());
testRetainAll(createSingleElementArrayListModel(), createSingleElementArrayListModel());
testRetainAll(createSingleElementLinkedListModel(), createSingleElementArrayListModel());
testRetainAll(createSingleElementArrayListModel(), createFilledArrayListModel());
testRetainAll(createSingleElementLinkedListModel(), createFilledArrayListModel());
testRetainAll(createFilledArrayListModel(), createEmptyArrayListModel());
testRetainAll(createFilledLinkedListModel(), createEmptyArrayListModel());
testRetainAll(createFilledArrayListModel(), createSingleElementArrayListModel());
testRetainAll(createFilledLinkedListModel(), createSingleElementArrayListModel());
testRetainAll(createFilledArrayListModel(), createFilledArrayListModel());
testRetainAll(createFilledLinkedListModel(), createFilledLinkedListModel());
}
/**
* Tests the #set operation on different observable lists.
*/
@Test
public void testSet() {
testSet(createEmptyArrayListModel(), 0);
testSet(createEmptyLinkedListModel(), 0);
testSet(createSingleElementArrayListModel(), 0);
testSet(createSingleElementLinkedListModel(), 0);
testSet(createSingleElementArrayListModel(), 1);
testSet(createSingleElementLinkedListModel(), 1);
int size1 = createFilledArrayListModel().size();
for (int i = 0; i < size1; i++) {
testSet(createFilledArrayListModel(), i);
}
int size2 = createFilledLinkedListModel().size();
for (int i = 0; i < size2; i++) {
testSet(createFilledLinkedListModel(), i);
}
}
/**
* Tests the list iterator's add operation on different observable lists.
*/
@Test
public void testListIteratorAdd() {
testListIteratorAdd(createEmptyArrayListModel(), 0, 0);
testListIteratorAdd(createEmptyLinkedListModel(), 0, 0);
testListIteratorAdd(createSingleElementArrayListModel(), 0, 0);
testListIteratorAdd(createSingleElementArrayListModel(), 0, 1);
testListIteratorAdd(createSingleElementArrayListModel(), 1, 1);
testListIteratorAdd(createSingleElementLinkedListModel(), 0, 0);
testListIteratorAdd(createSingleElementLinkedListModel(), 0, 1);
testListIteratorAdd(createSingleElementLinkedListModel(), 1, 1);
int size1 = createFilledArrayListModel().size();
for (int i = 0; i <= size1; i++) {
for (int j = i; j <= size1; j++) {
testListIteratorAdd(createFilledArrayListModel(), i, j);
}
}
int size2 = createFilledLinkedListModel().size();
for (int i = 0; i <= size2; i++) {
for (int j = i; j <= size2; j++) {
testListIteratorAdd(createFilledLinkedListModel(), i, j);
}
}
}
/**
* Tests the list iterator's remove operation on different observable lists.
*/
@Test
public void testListIteratorRemove() {
testListIteratorRemove(createEmptyArrayListModel(), 0, 0);
testListIteratorRemove(createEmptyLinkedListModel(), 0, 0);
testListIteratorRemove(createSingleElementArrayListModel(), 0, 0);
testListIteratorRemove(createSingleElementArrayListModel(), 0, 1);
testListIteratorRemove(createSingleElementArrayListModel(), 1, 1);
testListIteratorRemove(createSingleElementLinkedListModel(), 0, 0);
testListIteratorRemove(createSingleElementLinkedListModel(), 0, 1);
testListIteratorRemove(createSingleElementLinkedListModel(), 1, 1);
int size1 = createFilledArrayListModel().size();
for (int i = 0; i < size1; i++) {
for (int j = i; j < size1; j++) {
testListIteratorRemove(createFilledArrayListModel(), i, j);
}
}
int size2 = createFilledLinkedListModel().size();
for (int i = 0; i < size2; i++) {
for (int j = i; j < size2; j++) {
testListIteratorRemove(createFilledLinkedListModel(), i, j);
}
}
}
/**
* Tests the list iterator's remove operation on different observable lists.
*/
@Test
public void testListIteratorSet() {
testListIteratorSet(createEmptyArrayListModel(), 0, 0);
testListIteratorSet(createEmptyLinkedListModel(), 0, 0);
testListIteratorSet(createSingleElementArrayListModel(), 0, 0);
testListIteratorSet(createSingleElementArrayListModel(), 0, 1);
testListIteratorSet(createSingleElementArrayListModel(), 1, 1);
testListIteratorSet(createSingleElementLinkedListModel(), 0, 0);
testListIteratorSet(createSingleElementLinkedListModel(), 0, 1);
testListIteratorSet(createSingleElementLinkedListModel(), 1, 1);
int size1 = createFilledArrayListModel().size();
for (int i = 0; i < size1; i++) {
for (int j = i; j < size1; j++) {
testListIteratorSet(createFilledArrayListModel(), i, j);
}
}
int size2 = createFilledLinkedListModel().size();
for (int i = 0; i < size2; i++) {
for (int j = i; j < size2; j++) {
testListIteratorSet(createFilledLinkedListModel(), i, j);
}
}
}
/**
* Tests the iterator's remove operation on different observable lists.
*/
@Test
public void testIteratorRemove() {
testIteratorRemove(createEmptyArrayListModel(), 0);
testIteratorRemove(createEmptyLinkedListModel(), 0);
testIteratorRemove(createSingleElementArrayListModel(), 0);
testIteratorRemove(createSingleElementArrayListModel(), 1);
testIteratorRemove(createSingleElementLinkedListModel(), 0);
testIteratorRemove(createSingleElementLinkedListModel(), 1);
int size1 = createFilledArrayListModel().size();
for (int i = 0; i < size1; i++) {
testIteratorRemove(createFilledArrayListModel(), i);
}
int size2 = createFilledLinkedListModel().size();
for (int i = 0; i < size2; i++) {
testIteratorRemove(createFilledLinkedListModel(), i);
}
}
// Test the Event Listener List ******************************************
@Test
public void testGetListDataListenersWithoutListeners() {
ListDataListener[] listeners =
createEmptyArrayListModel().getListDataListeners();
assertEquals("The list of ArrayListModel's ListDataListeners is empty.",
0, listeners.length);
listeners = createEmptyLinkedListModel().getListDataListeners();
assertEquals("The list of LinkedListModel's ListDataListeners is empty.",
0, listeners.length);
}
// Test Implementations **************************************************
private static void testAdd(ObservableList list) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
list.add("OneAdded");
assertEquals("An element has been added.",
1, listDataReport.eventCountAdd());
assertEquals("One event has been fired.",
1, listDataReport.eventCount());
list.add("TwoAdded");
assertEquals("Another element has been added.",
2, listDataReport.eventCountAdd());
assertEquals("Another event has been fired.",
2, listDataReport.eventCountAdd());
}
private static void testAddIndexed(ObservableList list, int index) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
list.add(index, "OneAdded");
assertEquals("An element has been added.",
1, listDataReport.eventCountAdd());
assertEquals("One event has been fired.",
1, listDataReport.eventCount());
assertEquals("Proper index0 (first add).",
index, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (first add).",
index, listDataReport.lastEvent().getIndex1());
list.add(index, "TwoAdded");
assertEquals("Another element has been added.",
2, listDataReport.eventCountAdd());
assertEquals("Another event has been fired.",
2, listDataReport.eventCount());
assertEquals("Proper index0 (second add).",
index, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (second add).",
index, listDataReport.lastEvent().getIndex1());
}
private static void testAddAll(ObservableList list, List additions) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
int addCount = additions.size();
int eventCount = additions.isEmpty() ? 0 : 1;
int addIndex0 = list.size();
int addIndex1 = addIndex0 + addCount - 1;
list.addAll(additions);
assertEquals("Elements have been added.",
eventCount, listDataReport.eventCountAdd());
assertEquals("One event has been fired.",
eventCount, listDataReport.eventCount());
if (!additions.isEmpty()) {
assertEquals("Proper index0 (first addAll).",
addIndex0, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (first addAll).",
addIndex1, listDataReport.lastEvent().getIndex1());
}
addIndex0 = list.size();
addIndex1 = addIndex0 + addCount - 1;
list.addAll(additions);
assertEquals("More elements have been added.",
2 * eventCount, listDataReport.eventCountAdd());
assertEquals("Another event has been fired.",
2 * eventCount, listDataReport.eventCountAdd());
if (!additions.isEmpty()) {
assertEquals("Proper index0 (second addAll).",
addIndex0, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (second addAll).",
addIndex1, listDataReport.lastEvent().getIndex1());
}
}
private static void testAddAllIndexed(ObservableList list, List additions, int index) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
int addCount = additions.size();
int eventCount = additions.isEmpty() ? 0 : 1;
int addIndex0 = index;
int addIndex1 = addIndex0 + addCount - 1;
list.addAll(index, additions);
assertEquals("Elements have been added.",
eventCount, listDataReport.eventCountAdd());
assertEquals("One event has been fired.",
eventCount, listDataReport.eventCount());
if (!additions.isEmpty()) {
assertEquals("Proper index0 (first addAll).",
addIndex0, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (first addAll).",
addIndex1, listDataReport.lastEvent().getIndex1());
}
addIndex0 = index;
addIndex1 = addIndex0 + addCount - 1;
list.addAll(index, additions);
assertEquals("More elements have been added.",
2 * eventCount, listDataReport.eventCountAdd());
assertEquals("Another event has been fired.",
2 * eventCount, listDataReport.eventCountAdd());
if (!additions.isEmpty()) {
assertEquals("Proper index0 (second addAll).",
addIndex0, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (second addAll).",
addIndex1, listDataReport.lastEvent().getIndex1());
}
}
private static void testClear(ObservableList list) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
int eventCount = list.isEmpty() ? 0 : 1;
int index0 = 0;
int index1 = list.size() - 1;
list.clear();
assertEquals("All elements have been removed.",
eventCount, listDataReport.eventCountRemove());
assertEquals("One event has been fired.",
eventCount, listDataReport.eventCount());
if (!list.isEmpty()) {
assertEquals("Proper index0 (first clear).",
index0, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (first clear).",
index1, listDataReport.lastEvent().getIndex1());
}
list.clear();
assertEquals("No further elements have been removed.",
eventCount, listDataReport.eventCount());
}
private static void testRemoveIndex(ObservableList list, int index) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
if (index < 0 || index >= list.size()) {
try {
list.remove(index);
fail("IndexOutOfBoundsException expected when removing index " + index);
} catch (IndexOutOfBoundsException e) {
// Do nothing; this is the expected behavior.
}
} else {
list.remove(index);
assertEquals("An element has been removed.",
1, listDataReport.eventCountRemove());
assertEquals("One event has been fired.",
1, listDataReport.eventCount());
assertEquals("Proper index0 (first remove).",
index, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (first remove).",
index, listDataReport.lastEvent().getIndex1());
}
if (index < 0 || index >= list.size()) {
try {
list.remove(index);
fail("IndexOutOfBoundsException expected when removing index " + index);
} catch (IndexOutOfBoundsException e) {
// Do nothing; this is the expected behavior.
}
} else {
list.remove(index);
assertEquals("Another element has been removed.",
2, listDataReport.eventCountRemove());
assertEquals("Another event has been fired.",
2, listDataReport.eventCount());
assertEquals("Proper index0 (second remove).",
index, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (second remove).",
index, listDataReport.lastEvent().getIndex1());
}
}
private static void testRemoveObject(ObservableList list, int index) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
boolean contained = index >= 0 && index < list.size();
Object object = contained
? list.get(index)
: "AnObjectNotContainedInTheCollection";
boolean removed = list.remove(object);
assertEquals("Index != -1 iff the list changed.",
contained, removed);
if (removed) {
assertEquals("An element has been removed.",
1, listDataReport.eventCountRemove());
assertEquals("One event has been fired.",
1, listDataReport.eventCount());
assertEquals("Proper index0 (first remove).",
index, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (first remove).",
index, listDataReport.lastEvent().getIndex1());
}
}
private static void testRemoveAll(ObservableList list, List removals) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
List indicesToRemove = new LinkedList();
List testRemoveList = new LinkedList(list);
for (E e : removals) {
int index = testRemoveList.indexOf(e);
if (index != -1) {
indicesToRemove.add(Integer.valueOf(index));
testRemoveList.remove(index);
}
}
int oldSize = list.size();
list.removeAll(removals);
int newSize = list.size();
int removedCount = oldSize - newSize;
assertEquals("Removed element count and number of removal indices.",
removedCount, indicesToRemove.size());
assertEquals("Elements have been removed.",
removedCount, listDataReport.eventCountRemove());
assertEquals("One event has been fired.",
removedCount, listDataReport.eventCount());
// Check the indices fired by the ObservableList
Iterator indexIterator = indicesToRemove.iterator();
for (ListDataEvent event : listDataReport.eventList()) {
int index = indexIterator.next().intValue();
assertEquals("Proper index0 (removeAll).",
index, event.getIndex0());
assertEquals("Proper index1 (removeAll).",
index, event.getIndex1());
}
}
private static void testRetainAll(ObservableList list, List retains) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
int oldSize = list.size();
list.retainAll(retains);
int newSize = list.size();
int eventCount = oldSize - newSize;
assertEquals("Elements have been removed.",
eventCount, listDataReport.eventCountRemove());
assertEquals("One event has been fired.",
eventCount, listDataReport.eventCount());
}
private static void testSet(ObservableList list, int index) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
if (index >= list.size()) {
try {
list.set(index, "newValue1");
fail("IndexOutOfBoundsException expected when removing index " + index);
} catch (IndexOutOfBoundsException e) {
// Do nothing; this is the expected behavior.
}
} else {
list.set(index, "newValue1");
assertEquals("An element has been changed.",
1, listDataReport.eventCountChange());
assertEquals("One event has been fired.",
1, listDataReport.eventCount());
assertEquals("Proper index0 (first change).",
index, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (first change).",
index, listDataReport.lastEvent().getIndex1());
}
if (index >= list.size()) {
try {
list.set(index, "newValue2");
fail("IndexOutOfBoundsException expected when removing index " + index);
} catch (IndexOutOfBoundsException e) {
// Do nothing; this is the expected behavior.
}
} else {
list.set(index, "newValue2");
assertEquals("Another element has been changed.",
2, listDataReport.eventCountChange());
assertEquals("Another event has been fired.",
2, listDataReport.eventCount());
assertEquals("Proper index0 (second change).",
index, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1 (second change).",
index, listDataReport.lastEvent().getIndex1());
}
}
private static void testListIteratorAdd(ObservableList list, int iteratorIndex, int elementIndex) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
ListIterator listIterator = list.listIterator(iteratorIndex);
int relativeElementIndex = elementIndex - iteratorIndex;
for (int i = 0; i < relativeElementIndex; i++) {
listIterator.next();
}
listIterator.add("Added by ListIterator");
assertEquals("An element has been added.",
1, listDataReport.eventCountAdd());
assertEquals("One event has been fired.",
1, listDataReport.eventCount());
assertEquals("Proper index0.",
elementIndex, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1.",
elementIndex, listDataReport.lastEvent().getIndex1());
}
private static void testListIteratorRemove(
ObservableList list,
int iteratorIndex,
int elementIndex) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
ListIterator listIterator = list.listIterator(iteratorIndex);
int relativeElementIndex = elementIndex - iteratorIndex;
for (int i = 0; i <= relativeElementIndex && listIterator.hasNext(); i++) {
listIterator.next();
}
if (elementIndex < list.size()) {
listIterator.remove();
assertEquals("An element has been removed.",
1, listDataReport.eventCountRemove());
assertEquals("One event has been fired.",
1, listDataReport.eventCount());
assertEquals("Proper index0.",
elementIndex, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1.",
elementIndex, listDataReport.lastEvent().getIndex1());
}
}
private static void testListIteratorSet(
ObservableList list,
int iteratorIndex,
int elementIndex) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
ListIterator listIterator = list.listIterator(iteratorIndex);
int relativeElementIndex = elementIndex - iteratorIndex;
for (int i = 0; i <= relativeElementIndex && listIterator.hasNext(); i++) {
listIterator.next();
}
if (elementIndex < list.size()) {
listIterator.set("newValue1");
assertEquals("One event has been fired.",
1, listDataReport.eventCount());
assertEquals("An element has been removed.",
1, listDataReport.eventCountChange());
assertEquals("Proper index0.",
elementIndex, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1.",
elementIndex, listDataReport.lastEvent().getIndex1());
}
}
private static void testIteratorRemove(
ObservableList list,
int elementIndex) {
ListDataReport listDataReport = new ListDataReport();
list.addListDataListener(listDataReport);
Iterator iterator = list.iterator();
for (int i = 0; i <= elementIndex && iterator.hasNext(); i++) {
iterator.next();
}
if (elementIndex < list.size()) {
iterator.remove();
assertEquals("An element has been removed.",
1, listDataReport.eventCountRemove());
assertEquals("One event has been fired.",
1, listDataReport.eventCount());
assertEquals("Proper index0.",
elementIndex, listDataReport.lastEvent().getIndex0());
assertEquals("Proper index1.",
elementIndex, listDataReport.lastEvent().getIndex1());
}
}
// Creating Observable Lists *********************************************
private static ArrayListModel createEmptyArrayListModel() {
return new ArrayListModel();
}
private static LinkedListModel createEmptyLinkedListModel() {
return new LinkedListModel();
}
private static ArrayListModel createSingleElementArrayListModel() {
ArrayListModel list = new ArrayListModel();
list.add("One");
return list;
}
private static LinkedListModel createSingleElementLinkedListModel() {
LinkedListModel list = new LinkedListModel();
list.add("One");
return list;
}
private static ArrayListModel createFilledArrayListModel() {
ArrayListModel list = new ArrayListModel();
list.add("One");
list.add("Two");
list.add("Three");
list.add("Four");
list.add("Five");
list.add("Six");
return list;
}
private static LinkedListModel createFilledLinkedListModel() {
LinkedListModel list = new LinkedListModel();
list.add("One");
list.add("Two");
list.add("Three");
list.add("Four");
list.add("Five");
list.add("Six");
return list;
}
}
jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/test/ 0000755 0001750 0001750 00000000000 11731046166 022675 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/test/event/ 0000755 0001750 0001750 00000000000 11731046166 024016 5 ustar tony tony jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/test/event/ListDataReport.java 0000644 0001750 0001750 00000015311 11730624764 027570 0 ustar tony tony /*
* Copyright (c) 2002-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common.test.event;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import javax.swing.event.ListDataEvent;
import javax.swing.event.ListDataListener;
/**
* A ListDataListener that stores the received ListDataEvents.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*/
public final class ListDataReport implements ListDataListener {
/**
* Holds a list of all received ListDataEvents.
*/
private final List allEvents = new LinkedList();
/**
* Holds a list of all received add ListDataEvents.
*/
private final List addEvents = new LinkedList();
/**
* Holds a list of all received remove ListDataEvents.
*/
private final List removeEvents = new LinkedList();
/**
* Holds a list of all received change ListDataEvents.
*/
private final List changeEvents = new LinkedList();
// Implementing the ListDataListener Interface ***************************
/**
* Sent after the indices in the index0,index1
* interval have been inserted in the data model.
* The new interval includes both index0 and index1.
*
* @param evt a {@code ListDataEvent} encapsulating the
* event information
*/
@Override
public void intervalAdded(ListDataEvent evt) {
allEvents.add(0, evt);
addEvents.add(0, evt);
}
/**
* Sent after the indices in the index0,index1 interval
* have been removed from the data model. The interval
* includes both index0 and index1.
*
* @param evt a {@code ListDataEvent} encapsulating the
* event information
*/
@Override
public void intervalRemoved(ListDataEvent evt) {
allEvents.add(0, evt);
removeEvents.add(0, evt);
}
/**
* Sent when the contents of the list has changed in a way
* that's too complex to characterize with the previous
* methods. For example, this is sent when an item has been
* replaced. Index0 and index1 bracket the change.
*
* @param evt a {@code ListDataEvent} encapsulating the
* event information
*/
@Override
public void contentsChanged(ListDataEvent evt) {
allEvents.add(0, evt);
changeEvents.add(0, evt);
}
// Public Report API *****************************************************
private ListDataEvent getEvent(int index) {
return allEvents.get(index);
}
public ListDataEvent lastEvent() {
return eventCount() > 0
? getEvent(0)
: null;
}
public ListDataEvent previousEvent() {
return eventCount() > 1
? getEvent(1)
: null;
}
public List eventList() {
return allEvents;
}
public int eventCount() {
return allEvents.size();
}
public int eventCountAdd() {
return addEvents.size();
}
public int eventCountRemove() {
return removeEvents.size();
}
public int eventCountChange() {
return changeEvents.size();
}
public boolean hasEvents() {
return !allEvents.isEmpty();
}
public void clearEventList() {
allEvents.clear();
}
// ************************************************************************
/**
* Compares this report's event list with the event list
* of the given object and ignores the source of the contained
* ListDataEvents that may differ.
*
* @param o the object to compare with
* @return true if equal, false if not
*
* @see java.util.AbstractList#equals(Object)
*/
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof ListDataReport)) {
return false;
}
ListIterator e1 = eventList().listIterator();
ListIterator e2 = ((ListDataReport) o).eventList().listIterator();
while (e1.hasNext() && e2.hasNext()) {
ListDataEvent evt1 = e1.next();
ListDataEvent evt2 = e2.next();
if (!equalListDataEvents(evt1, evt2)) {
return false;
}
}
return !(e1.hasNext() || e2.hasNext());
}
/**
* Poor but valid implementation. Won't be used.
*
* @return this reports hash code
*/
@Override
public int hashCode() {
return eventList().size();
}
/**
* Checks and answers whether the two given ListDataEvents
* have the same type and indices. The source may differ.
*/
private static boolean equalListDataEvents(ListDataEvent evt1, ListDataEvent evt2) {
return evt1.getType() == evt2.getType()
&& evt1.getIndex0() == evt2.getIndex0()
&& evt1.getIndex1() == evt2.getIndex1();
}
}
jgoodies-common-1.4.0/src/test/java/com/jgoodies/common/AllCommonTests.java 0000644 0001750 0001750 00000004772 11730624764 025504 0 ustar tony tony /*
* Copyright (c) 2009-2012 JGoodies Karsten Lentzsch. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* o Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* o Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* o Neither the name of JGoodies Karsten Lentzsch nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jgoodies.common;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import com.jgoodies.common.base.ObjectsTest;
import com.jgoodies.common.base.PreconditionsTest;
import com.jgoodies.common.base.StringsTest;
import com.jgoodies.common.base.SystemUtilsTest;
import com.jgoodies.common.collect.ObservableListTest;
import com.jgoodies.common.format.FormatTest;
import com.jgoodies.common.swing.MnemonicUtilsTest;
/**
* A test suite for all tests related to the JGoodies Common classes.
*
* @author Karsten Lentzsch
* @version $Revision: 1.1 $
*/
@RunWith(Suite.class)
@Suite.SuiteClasses({
FormatTest.class,
MnemonicUtilsTest.class,
ObjectsTest.class,
ObservableListTest.class,
PreconditionsTest.class,
StringsTest.class,
SystemUtilsTest.class
})
public final class AllCommonTests {
// Just a suite definition class.
}
jgoodies-common-1.4.0/pom.xml 0000644 0001750 0001750 00000002277 12003474132 014672 0 ustar tony tony
4.0.0
com.jgoodies
jgoodies-common
1.4.0
jar
JGoodies Common
http://www.jgoodies.com/downloads/libraries.html
The JGoodies Common library provides convenience code
for other JGoodies libraries and applications.
The BSD License
http://www.opensource.org/licenses/bsd-license.html
junit
junit
4.8
test
JGoodies
http://www.jgoodies.com/
karsten
Karsten Lentzsch
JGoodies
http://www.jgoodies.com/
+0100
Project owner
Developer
com.jgoodies.common.internal.Messages