Apache
/
commons-lang
mirror of https://github.com/apache/commons-lang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Removing collections tests - far too complex a system for the comparators' needs. Will rewrite as standalone test classes 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/lang/trunk@1159018 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Henri Yandell 2011-08-18 03:59:16 +00:00
parent 2c499868db
commit 4335b4067d
8 changed files with 0 additions and 1710 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

227
src/test/java/org/apache/commons/lang3/compare/AbstractTestComparator.java
View File

@ -1,227 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3.compare;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Serializable;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
/**
* Abstract test class for testing the Comparator interface.
* <p>
* Concrete subclasses declare the comparator to be tested.
* They also declare certain aspects of the tests.
*
* @author Stephen Colebourne
*/
public abstract class AbstractTestComparator<T> extends AbstractTestObject {
/**
* JUnit constructor.
*
* @param testName the test class name
*/
public AbstractTestComparator(String testName) {
super(testName);
}
//-----------------------------------------------------------------------
/**
* Implement this method to return a list of sorted objects.
*
* @return sorted objects
*/
public abstract List<T> getComparableObjectsOrdered();
//-----------------------------------------------------------------------
/**
* Implements the abstract superclass method to return the comparator.
*
* @return a full iterator
*/
@Override
public abstract Comparator<T> makeObject();
/**
* Overrides superclass to block tests.
*/
@Override
public boolean supportsEmptyCollections() {
return false;
}
/**
* Overrides superclass to block tests.
*/
@Override
public boolean supportsFullCollections() {
return false;
}
/**
* Overrides superclass to set the compatability to version 2
* as there were no Comparators in version 1.x.
*/
@Override
public String getCompatibilityVersion() {
return "2";
}
//-----------------------------------------------------------------------
/**
* Reverse the list.
*/
protected void reverseObjects(List<?> list) {
Collections.reverse(list);
}
/**
* Randomize the list.
*/
protected void randomizeObjects(List<?> list) {
Collections.shuffle(list);
}
/**
* Sort the list.
*/
protected void sortObjects(List<T> list, Comparator<? super T> comparator) {
Collections.sort(list, comparator);
}
//-----------------------------------------------------------------------
/**
* Test sorting an empty list
*/
public void testEmptyListSort() {
List<T> list = new LinkedList<T>();
sortObjects(list, makeObject());
List<T> list2 = new LinkedList<T>();
assertTrue("Comparator cannot sort empty lists", list2.equals(list));
}
/**
* Test sorting a reversed list.
*/
public void testReverseListSort() {
Comparator<T> comparator = makeObject();
List<T> randomList = getComparableObjectsOrdered();
reverseObjects(randomList);
sortObjects(randomList, comparator);
List<T> orderedList = getComparableObjectsOrdered();
assertTrue("Comparator did not reorder the List correctly",
orderedList.equals(randomList));
}
/**
* Test sorting a random list.
*/
public void testRandomListSort() {
Comparator<T> comparator = makeObject();
List<T> randomList = getComparableObjectsOrdered();
randomizeObjects(randomList);
sortObjects(randomList,comparator);
List<T> orderedList = getComparableObjectsOrdered();
/* debug
Iterator i = randomList.iterator();
while (i.hasNext()) {
System.out.println(i.next());
}
*/
assertTrue("Comparator did not reorder the List correctly",
orderedList.equals(randomList));
}
/**
* Nearly all Comparators should be Serializable.
*/
public void testComparatorIsSerializable() {
Comparator<T> comparator = makeObject();
assertTrue("This comparator should be Serializable.",
comparator instanceof Serializable);
}
public String getCanonicalComparatorName(Object object) {
StringBuilder retval = new StringBuilder();
retval.append("data/test/");
String colName = object.getClass().getName();
colName = colName.substring(colName.lastIndexOf(".")+1,colName.length());
retval.append(colName);
retval.append(".version");
retval.append(getCompatibilityVersion());
retval.append(".obj");
return retval.toString();
}
/**
* Compare the current serialized form of the Comparator
* against the canonical version in SVN.
*/
@SuppressWarnings("unchecked")
public void testComparatorCompatibility() throws IOException, ClassNotFoundException {
if (!skipSerializedCanonicalTests()) {
Comparator<T> comparator = null;
// test to make sure the canonical form has been preserved
try {
comparator = (Comparator<T>) readExternalFormFromDisk(getCanonicalComparatorName(makeObject()));
} catch (FileNotFoundException exception) {
boolean autoCreateSerialized = false;
if (autoCreateSerialized) {
comparator = makeObject();
String fileName = getCanonicalComparatorName(comparator);
writeExternalFormToDisk((Serializable) comparator, fileName);
fail("Serialized form could not be found. A serialized version "
+ "has now been written (and should be added to CVS): " + fileName);
} else {
fail("The Serialized form could be located to test serialization "
+ "compatibility: " + exception.getMessage());
}
}
// make sure the canonical form produces the ordering we currently
// expect
List<T> randomList = getComparableObjectsOrdered();
reverseObjects(randomList);
sortObjects(randomList, comparator);
List<T> orderedList = getComparableObjectsOrdered();
assertTrue("Comparator did not reorder the List correctly",
orderedList.equals(randomList));
}
}
}

109
src/test/java/org/apache/commons/lang3/compare/AbstractTestNullComparator.java
View File

@ -1,109 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3.compare;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import junit.framework.Test;
import junit.framework.TestSuite;
/**
* Test the NullComparator.
*
* @version $Revision$ $Date$
*
* @author Michael A. Smith
*/
public abstract class AbstractTestNullComparator extends AbstractTestComparator<Integer> {
public AbstractTestNullComparator(String testName) {
super(testName);
}
public static Test suite() {
TestSuite suite = new TestSuite(AbstractTestNullComparator.class.getName());
suite.addTest(new TestSuite(TestNullComparator1.class));
suite.addTest(new TestSuite(TestNullComparator2.class));
return suite;
}
/**
* Test the NullComparator with nulls high, using comparable comparator
**/
public static class TestNullComparator1 extends AbstractTestNullComparator {
public TestNullComparator1(String testName) {
super(testName);
}
@Override
public Comparator<Integer> makeObject() {
return new NullComparator<Integer>();
}
@Override
public List<Integer> getComparableObjectsOrdered() {
List<Integer> list = new LinkedList<Integer>();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(5));
list.add(null);
return list;
}
@Override
public String getCanonicalComparatorName(Object object) {
return super.getCanonicalComparatorName(object) + "1";
}
}
/**
* Test the NullComparator with nulls low using the comparable comparator
**/
public static class TestNullComparator2 extends AbstractTestNullComparator {
public TestNullComparator2(String testName) {
super(testName);
}
@Override
public Comparator<Integer> makeObject() {
return new NullComparator<Integer>(false);
}
@Override
public List<Integer> getComparableObjectsOrdered() {
List<Integer> list = new LinkedList<Integer>();
list.add(null);
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(5));
return list;
}
@Override
public String getCanonicalComparatorName(Object object) {
return super.getCanonicalComparatorName(object) + "2";
}
}
}

334
src/test/java/org/apache/commons/lang3/compare/AbstractTestObject.java
View File

@ -1,334 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3.compare;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Serializable;
/**
* Abstract test class for {@link java.lang.Object} methods and contracts.
* <p>
* To use, simply extend this class, and implement
* the {@link #makeObject()} method.
* <p>
* If your {@link Object} fails one of these tests by design,
* you may still use this base set of cases. Simply override the
* test case (method) your {@link Object} fails.
*
* @version $Revision$ $Date$
*
* @author Rodney Waldhoff
* @author Stephen Colebourne
* @author Anonymous
*/
abstract class AbstractTestObject extends BulkTest {
/** Current major release for Collections */
public static final int COLLECTIONS_MAJOR_VERSION = 3;
/**
* JUnit constructor.
*
* @param testName the test class name
*/
public AbstractTestObject(String testName) {
super(testName);
}
//-----------------------------------------------------------------------
/**
* Implement this method to return the object to test.
*
* @return the object to test
*/
public abstract Object makeObject();
/**
* Override this method if a subclass is testing an object
* that cannot serialize an "empty" Collection.
* (e.g. Comparators have no contents)
*
* @return true
*/
public boolean supportsEmptyCollections() {
return true;
}
/**
* Override this method if a subclass is testing an object
* that cannot serialize a "full" Collection.
* (e.g. Comparators have no contents)
*
* @return true
*/
public boolean supportsFullCollections() {
return true;
}
/**
* Is serialization testing supported.
* Default is true.
*/
public boolean isTestSerialization() {
return true;
}
/**
* Returns true to indicate that the collection supports equals() comparisons.
* This implementation returns true;
*/
public boolean isEqualsCheckable() {
return true;
}
//-----------------------------------------------------------------------
public void testObjectEqualsSelf() {
Object obj = makeObject();
assertEquals("A Object should equal itself", obj, obj);
}
public void testEqualsNull() {
Object obj = makeObject();
assertEquals(false, obj.equals(null)); // make sure this doesn't throw NPE either
}
public void testObjectHashCodeEqualsSelfHashCode() {
Object obj = makeObject();
assertEquals("hashCode should be repeatable", obj.hashCode(), obj.hashCode());
}
public void testObjectHashCodeEqualsContract() {
Object obj1 = makeObject();
if (obj1.equals(obj1)) {
assertEquals(
"[1] When two objects are equal, their hashCodes should be also.",
obj1.hashCode(), obj1.hashCode());
}
Object obj2 = makeObject();
if (obj1.equals(obj2)) {
assertEquals(
"[2] When two objects are equal, their hashCodes should be also.",
obj1.hashCode(), obj2.hashCode());
assertTrue(
"When obj1.equals(obj2) is true, then obj2.equals(obj1) should also be true",
obj2.equals(obj1));
}
}
protected Object serializeDeserialize(Object obj) throws Exception {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(buffer);
out.writeObject(obj);
out.close();
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray()));
Object dest = in.readObject();
in.close();
return dest;
}
public void testSerializeDeserializeThenCompare() throws Exception {
Object obj = makeObject();
if (obj instanceof Serializable && isTestSerialization()) {
Object dest = serializeDeserialize(obj);
if (isEqualsCheckable()) {
assertEquals("obj != deserialize(serialize(obj))", obj, dest);
}
}
}
/**
* Sanity check method, makes sure that any Serializable
* class can be serialized and de-serialized in memory,
* using the handy makeObject() method
*
* @throws IOException
* @throws ClassNotFoundException
*/
public void testSimpleSerialization() throws Exception {
Object o = makeObject();
if (o instanceof Serializable && isTestSerialization()) {
byte[] objekt = writeExternalFormToBytes((Serializable) o);
readExternalFormFromBytes(objekt);
}
}
/**
* Tests serialization by comparing against a previously stored version in SVN.
* If the test object is serializable, confirm that a canonical form exists.
*/
public void testCanonicalEmptyCollectionExists() {
if (supportsEmptyCollections() && isTestSerialization() && !skipSerializedCanonicalTests()) {
Object object = makeObject();
if (object instanceof Serializable) {
String name = getCanonicalEmptyCollectionName(object);
assertTrue(
"Canonical empty collection (" + name + ") is not in SVN",
new File(name).exists());
}
}
}
/**
* Tests serialization by comparing against a previously stored version in SVN.
* If the test object is serializable, confirm that a canonical form exists.
*/
public void testCanonicalFullCollectionExists() {
if (supportsFullCollections() && isTestSerialization() && !skipSerializedCanonicalTests()) {
Object object = makeObject();
if (object instanceof Serializable) {
String name = getCanonicalFullCollectionName(object);
assertTrue(
"Canonical full collection (" + name + ") is not in SVN",
new File(name).exists());
}
}
}
// protected implementation
//-----------------------------------------------------------------------
/**
* Get the version of Collections that this object tries to
* maintain serialization compatibility with. Defaults to 1, the
* earliest Collections version. (Note: some collections did not
* even exist in this version).
*
* This constant makes it possible for TestMap (and other subclasses,
* if necessary) to automatically check SVN for a versionX copy of a
* Serialized object, so we can make sure that compatibility is maintained.
* See, for example, TestMap.getCanonicalFullMapName(Map map).
* Subclasses can override this variable, indicating compatibility
* with earlier Collections versions.
*
* @return The version, or <code>null</code> if this object shouldn't be
* tested for compatibility with previous versions.
*/
public String getCompatibilityVersion() {
return "1";
}
protected String getCanonicalEmptyCollectionName(Object object) {
StringBuilder retval = new StringBuilder();
retval.append("data/test/");
String colName = object.getClass().getName();
colName = colName.substring(colName.lastIndexOf(".") + 1, colName.length());
retval.append(colName);
retval.append(".emptyCollection.version");
retval.append(getCompatibilityVersion());
retval.append(".obj");
return retval.toString();
}
protected String getCanonicalFullCollectionName(Object object) {
StringBuilder retval = new StringBuilder();
retval.append("data/test/");
String colName = object.getClass().getName();
colName = colName.substring(colName.lastIndexOf(".") + 1, colName.length());
retval.append(colName);
retval.append(".fullCollection.version");
retval.append(getCompatibilityVersion());
retval.append(".obj");
return retval.toString();
}
/**
* Write a Serializable or Externalizable object as
* a file at the given path. NOT USEFUL as part
* of a unit test; this is just a utility method
* for creating disk-based objects in SVN that can become
* the basis for compatibility tests using
* readExternalFormFromDisk(String path)
*
* @param o Object to serialize
* @param path path to write the serialized Object
* @exception IOException
*/
protected void writeExternalFormToDisk(Serializable o, String path) throws IOException {
FileOutputStream fileStream = new FileOutputStream(path);
writeExternalFormToStream(o, fileStream);
}
/**
* Converts a Serializable or Externalizable object to
* bytes. Useful for in-memory tests of serialization
*
* @param o Object to convert to bytes
* @return serialized form of the Object
* @exception IOException
*/
protected byte[] writeExternalFormToBytes(Serializable o) throws IOException {
ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
writeExternalFormToStream(o, byteStream);
return byteStream.toByteArray();
}
/**
* Reads a Serialized or Externalized Object from disk.
* Useful for creating compatibility tests between
* different SVN versions of the same class
*
* @param path path to the serialized Object
* @return the Object at the given path
* @exception IOException
* @exception ClassNotFoundException
*/
protected Object readExternalFormFromDisk(String path) throws IOException, ClassNotFoundException {
FileInputStream stream = new FileInputStream(path);
return readExternalFormFromStream(stream);
}
/**
* Read a Serialized or Externalized Object from bytes.
* Useful for verifying serialization in memory.
*
* @param b byte array containing a serialized Object
* @return Object contained in the bytes
* @exception IOException
* @exception ClassNotFoundException
*/
protected Object readExternalFormFromBytes(byte[] b) throws IOException, ClassNotFoundException {
ByteArrayInputStream stream = new ByteArrayInputStream(b);
return readExternalFormFromStream(stream);
}
protected boolean skipSerializedCanonicalTests() {
return Boolean.getBoolean("org.apache.commons.lang3:with-clover");
}
// private implementation
//-----------------------------------------------------------------------
private Object readExternalFormFromStream(InputStream stream) throws IOException, ClassNotFoundException {
ObjectInputStream oStream = new ObjectInputStream(stream);
return oStream.readObject();
}
private void writeExternalFormToStream(Serializable o, OutputStream stream) throws IOException {
ObjectOutputStream oStream = new ObjectOutputStream(stream);
oStream.writeObject(o);
}
}

464
src/test/java/org/apache/commons/lang3/compare/BulkTest.java
View File

@ -1,464 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3.compare;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* A {@link TestCase} that can define both simple and bulk test methods.
* <p>
* A <I>simple test method</I> is the type of test traditionally
* supplied by by {@link TestCase}. To define a simple test, create a public
* no-argument method whose name starts with "test". You can specify the
* the name of simple test in the constructor of <code>BulkTest</code>;
* a subsequent call to {@link TestCase#run} will run that simple test.
* <p>
* A <I>bulk test method</I>, on the other hand, returns a new instance
* of <code>BulkTest</code>, which can itself define new simple and bulk
* test methods. By using the {@link #makeSuite} method, you can
* automatically create a hierarchal suite of tests and child bulk tests.
* <p>
* For instance, consider the following two classes:
*
* <Pre>
* public class TestSet extends BulkTest {
*
* private Set set;
*
* public TestSet(Set set) {
* this.set = set;
* }
*
* public void testContains() {
* boolean r = set.contains(set.iterator().next()));
* assertTrue("Set should contain first element, r);
* }
*
* public void testClear() {
* set.clear();
* assertTrue("Set should be empty after clear", set.isEmpty());
* }
* }
*
*
* public class TestHashMap extends BulkTest {
*
* private Map makeFullMap() {
* HashMap result = new HashMap();
* result.put("1", "One");
* result.put("2", "Two");
* return result;
* }
*
* public void testClear() {
* Map map = makeFullMap();
* map.clear();
* assertTrue("Map empty after clear", map.isEmpty());
* }
*
* public BulkTest bulkTestKeySet() {
* return new TestSet(makeFullMap().keySet());
* }
*
* public BulkTest bulkTestEntrySet() {
* return new TestSet(makeFullMap().entrySet());
* }
* }
* </Pre>
*
* In the above examples, <code>TestSet</code> defines two
* simple test methods and no bulk test methods; <code>TestHashMap</code>
* defines one simple test method and two bulk test methods. When
* <code>makeSuite(TestHashMap.class).run</code> is executed,
* <I>five</I> simple test methods will be run, in this order:<P>
*
* <Ol>
* <Li>TestHashMap.testClear()
* <Li>TestHashMap.bulkTestKeySet().testContains();
* <Li>TestHashMap.bulkTestKeySet().testClear();
* <Li>TestHashMap.bulkTestEntrySet().testContains();
* <Li>TestHashMap.bulkTestEntrySet().testClear();
* </Ol>
*
* In the graphical junit test runners, the tests would be displayed in
* the following tree:<P>
*
* <UL>
* <LI>TestHashMap</LI>
* <UL>
* <LI>testClear
* <LI>bulkTestKeySet
* <UL>
* <LI>testContains
* <LI>testClear
* </UL>
* <LI>bulkTestEntrySet
* <UL>
* <LI>testContains
* <LI>testClear
* </UL>
* </UL>
* </UL>
*
* A subclass can override a superclass's bulk test by
* returning <code>null</code> from the bulk test method. If you only
* want to override specific simple tests within a bulk test, use the
* {@link #ignoredTests} method.<P>
*
* Note that if you want to use the bulk test methods, you <I>must</I>
* define your <code>suite()</code> method to use {@link #makeSuite}.
* The ordinary {@link TestSuite} constructor doesn't know how to
* interpret bulk test methods.
*
* @author Paul Jack
* @version $Id$
*/
class BulkTest extends TestCase implements Cloneable {
// Note: BulkTest is Cloneable to make it easier to construct
// BulkTest instances for simple test methods that are defined in
// anonymous inner classes. Basically we don't have to worry about
// finding weird constructors. (And even if we found them, technically
// it'd be illegal for anyone but the outer class to invoke them).
// Given one BulkTest instance, we can just clone it and reset the
// method name for every simple test it defines.
/**
* The full name of this bulk test instance. This is the full name
* that is compared to {@link #ignoredTests} to see if this
* test should be ignored. It's also displayed in the text runner
* to ease debugging.
*/
String verboseName;
/**
* Constructs a new <code>BulkTest</code> instance that will run the
* specified simple test.
*
* @param name the name of the simple test method to run
*/
public BulkTest(String name) {
super(name);
this.verboseName = getClass().getName();
}
/**
* Creates a clone of this <code>BulkTest</code>.<P>
*
* @return a clone of this <code>BulkTest</code>
*/
@Override
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
throw new Error(); // should never happen
}
}
/**
* Returns an array of test names to ignore.<P>
*
* If a test that's defined by this <code>BulkTest</code> or
* by one of its bulk test methods has a name that's in the returned
* array, then that simple test will not be executed.<P>
*
* A test's name is formed by taking the class name of the
* root <code>BulkTest</code>, eliminating the package name, then
* appending the names of any bulk test methods that were invoked
* to get to the simple test, and then appending the simple test
* method name. The method names are delimited by periods:
*
* <pre>
* TestHashMap.bulkTestEntrySet.testClear
* </pre>
*
* is the name of one of the simple tests defined in the sample classes
* described above. If the sample <code>TestHashMap</code> class
* included this method:
*
* <pre>
* public String[] ignoredTests() {
* return new String[] { "TestHashMap.bulkTestEntrySet.testClear" };
* }
* </pre>
*
* then the entry set's clear method wouldn't be tested, but the key
* set's clear method would.
*
* @return an array of the names of tests to ignore, or null if
* no tests should be ignored
*/
public String[] ignoredTests() {
return null;
}
/**
* Returns the display name of this <code>BulkTest</code>.
*
* @return the display name of this <code>BulkTest</code>
*/
@Override
public String toString() {
return getName() + "(" + verboseName + ") ";
}
/**
* Returns a {@link TestSuite} for testing all of the simple tests
* <I>and</I> all the bulk tests defined by the given class.<P>
*
* The class is examined for simple and bulk test methods; any child
* bulk tests are also examined recursively; and the results are stored
* in a hierarchal {@link TestSuite}.<P>
*
* The given class must be a subclass of <code>BulkTest</code> and must
* not be abstract.<P>
*
* @param c the class to examine for simple and bulk tests
* @return a {@link TestSuite} containing all the simple and bulk tests
* defined by that class
*/
public static TestSuite makeSuite(Class<? extends BulkTest> c) {
if (Modifier.isAbstract(c.getModifiers())) {
throw new IllegalArgumentException("Class must not be abstract.");
}
if (!BulkTest.class.isAssignableFrom(c)) {
throw new IllegalArgumentException("Class must extend BulkTest.");
}
return new BulkTestSuiteMaker(c).make();
}
}
// It was easier to use a separate class to do all the reflection stuff
// for making the TestSuite instances. Having permanent state around makes
// it easier to handle the recursion.
class BulkTestSuiteMaker {
/** The class that defines simple and bulk tests methods. */
private Class<? extends BulkTest> startingClass;
/** List of ignored simple test names. */
private List<String> ignored;
/** The TestSuite we're currently populating. Can change over time. */
private TestSuite result;
/**
* The prefix for simple test methods. Used to check if a test is in
* the ignored list.
*/
private String prefix;
/**
* Constructor.
*
* @param startingClass the starting class
*/
public BulkTestSuiteMaker(Class<? extends BulkTest> startingClass) {
this.startingClass = startingClass;
}
/**
* Makes a hierarchal TestSuite based on the starting class.
*
* @return the hierarchal TestSuite for startingClass
*/
public TestSuite make() {
this.result = new TestSuite();
this.prefix = getBaseName(startingClass);
result.setName(prefix);
BulkTest bulk = makeFirstTestCase(startingClass);
ignored = new ArrayList<String>();
String[] s = bulk.ignoredTests();
if (s != null) {
ignored.addAll(Arrays.asList(s));
}
make(bulk);
return result;
}
/**
* Appends all the simple tests and bulk tests defined by the given
* instance's class to the current TestSuite.
*
* @param bulk An instance of the class that defines simple and bulk
* tests for us to append
*/
void make(BulkTest bulk) {
Class<? extends BulkTest> c = bulk.getClass();
Method[] all = c.getMethods();
for (int i = 0; i < all.length; i++) {
if (isTest(all[i])) addTest(bulk, all[i]);
if (isBulk(all[i])) addBulk(bulk, all[i]);
}
}
/**
* Adds the simple test defined by the given method to the TestSuite.
*
* @param bulk The instance of the class that defined the method
* (I know it's weird. But the point is, we can clone the instance
* and not have to worry about constructors.)
* @param m The simple test method
*/
void addTest(BulkTest bulk, Method m) {
BulkTest bulk2 = (BulkTest)bulk.clone();
bulk2.setName(m.getName());
bulk2.verboseName = prefix + "." + m.getName();
if (ignored.contains(bulk2.verboseName)) return;
result.addTest(bulk2);
}
/**
* Adds a whole new suite of tests that are defined by the result of
* the given bulk test method. In other words, the given bulk test
* method is invoked, and the resulting BulkTest instance is examined
* for yet more simple and bulk tests.
*
* @param bulk The instance of the class that defined the method
* @param m The bulk test method
*/
void addBulk(BulkTest bulk, Method m) {
String verboseName = prefix + "." + m.getName();
if (ignored.contains(verboseName)) return;
BulkTest bulk2;
try {
bulk2 = (BulkTest)m.invoke(bulk, (Object[]) null);
if (bulk2 == null) return;
} catch (InvocationTargetException ex) {
ex.getTargetException().printStackTrace();
throw new Error(); // FIXME;
} catch (IllegalAccessException ex) {
ex.printStackTrace();
throw new Error(); // FIXME;
}
// Save current state on the stack.
String oldPrefix = prefix;
TestSuite oldResult = result;
prefix = prefix + "." + m.getName();
result = new TestSuite();
result.setName(m.getName());
make(bulk2);
oldResult.addTest(result);
// Restore the old state
prefix = oldPrefix;
result = oldResult;
}
/**
* Returns the base name of the given class.
*
* @param c the class
* @return the name of that class, minus any package names
*/
private static String getBaseName(Class<?> c) {
String name = c.getName();
int p = name.lastIndexOf('.');
if (p > 0) {
name = name.substring(p + 1);
}
return name;
}
// These three methods are used to create a valid BulkTest instance
// from a class.
private static <T> Constructor<T> getTestCaseConstructor(Class<T> c) {
try {
return c.getConstructor(new Class[] { String.class });
} catch (NoSuchMethodException e) {
throw new IllegalArgumentException(c + " must provide " +
"a (String) constructor");
}
}
private static <T extends BulkTest> BulkTest makeTestCase(Class<T> c, Method m) {
Constructor<T> con = getTestCaseConstructor(c);
try {
return con.newInstance(new Object[] { m.getName() });
} catch (InvocationTargetException e) {
e.printStackTrace();
throw new RuntimeException(); // FIXME;
} catch (IllegalAccessException e) {
throw new Error(); // should never occur
} catch (InstantiationException e) {
throw new RuntimeException(); // FIXME;
}
}
private static <T extends BulkTest> BulkTest makeFirstTestCase(Class<T> c) {
Method[] all = c.getMethods();
for (int i = 0; i < all.length; i++) {
if (isTest(all[i])) return makeTestCase(c, all[i]);
}
throw new IllegalArgumentException(c.getName() + " must provide "
+ " at least one test method.");
}
/**
* Returns true if the given method is a simple test method.
*/
private static boolean isTest(Method m) {
if (!m.getName().startsWith("test")) return false;
if (m.getReturnType() != Void.TYPE) return false;
if (m.getParameterTypes().length != 0) return false;
int mods = m.getModifiers();
if (Modifier.isStatic(mods)) return false;
if (Modifier.isAbstract(mods)) return false;
return true;
}
/**
* Returns true if the given method is a bulk test method.
*/
private static boolean isBulk(Method m) {
if (!m.getName().startsWith("bulkTest")) return false;
if (m.getReturnType() != BulkTest.class) return false;
if (m.getParameterTypes().length != 0) return false;
int mods = m.getModifiers();
if (Modifier.isStatic(mods)) return false;
if (Modifier.isAbstract(mods)) return false;
return true;
}
}

52
src/test/java/org/apache/commons/lang3/compare/TestComparableComparator.java
View File

@ -1,52 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3.compare;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
/**
* Tests for ComparableComparator.
*
* @version $Revision$ $Date$
*
*/
@SuppressWarnings("boxing")
public class TestComparableComparator extends AbstractTestComparator<Integer> {
public TestComparableComparator(String testName) {
super(testName);
}
@Override
public Comparator<Integer> makeObject() {
return new ComparableComparator<Integer>();
}
@Override
public List<Integer> getComparableObjectsOrdered() {
List<Integer> list = new LinkedList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
return list;
}
}

211
src/test/java/org/apache/commons/lang3/compare/TestComparatorChain.java
View File

@ -1,211 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3.compare;
import java.io.Serializable;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
/**
* Tests for ComparatorChain.
*
* @version $Revision$ $Date$
*
* @author Unknown
*/
public class TestComparatorChain extends AbstractTestComparator<TestComparatorChain.PseudoRow> {
public TestComparatorChain(String testName) {
super(testName);
}
@Override
public Comparator<PseudoRow> makeObject() {
ComparatorChain<PseudoRow> chain = new ComparatorChain<PseudoRow>(new ColumnComparator(0));
chain.addComparator(new ColumnComparator(1), true); // reverse the second column
chain.addComparator(new ColumnComparator(2), false);
return chain;
}
public void testNoopComparatorChain() {
ComparatorChain<Integer> chain = new ComparatorChain<Integer>();
Integer i1 = new Integer(4);
Integer i2 = new Integer(6);
chain.addComparator(new ComparableComparator<Integer>());
int correctValue = i1.compareTo(i2);
assertTrue("Comparison returns the right order", chain.compare(i1, i2) == correctValue);
}
public void testBadNoopComparatorChain() {
ComparatorChain<Integer> chain = new ComparatorChain<Integer>();
Integer i1 = new Integer(4);
Integer i2 = new Integer(6);
try {
chain.compare(i1,i2);
fail("An exception should be thrown when a chain contains zero comparators.");
} catch (UnsupportedOperationException e) {
}
}
public void testListComparatorChain() {
List<Comparator<Integer>> list = new LinkedList<Comparator<Integer>>();
list.add(new ComparableComparator<Integer>());
ComparatorChain<Integer> chain = new ComparatorChain<Integer>(list);
Integer i1 = new Integer(4);
Integer i2 = new Integer(6);
int correctValue = i1.compareTo(i2);
assertTrue("Comparison returns the right order", chain.compare(i1, i2) == correctValue);
}
public void testBadListComparatorChain() {
List<Comparator<Integer>> list = new LinkedList<Comparator<Integer>>();
ComparatorChain<Integer> chain = new ComparatorChain<Integer>(list);
Integer i1 = new Integer(4);
Integer i2 = new Integer(6);
try {
chain.compare(i1, i2);
fail("An exception should be thrown when a chain contains zero comparators.");
} catch (UnsupportedOperationException e) {
}
}
public void testComparatorChainOnMinvaluedCompatator() {
// -1 * Integer.MIN_VALUE is less than 0,
// test that ComparatorChain handles this edge case correctly
ComparatorChain<Integer> chain = new ComparatorChain<Integer>();
chain.addComparator(new Comparator<Integer>() {
public int compare(Integer a, Integer b) {
int result = a.compareTo(b);
if (result < 0) {
return Integer.MIN_VALUE;
}
if (result > 0) {
return Integer.MAX_VALUE;
}
return 0;
}
}, true);
assertTrue(chain.compare(new Integer(4), new Integer(5)) > 0);
assertTrue(chain.compare(new Integer(5), new Integer(4)) < 0);
assertTrue(chain.compare(new Integer(4), new Integer(4)) == 0);
}
@Override
public List<PseudoRow> getComparableObjectsOrdered() {
List<PseudoRow> list = new LinkedList<PseudoRow>();
// this is the correct order assuming a
// "0th forward, 1st reverse, 2nd forward" sort
list.add(new PseudoRow(1, 2, 3));
list.add(new PseudoRow(2, 3, 5));
list.add(new PseudoRow(2, 2, 4));
list.add(new PseudoRow(2, 2, 8));
list.add(new PseudoRow(3, 1, 0));
list.add(new PseudoRow(4, 4, 4));
list.add(new PseudoRow(4, 4, 7));
return list;
}
@SuppressWarnings("serial")
public static class PseudoRow implements Serializable {
public int cols[] = new int[3];
public PseudoRow(int col1, int col2, int col3) {
cols[0] = col1;
cols[1] = col2;
cols[2] = col3;
}
public int getColumn(int colIndex) {
return cols[colIndex];
}
@Override
public String toString() {
StringBuilder buf = new StringBuilder();
buf.append("[");
buf.append(cols[0]);
buf.append(",");
buf.append(cols[1]);
buf.append(",");
buf.append(cols[2]);
buf.append("]");
return buf.toString();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof PseudoRow)) {
return false;
}
PseudoRow row = (PseudoRow) o;
if (getColumn(0) != row.getColumn(0)) {
return false;
}
if (getColumn(1) != row.getColumn(1)) {
return false;
}
if (getColumn(2) != row.getColumn(2)) {
return false;
}
return true;
}
}
public static class ColumnComparator implements Comparator<PseudoRow>, Serializable {
private static final long serialVersionUID = -2284880866328872105L;
protected int colIndex = 0;
public ColumnComparator(int colIndex) {
this.colIndex = colIndex;
}
public int compare(PseudoRow o1, PseudoRow o2) {
int col1 = o1.getColumn(colIndex);
int col2 = o2.getColumn(colIndex);
if (col1 > col2) {
return 1;
}
if (col1 < col2) {
return -1;
}
return 0;
}
@Override
public int hashCode() {
return colIndex;
}
@Override
public boolean equals(Object that) {
return that instanceof ColumnComparator && colIndex == ((ColumnComparator) that).colIndex;
}
}
}

225
src/test/java/org/apache/commons/lang3/compare/TestFixedOrderComparator.java
View File

@ -1,225 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3.compare;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import junit.framework.TestCase;
/**
* Test class for FixedOrderComparator.
*
* @version $Revision$ $Date$
*
* @author David Leppik
* @author Stephen Colebourne
*/
public class TestFixedOrderComparator extends TestCase {
/**
* Top cities of the world, by population including metro areas.
*/
private static final String topCities[] = new String[] {
"Tokyo",
"Mexico City",
"Mumbai",
"Sao Paulo",
"New York",
"Shanghai",
"Lagos",
"Los Angeles",
"Calcutta",
"Buenos Aires"
};
//
// Initialization and busywork
//
public TestFixedOrderComparator(String name) {
super(name);
}
//
// Set up and tear down
//
//
// The tests
//
/**
* Tests that the constructor plus add method compares items properly.
*/
public void testConstructorPlusAdd() {
FixedOrderComparator<String> comparator = new FixedOrderComparator<String>();
for (int i = 0; i < topCities.length; i++) {
comparator.add(topCities[i]);
}
String[] keys = topCities.clone();
assertComparatorYieldsOrder(keys, comparator);
}
/**
* Tests that the array constructor compares items properly.
*/
public void testArrayConstructor() {
String[] keys = topCities.clone();
String[] topCitiesForTest = topCities.clone();
FixedOrderComparator<String> comparator = new FixedOrderComparator<String>(topCitiesForTest);
assertComparatorYieldsOrder(keys, comparator);
// test that changing input after constructor has no effect
topCitiesForTest[0] = "Brighton";
assertComparatorYieldsOrder(keys, comparator);
}
/**
* Tests the list constructor.
*/
public void testListConstructor() {
String[] keys = topCities.clone();
List<String> topCitiesForTest = new LinkedList<String>(Arrays.asList(topCities));
FixedOrderComparator<String> comparator = new FixedOrderComparator<String>(topCitiesForTest);
assertComparatorYieldsOrder(keys, comparator);
// test that changing input after constructor has no effect
topCitiesForTest.set(0, "Brighton");
assertComparatorYieldsOrder(keys, comparator);
}
/**
* Tests addAsEqual method.
*/
public void testAddAsEqual() {
FixedOrderComparator<String> comparator = new FixedOrderComparator<String>(topCities);
comparator.addAsEqual("New York", "Minneapolis");
assertEquals(0, comparator.compare("New York", "Minneapolis"));
assertEquals(-1, comparator.compare("Tokyo", "Minneapolis"));
assertEquals(1, comparator.compare("Shanghai", "Minneapolis"));
}
/**
* Tests whether or not updates are disabled after a comparison is made.
*/
public void testLock() {
FixedOrderComparator<String> comparator = new FixedOrderComparator<String>(topCities);
assertEquals(false, comparator.isLocked());
comparator.compare("New York", "Tokyo");
assertEquals(true, comparator.isLocked());
try {
comparator.add("Minneapolis");
fail("Should have thrown an UnsupportedOperationException");
} catch (UnsupportedOperationException e) {
// success -- ignore
}
try {
comparator.addAsEqual("New York", "Minneapolis");
fail("Should have thrown an UnsupportedOperationException");
} catch (UnsupportedOperationException e) {
// success -- ignore
}
}
public void testUnknownObjectBehavior() {
FixedOrderComparator<String> comparator = new FixedOrderComparator<String>(topCities);
try {
comparator.compare("New York", "Minneapolis");
fail("Should have thrown a IllegalArgumentException");
} catch (IllegalArgumentException e) {
// success-- ignore
}
try {
comparator.compare("Minneapolis", "New York");
fail("Should have thrown a IllegalArgumentException");
} catch (IllegalArgumentException e) {
// success-- ignore
}
assertEquals(FixedOrderComparator.UnknownObjectBehavior.EXCEPTION, comparator.getUnknownObjectBehavior());
comparator = new FixedOrderComparator<String>(topCities);
comparator.setUnknownObjectBehavior(FixedOrderComparator.UnknownObjectBehavior.BEFORE);
assertEquals(FixedOrderComparator.UnknownObjectBehavior.BEFORE, comparator.getUnknownObjectBehavior());
LinkedList<String> keys = new LinkedList<String>(Arrays.asList(topCities));
keys.addFirst("Minneapolis");
assertComparatorYieldsOrder(keys.toArray(new String[0]), comparator);
assertEquals(-1, comparator.compare("Minneapolis", "New York"));
assertEquals( 1, comparator.compare("New York", "Minneapolis"));
assertEquals( 0, comparator.compare("Minneapolis", "St Paul"));
comparator = new FixedOrderComparator<String>(topCities);
comparator.setUnknownObjectBehavior(FixedOrderComparator.UnknownObjectBehavior.AFTER);
keys = new LinkedList<String>(Arrays.asList(topCities));
keys.add("Minneapolis");
assertComparatorYieldsOrder(keys.toArray(new String[0]), comparator);
assertEquals( 1, comparator.compare("Minneapolis", "New York"));
assertEquals(-1, comparator.compare("New York", "Minneapolis"));
assertEquals( 0, comparator.compare("Minneapolis", "St Paul"));
}
//
// Helper methods
//
/** Shuffles the keys and asserts that the comparator sorts them back to
* their original order.
*/
@SuppressWarnings("unused")
private void assertComparatorYieldsOrder(String[] orderedObjects,
Comparator<String> comparator) {
String[] keys = orderedObjects.clone();
// shuffle until the order changes. It's extremely rare that
// this requires more than one shuffle.
boolean isInNewOrder = false;
Random rand = new Random();
while (keys.length > 1 && isInNewOrder == false) {
// shuffle:
for (int i = keys.length-1; i > 0; i--) {
String swap = keys[i];
int j = rand.nextInt(i+1);
keys[i] = keys[j];
keys[j] = swap;
}
// testShuffle
for (int i = 0; i < keys.length && !isInNewOrder; i++) {
if( !orderedObjects[i].equals(keys[i])) {
isInNewOrder = true;
}
}
}
// The real test: sort and make sure they come out right.
Arrays.sort(keys, comparator);
for (int i = 0; i < orderedObjects.length; i++) {
assertEquals(orderedObjects[i], keys[i]);
}
}
}

88
src/test/java/org/apache/commons/lang3/compare/TestReverseComparator.java
View File

@ -1,88 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.lang3.compare;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
/**
* Tests for ReverseComparator.
*
* @version $Revision$ $Date$
*
* @author Unknown
*/
public class TestReverseComparator extends AbstractTestComparator<Integer> {
public TestReverseComparator(String testName) {
super(testName);
}
/**
* For the purposes of this test, return a
* ReverseComparator that wraps the java.util.Collections.reverseOrder()
* Comparator. The resulting comparator should
* sort according to natural Order. (Note: we wrap
* a Comparator taken from the JDK so that we can
* save a "canonical" form in SVN.
*
* @return Comparator that returns "natural" order
*/
@Override
public Comparator<Integer> makeObject() {
return new ReverseComparator<Integer>(Collections.<Integer>reverseOrder());
}
@Override
public List<Integer> getComparableObjectsOrdered() {
List<Integer> list = new LinkedList<Integer>();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(3));
list.add(new Integer(4));
list.add(new Integer(5));
return list;
}
/**
* Override this inherited test since Collections.reverseOrder
* doesn't adhere to the "soft" Comparator contract, and we've
* already "cannonized" the comparator returned by makeComparator.
*/
@Override
@SuppressWarnings("unchecked")
public void testSerializeDeserializeThenCompare() throws Exception {
Comparator comp = new ReverseComparator(new ComparableComparator());
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(buffer);
out.writeObject(comp);
out.close();
ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray()));
Object dest = in.readObject();
in.close();
assertEquals("obj != deserialize(serialize(obj))",comp,dest);
}
}