diff options
Diffstat (limited to 'common/tests')
15 files changed, 275 insertions, 66 deletions
diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/ArrayToolsTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/ArrayToolsTests.java index e142de2ef8..c411ca7b49 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/ArrayToolsTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/ArrayToolsTests.java @@ -24,7 +24,7 @@ import org.eclipse.jpt.common.utility.internal.Range; import org.eclipse.jpt.common.utility.internal.StringTools; import org.eclipse.jpt.common.utility.internal.closure.ClosureAdapter; import org.eclipse.jpt.common.utility.internal.closure.InterruptibleClosureAdapter; -import org.eclipse.jpt.common.utility.internal.comparator.ReverseComparator; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; import org.eclipse.jpt.common.utility.internal.iterator.EmptyIterator; import org.eclipse.jpt.common.utility.internal.predicate.PredicateAdapter; import org.eclipse.jpt.common.utility.internal.predicate.PredicateTools; @@ -1682,7 +1682,7 @@ public class ArrayToolsTests } public void testInsertionIndexOfObjectArrayObjectComparator() { - Comparator<String> c = new ReverseComparator<String>(); + Comparator<String> c = ComparatorTools.reverseComparator(); String[] a = new String[] { "D", "C", "A" }; assertEquals(2, ArrayTools.insertionIndexOf(a, "B", c)); @@ -1726,7 +1726,7 @@ public class ArrayToolsTests } public void testLastInsertionIndexOfObjectArrayObjectComparator() { - Comparator<String> c = new ReverseComparator<String>(); + Comparator<String> c = ComparatorTools.reverseComparator(); String[] a = new String[] { "D", "C", "A" }; assertEquals(2, ArrayTools.lastInsertionIndexOf(a, "B", c)); @@ -3712,7 +3712,7 @@ public class ArrayToolsTests a1[0] = "y"; a1[1] = "b"; a1[2] = "m"; - String[] a2 = ArrayTools.sort(a1, new ReverseComparator<String>()); + String[] a2 = ArrayTools.sort(a1, ComparatorTools.<String>reverseComparator()); String last = "z"; for (String x : a1) { assertTrue(last.compareTo(x) > 0); @@ -3752,7 +3752,7 @@ public class ArrayToolsTests a2[5] = "m"; int from = 3; int to = 6; - String[] a3 = ArrayTools.sort(a2, from, to, new ReverseComparator<String>()); + String[] a3 = ArrayTools.sort(a2, from, to, ComparatorTools.<String>reverseComparator()); String last = "z"; for (int i = 0; i < a1.length; i++) { String x = a1[i]; diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/JptCommonUtilityTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/JptCommonUtilityTests.java index 7412be4a74..34edf4821c 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/JptCommonUtilityTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/JptCommonUtilityTests.java @@ -61,7 +61,7 @@ public class JptCommonUtilityTests { suite.addTestSuite(ClassNameToolsTests.class); suite.addTestSuite(ClasspathTests.class); suite.addTestSuite(ListenerListTests.class); - suite.addTestSuite(MapKeyAssociationTests.class); + suite.addTestSuite(MapEntryAssociationTests.class); suite.addTestSuite(NameToolsTests.class); suite.addTestSuite(ObjectToolsTests.class); suite.addTestSuite(RangeTests.class); diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/MapKeyAssociationTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/MapEntryAssociationTests.java index f90c4d5c05..ca4a897040 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/MapKeyAssociationTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/MapEntryAssociationTests.java @@ -16,12 +16,12 @@ import org.eclipse.jpt.common.utility.Association; import org.eclipse.jpt.common.utility.internal.MapEntryAssociation; @SuppressWarnings("nls") -public class MapKeyAssociationTests +public class MapEntryAssociationTests extends TestCase { private MapEntryAssociation<String, String> assoc; - public MapKeyAssociationTests(String name) { + public MapEntryAssociationTests(String name) { super(name); } diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/collection/CollectionToolsTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/collection/CollectionToolsTests.java index ca3682beb6..d198057575 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/collection/CollectionToolsTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/collection/CollectionToolsTests.java @@ -25,7 +25,7 @@ import org.eclipse.jpt.common.utility.collection.Bag; import org.eclipse.jpt.common.utility.internal.ClassTools; import org.eclipse.jpt.common.utility.internal.collection.CollectionTools; import org.eclipse.jpt.common.utility.internal.collection.EmptyBag; -import org.eclipse.jpt.common.utility.internal.comparator.ReverseComparator; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; import org.eclipse.jpt.common.utility.internal.iterable.EmptyIterable; import org.eclipse.jpt.common.utility.internal.iterator.EmptyIterator; import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools; @@ -884,11 +884,11 @@ public class CollectionToolsTests list.add("3"); list.add("1"); - SortedSet<String> ss1 = new TreeSet<String>(new ReverseComparator<String>()); + SortedSet<String> ss1 = new TreeSet<String>(ComparatorTools.<String>reverseComparator()); ss1.addAll(list); Iterable<String> iterable = list; - SortedSet<String> ss2 = CollectionTools.<String>sortedSet(iterable, new ReverseComparator<String>()); + SortedSet<String> ss2 = CollectionTools.<String>sortedSet(iterable, ComparatorTools.<String>reverseComparator()); assertEquals(ss1, ss2); } @@ -899,11 +899,11 @@ public class CollectionToolsTests list.add("3"); list.add("1"); - SortedSet<String> ss1 = new TreeSet<String>(new ReverseComparator<String>()); + SortedSet<String> ss1 = new TreeSet<String>(ComparatorTools.<String>reverseComparator()); ss1.addAll(list); Iterable<String> iterable = list; - SortedSet<String> ss2 = CollectionTools.<String>sortedSet(iterable, new ReverseComparator<String>(), 5); + SortedSet<String> ss2 = CollectionTools.<String>sortedSet(iterable, ComparatorTools.<String>reverseComparator(), 5); assertEquals(ss1, ss2); } @@ -937,11 +937,11 @@ public class CollectionToolsTests list.add("3"); list.add("1"); - SortedSet<String> ss1 = new TreeSet<String>(new ReverseComparator<String>()); + SortedSet<String> ss1 = new TreeSet<String>(ComparatorTools.<String>reverseComparator()); ss1.addAll(list); String[] array = list.toArray(new String[list.size()]); - SortedSet<String> ss2 = CollectionTools.<String>sortedSet(array, new ReverseComparator<String>()); + SortedSet<String> ss2 = CollectionTools.<String>sortedSet(array, ComparatorTools.<String>reverseComparator()); assertEquals(ss1, ss2); } diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/collection/ListToolsTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/collection/ListToolsTests.java index 59db529fc1..6c24296ace 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/collection/ListToolsTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/collection/ListToolsTests.java @@ -27,7 +27,7 @@ import org.eclipse.jpt.common.utility.internal.ClassTools; import org.eclipse.jpt.common.utility.internal.Range; import org.eclipse.jpt.common.utility.internal.collection.CollectionTools; import org.eclipse.jpt.common.utility.internal.collection.ListTools; -import org.eclipse.jpt.common.utility.internal.comparator.ReverseComparator; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; import org.eclipse.jpt.common.utility.internal.iterable.EmptyIterable; import org.eclipse.jpt.common.utility.internal.iterator.EmptyIterator; import org.eclipse.jpt.common.utility.internal.predicate.PredicateTools; @@ -346,7 +346,7 @@ public class ListToolsTests } public void testInsertionIndexOfListObjectComparatorRandomAccess() { - Comparator<String> c = new ReverseComparator<String>(); + Comparator<String> c = ComparatorTools.reverseComparator(); List<String> list = Arrays.asList(new String[] { "D", "C", "A" }); assertEquals(2, ListTools.insertionIndexOf(list, "B", c)); @@ -367,7 +367,7 @@ public class ListToolsTests } public void testInsertionIndexOfListObjectComparatorNonRandomAccess() { - Comparator<String> c = new ReverseComparator<String>(); + Comparator<String> c = ComparatorTools.reverseComparator(); List<String> list = new LinkedList<String>(Arrays.asList(new String[] { "D", "C", "A" })); assertEquals(2, ListTools.insertionIndexOf(list, "B", c)); diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/BooleanComparatorTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/BooleanComparatorTests.java new file mode 100644 index 0000000000..25c8085869 --- /dev/null +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/BooleanComparatorTests.java @@ -0,0 +1,52 @@ +/******************************************************************************* + * Copyright (c) 2011, 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.common.utility.tests.internal.comparator; + +import java.util.Comparator; +import junit.framework.TestCase; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; + +public class BooleanComparatorTests + extends TestCase +{ + public BooleanComparatorTests(String name) { + super(name); + } + + public void testTrueFirstEqual() { + Comparator<Boolean> comparator = ComparatorTools.booleanComparator(true); + assertEquals(0, comparator.compare(Boolean.TRUE, Boolean.TRUE)); + } + + public void testTrueFirstLess() { + Comparator<Boolean> comparator = ComparatorTools.booleanComparator(true); + assertTrue(comparator.compare(Boolean.TRUE, Boolean.FALSE) < 0); + } + + public void testTrueFirstGreater() { + Comparator<Boolean> comparator = ComparatorTools.booleanComparator(true); + assertTrue(comparator.compare(Boolean.FALSE, Boolean.TRUE) > 0); + } + + public void testFalseFirstEqual() { + Comparator<Boolean> comparator = ComparatorTools.booleanComparator(false); + assertEquals(0, comparator.compare(Boolean.FALSE, Boolean.FALSE)); + } + + public void testFalseFirstLess() { + Comparator<Boolean> comparator = ComparatorTools.booleanComparator(false); + assertTrue(comparator.compare(Boolean.FALSE, Boolean.TRUE) < 0); + } + + public void testFalseFirstGreater() { + Comparator<Boolean> comparator = ComparatorTools.booleanComparator(false); + assertTrue(comparator.compare(Boolean.TRUE, Boolean.FALSE) > 0); + } +} diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/ComparatorToolsTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/ComparatorToolsTests.java new file mode 100644 index 0000000000..1b99f554ae --- /dev/null +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/ComparatorToolsTests.java @@ -0,0 +1,158 @@ +/******************************************************************************* + * Copyright (c) 2013 Oracle. All rights reserved. + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0, which accompanies this distribution + * and is available at http://www.eclipse.org/legal/epl-v10.html. + * + * Contributors: + * Oracle - initial API and implementation + ******************************************************************************/ +package org.eclipse.jpt.common.utility.tests.internal.comparator; + +import java.text.Collator; +import java.text.DateFormat; +import java.util.Comparator; +import java.util.Date; +import junit.framework.TestCase; +import org.eclipse.jpt.common.utility.internal.ObjectTools; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorAdapter; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; + +@SuppressWarnings("nls") +public class ComparatorToolsTests + extends TestCase +{ + public ComparatorToolsTests(String name) { + super(name); + } + + public void testMinObjectObject() { + String foo = "foo"; + String bar = "bar"; + assertEquals(bar, ComparatorTools.min(foo, bar)); + assertEquals(bar, ComparatorTools.min(bar, foo)); + } + + public void testMinObjectObjectComparator() { + String foo = "foo"; + String bar = "bar"; + assertEquals(foo, ComparatorTools.min(foo, bar, ComparatorTools.<String>reverseComparator())); + assertEquals(foo, ComparatorTools.min(bar, foo, ComparatorTools.<String>reverseComparator())); + } + + public void testMaxObjectObject() { + String foo = "foo"; + String bar = "bar"; + assertEquals(foo, ComparatorTools.max(foo, bar)); + assertEquals(foo, ComparatorTools.max(bar, foo)); + } + + public void testMaxObjectObjectComparator() { + String foo = "foo"; + String bar = "bar"; + assertEquals(bar, ComparatorTools.max(foo, bar, ComparatorTools.<String>reverseComparator())); + assertEquals(bar, ComparatorTools.max(bar, foo, ComparatorTools.<String>reverseComparator())); + } + + public void testComparableComparator() { + assertTrue(ComparatorTools.<String>comparableComparator().compare("foo", "foo") == 0); + assertTrue(ComparatorTools.<String>comparableComparator().compare("foo", "bar") > 0); + assertTrue(ComparatorTools.<String>comparableComparator().compare("bar", "foo") < 0); + } + + public void testNaturalComparator() { + assertTrue(ComparatorTools.<String>naturalComparator().compare("foo", "foo") == 0); + assertTrue(ComparatorTools.<String>naturalComparator().compare("foo", "bar") > 0); + assertTrue(ComparatorTools.<String>naturalComparator().compare("bar", "foo") < 0); + } + + public void testComparatorChain() throws Exception { + @SuppressWarnings("unchecked") + Comparator<Person> comparator = ComparatorTools.chain(Person.LAST_NAME_COMPARATOR, Person.FIRST_NAME_COMPARATOR, Person.BIRTH_DATE_COMPARATOR); + Person john = new Person("John", "Smith", DateFormat.getDateInstance(DateFormat.SHORT).parse("10/11/55")); + Person jane = new Person("Jane", "Smith", DateFormat.getDateInstance(DateFormat.SHORT).parse("10/11/55")); + assertTrue(comparator.compare(john, john) == 0); + assertTrue(comparator.compare(jane, john) < 0); + assertTrue(comparator.compare(john, jane) > 0); + Person oldJohn = new Person("John", "Smith", DateFormat.getDateInstance(DateFormat.SHORT).parse("10/11/33")); + assertTrue(comparator.compare(oldJohn, oldJohn) == 0); + assertTrue(comparator.compare(oldJohn, john) < 0); + assertTrue(comparator.compare(john, oldJohn) > 0); + } + + public void testNullsFirstComparator() { + assertTrue(ComparatorTools.nullsFirst(ComparatorTools.stringCollator()).compare("foo", "foo") == 0); + assertTrue(ComparatorTools.nullsFirst(ComparatorTools.stringCollator()).compare("foo", "bar") > 0); + assertTrue(ComparatorTools.nullsFirst(ComparatorTools.stringCollator()).compare("bar", "foo") < 0); + + assertTrue(ComparatorTools.nullsFirst(ComparatorTools.stringCollator()).compare(null, null) == 0); + assertTrue(ComparatorTools.nullsFirst(ComparatorTools.stringCollator()).compare("foo", null) > 0); + assertTrue(ComparatorTools.nullsFirst(ComparatorTools.stringCollator()).compare(null, "foo") < 0); + } + + public void testNullsLastComparator() { + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare("foo", "foo") == 0); + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare("foo", "bar") > 0); + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare("bar", "foo") < 0); + + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare(null, null) == 0); + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare("foo", null) < 0); + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare(null, "foo") > 0); + } + + public void testTransformationComparator() { + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare("foo", "foo") == 0); + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare("foo", "bar") > 0); + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare("bar", "foo") < 0); + + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare(null, null) == 0); + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare("foo", null) < 0); + assertTrue(ComparatorTools.nullsLast(ComparatorTools.stringCollator()).compare(null, "foo") > 0); + } + + public static class Person { + public final String firstName; + public final String lastName; + public final Date birthDate; + public Person(String firstName, String lastName, Date birthDate) { + super(); + this.firstName = firstName; + this.lastName = lastName; + this.birthDate = birthDate; + } + @Override + public String toString() { + return ObjectTools.toString(this, this.firstName + ' ' + this.lastName); + } + + public static final Comparator<Person> FIRST_NAME_COMPARATOR = new FirstNameComparator(); + public static class FirstNameComparator + extends ComparatorAdapter<Person> + { + @Override + public int compare(Person p1, Person p2) { + return Collator.getInstance().compare(p1.firstName, p2.firstName); + } + } + + public static final Comparator<Person> LAST_NAME_COMPARATOR = new LastNameComparator(); + public static class LastNameComparator + extends ComparatorAdapter<Person> + { + @Override + public int compare(Person p1, Person p2) { + return Collator.getInstance().compare(p1.lastName, p2.lastName); + } + } + + public static final Comparator<Person> BIRTH_DATE_COMPARATOR = new BirthDateComparator(); + public static class BirthDateComparator + extends ComparatorAdapter<Person> + { + @Override + public int compare(Person p1, Person p2) { + return p1.birthDate.compareTo(p2.birthDate); + } + } + } +} diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/JptCommonUtilityComparatorTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/JptCommonUtilityComparatorTests.java index 24fb62cff6..ec13492f0e 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/JptCommonUtilityComparatorTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/JptCommonUtilityComparatorTests.java @@ -17,6 +17,8 @@ public class JptCommonUtilityComparatorTests { public static Test suite() { TestSuite suite = new TestSuite(JptCommonUtilityComparatorTests.class.getPackage().getName()); + suite.addTestSuite(BooleanComparatorTests.class); + suite.addTestSuite(ComparatorToolsTests.class); suite.addTestSuite(ReverseComparatorTests.class); suite.addTestSuite(VersionComparatorTests.class); diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/ReverseComparatorTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/ReverseComparatorTests.java index 44c60a064a..57e28e9fc4 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/ReverseComparatorTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/ReverseComparatorTests.java @@ -15,6 +15,7 @@ import java.util.Comparator; import java.util.List; import junit.framework.TestCase; import org.eclipse.jpt.common.utility.internal.ObjectTools; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; import org.eclipse.jpt.common.utility.internal.comparator.ReverseComparator; import org.eclipse.jpt.common.utility.tests.internal.TestTools; @@ -33,7 +34,7 @@ public class ReverseComparatorTests @Override protected void setUp() throws Exception { super.setUp(); - this.naturalReverseComparator = new ReverseComparator<String>(); + this.naturalReverseComparator = ComparatorTools.reverseComparator(); this.customComparator = this.buildCustomComparator(); this.customReverseComparator = new ReverseComparator<String>(this.customComparator); } diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/VersionComparatorTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/VersionComparatorTests.java index ff595f05e4..a58ede28ec 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/VersionComparatorTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/comparator/VersionComparatorTests.java @@ -13,8 +13,8 @@ import java.io.Serializable; import java.math.BigDecimal; import java.util.Comparator; import junit.framework.TestCase; - import org.eclipse.jpt.common.utility.internal.ObjectTools; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; import org.eclipse.jpt.common.utility.internal.comparator.VersionComparator; import org.eclipse.jpt.common.utility.internal.comparator.VersionComparator.SegmentParser; @@ -27,28 +27,28 @@ public class VersionComparatorTests } public void testVersionIsEqual_integer() { - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.0", "2.0.0") == 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.0", "2.0.0.0") == 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.0.0.0.0.0000", "2.0") == 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.-1", "2.0.-1") == 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.0", "2.0.0") == 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.0", "2.0.0.0") == 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.0.0.0.0.0000", "2.0") == 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.-1", "2.0.-1") == 0); } public void testVersionIsLess_integer() { - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.0", "2.0.1") < 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.5.0", "2.14") < 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.5.0", "2.5.0.0.1.0") < 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.5.0.0.0.-1", "2.5") < 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.-1", "2.0.0") < 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.-1", "2") < 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.0", "2.0.1") < 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.5.0", "2.14") < 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.5.0", "2.5.0.0.1.0") < 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.5.0.0.0.-1", "2.5") < 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.-1", "2.0.0") < 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.-1", "2") < 0); } public void testVersionIsGreater_integer() { - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.2", "2.0.1") > 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.2", "2.0.1") > 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.5.0.0.1.0", "2.5.0") > 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.5", "2.5.0.0.0.-1") > 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.0", "2.0.-1") > 0); - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2", "2.0.-1") > 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.2", "2.0.1") > 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.2", "2.0.1") > 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.5.0.0.1.0", "2.5.0") > 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.5", "2.5.0.0.0.-1") > 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.0", "2.0.-1") > 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2", "2.0.-1") > 0); } public void testVersionIsEqual_integer_comma() { @@ -68,7 +68,7 @@ public class VersionComparatorTests } public void testVersionIsGreater_integer_comma() { - Comparator<String> versionComparator = new VersionComparator<BigDecimal>(',', DecimalSegmentParser.instance()); + Comparator<String> versionComparator = ComparatorTools.versionComparator(',', DecimalSegmentParser.instance()); assertTrue(versionComparator.compare("2,0,2", "2,0,1") > 0); assertTrue(versionComparator.compare("2,0,2.1", "2,0,1") > 0); assertTrue(versionComparator.compare("2,0,2", "2,0,1.9") > 0); @@ -76,7 +76,7 @@ public class VersionComparatorTests } public void testVersionIsEqual_subclass() { - Comparator<String> versionComparator = VersionComparator.INTEGER_VERSION_COMPARATOR; + Comparator<String> versionComparator = ComparatorTools.integerVersionComparator(); assertTrue(versionComparator.compare("2.0.0", "2.0.0") == 0); assertTrue(versionComparator.compare("2.0.0", "2.0.0.0") == 0); assertTrue(versionComparator.compare("2.0.0.0", "2.0") == 0); @@ -84,7 +84,7 @@ public class VersionComparatorTests } public void testVersionIsLess_subclass() { - Comparator<String> versionComparator = VersionComparator.INTEGER_VERSION_COMPARATOR; + Comparator<String> versionComparator = ComparatorTools.integerVersionComparator(); assertTrue(versionComparator.compare("2.0.0", "2.0.1") < 0); assertTrue(versionComparator.compare("2.5.0", "2.14") < 0); assertTrue(versionComparator.compare("2.5.0", "2.5.0.0.1.0") < 0); @@ -93,7 +93,7 @@ public class VersionComparatorTests } public void testVersionIsGreater_subclass() { - Comparator<String> versionComparator = VersionComparator.INTEGER_VERSION_COMPARATOR; + Comparator<String> versionComparator = ComparatorTools.integerVersionComparator(); assertTrue(versionComparator.compare("2.0.2", "2.0.1") > 0); assertTrue(versionComparator.compare("2.0.2", "2.0.1") > 0); assertTrue(versionComparator.compare("2.5.0.0.1.0", "2.5.0") > 0); @@ -105,7 +105,7 @@ public class VersionComparatorTests boolean exCaught = false; try { // note the letter 'O' instead of the numeral '0' - assertTrue(VersionComparator.INTEGER_VERSION_COMPARATOR.compare("2.0.0", "2.O.O") == 0); + assertTrue(ComparatorTools.integerVersionComparator().compare("2.0.0", "2.O.O") == 0); } catch (NumberFormatException ex) { exCaught = true; } diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/enumeration/EnumerationToolsTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/enumeration/EnumerationToolsTests.java index 7bb59468c0..3cf696033b 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/enumeration/EnumerationToolsTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/enumeration/EnumerationToolsTests.java @@ -20,7 +20,7 @@ import junit.framework.TestCase; import org.eclipse.jpt.common.utility.internal.ArrayTools; import org.eclipse.jpt.common.utility.internal.ClassTools; import org.eclipse.jpt.common.utility.internal.StringTools; -import org.eclipse.jpt.common.utility.internal.comparator.ReverseComparator; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; import org.eclipse.jpt.common.utility.internal.enumeration.EnumerationTools; import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools; @@ -410,11 +410,11 @@ public class EnumerationToolsTests list.add("3"); list.add("1"); - SortedSet<String> ss = new TreeSet<String>(new ReverseComparator<String>()); + SortedSet<String> ss = new TreeSet<String>(ComparatorTools.<String>reverseComparator()); ss.addAll(list); Enumeration<String> enumeration1 = list.elements(); - Enumeration<String> enumeration2 = EnumerationTools.<String>sort(enumeration1, new ReverseComparator<String>()); + Enumeration<String> enumeration2 = EnumerationTools.<String>sort(enumeration1, ComparatorTools.<String>reverseComparator()); assertTrue(EnumerationTools.elementsAreEqual(EnumerationTools.enumeration(ss), enumeration2)); } @@ -425,11 +425,11 @@ public class EnumerationToolsTests list.add("3"); list.add("1"); - SortedSet<String> ss = new TreeSet<String>(new ReverseComparator<String>()); + SortedSet<String> ss = new TreeSet<String>(ComparatorTools.<String>reverseComparator()); ss.addAll(list); Enumeration<String> enumeration1 = list.elements(); - Enumeration<String> enumeration2 = EnumerationTools.<String>sort(enumeration1, new ReverseComparator<String>(), 77); + Enumeration<String> enumeration2 = EnumerationTools.<String>sort(enumeration1, ComparatorTools.<String>reverseComparator(), 77); assertTrue(EnumerationTools.elementsAreEqual(EnumerationTools.enumeration(ss), enumeration2)); } diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/iterable/IterableToolsTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/iterable/IterableToolsTests.java index 9b2d52df57..4afe1fe8bb 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/iterable/IterableToolsTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/iterable/IterableToolsTests.java @@ -20,7 +20,7 @@ import java.util.TreeSet; import junit.framework.TestCase; import org.eclipse.jpt.common.utility.internal.ClassTools; import org.eclipse.jpt.common.utility.internal.collection.HashBag; -import org.eclipse.jpt.common.utility.internal.comparator.ReverseComparator; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; import org.eclipse.jpt.common.utility.internal.iterable.EmptyIterable; import org.eclipse.jpt.common.utility.internal.iterable.IterableTools; import org.eclipse.jpt.common.utility.tests.internal.ArrayToolsTests; @@ -337,11 +337,11 @@ public class IterableToolsTests list.add("3"); list.add("1"); - SortedSet<String> ss = new TreeSet<String>(new ReverseComparator<String>()); + SortedSet<String> ss = new TreeSet<String>(ComparatorTools.<String>reverseComparator()); ss.addAll(list); Iterable<String> iterable1 = list; - Iterable<String> iterable2 = IterableTools.<String>sort(iterable1, new ReverseComparator<String>()); + Iterable<String> iterable2 = IterableTools.<String>sort(iterable1, ComparatorTools.<String>reverseComparator()); assertTrue(IterableTools.elementsAreEqual(ss, iterable2)); } @@ -352,11 +352,11 @@ public class IterableToolsTests list.add("3"); list.add("1"); - SortedSet<String> ss = new TreeSet<String>(new ReverseComparator<String>()); + SortedSet<String> ss = new TreeSet<String>(ComparatorTools.<String>reverseComparator()); ss.addAll(list); Iterable<String> iterable1 = list; - Iterable<String> iterable2 = IterableTools.<String>sort(iterable1, new ReverseComparator<String>(), 77); + Iterable<String> iterable2 = IterableTools.<String>sort(iterable1, ComparatorTools.<String>reverseComparator(), 77); assertTrue(IterableTools.elementsAreEqual(ss, iterable2)); } diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/iterator/IteratorToolsTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/iterator/IteratorToolsTests.java index 8cc0b3a0ec..35f30ce138 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/iterator/IteratorToolsTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/iterator/IteratorToolsTests.java @@ -22,7 +22,7 @@ import java.util.TreeSet; import junit.framework.TestCase; import org.eclipse.jpt.common.utility.internal.ClassTools; import org.eclipse.jpt.common.utility.internal.collection.HashBag; -import org.eclipse.jpt.common.utility.internal.comparator.ReverseComparator; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; import org.eclipse.jpt.common.utility.internal.iterable.IterableTools; import org.eclipse.jpt.common.utility.internal.iterator.EmptyIterator; import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools; @@ -588,11 +588,11 @@ public class IteratorToolsTests list.add("3"); list.add("1"); - SortedSet<String> ss = new TreeSet<String>(new ReverseComparator<String>()); + SortedSet<String> ss = new TreeSet<String>(ComparatorTools.<String>reverseComparator()); ss.addAll(list); Iterator<String> iterator1 = list.iterator(); - Iterator<String> iterator2 = IteratorTools.<String>sort(iterator1, new ReverseComparator<String>()); + Iterator<String> iterator2 = IteratorTools.<String>sort(iterator1, ComparatorTools.<String>reverseComparator()); assertTrue(IteratorTools.elementsAreEqual(ss.iterator(), iterator2)); } @@ -603,11 +603,11 @@ public class IteratorToolsTests list.add("3"); list.add("1"); - SortedSet<String> ss = new TreeSet<String>(new ReverseComparator<String>()); + SortedSet<String> ss = new TreeSet<String>(ComparatorTools.<String>reverseComparator()); ss.addAll(list); Iterator<String> iterator1 = list.iterator(); - Iterator<String> iterator2 = IteratorTools.<String>sort(iterator1, new ReverseComparator<String>(), 77); + Iterator<String> iterator2 = IteratorTools.<String>sort(iterator1, ComparatorTools.<String>reverseComparator(), 77); assertTrue(IteratorTools.elementsAreEqual(ss.iterator(), iterator2)); } diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/model/value/SortedListValueModelAdapterTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/model/value/SortedListValueModelAdapterTests.java index e11c6e320e..83752b4735 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/model/value/SortedListValueModelAdapterTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/model/value/SortedListValueModelAdapterTests.java @@ -15,14 +15,12 @@ import java.util.Collection; import java.util.Comparator; import java.util.List; import java.util.TreeSet; - import junit.framework.TestCase; - import org.eclipse.jpt.common.utility.collection.Bag; import org.eclipse.jpt.common.utility.internal.collection.CollectionTools; import org.eclipse.jpt.common.utility.internal.collection.HashBag; import org.eclipse.jpt.common.utility.internal.collection.ListTools; -import org.eclipse.jpt.common.utility.internal.comparator.ReverseComparator; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; import org.eclipse.jpt.common.utility.internal.model.AbstractModel; import org.eclipse.jpt.common.utility.internal.model.value.SimpleCollectionValueModel; import org.eclipse.jpt.common.utility.internal.model.value.SortedListValueModelAdapter; @@ -166,8 +164,8 @@ public class SortedListValueModelAdapterTests extends TestCase { assertEquals(this.wrappedCollection, CollectionTools.collection(synchList.iterator())); assertEquals(this.wrappedCollection, synchCollection); - this.adapter.setComparator(new ReverseComparator<String>()); - this.verifyList(this.wrappedCollection, this.adapter, new ReverseComparator<String>()); + this.adapter.setComparator(ComparatorTools.<String>reverseComparator()); + this.verifyList(this.wrappedCollection, this.adapter, ComparatorTools.<String>reverseComparator()); assertEquals(this.wrappedCollection, CollectionTools.collection(synchList.iterator())); assertEquals(this.wrappedCollection, synchCollection); } diff --git a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/model/value/SortedListValueModelWrapperTests.java b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/model/value/SortedListValueModelWrapperTests.java index faff4b443e..e2a384aec0 100644 --- a/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/model/value/SortedListValueModelWrapperTests.java +++ b/common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/model/value/SortedListValueModelWrapperTests.java @@ -15,11 +15,9 @@ import java.util.Collection; import java.util.Comparator; import java.util.List; import java.util.TreeSet; - import junit.framework.TestCase; - import org.eclipse.jpt.common.utility.internal.collection.ListTools; -import org.eclipse.jpt.common.utility.internal.comparator.ReverseComparator; +import org.eclipse.jpt.common.utility.internal.comparator.ComparatorTools; import org.eclipse.jpt.common.utility.internal.model.AbstractModel; import org.eclipse.jpt.common.utility.internal.model.value.SimpleListValueModel; import org.eclipse.jpt.common.utility.internal.model.value.SortedListValueModelWrapper; @@ -183,8 +181,8 @@ public class SortedListValueModelWrapperTests extends TestCase { assertEquals(this.list, synchList); assertEquals(ListTools.list(this.sortedListModel), sortedSynchList); - this.sortedListModel.setComparator(new ReverseComparator<String>()); - this.verifyList(this.list, this.sortedListModel, new ReverseComparator<String>()); + this.sortedListModel.setComparator(ComparatorTools.<String>reverseComparator()); + this.verifyList(this.list, this.sortedListModel, ComparatorTools.<String>reverseComparator()); assertEquals(this.list, synchList); } |