org.apache.lucene.store

## Class MockDirectoryWrapper

- java.lang.Object
- - org.apache.lucene.store.Directory
  - - org.apache.lucene.store.BaseDirectoryWrapper
    - - org.apache.lucene.store.MockDirectoryWrapper

- All Implemented Interfaces:
    Closeable, AutoCloseable

      public class MockDirectoryWrapper
      extends BaseDirectoryWrapper

  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.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `MockDirectoryWrapper.Failure` Objects that represent fail-able conditions.
    `static class` | `MockDirectoryWrapper.Throttling` Enum for controlling hard disk throttling.

    - ### Nested classes/interfaces inherited from class org.apache.lucene.store.Directory

      `Directory.IndexInputSlicer`

  - ### Field Summary

    - ### Fields inherited from class org.apache.lucene.store.BaseDirectoryWrapper

      `delegate`

    - ### Fields inherited from class org.apache.lucene.store.Directory

      `isOpen, lockFactory`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `MockDirectoryWrapper(Random random, Directory delegate)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `clearCrash()`
    `void` | `clearLock(String name)`
    `void` | `close()`
    `void` | `copy(Directory to, String src, String dest, IOContext context)`
    `void` | `crash()` Simulates a crash of OS or machine by overwriting unsynced files.
    `IndexOutput` | `createOutput(String name, IOContext context)`
    `Directory.IndexInputSlicer` | `createSlicer(String name, IOContext context)`
    `void` | `deleteFile(String name)`
    `void` | `failOn(MockDirectoryWrapper.Failure fail)` add a Failure object to the list of objects to be evaluated at every potential failure point
    `boolean` | `fileExists(String name)`
    `long` | `fileLength(String name)`
    `Directory` | `getDelegate()`
    `int` | `getInputCloneCount()`
    `LockFactory` | `getLockFactory()`
    `String` | `getLockID()`
    `long` | `getMaxSizeInBytes()`
    `long` | `getMaxUsedSizeInBytes()` Returns the peek actual storage used (bytes) in this directory.
    `boolean` | `getNoDeleteOpenFile()`
    `Set<String>` | `getOpenDeletedFiles()`
    `double` | `getRandomIOExceptionRate()`
    `long` | `getRecomputedActualSizeInBytes()` Like getRecomputedSizeInBytes(), but, uses actual file lengths rather than buffer allocations (which are quantized up to nearest RAMOutputStream.BUFFER_SIZE (now 1024) bytes.
    `long` | `getRecomputedSizeInBytes()` Provided for testing purposes.
    `String[]` | `listAll()`
    `Lock` | `makeLock(String name)`
    `IndexInput` | `openInput(String name, IOContext context)`
    `void` | `removeIndexInput(IndexInput in, String name)`
    `void` | `removeIndexOutput(IndexOutput out, String name)`
    `void` | `resetMaxUsedSizeInBytes()`
    `void` | `setAssertNoUnrefencedFilesOnClose(boolean v)`
    `void` | `setFailOnCreateOutput(boolean v)`
    `void` | `setFailOnOpenInput(boolean v)`
    `void` | `setLockFactory(LockFactory lockFactory)`
    `void` | `setMaxSizeInBytes(long maxSize)`
    `void` | `setNoDeleteOpenFile(boolean value)` Emulate windows whereby deleting an open file is not allowed (raise IOException).
    `void` | `setPreventDoubleWrite(boolean value)` If set to true, we throw an IOException if the same file is opened by createOutput, ever.
    `void` | `setRandomIOExceptionRate(double rate)` If 0.0, no exceptions will be thrown.
    `void` | `setThrottling(MockDirectoryWrapper.Throttling throttling)`
    `void` | `setTrackDiskUsage(boolean v)`
    `void` | `setWrapLockFactory(boolean v)` Set to false if you want to return the pure lockfactory and not wrap it with MockLockFactoryWrapper.
    `long` | `sizeInBytes()`
    `void` | `sync(Collection<String> names)`
    `String` | `toString()`

    - ### Methods inherited from class org.apache.lucene.store.BaseDirectoryWrapper

      `getCheckIndexOnClose, getCrossCheckTermVectorsOnClose, indexPossiblyExists, isOpen, setCheckIndexOnClose, setCrossCheckTermVectorsOnClose`

    - ### Methods inherited from class org.apache.lucene.store.Directory

      `ensureOpen`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### MockDirectoryWrapper

          public MockDirectoryWrapper(Random random,
                              Directory delegate)

  - ### Method Detail

    - #### getDelegate

          public Directory getDelegate()

    - #### 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.

    - #### setThrottling

          public void setThrottling(MockDirectoryWrapper.Throttling throttling)

    - #### sync

          public void sync(Collection<String> names)
                    throws IOException

      Overrides:
        `sync` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `BaseDirectoryWrapper`

    - #### sizeInBytes

          public final long sizeInBytes()
                                 throws IOException

      Throws:
        `IOException`

    - #### crash

          public void crash()
                     throws IOException

      Simulates a crash of OS or machine by overwriting unsynced files.
      Throws:
        `IOException`

    - #### clearCrash

          public void clearCrash()

    - #### setMaxSizeInBytes

          public void setMaxSizeInBytes(long maxSize)

    - #### getMaxSizeInBytes

          public long getMaxSizeInBytes()

    - #### getMaxUsedSizeInBytes

          public long getMaxUsedSizeInBytes()

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

    - #### resetMaxUsedSizeInBytes

          public void resetMaxUsedSizeInBytes()
                                       throws IOException

      Throws:
        `IOException`

    - #### setNoDeleteOpenFile

          public void setNoDeleteOpenFile(boolean value)

      Emulate windows whereby deleting an open file is not allowed (raise IOException).

    - #### getNoDeleteOpenFile

          public boolean getNoDeleteOpenFile()

    - #### 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()

    - #### deleteFile

          public void deleteFile(String name)
                          throws IOException

      Overrides:
        `deleteFile` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### getOpenDeletedFiles

          public Set<String> getOpenDeletedFiles()

    - #### setFailOnCreateOutput

          public void setFailOnCreateOutput(boolean v)

    - #### createOutput

          public IndexOutput createOutput(String name,
                                 IOContext context)
                                   throws IOException

      Overrides:
        `createOutput` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### setFailOnOpenInput

          public void setFailOnOpenInput(boolean v)

    - #### openInput

          public IndexInput openInput(String name,
                             IOContext context)
                               throws IOException

      Overrides:
        `openInput` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### 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)

    - #### setWrapLockFactory

          public void setWrapLockFactory(boolean v)

      Set to false if you want to return the pure lockfactory and not wrap it with MockLockFactoryWrapper.

      Be careful if you turn this off: MockDirectoryWrapper might no longer be able to detect if you forget to close an IndexWriter, and spit out horribly scary confusing exceptions instead of simply telling you that.

    - #### close

          public void close()
                     throws IOException

      Specified by:
        `close` in interface `Closeable`
      Specified by:
        `close` in interface `AutoCloseable`
      Overrides:
        `close` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### removeIndexOutput

          public void removeIndexOutput(IndexOutput out,
                               String name)

    - #### removeIndexInput

          public void removeIndexInput(IndexInput in,
                              String name)

    - #### failOn

          public void failOn(MockDirectoryWrapper.Failure fail)

      add a Failure object to the list of objects to be evaluated at every potential failure point

    - #### listAll

          public String[] listAll()
                           throws IOException

      Overrides:
        `listAll` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### fileExists

          public boolean fileExists(String name)
                             throws IOException

      Overrides:
        `fileExists` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### fileLength

          public long fileLength(String name)
                          throws IOException

      Overrides:
        `fileLength` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### makeLock

          public Lock makeLock(String name)

      Overrides:
        `makeLock` in class `BaseDirectoryWrapper`

    - #### clearLock

          public void clearLock(String name)
                         throws IOException

      Overrides:
        `clearLock` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### setLockFactory

          public void setLockFactory(LockFactory lockFactory)
                              throws IOException

      Overrides:
        `setLockFactory` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### getLockFactory

          public LockFactory getLockFactory()

      Overrides:
        `getLockFactory` in class `BaseDirectoryWrapper`

    - #### getLockID

          public String getLockID()

      Overrides:
        `getLockID` in class `BaseDirectoryWrapper`

    - #### copy

          public void copy(Directory to,
                  String src,
                  String dest,
                  IOContext context)
                    throws IOException

      Overrides:
        `copy` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

    - #### createSlicer

          public Directory.IndexInputSlicer createSlicer(String name,
                                                IOContext context)
                                                  throws IOException

      Overrides:
        `createSlicer` in class `BaseDirectoryWrapper`
      Throws:
        `IOException`

Copyright © 2000-2013 Apache Software Foundation. All Rights Reserved.