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

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `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, 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`

Copyright © 2002 Mock Objects. All Rights Reserved.