*
     * @param tf the CIFS context to use
     * @param name the server name or address
     * @param port the port number
     * @param exclusive whether to acquire an unshared connection
     * @param forceSigning whether to enforce SMB signing
     * @return a connected transport
     * @throws UnknownHostException if the host cannot be resolved

	lrwm := NewLRWMutex()

	if !lrwm.GetRLock(ctx, "", "object1", time.Second) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("1st read lock acquired, waiting...")

	if !lrwm.GetRLock(ctx, "", "object1", time.Second) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("2nd read lock acquired, waiting...")

	go func() {
		time.Sleep(2 * time.Second)
		lrwm.RUnlock()

 *
 * <p>Deadlocks can arise when locks are acquired in an order that forms a cycle. In a simple
 * example involving two locks and two threads, deadlock occurs when one thread acquires Lock A, and
 * then Lock B, while another thread acquires Lock B, and then Lock A:
 *
 * <pre>
 * Thread1: acquire(LockA) --X acquire(LockB)
 * Thread2: acquire(LockB) --X acquire(LockA)
 * </pre>
 *

	quorumLocked := checkQuorumLocked(locks, quorum) && locksFailed <= tolerance
	if !quorumLocked {
		log("dsync: Unable to acquire lock in quorum %#v\n", args)
		// Release all acquired locks without quorum.
		if !releaseAll(ctx, ds, tolerance, owner, locks, isReadLock, restClnts, names...) {
			log("Unable to release acquired locks, these locks will expire automatically %#v\n", args)
		}
	}

		panic("Failed to acquire read lock")
	}
	// fmt.Println("1st read lock acquired, waiting...")

	drwm2 := NewDRWMutex(ds, "simplelock")
	ctx2, cancel2 := context.WithCancel(t.Context())
	if !drwm2.GetRLock(ctx2, cancel2, id, source, Options{Timeout: time.Second}) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("2nd read lock acquired, waiting...")

	go func() {

        // Then: Should create successfully
        assertNotNull(iterator);
        assertFalse(iterator.hasNext()); // Empty results

        // Verify tree handle was acquired
        verify(treeHandle).acquire();

        // Cleanup
        iterator.close();
    }

    @Test
    @DisplayName("Constructor should handle workgroup type with non-empty host")

        verify(pipe, times(1)).ensureTreeConnected();
        verify(tree, times(2)).acquire();
    }

    @Test
    @DisplayName("isOpen and isStale reflect underlying handle validity")
    void testIsOpenAndIsStale() throws CIFSException {
        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);

                            SmbConstants.ATTR_NORMAL, 0);
                }
                // one extra acquire to keep this open till the stream is released
                return this.handle.acquire();
            }

        }
        log.trace("Pipe already open");
        return this.handle.acquire();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbPipeHandle#getInput()
     */

     * <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.
     */

     */
    public SmbTreeImpl acquire(final boolean track) {
        final long usage = this.usageCount.incrementAndGet();
        if (log.isTraceEnabled()) {
            log.trace("Acquire tree " + usage + " " + this);
        }

        if (track && this.traceResource) {
            synchronized (this.acquires) {
                this.acquires.add(truncateTrace(Thread.currentThread().getStackTrace()));