Package org.apache.lucene.store

Class MockDirectoryWrapper

  • All Implemented Interfaces:
    Closeable, AutoCloseable
    public class MockDirectoryWrapper
extends Directory
    This is a Directory Wrapper that adds methods intended to be used only by unit tests. It also adds a number of features useful for testing:
    • Instances created by LuceneTestCase.newDirectory() are tracked to ensure they are closed by the test.
    • When a MockDirectoryWrapper is closed, it will throw an exception if it has any open files against it (with a stacktrace indicating where they were opened from).
    • When a MockDirectoryWrapper is closed, it runs CheckIndex to test if the index was corrupted.
    • MockDirectoryWrapper simulates some "features" of Windows, such as refusing to write/delete to open files.

    • Constructor Detail

      • MockDirectoryWrapper

        public MockDirectoryWrapper​(Random random,
                            Directory delegate)

    • Method Detail

      • getInputCloneCount

        public int getInputCloneCount()

      • setTrackDiskUsage

        public void setTrackDiskUsage​(boolean v)

      • setPreventDoubleWrite

        public void setPreventDoubleWrite​(boolean value)
        If set to true, we throw an IOException if the same file is opened by createOutput, ever.

      • sync

        @Deprecated
public void sync​(String name)
          throws IOException
        Deprecated.
        Description copied from class: Directory
        Ensure that any writes to this file are moved to stable storage. Lucene uses this to properly commit changes to the index, to prevent a machine/OS crash from corrupting the index.
        Overrides:
        sync in class Directory
        Throws:
        IOException

      • sync

        public void sync​(Collection<String> names)
          throws IOException
        Description copied from class: Directory
        Ensure that any writes to these files are moved to stable storage. Lucene uses this to properly commit changes to the index, to prevent a machine/OS crash from corrupting the index.

        NOTE: Clients may call this method for same files over and over again, so some impls might optimize for that. For other impls the operation can be a noop, for various reasons.
        Overrides:
        sync in class Directory
        Throws:
        IOException

      • crash

        public void crash()
           throws IOException
        Simulates a crash of OS or machine by overwriting unsynced files.
        Throws:
        IOException

      • setMaxSizeInBytes

        public void setMaxSizeInBytes​(long maxSize)

      • getMaxSizeInBytes

        public long getMaxSizeInBytes()

      • getMaxUsedSizeInBytes

        public long getMaxUsedSizeInBytes()
        Returns the peek actual storage used (bytes) in this directory.

      • setNoDeleteOpenFile

        public void setNoDeleteOpenFile​(boolean value)
        Emulate windows whereby deleting an open file is not allowed (raise IOException).

      • getNoDeleteOpenFile

        public boolean getNoDeleteOpenFile()

      • setCheckIndexOnClose

        public void setCheckIndexOnClose​(boolean value)
        Set whether or not checkindex should be run on close

      • getCheckIndexOnClose

        public boolean getCheckIndexOnClose()

      • setRandomIOExceptionRate

        public void setRandomIOExceptionRate​(double rate)
        If 0.0, no exceptions will be thrown. Else this should be a double 0.0 - 1.0. We will randomly throw an IOException on the first write to an OutputStream based on this probability.

      • getRandomIOExceptionRate

        public double getRandomIOExceptionRate()

      • getOpenDeletedFiles

        public Set<String> getOpenDeletedFiles()

      • setFailOnCreateOutput

        public void setFailOnCreateOutput​(boolean v)

      • setFailOnOpenInput

        public void setFailOnOpenInput​(boolean v)

      • getRecomputedSizeInBytes

        public final long getRecomputedSizeInBytes()
                                    throws IOException
        Provided for testing purposes. Use sizeInBytes() instead.
        Throws:
        IOException

      • getRecomputedActualSizeInBytes

        public final long getRecomputedActualSizeInBytes()
                                          throws IOException
        Like getRecomputedSizeInBytes(), but, uses actual file lengths rather than buffer allocations (which are quantized up to nearest RAMOutputStream.BUFFER_SIZE (now 1024) bytes.
        Throws:
        IOException

      • setAssertNoUnrefencedFilesOnClose

        public void setAssertNoUnrefencedFilesOnClose​(boolean v)

      • removeIndexOutput

        public void removeIndexOutput​(IndexOutput out,
                              String name)

      • removeIndexInput

        public void removeIndexInput​(IndexInput in,
                             String name)

      • isOpen

        public boolean isOpen()

      • failOn

        public void failOn​(MockDirectoryWrapper.Failure fail)
        add a Failure object to the list of objects to be evaluated at every potential failure point

      • fileLength

        public long fileLength​(String name)
                throws IOException
        Description copied from class: Directory
        Returns the length of a file in the directory. This method follows the following contract:
        • Throws FileNotFoundException if the file does not exist
        • Returns a value ≥0 if the file exists, which specifies its length.
        Specified by:
        fileLength in class Directory
        Parameters:
        name - the name of the file for which to return the length.
        Throws:
        FileNotFoundException - if the file does not exist.
        IOException - if there was an IO error while retrieving the file's length.

      • clearLock

        public void clearLock​(String name)
               throws IOException
        Description copied from class: Directory
        Attempt to clear (forcefully unlock and remove) the specified lock. Only call this at a time when you are certain this lock is no longer in use.
        Overrides:
        clearLock in class Directory
        Parameters:
        name - name of the lock to be cleared.
        Throws:
        IOException

      • setLockFactory

        public void setLockFactory​(LockFactory lockFactory)
                    throws IOException
        Description copied from class: Directory
        Set the LockFactory that this Directory instance should use for its locking implementation. Each * instance of LockFactory should only be used for one directory (ie, do not share a single instance across multiple Directories).
        Overrides:
        setLockFactory in class Directory
        Parameters:
        lockFactory - instance of LockFactory.
        Throws:
        IOException

      • getLockFactory

        public LockFactory getLockFactory()
        Description copied from class: Directory
        Get the LockFactory that this Directory instance is using for its locking implementation. Note that this may be null for Directory implementations that provide their own locking implementation.
        Overrides:
        getLockFactory in class Directory

      • getLockID

        public String getLockID()
        Description copied from class: Directory
        Return a string identifier that uniquely differentiates this Directory instance from other Directory instances. This ID should be the same if two Directory instances (even in different JVMs and/or on different machines) are considered "the same index". This is how locking "scopes" to the right index.
        Overrides:
        getLockID in class Directory

      • copy

        public void copy​(Directory to,
                 String src,
                 String dest)
          throws IOException
        Description copied from class: Directory
        Copies the file src to Directory to under the new file name dest.

        If you want to copy the entire source directory to the destination one, you can do so like this: 

         Directory to; // the directory to copy to
 for (String file : dir.listAll()) {
   dir.copy(to, file, newFile); // newFile can be either file, or a new name
 }

        NOTE: this method does not check whether dest exist and will overwrite it if it does.

        Overrides:
        copy in class Directory
        Throws:
        IOException