return openInputStream();
            }
          };
    }
  }

  /**
   * Returns a readable {@link ByteSource} view of the data that has been written to this stream.
   *
   * @since 15.0
   */
  public ByteSource asByteSource() {
    return source;
  }

  private synchronized InputStream openInputStream() throws IOException {
    if (file != null) {

              SmbResource exclFile = new SmbFile(sr, fname) ) {

            exclFile.createNewFile();
            try {
                try ( InputStream is = exclFile.openInputStream(SmbConstants.FILE_NO_SHARE);
                      InputStream is2 = exclFile.openInputStream(SmbConstants.FILE_NO_SHARE) ) {
                    fail("No sharing violation");
                }
                catch ( SmbException e ) {

                int before = t.getInflightRequests();
                if ( before > 0 ) {
                    log.warn("Have existing inflight requests");
                }
                try ( InputStream is = f.openInputStream() ) {

                }
                catch ( SmbException e ) {
                    // expected
                }
                assertEquals(before, t.getInflightRequests());
            }

                    assertTrue(f.exists());

                    try ( SmbResource e2 = new SmbFile(t, "test") ) {
                        assertTrue(e2.exists());
                        try ( InputStream is = e2.openInputStream() ) {
                            ReadWriteTest.verifyRandom(bufSize, length, is);
                        }
                    }
                }
                finally {
                    d1.delete();

     * @throws CIFSException
     */
    InputStream openInputStream ( int sharing ) throws CIFSException;


    /**
     * Opens an input stream reading the file (read only, sharable)
     * 
     * @return input stream, needs to be closed when finished
     * @throws CIFSException
     */
    InputStream openInputStream () throws CIFSException;


    /**
     * Close/release the file

 *
 * <p>This class is intended to be used in the following pattern:
 *
 * <pre>{@code
 * Closer closer = Closer.create();
 * try {
 *   InputStream in = closer.register(openInputStream());
 *   OutputStream out = closer.register(openOutputStream());
 *   // do stuff
 * } catch (Throwable e) {
 *   // ensure that any checked exception types other than IOException that could be thrown are

    @Override
    public SmbFileInputStream openInputStream () throws SmbException {
        return new SmbFileInputStream(this);
    }


    @Override
    public SmbFileInputStream openInputStream ( int sharing ) throws SmbException {
        return openInputStream(0, O_RDONLY, sharing);
    }


    @Override