Extending and Modifying sorting feature of JUnit4.

src/main/java/junit/framework/JUnit4TestAdapter.java

@@ -81,6 +81,7 @@ public void filter(Filter filter) throws NoTestsRemainException {
     }
 
     public void sort(Sorter sorter) {
-        sorter.apply(fRunner);
+        if(sorter!=null)
+            sorter.apply(fRunner);
     }
 }

src/main/java/org/junit/SortWith.java

@@ -0,0 +1,67 @@
+package org.junit;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.Comparator;
+
+import org.junit.runners.Sorters;
+
+/**
+ * The <code>SortWith</code> Annotation that tells JUnit to execute test methods 
+ * or test classes defined in a test suite in a order specified by users.
+ * It also supports randomness of test by designating a random sorting method 
+ * to either a test class or a test suite. 
+ *
+ * <p>
+ * A sortable test class with its test methods executed in name ascending order looks like:
+ * <pre>
+ * 
+ * <b>&#064;RunWith(JUnit4.class)</b>
+ * <b>&#064;SortWith(Sorters.NAME_ASCENDING)</b>
+ * public class Example {
+ *    <b>&#064;Test</b>
+ *    public void testMethod1() {
+ *       
+ *    }
+ *    
+ *    <b>&#064;Test</b>
+ *    public void testMethod2() {
+ *     
+ *    }
+ * }
+ * </pre>
+ * <p>
+ *
+ * <p>
+ * A sortable test suite with its test classes executed in name ascending order looks like:
+ * <pre>
+ * 
+ * <b>&#064;RunWith(Suite.class)</b>
+ * <b>&#064;Suite.SuiteClasses({ ClassA.class, ClassB.class })</b>
+ * <b>&#064;SortWith(Sorters.NAME_ASCENDING)</b>
+ * public class Example {
+ * 
+ * }
+ * </pre>
+ * <p>
+ * 
+ * The <code>SortWith</code> Annotation takes one input parameter, see {@link org.junit.runner.manipulation.Sorter}.
+ * The parameter declares which sorting method JUnit should adopt when
+ * starts running tests. If no sorting method is specified for the 
+ * Annotation, then by default the default sorting method which compares
+ * hash codes of names of the two methods or names of two test classes is
+ * used. 
+ *
+ * Be aware that using {@link org.junit.runner.Request#sortWith(Comparator)} to manually specify a sorting
+ * method for JUnit overrides all the declarative sorting methods specified through <code>SortWith</code> Annotation.
+ *
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface SortWith {
+
+    Sorters value() default Sorters.DEFAULT;
+
+}

src/main/java/org/junit/internal/requests/ClassRequest.java

@@ -3,6 +3,9 @@
 import org.junit.internal.builders.AllDefaultPossibilitiesBuilder;
 import org.junit.runner.Request;
 import org.junit.runner.Runner;
+import org.junit.runner.manipulation.Sortable;
+import org.junit.runner.manipulation.Sorter;
+import org.junit.runners.ParentRunner;
 
 public class ClassRequest extends Request {
     private final Object fRunnerLock = new Object();
@@ -25,6 +28,8 @@ public Runner getRunner() {
             synchronized (fRunnerLock) {
                 if (fRunner == null) {
                     fRunner = new AllDefaultPossibilitiesBuilder(fCanUseSuiteMethod).safeRunnerForClass(fTestClass);
+                    if(fRunner instanceof Sortable)
+                        ((Sortable)fRunner).sort(Sorter.ANNOTATED_SORTER);
                 }
             }
         }

src/main/java/org/junit/runner/manipulation/Sorter.java

@@ -5,8 +5,11 @@
 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)}.
+ * A <code>Sorter</code> orders tests. In general you should specify the Sorter you
+ * want using <code>SortWith</code> Annotation.
+ * To use a <code>Sorter</code> directly, use {@link org.junit.runner.Request#sortWith(Comparator)}.
+ * Be aware, as long as a Sorter is manually specified, all declarative sorting methods defined by
+ * <code>SortWith</code> Annotation will be overridden.
  *
  * @since 4.0
  */
@@ -19,6 +22,59 @@ public int compare(Description o1, Description o2) {
             return 0;
         }
     });
+
+    public static final Sorter ANNOTATED_SORTER=null;
+
+    /**
+     * DEFAULT sorting method. It compares hash codes of either names of two test methods or names of two test classes, 
+     * depending on whether it is used for sorting execution order for test methods or sorting execution order for
+     * test classes defined in a test suite. 
+     */
+    public static final Sorter DEFAULT=new Sorter(new Comparator<Description>(){
+
+        public int compare(Description o1, Description o2) {
+            String[] items = getComparisonItems(o1,o2);
+            int hash1 = items[0].hashCode();
+            int hash2 = items[1].hashCode();
+            if (hash1 != hash2) {
+                return hash1 < hash2 ? -1 : 1;
+            }
+            return NAME_ASCENDING.compare(o1, o2);
+        }
+
+    });
+
+    /**
+    * Sorting method based on name ascending order. It compares names of two test methods or names of two test classes, 
+    * depending on whether it is used for sorting execution order for test methods or sorting execution order for
+    * test classes defined in a test suite. 
+    */
+    public static final Sorter NAME_ASCENDING = new Sorter(new Comparator<Description>(){
+
+        public int compare(Description o1, Description o2) {
+            String[] items = getComparisonItems(o1,o2);
+            final int comparison = items[0].compareTo(items[1]);
+            if (comparison != 0) {
+                return comparison;
+            }
+            return items[0].toString().compareTo(items[1].toString());
+        }
+
+    });
+
+    /**
+    * Random sorting method. It generates a random double value between 0 and 1 during runtime such that 
+    * a set of test methods or a set of test classes will always run in a random order. 
+    */
+    public static final Sorter RANDOM = new Sorter(new Comparator<Description>(){
+
+        public int compare(Description o1, Description o2) {
+            return Math.random() - 0.5 >0 ? 1 : -1;
+        }
+
+    });
+
+    //public static final Sorter JVM
 
     private final Comparator<Description> fComparator;
 
@@ -45,4 +101,15 @@ public void apply(Object object) {
     public int compare(Description o1, Description o2) {
         return fComparator.compare(o1, o2);
     }
+
+    private final static String[] getComparisonItems(Description o1,Description o2){
+        if(o1.isSuite()){
+            final String[] items={o1.getClassName(),o2.getClassName()};
+            return items;
+        }else{
+            final String[] items={o1.getMethodName(),o2.getMethodName()};
+            return items;
+        }
+    }
+
 }

src/main/java/org/junit/runners/ParentRunner.java

@@ -17,6 +17,7 @@
 import org.junit.ClassRule;
 import org.junit.Ignore;
 import org.junit.Rule;
+import org.junit.SortWith;
 import org.junit.internal.AssumptionViolatedException;
 import org.junit.internal.runners.model.EachTestNotifier;
 import org.junit.internal.runners.statements.RunAfters;
@@ -384,13 +385,25 @@ public void filter(Filter filter) throws NoTestsRemainException {
     }
 
     public void sort(Sorter sorter) {
-        synchronized (fChildrenLock) {
-            for (T each : getFilteredChildren()) {
-                sorter.apply(each);
-            }
+        if(sorter==Sorter.ANNOTATED_SORTER){
             List<T> sortedChildren = new ArrayList<T>(getFilteredChildren());
-            Collections.sort(sortedChildren, comparator(sorter));
+            Sorter annotatedSorter=getSorter();
+            if(annotatedSorter!=null)
+                Collections.sort(sortedChildren, comparator(annotatedSorter));
             fFilteredChildren = Collections.unmodifiableCollection(sortedChildren);
+            for (T each : getFilteredChildren()) {
+                if(each instanceof Sortable)
+                    ((Sortable)each).sort(null);
+            }
+        }else{
+            synchronized (fChildrenLock) {
+                for (T each : getFilteredChildren()) {
+                    sorter.apply(each);
+                }
+                List<T> sortedChildren = new ArrayList<T>(getFilteredChildren());
+                Collections.sort(sortedChildren, comparator(sorter));
+                fFilteredChildren = Collections.unmodifiableCollection(sortedChildren);
+            }
         }
     }
 
@@ -436,4 +449,14 @@ public int compare(T o1, T o2) {
     public void setScheduler(RunnerScheduler scheduler) {
         this.fScheduler = scheduler;
     }
+
+    private Sorter getSorter(){
+        final TestClass clazz = getTestClass();
+        if(clazz==null)
+            return null;
+        SortWith sortMethod=clazz.getJavaClass().getAnnotation(SortWith.class);
+        if(sortMethod==null)
+            return null;
+        return sortMethod.value().getSorter();
+    }
 }

src/main/java/org/junit/runners/Sorters.java

@@ -0,0 +1,44 @@
+package org.junit.runners;
+
+import org.junit.runner.manipulation.Sorter;
+
+
+/**
+ * Sorters enumerator used for defining sorting
+ * method for {@link SortWith} 
+ * 
+ */
+public enum Sorters {
+
+    /**
+     * default sorting method, using hash code
+     * of a method name o a class name to compare
+     */
+    DEFAULT(Sorter.DEFAULT),
+
+    /**
+     * random sorting method.
+     */
+    RANDOM(Sorter.RANDOM),
+
+    /**
+     * sorting method based on name ascending order
+     */
+    NAME_ASCENDING(Sorter.NAME_ASCENDING),
+
+    /**
+     * JVM sorting method
+     */
+    JVM(null);
+
+    private final Sorter sorter;
+
+    private Sorters(Sorter sorter){
+        this.sorter=sorter;
+    }
+
+    public Sorter getSorter(){
+        return sorter;
+    }
+
+}

src/main/java/org/junit/runners/model/TestClass.java

@@ -61,7 +61,7 @@ public TestClass(Class<?> klass) {
 
     protected void scanAnnotatedMembers(Map<Class<? extends Annotation>, List<FrameworkMethod>> methodsForAnnotations, Map<Class<? extends Annotation>, List<FrameworkField>> fieldsForAnnotations) {
         for (Class<?> eachClass : getSuperClasses(fClass)) {
-            for (Method eachMethod : MethodSorter.getDeclaredMethods(eachClass)) {
+            for (Method eachMethod : eachClass.getDeclaredMethods()) {
                 addToAnnotationLists(new FrameworkMethod(eachMethod), methodsForAnnotations);
             }
             // ensuring fields are sorted to make sure that entries are inserted