--- /dev/null
+package org.apache.lucene.util;
+
+/**
+ * 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.
+ */
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Random;
+
+import org.apache.lucene.util.LuceneTestCase.Nightly;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runner.manipulation.Filter;
+import org.junit.runner.manipulation.NoTestsRemainException;
+import org.junit.runner.notification.Failure;
+import org.junit.runner.notification.RunListener;
+import org.junit.runner.notification.RunNotifier;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+
+// please don't reorganize these into a wildcard!
+import static org.apache.lucene.util.LuceneTestCase.TEST_ITER;
+import static org.apache.lucene.util.LuceneTestCase.TEST_ITER_MIN;
+import static org.apache.lucene.util.LuceneTestCase.TEST_METHOD;
+import static org.apache.lucene.util.LuceneTestCase.TEST_SEED;
+import static org.apache.lucene.util.LuceneTestCase.TEST_NIGHTLY;
+import static org.apache.lucene.util.LuceneTestCase.VERBOSE;
+
+/** optionally filters the tests to be run by TEST_METHOD */
+public class LuceneTestCaseRunner extends BlockJUnit4ClassRunner {
+ private List<FrameworkMethod> testMethods;
+ static final long runnerSeed;
+ static {
+ runnerSeed = "random".equals(TEST_SEED) ? LuceneTestCase.seedRand.nextLong() : ThreeLongs.fromString(TEST_SEED).l3;
+ }
+
+ @Override
+ protected List<FrameworkMethod> computeTestMethods() {
+ if (testMethods != null)
+ return testMethods;
+
+ Random r = new Random(runnerSeed);
+
+ LuceneTestCase.testClassesRun.add(getTestClass().getJavaClass().getSimpleName());
+ testMethods = new ArrayList<FrameworkMethod>();
+ for (Method m : getTestClass().getJavaClass().getMethods()) {
+ // check if the current test's class has methods annotated with @Ignore
+ final Ignore ignored = m.getAnnotation(Ignore.class);
+ if (ignored != null && !m.getName().equals("alwaysIgnoredTestMethod")) {
+ System.err.println("NOTE: Ignoring test method '" + m.getName() + "': " + ignored.value());
+ }
+ // add methods starting with "test"
+ final int mod = m.getModifiers();
+ if (m.getAnnotation(Test.class) != null ||
+ (m.getName().startsWith("test") &&
+ !Modifier.isAbstract(mod) &&
+ m.getParameterTypes().length == 0 &&
+ m.getReturnType() == Void.TYPE))
+ {
+ if (Modifier.isStatic(mod))
+ throw new RuntimeException("Test methods must not be static.");
+ testMethods.add(new FrameworkMethod(m));
+ }
+ }
+
+ if (testMethods.isEmpty()) {
+ throw new RuntimeException("No runnable methods!");
+ }
+
+ if (TEST_NIGHTLY == false) {
+ if (getTestClass().getJavaClass().isAnnotationPresent(Nightly.class)) {
+ /* the test class is annotated with nightly, remove all methods */
+ String className = getTestClass().getJavaClass().getSimpleName();
+ System.err.println("NOTE: Ignoring nightly-only test class '" + className + "'");
+ testMethods.clear();
+ } else {
+ /* remove all nightly-only methods */
+ for (int i = 0; i < testMethods.size(); i++) {
+ final FrameworkMethod m = testMethods.get(i);
+ if (m.getAnnotation(Nightly.class) != null) {
+ System.err.println("NOTE: Ignoring nightly-only test method '" + m.getName() + "'");
+ testMethods.remove(i--);
+ }
+ }
+ }
+ /* dodge a possible "no-runnable methods" exception by adding a fake ignored test */
+ if (testMethods.isEmpty()) {
+ try {
+ testMethods.add(new FrameworkMethod(LuceneTestCase.class.getMethod("alwaysIgnoredTestMethod")));
+ } catch (Exception e) { throw new RuntimeException(e); }
+ }
+ }
+ // sort the test methods first before shuffling them, so that the shuffle is consistent
+ // across different implementations that might order the methods different originally.
+ Collections.sort(testMethods, new Comparator<FrameworkMethod>() {
+ public int compare(FrameworkMethod f1, FrameworkMethod f2) {
+ return f1.getName().compareTo(f2.getName());
+ }
+ });
+ Collections.shuffle(testMethods, r);
+ return testMethods;
+ }
+
+ @Override
+ protected void runChild(FrameworkMethod arg0, RunNotifier arg1) {
+ if (VERBOSE) {
+ System.out.println("\nNOTE: running test " + arg0.getName());
+ }
+
+ // only print iteration info if the user requested more than one iterations
+ final boolean verbose = VERBOSE && TEST_ITER > 1;
+
+ final int currentIter[] = new int[1];
+ arg1.addListener(new RunListener() {
+ @Override
+ public void testFailure(Failure failure) throws Exception {
+ if (verbose) {
+ System.out.println("\nNOTE: iteration " + currentIter[0] + " failed! ");
+ }
+ }
+ });
+ for (int i = 0; i < TEST_ITER; i++) {
+ currentIter[0] = i;
+ if (verbose) {
+ System.out.println("\nNOTE: running iter=" + (1+i) + " of " + TEST_ITER);
+ }
+ super.runChild(arg0, arg1);
+ if (LuceneTestCase.testsFailed) {
+ if (i >= TEST_ITER_MIN - 1) { // XXX is this still off-by-one?
+ break;
+ }
+ }
+ }
+ }
+
+ public LuceneTestCaseRunner(Class<?> clazz) throws InitializationError {
+ super(clazz);
+ // evil we cannot init our random here, because super() calls computeTestMethods!!!!;
+ Filter f = new Filter() {
+
+ @Override
+ public String describe() { return "filters according to TEST_METHOD"; }
+
+ @Override
+ public boolean shouldRun(Description d) {
+ return TEST_METHOD == null || d.getMethodName().equals(TEST_METHOD);
+ }
+ };
+
+ try {
+ f.apply(this);
+ } catch (NoTestsRemainException e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
fnp / pylucene.git / blobdiff