diff options
Diffstat (limited to 'src/main/java/org/junit/runner/manipulation')
7 files changed, 7 insertions, 352 deletions
diff --git a/src/main/java/org/junit/runner/manipulation/Alphanumeric.java b/src/main/java/org/junit/runner/manipulation/Alphanumeric.java deleted file mode 100644 index 8388d21..0000000 --- a/src/main/java/org/junit/runner/manipulation/Alphanumeric.java +++ /dev/null @@ -1,27 +0,0 @@ -package org.junit.runner.manipulation; - -import java.util.Comparator; - -import org.junit.runner.Description; - -/** - * A sorter that orders tests alphanumerically by test name. - * - * @since 4.13 - */ -public final class Alphanumeric extends Sorter implements Ordering.Factory { - - public Alphanumeric() { - super(COMPARATOR); - } - - public Ordering create(Context context) { - return this; - } - - private static final Comparator<Description> COMPARATOR = new Comparator<Description>() { - public int compare(Description o1, Description o2) { - return o1.getDisplayName().compareTo(o2.getDisplayName()); - } - }; -} diff --git a/src/main/java/org/junit/runner/manipulation/InvalidOrderingException.java b/src/main/java/org/junit/runner/manipulation/InvalidOrderingException.java deleted file mode 100644 index d9d60f7..0000000 --- a/src/main/java/org/junit/runner/manipulation/InvalidOrderingException.java +++ /dev/null @@ -1,21 +0,0 @@ -package org.junit.runner.manipulation; - -/** - * Thrown when an ordering does something invalid (like remove or add children) - * - * @since 4.13 - */ -public class InvalidOrderingException extends Exception { - private static final long serialVersionUID = 1L; - - public InvalidOrderingException() { - } - - public InvalidOrderingException(String message) { - super(message); - } - - public InvalidOrderingException(String message, Throwable cause) { - super(message, cause); - } -} diff --git a/src/main/java/org/junit/runner/manipulation/Orderable.java b/src/main/java/org/junit/runner/manipulation/Orderable.java deleted file mode 100644 index 9a12a3b..0000000 --- a/src/main/java/org/junit/runner/manipulation/Orderable.java +++ /dev/null @@ -1,21 +0,0 @@ -package org.junit.runner.manipulation; - -/** - * Interface for runners that allow ordering of tests. - * - * <p>Beware of using this interface to cope with order dependencies between tests. - * Tests that are isolated from each other are less expensive to maintain and - * can be run individually. - * - * @since 4.13 - */ -public interface Orderable extends Sortable { - - /** - * Orders the tests using <code>orderer</code> - * - * @throws InvalidOrderingException if orderer does something invalid (like remove or add - * children) - */ - void order(Orderer orderer) throws InvalidOrderingException; -} diff --git a/src/main/java/org/junit/runner/manipulation/Orderer.java b/src/main/java/org/junit/runner/manipulation/Orderer.java deleted file mode 100644 index eb13054..0000000 --- a/src/main/java/org/junit/runner/manipulation/Orderer.java +++ /dev/null @@ -1,62 +0,0 @@ -package org.junit.runner.manipulation; - -import java.util.Collection; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import org.junit.runner.Description; - -/** - * Orders tests. - * - * @since 4.13 - */ -public final class Orderer { - private final Ordering ordering; - - Orderer(Ordering delegate) { - this.ordering = delegate; - } - - /** - * Orders the descriptions. - * - * @return descriptions in order - */ - public List<Description> order(Collection<Description> descriptions) - throws InvalidOrderingException { - List<Description> inOrder = ordering.orderItems( - Collections.unmodifiableCollection(descriptions)); - if (!ordering.validateOrderingIsCorrect()) { - return inOrder; - } - - Set<Description> uniqueDescriptions = new HashSet<Description>(descriptions); - if (!uniqueDescriptions.containsAll(inOrder)) { - throw new InvalidOrderingException("Ordering added items"); - } - Set<Description> resultAsSet = new HashSet<Description>(inOrder); - if (resultAsSet.size() != inOrder.size()) { - throw new InvalidOrderingException("Ordering duplicated items"); - } else if (!resultAsSet.containsAll(uniqueDescriptions)) { - throw new InvalidOrderingException("Ordering removed items"); - } - - return inOrder; - } - - /** - * Order the tests in <code>target</code>. - * - * @throws InvalidOrderingException if ordering does something invalid (like remove or add - * children) - */ - public void apply(Object target) throws InvalidOrderingException { - if (target instanceof Orderable) { - Orderable orderable = (Orderable) target; - orderable.order(this); - } - } -} diff --git a/src/main/java/org/junit/runner/manipulation/Ordering.java b/src/main/java/org/junit/runner/manipulation/Ordering.java deleted file mode 100644 index 0d0ce93..0000000 --- a/src/main/java/org/junit/runner/manipulation/Ordering.java +++ /dev/null @@ -1,172 +0,0 @@ -package org.junit.runner.manipulation; - -import java.lang.reflect.Constructor; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.Random; - -import org.junit.runner.Description; -import org.junit.runner.OrderWith; - -/** - * Reorders tests. An {@code Ordering} can reverse the order of tests, sort the - * order or even shuffle the order. - * - * <p>In general you will not need to use a <code>Ordering</code> directly. - * Instead, use {@link org.junit.runner.Request#orderWith(Ordering)}. - * - * @since 4.13 - */ -public abstract class Ordering { - private static final String CONSTRUCTOR_ERROR_FORMAT - = "Ordering class %s should have a public constructor with signature " - + "%s(Ordering.Context context)"; - - /** - * Creates an {@link Ordering} that shuffles the items using the given - * {@link Random} instance. - */ - public static Ordering shuffledBy(final Random random) { - return new Ordering() { - @Override - boolean validateOrderingIsCorrect() { - return false; - } - - @Override - protected List<Description> orderItems(Collection<Description> descriptions) { - List<Description> shuffled = new ArrayList<Description>(descriptions); - Collections.shuffle(shuffled, random); - return shuffled; - } - }; - } - - /** - * Creates an {@link Ordering} from the given factory class. The class must have a public no-arg - * constructor. - * - * @param factoryClass class to use to create the ordering - * @param annotatedTestClass test class that is annotated with {@link OrderWith}. - * @throws InvalidOrderingException if the instance could not be created - */ - public static Ordering definedBy( - Class<? extends Ordering.Factory> factoryClass, Description annotatedTestClass) - throws InvalidOrderingException { - if (factoryClass == null) { - throw new NullPointerException("factoryClass cannot be null"); - } - if (annotatedTestClass == null) { - throw new NullPointerException("annotatedTestClass cannot be null"); - } - - Ordering.Factory factory; - try { - Constructor<? extends Ordering.Factory> constructor = factoryClass.getConstructor(); - factory = constructor.newInstance(); - } catch (NoSuchMethodException e) { - throw new InvalidOrderingException(String.format( - CONSTRUCTOR_ERROR_FORMAT, - getClassName(factoryClass), - factoryClass.getSimpleName())); - } catch (Exception e) { - throw new InvalidOrderingException( - "Could not create ordering for " + annotatedTestClass, e); - } - return definedBy(factory, annotatedTestClass); - } - - /** - * Creates an {@link Ordering} from the given factory. - * - * @param factory factory to use to create the ordering - * @param annotatedTestClass test class that is annotated with {@link OrderWith}. - * @throws InvalidOrderingException if the instance could not be created - */ - public static Ordering definedBy( - Ordering.Factory factory, Description annotatedTestClass) - throws InvalidOrderingException { - if (factory == null) { - throw new NullPointerException("factory cannot be null"); - } - if (annotatedTestClass == null) { - throw new NullPointerException("annotatedTestClass cannot be null"); - } - - return factory.create(new Ordering.Context(annotatedTestClass)); - } - - private static String getClassName(Class<?> clazz) { - String name = clazz.getCanonicalName(); - if (name == null) { - return clazz.getName(); - } - return name; - } - - /** - * Order the tests in <code>target</code> using this ordering. - * - * @throws InvalidOrderingException if ordering does something invalid (like remove or add - * children) - */ - public void apply(Object target) throws InvalidOrderingException { - /* - * Note that some subclasses of Ordering override apply(). The Sorter - * subclass of Ordering overrides apply() to apply the sort (this is - * done because sorting is more efficient than ordering). - */ - if (target instanceof Orderable) { - Orderable orderable = (Orderable) target; - orderable.order(new Orderer(this)); - } - } - - /** - * Returns {@code true} if this ordering could produce invalid results (i.e. - * if it could add or remove values). - */ - boolean validateOrderingIsCorrect() { - return true; - } - - /** - * Implemented by sub-classes to order the descriptions. - * - * @return descriptions in order - */ - protected abstract List<Description> orderItems(Collection<Description> descriptions); - - /** Context about the ordering being applied. */ - public static class Context { - private final Description description; - - /** - * Gets the description for the top-level target being ordered. - */ - public Description getTarget() { - return description; - } - - private Context(Description description) { - this.description = description; - } - } - - /** - * Factory for creating {@link Ordering} instances. - * - * <p>For a factory to be used with {@code @OrderWith} it needs to have a public no-arg - * constructor. - */ - public interface Factory { - /** - * Creates an Ordering instance using the given context. Implementations - * of this method that do not need to use the context can return the - * same instance every time. - */ - Ordering create(Context context); - } -} diff --git a/src/main/java/org/junit/runner/manipulation/Sortable.java b/src/main/java/org/junit/runner/manipulation/Sortable.java index 0c59f33..9ac864c 100644 --- a/src/main/java/org/junit/runner/manipulation/Sortable.java +++ b/src/main/java/org/junit/runner/manipulation/Sortable.java @@ -15,6 +15,6 @@ public interface Sortable { * * @param sorter the {@link Sorter} to use for sorting the tests */ - void sort(Sorter sorter); + public void sort(Sorter sorter); } diff --git a/src/main/java/org/junit/runner/manipulation/Sorter.java b/src/main/java/org/junit/runner/manipulation/Sorter.java index 4b5274c..20192d0 100644 --- a/src/main/java/org/junit/runner/manipulation/Sorter.java +++ b/src/main/java/org/junit/runner/manipulation/Sorter.java @@ -1,21 +1,16 @@ package org.junit.runner.manipulation; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; import java.util.Comparator; -import java.util.List; import org.junit.runner.Description; /** * A <code>Sorter</code> orders tests. In general you will not need - * to use a <code>Sorter</code> directly. Instead, use - * {@link org.junit.runner.Request#sortWith(Comparator)}. + * to use a <code>Sorter</code> directly. Instead, use {@link org.junit.runner.Request#sortWith(Comparator)}. * * @since 4.0 */ -public class Sorter extends Ordering implements Comparator<Description> { +public class Sorter implements Comparator<Description> { /** * NULL is a <code>Sorter</code> that leaves elements in an undefined order */ @@ -32,26 +27,17 @@ public class Sorter extends Ordering implements Comparator<Description> { * to sort tests * * @param comparator the {@link Comparator} to use when sorting tests - * @since 4.0 */ public Sorter(Comparator<Description> comparator) { this.comparator = comparator; } /** - * Sorts the tests in <code>target</code> using <code>comparator</code>. - * - * @since 4.0 + * Sorts the test in <code>runner</code> using <code>comparator</code> */ - @Override - public void apply(Object target) { - /* - * Note that all runners that are Orderable are also Sortable (because - * Orderable extends Sortable). Sorting is more efficient than ordering, - * so we override the parent behavior so we sort instead. - */ - if (target instanceof Sortable) { - Sortable sortable = (Sortable) target; + public void apply(Object object) { + if (object instanceof Sortable) { + Sortable sortable = (Sortable) object; sortable.sort(this); } } @@ -59,32 +45,4 @@ public class Sorter extends Ordering implements Comparator<Description> { public int compare(Description o1, Description o2) { return comparator.compare(o1, o2); } - - /** - * {@inheritDoc} - * - * @since 4.13 - */ - @Override - protected final List<Description> orderItems(Collection<Description> descriptions) { - /* - * In practice, we will never get here--Sorters do their work in the - * compare() method--but the Liskov substitution principle demands that - * we obey the general contract of Orderable. Luckily, it's trivial to - * implement. - */ - List<Description> sorted = new ArrayList<Description>(descriptions); - Collections.sort(sorted, this); // Note: it would be incorrect to pass in "comparator" - return sorted; - } - - /** - * {@inheritDoc} - * - * @since 4.13 - */ - @Override - boolean validateOrderingIsCorrect() { - return false; - } } |