C# (CSharp) Lucene.Net.Index Namespace

Nested Namespaces

Lucene.Net.Index.Memory
Lucene.Net.Index.Sorter
Lucene.Net.Index.Store

Classes

Name Description
AssertingAtomicReader A FilterAtomicReader that can be used to apply additional checks for tests.
AssertingAtomicReader.AssertingBinaryDocValues Wraps a BinaryDocValues but with additional asserts
AssertingAtomicReader.AssertingBits Wraps a Bits but with additional asserts
AssertingAtomicReader.AssertingDocsAndPositionsEnum
AssertingAtomicReader.AssertingDocsEnum Wraps a docsenum with additional checks
AssertingAtomicReader.AssertingFields Wraps a Fields but with additional asserts
AssertingAtomicReader.AssertingNumericDocValues Wraps a NumericDocValues but with additional asserts
AssertingAtomicReader.AssertingSortedDocValues Wraps a SortedDocValues but with additional asserts
AssertingAtomicReader.AssertingSortedSetDocValues Wraps a SortedSetDocValues but with additional asserts
AssertingAtomicReader.AssertingTerms Wraps a Terms but with additional asserts
AssertingAtomicReader.AssertingTermsEnum
AssertingDirectoryReader A DirectoryReader that wraps all its subreaders with AssertingAtomicReader
AssertingDirectoryReader.AssertingSubReaderWrapper
AtomicReader {@code AtomicReader} is an abstract class, providing an interface for accessing an index. Search of an index is done entirely through this abstract interface, so that any subclass which implements it is searchable. IndexReaders implemented by this subclass do not consist of several sub-readers, they are atomic. They support retrieval of stored fields, doc values, terms, and postings.

For efficiency, in this API documents are often referred to via document numbers, non-negative integers which each name a unique document in the index. These document numbers are ephemeral -- they may change as documents are added to and deleted from an index. Clients should thus not rely on a given document having the same number between sessions.

NOTE: {@link IndexReader} instances are completely thread safe, meaning multiple threads can call any of its methods, concurrently. If your application requires external synchronization, you should not synchronize on the IndexReader instance; use your own (non-Lucene) objects instead.

BaseCompressingDocValuesFormatTestCase Extends BaseDocValuesFormatTestCase to add compression checks.
BaseDocValuesFormatTestCase Abstract class to do basic tests for a docvalues format. NOTE: this test focuses on the docvalues impl, nothing else. The [stretch] goal is for this test to be so thorough in testing a new DocValuesFormat that if this test passes, then all Lucene/Solr tests should also pass. Ie, if there is some bug in a given DocValuesFormat that this test fails to catch then this test needs to be improved!
BaseDocValuesFormatTestCase.LongProducer
BaseDocValuesFormatTestCase.LongProducerAnonymousInnerClassHelper
BaseDocValuesFormatTestCase.LongProducerAnonymousInnerClassHelper2
BaseDocValuesFormatTestCase.LongProducerAnonymousInnerClassHelper3
BaseDocValuesFormatTestCase.LongProducerAnonymousInnerClassHelper4
BaseDocValuesFormatTestCase.ThreadAnonymousInnerClassHelper
BaseDocValuesFormatTestCase.ThreadAnonymousInnerClassHelper2
BaseIndexFileFormatTestCase Common tests to all index formats.
BasePostingsFormatTestCase
BasePostingsFormatTestCase.FieldAndTerm
BasePostingsFormatTestCase.SeedPostings Given the same random seed this always enumerates the same random postings
BasePostingsFormatTestCase.TestThread
BasePostingsFormatTestCase.ThreadState
BaseStoredFieldsFormatTestCase Base class aiming at testing StoredFieldsFormat. To test a new format, all you need is to register a new Codec which uses it and extend this class and override #getCodec(). @lucene.experimental
BaseStoredFieldsFormatTestCase.ThreadAnonymousInnerClassHelper
BaseTermVectorsFormatTestCase Base class aiming at testing TermVectorsFormat. To test a new format, all you need is to register a new Codec which uses it and extend this class and override #getCodec(). @lucene.experimental
BaseTermVectorsFormatTestCase.OptionsWrapper
BaseTermVectorsFormatTestCase.PermissiveOffsetAttributeImpl
BaseTermVectorsFormatTestCase.RandomDocument
BaseTermVectorsFormatTestCase.RandomDocumentFactory
BaseTermVectorsFormatTestCase.RandomTokenStream
BaseTermVectorsFormatTestCase.ThreadAnonymousInnerClassHelper
BinaryDocValuesWriter Buffers up pending byte[] per doc, then flushes when segment flushes.
BufferedUpdates
CheckIndex Basic tool and API to check the health of an index and write a new segments file that removes reference to problematic segments.

As this tool checks every byte in the index, on a large index it can take quite a long time to run.

WARNING: this tool and API is new and experimental and is subject to suddenly change in the next release. Please make a complete backup of your index before using this to fix your index!

CheckIndex.MySegmentTermDocs
CheckIndex.Status Returned from {@link #CheckIndex()} detailing the health and status of the index.

WARNING: this API is new and experimental and is subject to suddenly change in the next release.

CheckIndex.Status.FieldNormStatus Status from testing field norms.
CheckIndex.Status.SegmentInfoStatus Holds the status of each segment in the index. See SegmentInfos.

WARNING: this API is new and experimental and is subject to suddenly change in the next release.

CheckIndex.Status.StoredFieldStatus Status from testing stored fields.
CheckIndex.Status.TermIndexStatus Status from testing term index.
CheckIndex.Status.TermVectorStatus Status from testing stored fields.
CompoundFileExtractor Command-line tool for extracting sub-files out of a compound file.
ConcurrentMergeScheduler A {@link MergeScheduler} that runs each merge using a separate thread, up until a maximum number of threads ({@link #setMaxThreadCount}) at which points merges are run in the foreground, serially. This is a simple way to use concurrency in the indexing process without having to create and manage application level threads.
ConcurrentMergeScheduler.MergeThread
CorruptIndexException
DirectoryReader An IndexReader which reads indexes with multiple segments.
DirectoryReader.AnonymousClassFindSegmentsFile
DirectoryReader.AnonymousClassFindSegmentsFile1
DirectoryReader.AnonymousFindSegmentsFile
DirectoryReader.MultiTermDocs
DirectoryReader.MultiTermEnum
DirectoryReader.MultiTermPositions
DirectoryReader.ReaderCommit
DocHelper
DocTermOrds
DocTermOrds.Iterator
DocTermOrds.OrdWrappedTermsEnum
DocTest
DocValuesProcessor
DocValuesUpdate An in-place update to a DocValues field.
DocValuesUpdate.BinaryDocValuesUpdate An in-place update to a binary DocValues field
DocValuesUpdate.NumericDocValuesUpdate An in-place update to a numeric DocValues field
DocumentsWriter
DocumentsWriter.AnonymousClassIndexingChain
DocumentsWriter.ByteBlockAllocator
DocumentsWriter.DocState
DocumentsWriter.DocWriter Consumer returns this on each doc. This holds any state that must be flushed synchronized "in docID order". We gather these and flush them in order.
DocumentsWriter.IndexingChain The IndexingChain must define the GetChain(DocumentsWriter) method which returns the DocConsumer that the DocumentsWriter calls to process the documents.
DocumentsWriter.PerDocBuffer
DocumentsWriter.SkipDocWriter
DocumentsWriter.WaitQueue
DocumentsWriterDeleteQueue DocumentsWriterDeleteQueue is a non-blocking linked pending deletes queue. In contrast to other queue implementation we only maintain the tail of the queue. A delete queue is always used in a context of a set of DWPTs and a global delete pool. Each of the DWPT and the global pool need to maintain their 'own' head of the queue (as a DeleteSlice instance per DWPT). The difference between the DWPT and the global pool is that the DWPT starts maintaining a head once it has added its first document since for its segments private deletes only the deletes after that document are relevant. The global pool instead starts maintaining the head once this instance is created by taking the sentinel instance as its initial head.

Since each DeleteSlice maintains its own head and the list is only single linked the garbage collector takes care of pruning the list for us. All nodes in the list that are still relevant should be either directly or indirectly referenced by one of the DWPT's private DeleteSlice or by the global BufferedUpdates slice.

Each DWPT as well as the global delete pool maintain their private DeleteSlice instance. In the DWPT case updating a slice is equivalent to atomically finishing the document. The slice update guarantees a "happens before" relationship to all other updates in the same indexing session. When a DWPT updates a document it:

  1. consumes a document and finishes its processing
  2. updates its private DeleteSlice either by calling #updateSlice(DeleteSlice) or #add(Term, DeleteSlice) (if the document has a delTerm)
  3. applies all deletes in the slice to its private BufferedUpdates and resets it
  4. increments its internal document id
The DWPT also doesn't apply its current documents delete term until it has updated its delete slice which ensures the consistency of the update. If the update fails before the DeleteSlice could have been updated the deleteTerm will also not be added to its private deletes neither to the global deletes.
DocumentsWriterDeleteQueue.BinaryUpdateNode
DocumentsWriterDeleteQueue.DeleteSlice
DocumentsWriterDeleteQueue.Node
DocumentsWriterDeleteQueue.NumericUpdateNode
DocumentsWriterDeleteQueue.QueryArrayNode
DocumentsWriterDeleteQueue.TermArrayNode
DocumentsWriterDeleteQueue.TermNode
DocumentsWriterStallControl Controls the health status of a DocumentsWriter sessions. this class used to block incoming indexing threads if flushing significantly slower than indexing to ensure the DocumentsWriters healthiness. If flushing is significantly slower than indexing the net memory used within an IndexWriter session can increase very quickly and easily exceed the JVM's available memory.

To prevent OOM Errors and ensure IndexWriter's stability this class blocks incoming threads from indexing once 2 x number of available ThreadStates in DocumentsWriterPerThreadPool is exceeded. Once flushing catches up and the number of flushing DWPT is equal or lower than the number of active ThreadStates threads are released and can continue indexing.

FilterAtomicReader A FilterAtomicReader contains another AtomicReader, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality. The class FilterAtomicReader itself simply implements all abstract methods of IndexReader with versions that pass all requests to the contained index reader. Subclasses of FilterAtomicReader may further override some of these methods and may also provide additional methods and fields.

NOTE: If you override #getLiveDocs(), you will likely need to override #numDocs() as well and vice-versa.

NOTE: If this FilterAtomicReader does not change the content the contained reader, you could consider overriding #getCoreCacheKey() so that IFieldCache and CachingWrapperFilter share the same entries for this atomic reader and the wrapped one. #getCombinedCoreAndDeletesKey() could be overridden as well if the #getLiveDocs() live docs are not changed either.

FilterAtomicReader.FilterDocsAndPositionsEnum Base class for filtering DocsAndPositionsEnum implementations.
FilterAtomicReader.FilterDocsEnum Base class for filtering DocsEnum implementations.
FilterAtomicReader.FilterFields Base class for filtering Fields implementations.
FilterAtomicReader.FilterTerms Base class for filtering Terms implementations.

NOTE: If the order of terms and documents is not changed, and if these terms are going to be intersected with automata, you could consider overriding #intersect for better performance.

FilterAtomicReader.FilterTermsEnum Base class for filtering TermsEnum implementations.
IndexCommit

Expert: represents a single commit into an index as seen by the {@link IndexDeletionPolicy} or {@link IndexReader}.

Changes to the content of an index are made visible only after the writer who made that change commits by writing a new segments file (segments_N). This point in time, when the action of writing of a new segments file to the directory is completed, is an index commit.

Each index commit point has a unique segments file associated with it. The segments file associated with a later index commit point would have a larger N.

WARNING: This API is a new and experimental and may suddenly change.

IndexFileNames this class contains useful constants representing filenames and extensions used by lucene, as well as convenience methods for querying whether a file name matches an extension ({@link #matchesExtension(String, String) matchesExtension}), as well as generating file names from a segment name, generation and extension ( #fileNameFromGeneration(String, String, long) fileNameFromGeneration, #segmentFileName(String, String, String) segmentFileName).

NOTE: extensions used by codecs are not listed here. You must interact with the Codec directly. @lucene.internal

IndexReader IndexReader is an abstract class, providing an interface for accessing an index. Search of an index is done entirely through this abstract interface, so that any subclass which implements it is searchable.

There are two different types of IndexReaders:

  • AtomicReader: These indexes do not consist of several sub-readers, they are atomic. They support retrieval of stored fields, doc values, terms, and postings.
  • CompositeReader: Instances (like DirectoryReader) of this reader can only be used to get stored fields from the underlying AtomicReaders, but it is not possible to directly retrieve postings. To do that, get the sub-readers via CompositeReader#getSequentialSubReaders. Alternatively, you can mimic an AtomicReader (with a serious slowdown), by wrapping composite readers with SlowCompositeReaderWrapper.

IndexReader instances for indexes on disk are usually constructed with a call to one of the static DirectoryReader.open() methods, e.g. DirectoryReader#open(Lucene.Net.Store.Directory). DirectoryReader implements the CompositeReader interface, it is not possible to directly get postings.

For efficiency, in this API documents are often referred to via document numbers, non-negative integers which each name a unique document in the index. These document numbers are ephemeral -- they may change as documents are added to and deleted from an index. Clients should thus not rely on a given document having the same number between sessions.

NOTE: {@link IndexReader} instances are completely thread safe, meaning multiple threads can call any of its methods, concurrently. If your application requires external synchronization, you should not synchronize on the IndexReader instance; use your own (non-Lucene) objects instead.

IndexReader.AnonymousClassFindSegmentsFile
IndexReader.FieldOption Constants describing field properties, for example used for {@link IndexReader#GetFieldNames(FieldOption)}.
IndexSplitter Command-line tool that enables listing segments in an index, copying specific segments to another index, and deleting segments from an index.

This tool does file-level copying of segments files. This means it's unable to split apart a single segment into multiple segments. For example if your index is a single segment, this tool won't help. Also, it does basic file-level copying (using simple FileInfo) so it will not work with non FSDirectory Directory impls.

@lucene.experimental You can easily accidentally remove segments from your index so be careful!
IndexUpgrader this is an easy-to-use tool that upgrades all segments of an index from previous Lucene versions to the current segment file format. It can be used from command line:
 java -cp lucene-core.jar Lucene.Net.Index.IndexUpgrader [-delete-prior-commits] [-verbose] indexDir 
Alternatively this class can be instantiated and #upgrade invoked. It uses UpgradeIndexMergePolicy and triggers the upgrade via an forceMerge request to IndexWriter.

this tool keeps only the last commit in an index; for this reason, if the incoming index has more than one commit, the tool refuses to run by default. Specify {@code -delete-prior-commits} to override this, allowing the tool to delete all but the last commit. From Java code this can be enabled by passing {@code true} to #IndexUpgrader(Directory,Version,StreamWriter,boolean).

Warning: this tool may reorder documents if the index was partially upgraded before execution (e.g., documents were added). If your application relies on "monotonicity" of doc IDs (which means that the order in which the documents were added to the index is preserved), do a full forceMerge instead. The MergePolicy set by IndexWriterConfig may also reorder documents.

IndexWriter An IndexWriter creates and maintains an index. The third argument to the constructor determines whether a new index is created, or whether an existing index is opened for the addition of new documents. In either case, documents are added with the addDocument method. When finished adding documents, close should be called.

If an index will not have more documents added for a while and optimal search performance is desired, then the optimize method should be called before the index is closed.

IndexWriter.IndexReaderWarmer If DirectoryReader#open(IndexWriter,boolean) has been called (ie, this writer is in near real-time mode), then after a merge completes, this class can be invoked to warm the reader on the newly merged segment, before the merge commits. this is not required for near real-time search, but will reduce search latency on opening a new near real-time reader after a merge completes. @lucene.experimental

NOTE: warm is called before any deletes have been carried over to the merged segment.

IndexWriter.MaxFieldLength
IndexWriter.MergedDeletesAndUpdates
IndexWriter.ReaderPool Holds shared SegmentReader instances. IndexWriter uses SegmentReaders for 1) applying deletes, 2) doing merges, 3) handing out a real-time reader. this pool reuses instances of the SegmentReaders in all these places if it is in "near real-time mode" (getReader() has been called on this instance).
IndexWriterConfig Holds all the configuration that is used to create an IndexWriter. Once IndexWriter has been created with this object, changes to this object will not affect the IndexWriter instance. For that, use LiveIndexWriterConfig that is returned from IndexWriter#getConfig().

All setter methods return IndexWriterConfig to allow chaining settings conveniently, for example:

 IndexWriterConfig conf = new IndexWriterConfig(analyzer); conf.setter1().setter2(); 
LiveIndexWriterConfig Holds all the configuration used by IndexWriter with few setters for settings that can be changed on an IndexWriter instance "live". @since 4.0
LogByteSizeMergePolicy this is a LogMergePolicy that measures size of a segment as the total byte size of the segment's files.
LogMergePolicy

This class implements a {@link MergePolicy} that tries to merge segments into levels of exponentially increasing size, where each level has < mergeFactor segments in it. Whenever a given levle has mergeFactor segments or more in it, they will be merged.

This class is abstract and requires a subclass to define the {@link #size} method which specifies how a segment's size is determined. {@link LogDocMergePolicy} is one subclass that measures size by document count in the segment. {@link LogByteSizeMergePolicy} is another subclass that measures size as the total byte size of the file(s) for the segment.

MergePolicy

Expert: a MergePolicy determines the sequence of primitive merge operations to be used for overall merge and optimize operations.

Whenever the segments in an index have been altered by {@link IndexWriter}, either the addition of a newly flushed segment, addition of many segments from addIndexes* calls, or a previous merge that may now need to cascade, {@link IndexWriter} invokes {@link #findMerges} to give the MergePolicy a chance to pick merges that are now required. This method returns a {@link MergeSpecification} instance describing the set of merges that should be done, or null if no merges are necessary. When IndexWriter.optimize is called, it calls {@link #findMergesForOptimize} and the MergePolicy should then return the necessary merges.

Note that the policy can return more than one merge at a time. In this case, if the writer is using {@link SerialMergeScheduler}, the merges will be run sequentially but if it is using {@link ConcurrentMergeScheduler} they will be run concurrently.

The default MergePolicy is {@link LogByteSizeMergePolicy}.

NOTE: This API is new and still experimental (subject to change suddenly in the next release)

MergePolicy.DocMap A map of doc IDs.
MergePolicy.MergeAbortedException
MergePolicy.MergeException
MergePolicy.MergeSpecification A MergeSpecification instance provides the information necessary to perform multiple merges. It simply contains a list of {@link OneMerge} instances.
MergePolicy.OneMerge OneMerge provides the information necessary to perform an individual primitive merge operation, resulting in a single new segment. The merge spec includes the subset of segments to be merged as well as whether the new segment should use the compound file format.
MergePolicy.OneMerge.DocMapAnonymousInnerClassHelper
MockIndexInput IndexInput backed by a byte[] for testing.
MockInputStream
PKIndexSplitter Split an index based on a Filter.
PKIndexSplitter.DocumentFilteredAtomicIndexReader
ParallelReader An IndexReader which reads multiple, parallel indexes. Each index added must have the same number of documents, but typically each contains different fields. Each document contains the union of the fields of all documents with the same document number. When searching, matches for a query term are from the first index added that has the field.

This is useful, e.g., with collections that have large fields which change rarely and small fields that change more frequently. The smaller fields may be re-indexed in a new index and both indexes may be searched together.

Warning: It is up to you to make sure all indexes are created and modified the same way. For example, if you add documents to one index, you need to add the same documents in the same order to the other indexes. Failure to do so will result in undefined behavior.

ParallelReader.ParallelTermDocs
ParallelReader.ParallelTermEnum
ParallelReader.ParallelTermPositions
Payload
ReadersAndUpdates
RepeatingTokenStream
RepeatingTokenizer
SegmentInfo Information about a segment such as it's name, directory, and files related to the segment. *

NOTE: This API is new and still experimental (subject to change suddenly in the next release)

SegmentInfos
SegmentInfos.FindSegmentsFile Utility class for executing code that needs to do something with the current segments file. This is necessary with lock-less commits because from the time you locate the current segments file name, until you actually open it, read its contents, or check modified time, etc., it could have been deleted due to a writer commit finishing.
SegmentInfos.FindSegmentsFileAnonymousInnerClassHelper
SegmentMerger The SegmentMerger class combines two or more Segments, represented by an IndexReader, into a single Segment. Call the merge method to combine the segments.
SegmentMerger.AnonymousClassCheckAbort
SegmentMerger.AnonymousClassCheckAbort1
SegmentMerger.CheckAbort
SimpleMergedSegmentWarmer A very simple merged segment warmer that just ensures data structures are initialized.
SortedDocValuesWriter Buffers up pending byte[] per doc, deref and sorting via int ord, then flushes when segment flushes.
SortedSetDocValuesWriter Buffers up pending byte[]s per doc, deref and sorting via int ord, then flushes when segment flushes.
StandardDirectoryReader
StandardDirectoryReader.FindSegmentsFileAnonymousInnerClassHelper
StandardDirectoryReader.FindSegmentsFileAnonymousInnerClassHelper2
StandardDirectoryReader.ReaderCommit
StoredFieldsProcessor this is a StoredFieldsConsumer that writes stored fields.
TermContext Maintains a IndexReader TermState view over IndexReader instances containing a single term. The TermContext doesn't track if the given TermState objects are valid, neither if the TermState instances refer to the same terms in the associated readers. @lucene.experimental
TermInfosTest
TermVectorsConsumerPerField
TermVectorsConsumerPerField.TermVectorsPostingsArray
Test2BBinaryDocValues
Test2BDocs
Test2BPostings
Test2BPostings.MyTokenStream
Test2BPostingsBytes
Test2BPostingsBytes.MyTokenStream
Test2BSortedDocValues
TestAddIndexes
TestAddIndexes.CommitAndAddIndexes
TestAddIndexes.CommitAndAddIndexes2
TestAddIndexes.CommitAndAddIndexes3
TestAddIndexes.CustomPerFieldCodec
TestAddIndexes.RunAddIndexesThreads
TestAddIndexes.RunAddIndexesThreads.ThreadAnonymousInnerClassHelper
TestAddIndexes.UnRegisteredCodec
TestAddIndexesNoOptimize
TestAtomicUpdate
TestAtomicUpdate.IndexerThread
TestAtomicUpdate.MockIndexWriter
TestAtomicUpdate.SearcherThread
TestAtomicUpdate.TimedThread
TestBackwardsCompatibility
TestBackwardsCompatibility.AnonymousFieldSelector
TestBagOfPositions
TestBagOfPositions.ThreadAnonymousInnerClassHelper
TestBagOfPostings
TestBagOfPostings.ThreadAnonymousInnerClassHelper
TestBinaryDocValuesUpdates
TestBinaryDocValuesUpdates.Lucene46CodecAnonymousInnerClassHelper
TestBinaryDocValuesUpdates.Lucene46CodecAnonymousInnerClassHelper2
TestBinaryDocValuesUpdates.Lucene46CodecAnonymousInnerClassHelper3
TestBinaryDocValuesUpdates.ThreadAnonymousInnerClassHelper
TestBinaryTerms
TestByteSlices
TestByteSlices.ByteBlockAllocator
TestCheckIndex
TestCodecHoldsOpenFiles
TestCompoundFile
TestConcurrentMergeScheduler
TestConcurrentMergeScheduler.ConcurrentMergeSchedulerAnonymousInnerClassHelper
TestConcurrentMergeScheduler.FailOnlyOnFlush
TestConcurrentMergeScheduler.TrackingCMS
TestConsistentFieldNumbers
TestCrash
TestCrashCausesCorruptIndex
TestCrashCausesCorruptIndex.CrashAfterCreateOutput this test class provides direct access to "simulating" a crash right after realDirectory.CreateOutput(..) has been called on a certain specified name.
TestCrashCausesCorruptIndex.CrashingException The marker RuntimeException that we use in lieu of an actual machine crash.
TestCustomNorms
TestCustomNorms.FloatEncodingBoostSimilarity
TestCustomNorms.MySimProvider
TestDirectoryReader
TestDirectoryReader.IncThread
TestDirectoryReader.ReaderClosedListenerAnonymousInnerClassHelper
TestDoc
TestDocInverterPerFieldErrorInfo
TestDocInverterPerFieldErrorInfo.BadNews
TestDocInverterPerFieldErrorInfo.ThrowingAnalyzer
TestDocInverterPerFieldErrorInfo.ThrowingAnalyzer.TokenFilterAnonymousInnerClassHelper
TestDocValuesFormat
TestDocValuesIndexing
TestDocValuesIndexing.ThreadAnonymousInnerClassHelper
TestDocValuesWithThreads
TestDocValuesWithThreads.ThreadAnonymousInnerClassHelper
TestDocValuesWithThreads.ThreadAnonymousInnerClassHelper2
TestDocsAndPositions
TestDocumentWriter
TestDocumentWriter.AnalyzerAnonymousInnerClassHelper
TestDocumentWriter.AnalyzerAnonymousInnerClassHelper2
TestDocumentWriter.AnalyzerAnonymousInnerClassHelper2.TokenFilterAnonymousInnerClassHelper
TestDocumentWriter.AnonymousClassAnalyzer
TestDocumentWriter.AnonymousClassAnalyzer1
TestDocumentWriter.AnonymousClassAnalyzer1.AnonymousClassTokenFilter
TestDocumentWriter.AnonymousClassTokenStream
TestDocumentWriter.TokenStreamAnonymousInnerClassHelper
TestDocumentsWriterDeleteQueue
TestDocumentsWriterDeleteQueue.ThreadAnonymousInnerClassHelper
TestDocumentsWriterDeleteQueue.UpdateThread
TestDocumentsWriterStallControl
TestDocumentsWriterStallControl.Synchronizer
TestDocumentsWriterStallControl.ThreadAnonymousInnerClassHelper
TestDocumentsWriterStallControl.ThreadAnonymousInnerClassHelper2
TestDocumentsWriterStallControl.Updater
TestDocumentsWriterStallControl.Waiter
TestDuelingCodecs
TestFieldInfos
TestFieldsReader
TestFieldsReader.AnonymousClassFieldSelector
TestFieldsReader.FaultyFSDirectory
TestFieldsReader.FaultyIndexInput
TestFilterAtomicReader
TestFilterAtomicReader.TestReader
TestFilterAtomicReader.TestReader.TestFields Filter that only permits terms containing 'e'.
TestFilterAtomicReader.TestReader.TestPositions Filter that only returns odd numbered documents.
TestFilterAtomicReader.TestReader.TestTerms
TestFilterAtomicReader.TestReader.TestTermsEnum
TestFilterIndexReader
TestFilterIndexReader.TestReader
TestFilterIndexReader.TestReader.TestTermEnum Filter that only permits terms containing 'e'.
TestFilterIndexReader.TestReader.TestTermPositions Filter that only returns odd numbered documents.
TestFlushByRamOrCountsPolicy
TestFlushByRamOrCountsPolicy.IndexThread
TestFlushByRamOrCountsPolicy.MockDefaultFlushPolicy
TestIndexCommit
TestIndexCommit.IndexCommitFirst
TestIndexCommit.IndexCommitSecond
TestIndexFileDeleter
TestIndexReader
TestIndexReaderClone
TestIndexReaderCloneNorms
TestIndexReaderCloneNorms.SimilarityOne
TestIndexReaderClose
TestIndexReaderClose.CountListener
TestIndexReaderClose.FaultyListener
TestIndexReaderClose.FilterAtomicReaderAnonymousInnerClassHelper
TestIndexSplitter
TestIndexWriter
TestIndexWriterCommit
TestIndexWriterCommit.AnalyzerAnonymousInnerClassHelper
TestIndexWriterCommit.AnalyzerAnonymousInnerClassHelper2
TestIndexWriterCommit.ThreadAnonymousInnerClassHelper
TestIndexWriterConfig
TestIndexWriterConfig.MyIndexingChain
TestIndexWriterDelete
TestIndexWriterDelete.AnalyzerAnonymousInnerClassHelper
TestIndexWriterDelete.AnonymousClassFailure
TestIndexWriterDelete.AnonymousClassFailure1
TestIndexWriterDelete.FailureAnonymousInnerClassHelper
TestIndexWriterDelete.FailureAnonymousInnerClassHelper2
TestIndexWriterDelete.IndexWriterAnonymousInnerClassHelper
TestIndexWriterDelete.ThreadAnonymousInnerClassHelper
TestIndexWriterExceptions
TestIndexWriterExceptions.IndexerThread
TestIndexWriterExceptions.MockIndexWriter
TestIndexWriterForceMerge
TestIndexWriterLockRelease
TestIndexWriterMergePolicy
TestIndexWriterReader
TestIndexWriterReader.AddDirectoriesThreads
TestIndexWriterReader.AddDirectoriesThreads.AnonymousClassThread2
TestIndexWriterReader.AddDirectoriesThreads.ThreadAnonymousInnerClassHelper
TestIndexWriterReader.AnonymousClassThread
TestIndexWriterReader.AnonymousClassThread1
TestIndexWriterReader.AnonymousIndexReaderWarmer
TestIndexWriterReader.DeleteThreads
TestIndexWriterReader.DeleteThreads.AnonymousClassThread2
TestIndexWriterReader.FailureAnonymousInnerClassHelper
TestIndexWriterReader.HeavyAtomicInt
TestIndexWriterReader.IndexReaderWarmerAnonymousInnerClassHelper
TestIndexWriterReader.InfoStreamAnonymousInnerClassHelper
TestIndexWriterReader.MyWarmer
TestIndexWriterReader.ThreadAnonymousInnerClassHelper
TestIndexWriterReader.ThreadAnonymousInnerClassHelper2
TestIndexWriterUnicode
TestIndexWriterWithThreads
TestIndexWriterWithThreads.DelayedIndexAndCloseRunnable
TestIndexWriterWithThreads.FailOnlyInWriteSegment
TestIndexWriterWithThreads.FailOnlyOnAbortOrFlush
TestIndexWriterWithThreads.IndexerThread
TestIndexWriterWithThreads.ThreadAnonymousInnerClassHelper
TestInputStream
TestIsCurrent
TestLazyBug
TestLazyBug.AnonymousClassFieldSelector
TestLazyProxSkipping
TestLazyProxSkipping.SeekCountingDirectory
TestLazyProxSkipping.SeeksCountingStream
TestLogMergePolicy
TestLongPostings
TestMultiDocValues
TestMultiLevelSkipList
TestMultiLevelSkipList.CountingRAMDirectory
TestMultiLevelSkipList.CountingStream
TestMultiLevelSkipList.PayloadAnalyzer
TestMultiLevelSkipList.PayloadFilter
TestMultiPassIndexSplitter
TestMultiReader
TestNRTReaderWithThreads
TestNRTReaderWithThreads.RunThread
TestNRTThreads
TestNeverDelete
TestNeverDelete.ThreadAnonymousInnerClassHelper
TestNoDeletionPolicy
TestNoMergePolicy
TestNorms
TestNorms.SimilarityOne
TestNumericDocValuesUpdates
TestNumericDocValuesUpdates.Lucene46CodecAnonymousInnerClassHelper
TestNumericDocValuesUpdates.Lucene46CodecAnonymousInnerClassHelper2
TestNumericDocValuesUpdates.Lucene46CodecAnonymousInnerClassHelper3
TestNumericDocValuesUpdates.ThreadAnonymousInnerClassHelper
TestOmitTf
TestOmitTf.AnonymousClassCountingHitCollector
TestOmitTf.AnonymousClassCountingHitCollector1
TestOmitTf.AnonymousClassCountingHitCollector2
TestOmitTf.AnonymousClassCountingHitCollector3
TestOmitTf.AnonymousClassCountingHitCollector4
TestOmitTf.AnonymousIDFExplanation
TestOmitTf.CountingHitCollector
TestOmitTf.SimpleSimilarity
TestPKIndexSplitter
TestParallelCompositeReader
TestParallelCompositeReader.ReaderClosedListenerAnonymousInnerClassHelper
TestParallelCompositeReader.ReaderClosedListenerAnonymousInnerClassHelper2
TestParallelReader
TestParallelTermEnum
TestPayloads
TestPayloads.AnonymousClassThread
TestPayloads.ByteArrayPool
TestPayloads.PayloadAnalyzer this Analyzer uses an WhitespaceTokenizer and PayloadFilter.
TestPayloads.PayloadAnalyzer.PayloadData
TestPayloads.PayloadFilter this Filter adds payloads to the tokens.
TestPayloads.PoolingPayloadTokenStream
TestPayloads.ThreadAnonymousInnerClassHelper
TestPayloadsOnVectors
TestPerSegmentDeletes
TestPerSegmentDeletes.RangeMergePolicy
TestPersistentSnapshotDeletionPolicy
TestPersistentSnapshotDeletionPolicy.FailureAnonymousInnerClassHelper
TestPositionBasedTermVectorMapper
TestPostingsOffsets
TestRollback
TestRollingUpdates
TestRollingUpdates.IndexingThread
TestSegmentMerger
TestSegmentReader
TestSegmentTermDocs
TestSegmentTermEnum
TestSizeBoundedForceMerge
TestSnapshotDeletionPolicy
TestSnapshotDeletionPolicy.AnonymousClassThread
TestSnapshotDeletionPolicy.ThreadAnonymousInnerClassHelper
TestSnapshotDeletionPolicy.ThreadAnonymousInnerClassHelper2
TestStoredFieldsFormat
TestStressAdvance
TestStressIndexing
TestStressIndexing.IndexerThread
TestStressIndexing.SearcherThread
TestStressIndexing.TimedThread
TestStressIndexing2
TestStressIndexing2.AnonymousClassComparator
TestStressIndexing2.DocsAndWriter
TestStressIndexing2.IndexingThread
TestStressIndexing2.MockIndexWriter
TestStressNRT
TestStressNRT.ThreadAnonymousInnerClassHelper
TestStressNRT.ThreadAnonymousInnerClassHelper2
TestSumDocFreq
TestTerm
TestTermVectorsFormat
TestTermVectorsReader
TestTermVectorsWriter
TestTermdocPerf
TestTermdocPerf.AnalyzerAnonymousInnerClassHelper
TestTermdocPerf.AnonymousClassAnalyzer
TestTermsEnum
TestTermsEnum.TermAndState
TestThreadedForceMerge
TestThreadedForceMerge.ThreadAnonymousInnerClassHelper
TestThreadedOptimize
TestThreadedOptimize.AnonymousClassThread
TestTransactions
TestTransactions.IndexerThread
TestTransactions.RandomFailure
TestTransactions.SearcherThread
TestTransactions.TimedThread
TestUniqueTermCount Tests the uniqueTermCount statistic in FieldInvertState
TestUniqueTermCount.TestSimilarity
TestWordlistLoader
ThreadedIndexingAndSearchingTestCase Utility class that spawns multiple indexing and searching threads.
ThreadedIndexingAndSearchingTestCase.IndexReaderWarmerAnonymousInnerClassHelper
ThreadedIndexingAndSearchingTestCase.PrintStreamInfoStreamAnonymousInnerClassHelper
ThreadedIndexingAndSearchingTestCase.SubDocs
ThreadedIndexingAndSearchingTestCase.ThreadAnonymousInnerClassHelper
ThreadedIndexingAndSearchingTestCase.ThreadAnonymousInnerClassHelper2