com.mockobjects.io

## Class MockWriter

- java.lang.Object
- - java.io.Writer
  - - com.mockobjects.io.MockWriter

All Implemented Interfaces:
  Verifiable, java.io.Closeable, java.io.Flushable, java.lang.Appendable, java.lang.AutoCloseable

    public class MockWriter
    extends java.io.Writer
    implements Verifiable

A mock `Writer`.

### Example usage

You may use the `MockWriter` like this:

     public void testSomething() throws IOException {
         MockWriter out = new MockWriter();
         out.setExpectedSegment("some string");
         out.setExpectedFlushCalls(1);
         out.setExpectedCloseCalls(1);

         ObjectUnderTest testee = new ObjectUnderTest(out);
         out.verify();

         // If we get here, the mock's flush() and close() methods were
         // called exactly once each (order cannot be determined) and
         // the write() method was called with the string "some string" in it.
     }

Author:
  Francois Beausoleil, fbos@users.sourceforge.net

### Constructor Summary

Constructors
Constructor and Description
`MockWriter()` Instantiates a new mock writer which will act as a data sink.

### Method Summary

Methods
`void` `close()` Increments the close counter and asserts that this method was not called too many times.
`void` `flush()` This method will also throw an `IOException` if asked to do so by calling `setFlushShouldThrowException()`.
`void` `setCloseShouldThrowException()` Sets the mock's behavior when closing.
`void` `setExpectedCloseCalls(int calls)` Sets the expected number of times that the `close()` method will be called.
`void` `setExpectedFlushCalls(int calls)` Sets the expected number of times that the `flush()` method will be called.
`void` `setExpectedSegment(java.lang.String aString)` Sets the value of the expected string segment.
`void` `setFlushShouldThrowException()` Sets the mock's behavior when flushing.
`void` `setWriteShouldThrowException()` Sets the mock's behavior when writing.
`void` `verify()` Throw an AssertionFailedException if any expectations have not been met.
`void` `write(char[] cbuf, int off, int len)` Either throws an exception or asserts a string segment for equality.

### Methods inherited from class java.io.Writer

`append, append, append, append, append, append, write, write, write, write`

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

`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### MockWriter

    public MockWriter()

Instantiates a new mock writer which will act as a data sink. Once instantiated, mocks of this class do not expect anything special. Once the object is instantiated, you should set your expectations using the provided methods.

### Method Detail

#### setWriteShouldThrowException

    public void setWriteShouldThrowException()

Sets the mock's behavior when writing. If this method has been called, then `write(char[], int, int)` will throw an `IOException`.

#### setFlushShouldThrowException

    public void setFlushShouldThrowException()

Sets the mock's behavior when flushing. If this method has been called, then `flush()` will throw an `IOException`.

#### setCloseShouldThrowException

    public void setCloseShouldThrowException()

Sets the mock's behavior when closing. If this method has been called, then `close()` will throw an `IOException`.

#### setExpectedFlushCalls

    public void setExpectedFlushCalls(int calls)

Sets the expected number of times that the `flush()` method will be called.

See Also:
  `flush()`

#### setExpectedCloseCalls

    public void setExpectedCloseCalls(int calls)

Sets the expected number of times that the `close()` method will be called.

See Also:
  `close()`

#### setExpectedSegment

    public void setExpectedSegment(java.lang.String aString)

Sets the value of the expected string segment. When the `write(char[], int, int)` method is called, a string is instantiated with the passed array and compared to the `aString` parameter of this method. If the two strings differ, an `AssertionFailedError` will be thrown.

See Also:
  `ExpectationSegment`, `write(char[], int, int)`

#### write

    public void write(char[] cbuf,
             int off,
             int len)
               throws java.io.IOException

Either throws an exception or asserts a string segment for equality.

Specified by:
  `write` in class `java.io.Writer`
Throws:
  `java.io.IOException`
See Also:
  `ExpectationSegment`, `#setWriteShouldThrowException(boolean)`

#### flush

    public void flush()
               throws java.io.IOException

This method will also throw an `IOException` if asked to do so by calling `setFlushShouldThrowException()`. Please note that the call count will be incremented before the check for the exception is done.

Specified by:
  `flush` in interface `java.io.Flushable`
Specified by:
  `flush` in class `java.io.Writer`
Throws:
  `java.io.IOException`
See Also:
  `setExpectedFlushCalls(int)`, `setFlushShouldThrowException()`

#### close

    public void close()
               throws java.io.IOException

Increments the close counter and asserts that this method was not called too many times. This method will also throw an `IOException` if asked to do so by calling `setCloseShouldThrowException()`. Please note that the call count will be incremented before the check for the exception is done.

Specified by:
  `close` in interface `java.io.Closeable`
Specified by:
  `close` in interface `java.lang.AutoCloseable`
Specified by:
  `close` in class `java.io.Writer`
Throws:
  `java.io.IOException`
See Also:
  `setExpectedCloseCalls(int)`, `setCloseShouldThrowException()`

#### verify

    public void verify()

Description copied from interface: `Verifiable`
Throw an AssertionFailedException if any expectations have not been met.

Specified by:
  `verify` in interface `Verifiable`