X-Git-Url: https://git.mdrn.pl/pylucene.git/blobdiff_plain/a2e61f0c04805cfcb8706176758d1283c7e3a55c..aaeed5504b982cf3545252ab528713250aa33eed:/lucene-java-3.5.0/lucene/backwards/src/test-framework/org/apache/lucene/util/LuceneTestCaseRunner.java diff --git a/lucene-java-3.5.0/lucene/backwards/src/test-framework/org/apache/lucene/util/LuceneTestCaseRunner.java b/lucene-java-3.5.0/lucene/backwards/src/test-framework/org/apache/lucene/util/LuceneTestCaseRunner.java new file mode 100644 index 0000000..5a9bcdd --- /dev/null +++ b/lucene-java-3.5.0/lucene/backwards/src/test-framework/org/apache/lucene/util/LuceneTestCaseRunner.java @@ -0,0 +1,176 @@ +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 testMethods; + static final long runnerSeed; + static { + runnerSeed = "random".equals(TEST_SEED) ? LuceneTestCase.seedRand.nextLong() : ThreeLongs.fromString(TEST_SEED).l3; + } + + @Override + protected List computeTestMethods() { + if (testMethods != null) + return testMethods; + + Random r = new Random(runnerSeed); + + LuceneTestCase.testClassesRun.add(getTestClass().getJavaClass().getSimpleName()); + testMethods = new ArrayList(); + 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() { + 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); + } + } +}