release();
    }


    /**
     * @return tree handle with increased usage count
     */
    public SmbTreeHandleImpl acquire () {
        if ( this.usageCount.incrementAndGet() == 1 ) {
            this.treeConnection.acquire();
        }
        return this;
    }


    @Override
    public void release () {
        long us = this.usageCount.decrementAndGet();

    protected synchronized SmbFileHandleImpl ensureOpen () throws CIFSException {
        if ( !isOpen() ) {
            // one extra acquire to keep this open till the stream is released
            this.handle = this.file.openUnshared(this.openFlags, this.access, this.sharing, SmbConstants.ATTR_NORMAL, 0).acquire();
            if ( this.append ) {
                this.fp = this.handle.getInitialSize();
                if ( log.isDebugEnabled() ) {

     * <p>To avoid races between threads doing release and acquire, we transition to the final state
     * in two steps. One thread will successfully CAS from RUNNING to COMPLETING, that thread will
     * then set the result of the computation, and only then transition to COMPLETED, CANCELLED, or
     * INTERRUPTED.
     *
     * <p>We don't use the integer argument passed between acquire methods so we pass around a -1
     * everywhere.
     */

     * <p>To avoid races between threads doing release and acquire, we transition to the final state
     * in two steps. One thread will successfully CAS from RUNNING to COMPLETING, that thread will
     * then set the result of the computation, and only then transition to COMPLETED, CANCELLED, or
     * INTERRUPTED.
     *
     * <p>We don't use the integer argument passed between acquire methods so we pass around a -1
     * everywhere.
     */

        throw new ClassCastException();
    }


    /**
     * @return session increased usage count
     */
    public SmbSessionImpl acquire () {
        long usage = this.usageCount.incrementAndGet();
        if ( log.isTraceEnabled() ) {
            log.trace("Acquire session " + usage + " " + this);
        }

        if ( usage == 1 ) {
            synchronized ( this ) {

    assertEquals("<hello><hi><lo>", charEscaper.escape("x\uD800\uDC00"));
    assertEquals("<hello><hi><lo>", unicodeEscaper.escape("x\uD800\uDC00"));

    // Test that wrapped escapers acquire good Unicode semantics.
    assertEquals("<hi><hello><lo>", charEscaper.escape("\uD800x\uDC00"));
    try {
      unicodeEscaper.escape("\uD800x\uDC00");
      fail("should have failed for bad Unicode input");

    /**
     * Get transport connection
     * 
     * @param tc
     *            context to use
     * @param address
     * @param port
     * @param exclusive
     *            whether to acquire an unshared connection
     * @return a transport connection to the target
     */
    SmbTransport getSmbTransport ( CIFSContext tc, Address address, int port, boolean exclusive );


    /**

                    continue;
                }

                if ( log.isTraceEnabled() ) {
                    log.trace("Reusing transport connection " + conn);
                }
                return conn.acquire();
            }
        }

        return null;
    }


    @Override

        if ( this.handle == null || !this.handle.isValid() ) {
            // one extra acquire to keep this open till the stream is released
            this.handle = this.file.openUnshared(this.openFlags, this.access, this.sharing, SmbConstants.ATTR_NORMAL, this.options).acquire();
            return this.handle;
        }
        return this.handle.acquire();
    }


    /**
     * Ensures that the file descriptor is openend

  Striped64() {}

  /** CASes the base field. */
  final boolean casBase(long cmp, long val) {
    return UNSAFE.compareAndSwapLong(this, baseOffset, cmp, val);
  }

  /** CASes the busy field from 0 to 1 to acquire lock. */
  final boolean casBusy() {
    return UNSAFE.compareAndSwapInt(this, busyOffset, 0, 1);
  }

  /**
   * Computes the function of current and new value. Subclasses should open-code this update