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

}

func TestDynamicTimeoutDualDecrease(t *testing.T) {
	timeout := newDynamicTimeout(time.Minute, time.Second)

	initial := timeout.Timeout()

	for range dynamicTimeoutLogSize {
		timeout.LogSuccess(20 * time.Second)
	}

	adjusted := timeout.Timeout()

	for range dynamicTimeoutLogSize {
		timeout.LogSuccess(20 * time.Second)
	}

	adjustedAgain := timeout.Timeout()

        if (t != 0L) {
            t = (t + SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601) * 10000L;
        }
        writeInt8(t, dst, dstIndex);
    }

    /**
     * Reads a Unix time value (32-bit seconds) and converts it to Java time in milliseconds
     * @param buffer the source byte array
     * @param bufferIndex the starting index in the source array
     * @return the time value in milliseconds since January 1, 1970 UTC

	biggerBufMax = maxBufferSize

	// If there is a queue, merge up to this many messages.
	maxMergeMessages = 50

	// clientPingInterval will ping the remote handler every 15 seconds.
	// Clients disconnect when we exceed 2 intervals.
	clientPingInterval = 15 * time.Second

	// Deadline for single (non-streaming) requests to complete.
	// Used if no deadline is provided on context.
	defaultSingleRequestTimeout = time.Minute
)

        this.value1 = value1;
    }

    /**
     * Returns the second value.
     *
     * @return The second value
     */
    public T2 getValue2() {
        return value2;
    }

    /**
     * Sets the second value.
     *
     * @param value2
     *            The second value
     */
    public void setValue2(final T2 value2) {
        this.value2 = value2;

        assertEquals("file1.txt", first.getName());

        assertTrue(iterator.hasNext(), "Should have second element");
        SmbResource second = iterator.next();
        assertNotNull(second, "Second element should not be null");
        assertEquals("file2.txt", second.getName());

        assertTrue(iterator.hasNext(), "Should have third element");
        SmbResource third = iterator.next();

import static com.google.common.util.concurrent.Uninterruptibles.awaitUninterruptibly;
import static java.util.concurrent.Executors.newSingleThreadExecutor;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertThrows;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;

    future.set(RESULT);
    /*
     * getUninterruptibly should call the timed get method once with a
     * wait of 0 seconds (and it should succeed, since the result is already
     * available).
     */
    assertThat(getUninterruptibly(future, 0, SECONDS)).isEqualTo(RESULT);
  }

  public void testMakeUninterruptible_timedGetNegativeTimeoutAttempted()
      throws TimeoutException, ExecutionException {

        String first = "first";
        String second = "second";
        String componentName = "testComponent";

        ComponentUtil.register(first, componentName);
        String retrieved1 = ComponentUtil.getComponent(componentName);
        assertSame(first, retrieved1);

        ComponentUtil.register(second, componentName);
        String retrieved2 = ComponentUtil.getComponent(componentName);

      """
      |data: first event
      |id: 1
      |
      |data: second event
      |id
      |
      |data: third event
      |
      |
      """.trimMargin(),
    )
    assertThat(callbacks.remove()).isEqualTo(Event("1", null, "first event"))
    assertThat(callbacks.remove()).isEqualTo(Event(null, null, "second event"))
    assertThat(callbacks.remove()).isEqualTo(Event(null, null, "third event"))
  }