readControlFrame()
    } else {
      readMessageFrame()
    }
  }

  @Throws(IOException::class, ProtocolException::class)
  private fun readHeader() {
    if (closed) throw IOException("closed")

    // Disable the timeout to read the first byte of a new frame.
    val b0: Int
    val timeoutBefore = source.timeout().timeoutNanos()
    source.timeout().clearTimeout()
    try {

 *
 *  * **Closing:** one of the peers on the web socket has initiated a graceful shutdown. The web
 *    socket will continue to transmit already-enqueued messages but will refuse to enqueue new
 *    ones.
 *
 *  * **Closed:** the web socket has transmitted all of its messages and has received all messages
 *    from the peer.
 *
 * Web sockets may fail due to HTTP upgrade problems, connectivity problems, or if either peer

     */
    void write(File output, Map<String, Object> options, Model model) throws IOException;

    /**
     * Writes the supplied model to the specified character writer. The writer will be automatically closed before the
     * method returns.
     *
     * @param output The writer to serialize the model to, must not be {@code null}.

	crc32     hash.Hash32
	closed    bool
}

func (w *fileWriter) Write(p []byte) (int, error) {
	if w.closed {
		return 0, errors.New("zip: write to closed file")
	}
	if w.raw {
		return w.zipw.Write(p)
	}
	w.crc32.Write(p)
	return w.rawCount.Write(p)
}

func (w *fileWriter) close() error {
	if w.closed {
		return errors.New("zip: file closed twice")
	}
	w.closed = true

    flush();
  }

  @Override
  public void write(String str, int off, int len) throws IOException {
    super.write(str, off, len);
    flush();
  }

  public boolean closed() {
    return out.closed();
  }

     */
    @Test
    public void testClose() throws Exception {
        final NotifyOutputStream out = new NotifyOutputStream();
        CloseableUtil.close(out);
        assertThat(out.getNotify(), is("closed"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testCloseNull() throws Exception {
        CloseableUtil.close((OutputStream) null);
    }

    /**

    return getSubMultiset(0, elementSet.headIndex(upperBound, checkNotNull(boundType) == CLOSED));
  }

  @Override
  public ImmutableSortedMultiset<E> tailMultiset(E lowerBound, BoundType boundType) {
    return getSubMultiset(
        elementSet.tailIndex(lowerBound, checkNotNull(boundType) == CLOSED), length);
  }

  ImmutableSortedMultiset<E> getSubMultiset(int from, int to) {

     * @return random access file, needs to be closed when finished
     * @throws CIFSException
     * 
     */
    SmbRandomAccess openRandomAccess ( String mode, int sharing ) throws CIFSException;


    /**
     * Opens the file for random access
     * 
     * @param mode
     *            access mode (r|rw)
     * @return random access file, needs to be closed when finished
     * @throws CIFSException

   *     // If an exception occurs, rethrow it only if threw==false:
   *     Closeables.close(stream, threw);
   *   }
   * }
   * }</pre>
   *
   * @param closeable the {@code Closeable} object to be closed, or null, in which case this method
   *     does nothing
   * @param swallowIOException if true, don't propagate IO exceptions thrown by the {@code close}
   *     methods

    private TestCloseable(@Nullable Throwable throwOnClose) {
      this.throwOnClose = throwOnClose;
    }

    public boolean isClosed() {
      return closed;
    }

    @Override
    public void close() throws IOException {
      closed = true;
      if (throwOnClose != null) {
        throwIfInstanceOf(throwOnClose, IOException.class);
        throwIfUnchecked(throwOnClose);