// make sure that no exception is thrown if 'swallowException' is true
    // when the mock does throw an exception.
    setupCloseable(true);
    doClose(mockCloseable, true);
  }

  public void testClose_closeableWithThrownException() throws IOException {
    // make sure that the exception is thrown if 'swallowException' is false
    // when the mock does throw an exception.

    protected abstract long makeKey ( Request request ) throws IOException;


    protected abstract Long peekKey () throws IOException;


    protected abstract void doSend ( Request request ) throws IOException;


    protected abstract void doRecv ( Response response ) throws IOException;


    protected abstract void doSkip ( Long key ) throws IOException;


    /**
     * 

      this.closeable = closeable;
      this.thrown = thrown;
      this.suppressed = suppressed;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof Suppression) {
        Suppression other = (Suppression) obj;
        return closeable.equals(other.closeable)
            && thrown.equals(other.thrown)

   *
   * <p>This method always throws, and as such should be called as {@code throw closer.rethrow(e);}
   * to ensure the compiler knows that it will throw.
   *
   * @return this method does not return; it always throws
   * @throws IOException when the given throwable is an IOException
   */
  public RuntimeException rethrow(Throwable e) throws IOException {
    checkNotNull(e);
    thrown = e;

    }


    public int available () throws IOException {
        return this.dis.available();
    }


    public void readFully ( byte[] b ) throws IOException {
        this.dis.readFully(b);
    }


    public void readFully ( byte[] b, int off, int len ) throws IOException {
        this.dis.readFully(b, off, len);
    }


    public char readChar () throws IOException {
        align(2);

    // make sure that no exception is thrown if 'swallowException' is true
    // when the mock does throw an exception.
    setupCloseable(true);
    doClose(mockCloseable, true);
  }

  public void testClose_closeableWithThrownException() throws IOException {
    // make sure that the exception is thrown if 'swallowException' is false
    // when the mock does throw an exception.

     * 
     * @throws CIFSException
     */
    public void open () throws CIFSException {
        try ( SmbFileHandleImpl fh = ensureOpen() ) {}
    }


    /**
     * @param file
     * @param openFlags
     * @return
     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen () throws CIFSException {

            "smb31");
    }


    @Test
    public void logonUser () throws IOException {
        try ( SmbResource f = getDefaultShareRoot() ) {
            checkConnection(f);
            f.resolve("test").exists();
        }
    }


    @Test
    public void logonUserHash () throws IOException {

public class CloseableUtilTest {

    /**
     * @throws Exception
     */
    @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 {

                throws UnresolvableModelException {
            return null;
        }

        @Override
        public void addRepository(Repository repository) throws InvalidRepositoryException {}

        @Override
        public void addRepository(Repository repository, boolean replace) throws InvalidRepositoryException {}

        @Override