Package org.apache.lucene.tests.util

Class LuceneTestCase

java.lang.Object
org.junit.Assert
org.apache.lucene.tests.util.LuceneTestCase
Direct Known Subclasses:
BaseBitSetTestCase, BaseCompoundFormatTestCase, BaseDirectoryTestCase, BaseDocIdSetTestCase, BaseDocValuesFormatTestCase, BaseExplanationTestCase, BaseFieldInfoFormatTestCase, BaseGeoPointTestCase, BaseKnnVectorsFormatTestCase, BaseLiveDocsFormatTestCase, BaseLockFactoryTestCase, BaseMergePolicyTestCase, BaseNormsFormatTestCase, BasePointsFormatTestCase, BasePostingsFormatTestCase, BaseRangeFieldQueryTestCase, BaseSegmentInfoFormatTestCase, BaseSimilarityTestCase, BaseStoredFieldsFormatTestCase, BaseTermVectorsFormatTestCase, BaseTestCheckIndex, BaseTokenStreamTestCase, BaseXYPointTestCase, CollationTestBase, MatchesTestBase, MockFileSystemTestCase, SearchEquivalenceTestBase, ShardSearchingTestBase, ThreadedIndexingAndSearchingTestCase
@TestMethodProviders({LuceneJUnit3MethodProvider.class,com.carrotsearch.randomizedtesting.JUnit4MethodProvider.class}) @Listeners({RunListenerPrintReproduceInfo.class,FailureMarker.class}) @SeedDecorators(com.carrotsearch.randomizedtesting.MixWithSuiteName.class) @Limit(bytes=8192L, hardLimit=2147483648L) public abstract class LuceneTestCase extends Assert
Base class for all Lucene unit tests, Junit3 or Junit4 variant.

Class and instance setup.

The preferred way to specify class (suite-level) setup/cleanup is to use static methods annotated with BeforeClass and AfterClass. Any code in these methods is executed within the test framework's control and ensure proper setup has been made. Try not to use static initializers (including complex final field initializers). Static initializers are executed before any setup rules are fired and may cause you (or somebody else) headaches.

For instance-level setup, use Before and After annotated methods. If you override either setUp() or tearDown() in your subclass, make sure you call super.setUp() and super.tearDown(). This is detected and enforced.

Specifying test cases

Any test method with a testXXX prefix is considered a test case. Any test method annotated with Test is considered a test case.

Randomized execution and test facilities

LuceneTestCase uses RandomizedRunner to execute test cases. RandomizedRunner has built-in support for tests randomization including access to a repeatable Random instance. See random() method. Any test using Random acquired from random() should be fully reproducible (assuming no race conditions between threads etc.). The initial seed for a test case is reported in many ways:

  • as part of any exception thrown from its body (inserted as a dummy stack trace entry),
  • as part of the main thread executing the test case (if your test hangs, just dump the stack trace of all threads and you'll see the seed),
  • the master seed can also be accessed manually by getting the current context (RandomizedContext.current()) and then calling RandomizedContext.getRunnerSeedAsString().

  • Field Details

    • SYSPROP_NIGHTLY

      public static final String SYSPROP_NIGHTLY
      See Also:

    • SYSPROP_WEEKLY

      public static final String SYSPROP_WEEKLY
      See Also:

    • SYSPROP_MONSTER

      public static final String SYSPROP_MONSTER
      See Also:

    • SYSPROP_AWAITSFIX

      public static final String SYSPROP_AWAITSFIX
      See Also:

    • SYSPROP_SLOW

      public static final String SYSPROP_SLOW
      See Also:

    • SYSPROP_BADAPPLES

      public static final String SYSPROP_BADAPPLES
      See Also:

    • SYSPROP_MAXFAILURES

      public static final String SYSPROP_MAXFAILURES
      See Also:

    • SYSPROP_FAILFAST

      public static final String SYSPROP_FAILFAST
      See Also:

    • VERBOSE

      public static final boolean VERBOSE
      True if and only if tests are run in verbose mode. If this flag is false tests are not expected to print any messages. Enforced with TestRuleLimitSysouts.

    • INFOSTREAM

      public static final boolean INFOSTREAM
      Enables or disables dumping of InfoStream messages.

    • RANDOM_MULTIPLIER

      public static final int RANDOM_MULTIPLIER
      A random multiplier which you should use when writing random tests: multiply it by the number of iterations to scale your tests (for nightly builds).

    • TEST_ASSERTS_ENABLED

      public static final boolean TEST_ASSERTS_ENABLED

    • DEFAULT_LINE_DOCS_FILE

      public static final String DEFAULT_LINE_DOCS_FILE
      The default (embedded resource) lines file.
      See Also:

    • JENKINS_LARGE_LINE_DOCS_FILE

      public static final String JENKINS_LARGE_LINE_DOCS_FILE
      Random sample from enwiki used in tests. See help/tests.txt. gradle task downloading this data set: gradlew getEnWikiRandomLines.
      See Also:

    • TEST_CODEC

      public static final String TEST_CODEC
      Gets the codec to run tests with.

    • TEST_POSTINGSFORMAT

      public static final String TEST_POSTINGSFORMAT
      Gets the postingsFormat to run tests with.

    • TEST_DOCVALUESFORMAT

      public static final String TEST_DOCVALUESFORMAT
      Gets the docValuesFormat to run tests with

    • TEST_DIRECTORY

      public static final String TEST_DIRECTORY
      Gets the directory to run tests with

    • TEST_LINE_DOCS_FILE

      public static final String TEST_LINE_DOCS_FILE
      The line file used in tests (by LineFileDocs).

    • TEST_NIGHTLY

      public static final boolean TEST_NIGHTLY
      Whether or not LuceneTestCase.Nightly tests should run.

    • TEST_WEEKLY

      public static final boolean TEST_WEEKLY
      Whether or not LuceneTestCase.Weekly tests should run.

    • TEST_MONSTER

      public static final boolean TEST_MONSTER
      Whether or not LuceneTestCase.Monster tests should run.

    • TEST_AWAITSFIX

      public static final boolean TEST_AWAITSFIX
      Whether or not LuceneTestCase.AwaitsFix tests should run.

    • TEST_BADAPPLES

      public static final boolean TEST_BADAPPLES
      Whether or not LuceneTestCase.BadApple tests should run.

    • TEST_SLOW

      public static final boolean TEST_SLOW
      Whether or not LuceneTestCase.Slow tests should run.

    • TEST_THROTTLING

      public static final MockDirectoryWrapper.Throttling TEST_THROTTLING
      Throttling, see MockDirectoryWrapper.setThrottling(Throttling).

    • LEAVE_TEMPORARY

      public static final boolean LEAVE_TEMPORARY
      Leave temporary files on disk, even on successful runs.

    • MAYBE_CACHE_POLICY

      public static final QueryCachingPolicy MAYBE_CACHE_POLICY
      A QueryCachingPolicy that randomly caches.

    • suiteFailureMarker

      protected static TestRuleMarkFailure suiteFailureMarker
      Suite failure marker (any error in the test or suite scope).

    • classRules

      public static org.junit.rules.TestRule classRules
      This controls how suite-level rules are nested. It is important that _all_ rules declared in LuceneTestCase are executed in proper order if they depend on each other.

    • ruleChain

      public final org.junit.rules.TestRule ruleChain
      This controls how individual test rules are nested. It is important that _all_ rules declared in LuceneTestCase are executed in proper order if they depend on each other.

    • assertsAreEnabled

      public static final boolean assertsAreEnabled
      True if assertions (-ea) are enabled (at least for this class).

  • Constructor Details

    • LuceneTestCase

      public LuceneTestCase()

  • Method Details

    • hasWorkingMMapOnWindows

      public static boolean hasWorkingMMapOnWindows()
      Returns true, if MMapDirectory supports unmapping on this platform (required for Windows), or if we are not on Windows.

    • assumeWorkingMMapOnWindows

      public static void assumeWorkingMMapOnWindows()
      Assumes that the current MMapDirectory implementation supports unmapping, so the test will not fail on Windows.
      See Also:

    • replaceMaxFailureRule

      public static TestRuleIgnoreAfterMaxFailures replaceMaxFailureRule(TestRuleIgnoreAfterMaxFailures newValue)
      Temporarily substitute the global TestRuleIgnoreAfterMaxFailures. See ignoreAfterMaxFailuresDelegate for some explanation why this method is needed.

    • setUp

      public void setUp() throws Exception
      For subclasses to override. Overrides must call super.setUp().
      Throws:
      Exception

    • tearDown

      public void tearDown() throws Exception
      For subclasses to override. Overrides must call super.tearDown().
      Throws:
      Exception

    • setIndexWriterMaxDocs

      public void setIndexWriterMaxDocs(int limit)
      Tells IndexWriter to enforce the specified limit as the maximum number of documents in one index; call restoreIndexWriterMaxDocs() once your test is done.

    • restoreIndexWriterMaxDocs

      public void restoreIndexWriterMaxDocs()
      Returns to the default IndexWriter.MAX_DOCS limit.

    • random

      public static Random random()
      Access to the current RandomizedContext's Random instance. It is safe to use this method from multiple threads, etc., but it should be called while within a runner's scope (so no static initializers). The returned Random instance will be different when this method is called inside a BeforeClass hook (static suite scope) and within Before/ After hooks or test methods.

      The returned instance must not be shared with other threads or cross a single scope's boundary. For example, a Random acquired within a test method shouldn't be reused for another test case.

      There is an overhead connected with getting the Random for a particular context and thread. It is better to cache the Random locally if tight loops with multiple invocations are present or create a derivative local Random for millions of calls like this: 

       Random random = new Random(random().nextLong());
 // tight loop with many invocations.

    • closeAfterTest

      public <T extends Closeable> T closeAfterTest(T resource)
      Registers a Closeable resource that should be closed after the test completes.
      Returns:
      resource (for call chaining).

    • closeAfterSuite

      public static <T extends Closeable> T closeAfterSuite(T resource)
      Registers a Closeable resource that should be closed after the suite completes.
      Returns:
      resource (for call chaining).

    • getTestClass

      public static Class<?> getTestClass()
      Return the current class being tested.

    • getTestName

      public String getTestName()
      Return the name of the currently executing test case.

    • getOnlyLeafReader

      public static LeafReader getOnlyLeafReader(IndexReader reader)
      Some tests expect the directory to contain a single segment, and want to do tests on that segment's reader. This is an utility method to help them.

    • isTestThread

      protected boolean isTestThread()
      Returns true if and only if the calling thread is the primary thread executing the test case.

    • atLeast

      public static int atLeast(Random random, int i)
      Returns a number of at least i

      The actual number returned will be influenced by whether TEST_NIGHTLY is active and RANDOM_MULTIPLIER, but also with some random fudge.

    • atLeast

      public static int atLeast(int i)

    • rarely

      public static boolean rarely(Random random)
      Returns true if something should happen rarely,

      The actual number returned will be influenced by whether TEST_NIGHTLY is active and RANDOM_MULTIPLIER.

    • rarely

      public static boolean rarely()

    • usually

      public static boolean usually(Random random)

    • usually

      public static boolean usually()

    • assumeTrue

      public static void assumeTrue(String msg, boolean condition)

    • assumeFalse

      public static void assumeFalse(String msg, boolean condition)

    • assumeNoException

      public static void assumeNoException(String msg, Exception e)

    • asSet

      @SafeVarargs public static <T> Set<T> asSet(T... args)
      Return args as a Set instance. The order of elements is not preserved in iterators.

    • dumpIterator

      public static void dumpIterator(String label, Iterator<?> iter, PrintStream stream)
      Convenience method for logging an iterator.
      Parameters:
      label - String logged before/after the items in the iterator
      iter - Each next() is toString()ed and logged on its own line. If iter is null this is logged differently then an empty iterator.
      stream - Stream to log messages to.

    • dumpArray

      public static void dumpArray(String label, Object[] objs, PrintStream stream)
      Convenience method for logging an array. Wraps the array in an iterator and delegates
      See Also:

    • newIndexWriterConfig

      public static IndexWriterConfig newIndexWriterConfig()
      create a new index writer config with random defaults

    • newIndexWriterConfig

      public static IndexWriterConfig newIndexWriterConfig(Analyzer a)
      create a new index writer config with random defaults

    • newIndexWriterConfig

      public static IndexWriterConfig newIndexWriterConfig(Random r, Analyzer a)
      create a new index writer config with random defaults using the specified random

    • newMergePolicy

      public static MergePolicy newMergePolicy(Random r)

    • newMergePolicy

      public static MergePolicy newMergePolicy(Random r, boolean includeMockMP)

    • newMergePolicy

      public static MergePolicy newMergePolicy()

    • newLogMergePolicy

      public static LogMergePolicy newLogMergePolicy()

    • newTieredMergePolicy

      public static TieredMergePolicy newTieredMergePolicy()

    • newAlcoholicMergePolicy

      public static AlcoholicMergePolicy newAlcoholicMergePolicy()

    • newAlcoholicMergePolicy

      public static AlcoholicMergePolicy newAlcoholicMergePolicy(Random r, TimeZone tz)

    • newLogMergePolicy

      public static LogMergePolicy newLogMergePolicy(Random r)

    • newTieredMergePolicy

      public static TieredMergePolicy newTieredMergePolicy(Random r)

    • newLogMergePolicy

      public static MergePolicy newLogMergePolicy(boolean useCFS)

    • newLogMergePolicy

      public static MergePolicy newLogMergePolicy(boolean useCFS, int mergeFactor)

    • newLogMergePolicy

      public static MergePolicy newLogMergePolicy(int mergeFactor)

    • maybeChangeLiveIndexWriterConfig

      public static void maybeChangeLiveIndexWriterConfig(Random r, LiveIndexWriterConfig c)

    • newDirectory

      public static BaseDirectoryWrapper newDirectory()
      Returns a new Directory instance. Use this when the test does not care about the specific Directory implementation (most tests).

      The Directory is wrapped with BaseDirectoryWrapper. this means usually it will be picky, such as ensuring that you properly close it and all open files in your test. It will emulate some features of Windows, such as not allowing open files to be overwritten.

    • newMaybeVirusCheckingDirectory

      public static BaseDirectoryWrapper newMaybeVirusCheckingDirectory()
      Like newDirectory() except randomly the VirusCheckingFS may be installed

    • newDirectory

      public static BaseDirectoryWrapper newDirectory(Random r)
      Returns a new Directory instance, using the specified random. See newDirectory() for more information.

    • newDirectory

      public static BaseDirectoryWrapper newDirectory(Random r, LockFactory lf)
      Returns a new Directory instance, using the specified random. See newDirectory() for more information.

    • newMockDirectory

      public static MockDirectoryWrapper newMockDirectory()

    • newMockDirectory

      public static MockDirectoryWrapper newMockDirectory(Random r)

    • newMockDirectory

      public static MockDirectoryWrapper newMockDirectory(Random r, LockFactory lf)

    • newMockFSDirectory

      public static MockDirectoryWrapper newMockFSDirectory(Path f)

    • newMockFSDirectory

      public static MockDirectoryWrapper newMockFSDirectory(Path f, LockFactory lf)

    • addVirusChecker

      public static Path addVirusChecker(Path path)

    • newDirectory

      public static BaseDirectoryWrapper newDirectory(Directory d) throws IOException
      Returns a new Directory instance, with contents copied from the provided directory. See newDirectory() for more information.
      Throws:
      IOException

    • newFSDirectory

      public static BaseDirectoryWrapper newFSDirectory(Path f)
      Returns a new FSDirectory instance over the given file, which must be a folder.

    • newMaybeVirusCheckingFSDirectory

      public static BaseDirectoryWrapper newMaybeVirusCheckingFSDirectory(Path f)
      Like newFSDirectory(Path), but randomly insert VirusCheckingFS

    • newFSDirectory

      public static BaseDirectoryWrapper newFSDirectory(Path f, LockFactory lf)
      Returns a new FSDirectory instance over the given file, which must be a folder.

    • newDirectory

      public static BaseDirectoryWrapper newDirectory(Random r, Directory d) throws IOException
      Returns a new Directory instance, using the specified random with contents copied from the provided directory. See newDirectory() for more information.
      Throws:
      IOException

    • newStringField

      public static Field newStringField(String name, String value, Field.Store stored)

    • newStringField

      public static Field newStringField(String name, BytesRef value, Field.Store stored)

    • newTextField

      public static Field newTextField(String name, String value, Field.Store stored)

    • newStringField

      public static Field newStringField(Random random, String name, String value, Field.Store stored)

    • newStringField

      public static Field newStringField(Random random, String name, BytesRef value, Field.Store stored)

    • newTextField

      public static Field newTextField(Random random, String name, String value, Field.Store stored)

    • newField

      public static Field newField(String name, String value, FieldType type)

    • newField

      public static Field newField(Random random, String name, Object value, FieldType type)

    • randomLocale

      public static Locale randomLocale(Random random)
      Return a random Locale from the available locales on the system.
      See Also:

    • randomTimeZone

      public static TimeZone randomTimeZone(Random random)
      Return a random TimeZone from the available timezones on the system
      See Also:

    • localeForLanguageTag

      public static Locale localeForLanguageTag(String languageTag)
      return a Locale object equivalent to its programmatic name

    • wrapReader

      public static IndexReader wrapReader(IndexReader r) throws IOException
      Throws:
      IOException

    • maybeWrapReader

      public static IndexReader maybeWrapReader(IndexReader r) throws IOException
      Sometimes wrap the IndexReader as slow, parallel or filter reader (or combinations of that)
      Throws:
      IOException

    • newIOContext

      public static IOContext newIOContext(Random random)
      TODO: javadoc

    • newIOContext

      public static IOContext newIOContext(Random random, IOContext oldContext)
      TODO: javadoc

    • overrideTestDefaultQueryCache

      public void overrideTestDefaultQueryCache()

    • overrideDefaultQueryCache

      public static void overrideDefaultQueryCache()

    • resetDefaultQueryCache

      public static void resetDefaultQueryCache()

    • setupCPUCoreCount

      public static void setupCPUCoreCount()

    • restoreCPUCoreCount

      public static void restoreCPUCoreCount()

    • newSearcher

      public static IndexSearcher newSearcher(IndexReader r)
      Create a new searcher over the reader. This searcher might randomly use threads.

    • newSearcher

      public static IndexSearcher newSearcher(IndexReader r, boolean maybeWrap)
      Create a new searcher over the reader. This searcher might randomly use threads.

    • newSearcher

      public static IndexSearcher newSearcher(IndexReader r, boolean maybeWrap, boolean wrapWithAssertions)
      Create a new searcher over the reader. This searcher might randomly use threads. if maybeWrap is true, this searcher might wrap the reader with one that returns null for getSequentialSubReaders. If wrapWithAssertions is true, this searcher might be an AssertingIndexSearcher instance.

    • newSearcher

      public static IndexSearcher newSearcher(IndexReader r, boolean maybeWrap, boolean wrapWithAssertions, boolean useThreads)
      Create a new searcher over the reader. If maybeWrap is true, this searcher might wrap the reader with one that returns null for getSequentialSubReaders. If wrapWithAssertions is true, this searcher might be an AssertingIndexSearcher instance. The searcher will use threads if useThreads is set to true.

    • getDataPath

      protected Path getDataPath(String name) throws IOException
      Gets a resource from the test's classpath as Path. This method should only be used, if a real file is needed. To get a stream, code should prefer getDataInputStream(String).
      Throws:
      IOException

    • getDataInputStream

      protected InputStream getDataInputStream(String name) throws IOException
      Gets a resource from the test's classpath as InputStream.
      Throws:
      IOException

    • assertReaderEquals

      public void assertReaderEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException
      Throws:
      IOException

    • assertReaderStatisticsEquals

      public void assertReaderStatisticsEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException
      checks that reader-level statistics are the same
      Throws:
      IOException

    • assertTermsEquals

      public void assertTermsEquals(String info, IndexReader leftReader, IndexReader rightReader, boolean deep) throws IOException
      Fields api equivalency
      Throws:
      IOException

    • assertTermsEquals

      public void assertTermsEquals(String info, IndexReader leftReader, Terms leftTerms, Terms rightTerms, boolean deep) throws IOException
      Terms api equivalency
      Throws:
      IOException

    • assertTermsStatisticsEquals

      public void assertTermsStatisticsEquals(String info, Terms leftTerms, Terms rightTerms) throws IOException
      checks collection-level statistics on Terms
      Throws:
      IOException

    • assertTermsEnumEquals

      public void assertTermsEnumEquals(String info, IndexReader leftReader, TermsEnum leftTermsEnum, TermsEnum rightTermsEnum, boolean deep) throws IOException
      checks the terms enum sequentially if deep is false, it does a 'shallow' test that doesnt go down to the docsenums
      Throws:
      IOException

    • assertDocsAndPositionsEnumEquals

      public void assertDocsAndPositionsEnumEquals(String info, PostingsEnum leftDocs, PostingsEnum rightDocs) throws IOException
      checks docs + freqs + positions + payloads, sequentially
      Throws:
      IOException

    • assertDocsEnumEquals

      public void assertDocsEnumEquals(String info, PostingsEnum leftDocs, PostingsEnum rightDocs, boolean hasFreqs) throws IOException
      checks docs + freqs, sequentially
      Throws:
      IOException

    • assertDocsSkippingEquals

      public void assertDocsSkippingEquals(String info, IndexReader leftReader, int docFreq, PostingsEnum leftDocs, PostingsEnum rightDocs, boolean hasFreqs) throws IOException
      checks advancing docs
      Throws:
      IOException

    • assertPositionsSkippingEquals

      public void assertPositionsSkippingEquals(String info, IndexReader leftReader, int docFreq, PostingsEnum leftDocs, PostingsEnum rightDocs) throws IOException
      checks advancing docs + positions
      Throws:
      IOException

    • assertTermStatsEquals

      public void assertTermStatsEquals(String info, TermsEnum leftTermsEnum, TermsEnum rightTermsEnum) throws IOException
      checks term-level statistics
      Throws:
      IOException

    • assertNormsEquals

      public void assertNormsEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException
      checks that norms are the same across all fields
      Throws:
      IOException

    • assertStoredFieldsEquals

      public void assertStoredFieldsEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException
      checks that stored fields of all documents are the same
      Throws:
      IOException

    • assertStoredFieldEquals

      public void assertStoredFieldEquals(String info, IndexableField leftField, IndexableField rightField)
      checks that two stored fields are equivalent

    • assertTermVectorsEquals

      public void assertTermVectorsEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException
      checks that term vectors across all fields are equivalent
      Throws:
      IOException

    • assertDocValuesEquals

      public void assertDocValuesEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException
      checks that docvalues across all fields are equivalent
      Throws:
      IOException

    • assertDocValuesEquals

      public void assertDocValuesEquals(String info, int num, NumericDocValues leftDocValues, NumericDocValues rightDocValues) throws IOException
      Throws:
      IOException

    • assertDeletedDocsEquals

      public void assertDeletedDocsEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException
      Throws:
      IOException

    • assertFieldInfosEquals

      public void assertFieldInfosEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException
      Throws:
      IOException

    • assertPointsEquals

      public void assertPointsEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException
      Throws:
      IOException

    • callStackContains

      public static boolean callStackContains(Class<?> clazz, String methodName)
      Inspects stack trace to figure out if a method of a specific class called us.

    • callStackContainsAnyOf

      public static boolean callStackContainsAnyOf(String... methodNames)
      Inspects stack trace to figure out if one of the given method names (no class restriction) called us.

    • callStackContains

      public static boolean callStackContains(Class<?> clazz)
      Inspects stack trace if the given class called us.

    • expectThrows

      public static <T extends Throwable> T expectThrows(Class<T> expectedType, LuceneTestCase.ThrowingRunnable runnable)
      Checks a specific exception class is thrown by the given runnable, and returns it.

    • expectThrows

      public static <T extends Throwable> T expectThrows(Class<T> expectedType, String noExceptionMessage, LuceneTestCase.ThrowingRunnable runnable)
      Checks a specific exception class is thrown by the given runnable, and returns it.

    • expectThrowsAnyOf

      public static <T extends Throwable> T expectThrowsAnyOf(List<Class<? extends T>> expectedTypes, LuceneTestCase.ThrowingRunnable runnable)
      Checks a specific exception class is thrown by the given runnable, and returns it.

    • expectThrows

      public static <TO extends Throwable, TW extends Throwable> TW expectThrows(Class<TO> expectedOuterType, Class<TW> expectedWrappedType, LuceneTestCase.ThrowingRunnable runnable)
      Checks that specific wrapped and outer exception classes are thrown by the given runnable, and returns the wrapped exception.

    • expectThrowsAnyOf

      public static <TO extends Throwable, TW extends Throwable> TO expectThrowsAnyOf(LinkedHashMap<Class<? extends TO>,List<Class<? extends TW>>> expectedOuterToWrappedTypes, LuceneTestCase.ThrowingRunnable runnable)
      Checks that one of the specified wrapped and outer exception classes are thrown by the given runnable, and returns the outer exception.

      This method accepts outer exceptions with no wrapped exception; an empty list of expected wrapped exception types indicates no wrapped exception.

    • slowFileExists

      public static boolean slowFileExists(Directory dir, String fileName) throws IOException
      Returns true if the file exists (can be opened), false if it cannot be opened, and (unlike Java's File.exists) throws IOException if there's some unexpected error.
      Throws:
      IOException

    • createTempDir

      public static Path createTempDir()
      Creates an empty, temporary folder (when the name of the folder is of no importance).
      See Also:

    • createTempDir

      public static Path createTempDir(String prefix)
      Creates an empty, temporary folder with the given name prefix.

      The folder will be automatically removed after the test class completes successfully. The test should close any file handles that would prevent the folder from being removed.

    • createTempFile

      public static Path createTempFile(String prefix, String suffix) throws IOException
      Creates an empty file with the given prefix and suffix.

      The file will be automatically removed after the test class completes successfully. The test should close any file handles that would prevent the folder from being removed.

      Throws:
      IOException

    • createTempFile

      public static Path createTempFile() throws IOException
      Creates an empty temporary file.
      Throws:
      IOException
      See Also:

    • runWithRestrictedPermissions

      public static <T> T runWithRestrictedPermissions(PrivilegedExceptionAction<T> action, Permission... permissions) throws Exception
      Runs a code part with restricted permissions (be sure to add all required permissions, because it would start with empty permissions). You cannot grant more permissions than our policy file allows, but you may restrict writing to several dirs...

      Note: This assumes a SecurityManager enabled, otherwise it stops test execution. If enabled, it needs the following SecurityPermission: "createAccessControlContext"

      Throws:
      Exception

    • collate

      public static int collate(Collator collator, String s1, String s2)
      Compares two strings with a collator, also looking to see if the the strings are impacted by jdk bugs. may not avoid all jdk bugs in tests. see https://bugs.openjdk.java.net/browse/JDK-8071862

    • ensureSaneIWCOnNightly

      protected static IndexWriterConfig ensureSaneIWCOnNightly(IndexWriterConfig conf)
      Ensures that the MergePolicy has sane values for tests that test with lots of documents.

    • newBytesRef

      public static BytesRef newBytesRef(String s)
      Creates a BytesRef holding UTF-8 bytes for the incoming String, that sometimes uses a non-zero offset, and non-zero end-padding, to tickle latent bugs that fail to look at BytesRef.offset.

    • newBytesRef

      public static BytesRef newBytesRef(BytesRef b)
      Creates a copy of the incoming BytesRef that sometimes uses a non-zero offset, and non-zero end-padding, to tickle latent bugs that fail to look at BytesRef.offset.

    • newBytesRef

      public static BytesRef newBytesRef(byte[] b)
      Creates a random BytesRef from the incoming bytes that sometimes uses a non-zero offset, and non-zero end-padding, to tickle latent bugs that fail to look at BytesRef.offset.

    • newBytesRef

      public static BytesRef newBytesRef()
      Creates a random empty BytesRef that sometimes uses a non-zero offset, and non-zero end-padding, to tickle latent bugs that fail to look at BytesRef.offset.

    • newBytesRef

      public static BytesRef newBytesRef(int byteLength)
      Creates a random empty BytesRef, with at least the requested length of bytes free, that sometimes uses a non-zero offset, and non-zero end-padding, to tickle latent bugs that fail to look at BytesRef.offset.

    • newBytesRef

      public static BytesRef newBytesRef(byte[] bytesIn, int offset, int length)
      Creates a copy of the incoming bytes slice that sometimes uses a non-zero offset, and non-zero end-padding, to tickle latent bugs that fail to look at BytesRef.offset.