Package org.apache.lucene.tests.index

Class BaseCompoundFormatTestCase

  • public abstract class BaseCompoundFormatTestCase
extends LuceneTestCase
    Abstract class to do basic tests for a compound format. NOTE: This test focuses on the compound impl, nothing else. The [stretch] goal is for this test to be so thorough in testing a new CompoundFormat that if this test passes, then all Lucene/Solr tests should also pass. Ie, if there is some bug in a given CompoundFormat that this test fails to catch then this test needs to be improved!

    • Constructor Detail

      • BaseCompoundFormatTestCase

        public BaseCompoundFormatTestCase()

    • Method Detail

      • testSingleFile

        public void testSingleFile()
                    throws IOException
        This test creates compound file based on a single file. Files of different sizes are tested: 0, 1, 10, 100 bytes.
        Throws:
        IOException

      • testTwoFiles

        public void testTwoFiles()
                  throws IOException
        This test creates compound file based on two files.
        Throws:
        IOException

      • testRandomFiles

        public void testRandomFiles()
                     throws IOException
        This test creates a compound file based on a large number of files of various length. The file content is generated randomly. The sizes range from 0 to 1Mb. Some of the sizes are selected to test the buffering logic in the file reading code. For this the chunk variable is set to the length of the buffer used internally by the compound file logic.
        Throws:
        IOException

      • testRandomAccess

        public void testRandomAccess()
                      throws IOException
        This test opens two files from a compound stream and verifies that their file positions are independent of each other.
        Throws:
        IOException

      • testRandomAccessClones

        public void testRandomAccessClones()
                            throws IOException
        This test opens two files from a compound stream and verifies that their file positions are independent of each other.
        Throws:
        IOException

      • createRandomFile

        protected static void createRandomFile​(Directory dir,
                                       String name,
                                       int size,
                                       byte[] segId)
                                throws IOException
        Creates a file of the specified size with random data.
        Throws:
        IOException

      • createSequenceFile

        protected static void createSequenceFile​(Directory dir,
                                         String name,
                                         byte start,
                                         int size,
                                         byte[] segID,
                                         String segSuffix)
                                  throws IOException
        Creates a file of the specified size with sequential data. The first byte is written as the start byte provided. All subsequent bytes are computed as start + offset where offset is the number of the byte.
        Throws:
        IOException

      • assertEqualArrays

        protected static void assertEqualArrays​(String msg,
                                        byte[] expected,
                                        byte[] test,
                                        int start,
                                        int len)

      • createLargeCFS

        protected static Directory createLargeCFS​(Directory dir)
                                   throws IOException
        Setup a large compound file with a number of components, each of which is a sequential file (so that we can easily tell that we are reading in the right byte). The methods sets up 20 files - _123.0 to _123.19, the size of each file is 1000 bytes.
        Throws:
        IOException

      • addRandomFields

        protected void addRandomFields​(Document doc)
        Add random fields to the provided document.

      • testMergeStability

        public void testMergeStability()
                        throws Exception
        The purpose of this test is to make sure that bulk merge doesn't accumulate useless data over runs.
        Throws:
        Exception

      • testResourceNameInsideCompoundFile

        public void testResourceNameInsideCompoundFile()
                                        throws Exception
        Throws:
        Exception

      • testMissingCodecHeadersAreCaught

        public void testMissingCodecHeadersAreCaught()
                                      throws Exception
        Throws:
        Exception

      • testCorruptFilesAreCaught

        public void testCorruptFilesAreCaught()
                               throws Exception
        Throws:
        Exception

      • getCodec

        protected abstract Codec getCodec()
        Returns the codec to run tests against

      • getCreatedVersionMajor

        protected int getCreatedVersionMajor()
        Returns the major version that this codec is compatible with.

      • applyCreatedVersionMajor

        protected final <D extends Directory> D applyCreatedVersionMajor​(D d)
                                                          throws IOException
        Set the created version of the given Directory and return it.
        Throws:
        IOException

      • excludedExtensionsFromByteCounts

        protected Collection<String> excludedExtensionsFromByteCounts()
        Return the list of extensions that should be excluded from byte counts when comparing indices that store the same content.

      • mergeIsStable

        protected boolean mergeIsStable()

      • testMultiClose

        public void testMultiClose()
                    throws IOException
        Calls close multiple times on closeable codec apis
        Throws:
        IOException

      • testRandomExceptions

        public void testRandomExceptions()
                          throws Exception
        Tests exception handling on write and openInput/createOutput
        Throws:
        Exception

      • shouldTestMergeInstance

        protected boolean shouldTestMergeInstance()
        Returns false if only the regular fields reader should be tested, and true if only the merge instance should be tested.

      • testCheckIntegrityReadsAllBytes

        public void testCheckIntegrityReadsAllBytes()
                                     throws Exception
        This test is a best effort at verifying that checkIntegrity doesn't miss any files. It tests that the combination of opening a reader and calling checkIntegrity on it reads all bytes of all files.
        Throws:
        Exception