assertTrue(session.isInUse(), "New session should be in use due to transport acquisition");

        // Test additional acquire
        session.acquire();
        assertTrue(session.isInUse(), "Session should still be in use after additional acquire");

        // Test release (still in use because of initial transport acquire)
        session.release();

    limiter.acquire(Integer.MAX_VALUE / 4);
    limiter.acquire(Integer.MAX_VALUE / 2);
    limiter.acquire(Integer.MAX_VALUE);
    assertEvents("R0.00", "R0.00", "R0.00"); // no wait, infinite rate!

    limiter.setRate(2.0);
    limiter.acquire();
    limiter.acquire();
    limiter.acquire();
    limiter.acquire();
    limiter.acquire();
    assertEvents(

    limiter.acquire(Integer.MAX_VALUE / 4);
    limiter.acquire(Integer.MAX_VALUE / 2);
    limiter.acquire(Integer.MAX_VALUE);
    assertEvents("R0.00", "R0.00", "R0.00"); // no wait, infinite rate!

    limiter.setRate(2.0);
    limiter.acquire();
    limiter.acquire();
    limiter.acquire();
    limiter.acquire();
    limiter.acquire();
    assertEvents(

   * evaluate the integral of the function from 7.0 to 10.0.
   *
   * Using integrals guarantees that the effect of a single acquire(3) is equivalent to {
   * acquire(1); acquire(1); acquire(1); }, or { acquire(2); acquire(1); }, etc, since the integral
   * of the function in [7.0, 10.0] is equivalent to the sum of the integrals of [7.0, 8.0], [8.0,

        // Acquire session multiple times
        for (int i = 0; i < threadCount - 1; i++) {
            session.acquire();
        }

        // When - Multiple threads try to release/acquire concurrently
        for (int t = 0; t < threadCount; t++) {
            final boolean shouldRelease = (t < 3); // First 3 threads release, others acquire

            executor.submit(() -> {

    }

    @Test
    @DisplayName("acquire after release reacquires transport")
    void testAcquireReacquiresTransport() {
        SmbSessionImpl session = newSession();

        // Drop usage to zero which releases transport and flips transportAcquired=false
        session.release();
        clearInvocations(transport);

        // Re-acquire should reacquire transport

        // Act: create wrapper using delegate, then acquire and release once
        SmbTreeConnectionTrace wrapper = new SmbTreeConnectionTrace(delegate);
        wrapper.acquire();
        wrapper.release();

        // Assert: delegate interactions occur when usage transitions happen
        verify(delegate, times(1)).acquire();
        verify(delegate, times(1)).release();
    }

    @Test

        c.acquire();
        verify(tree, times(1)).acquire();

        // Act: second acquire does not call tree.acquire again
        c.acquire();
        verify(tree, times(1)).acquire();

        // Act: first release does not release yet (usage -> 1)
        c.release();
        verify(tree, never()).release();

        // Act: second release (usage -> 0) releases the tree
        c.release();

     *
     * @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()