when(mockNdrBuffer.dec_ndr_short()).thenReturn((int) (short) 0x9ABC, (int) (short) 0xDEF0);
            when(mockNdrBuffer.dec_ndr_small()).thenReturn((int) (byte) 0x11, (int) (byte) 0x22, // clock seq bytes
                    (int) (byte) 0xAA, (int) (byte) 0xBB, (int) (byte) 0xCC, (int) (byte) 0xDD, (int) (byte) 0xEE, (int) (byte) 0xFF // node bytes
            );

    protected String name = "Transport" + id++;
    private volatile Thread thread;
    private volatile TransportException te;

    /**
     * Lock object for synchronizing input operations
     */
    protected final Object inLock = new Object();
    /**
     * Lock object for synchronizing output operations
     */
    protected final Object outLock = new Object();

    /**

#FESS_JAVA_OPTS="$FESS_JAVA_OPTS -Djavax.net.ssl.trustStorePassword=changeit"

# min and max heap sizes should be set to the same value to avoid
# stop-the-world GC pauses during resize, and so that we can lock the
# heap in memory on startup to prevent any of it from being swapped
# out.
FESS_JAVA_OPTS="$FESS_JAVA_OPTS -Xms${FESS_MIN_MEM}"
FESS_JAVA_OPTS="$FESS_JAVA_OPTS -Xmx${FESS_MAX_MEM}"

func (dt *dynamicTimeout) logEntry(duration time.Duration) {
	if duration < 0 {
		return
	}
	entries := int(atomic.AddInt64(&dt.entries, 1))
	index := entries - 1
	if index < dynamicTimeoutLogSize {
		dt.mutex.Lock()
		dt.log[index] = duration

		// We leak entries while we copy
		if entries == dynamicTimeoutLogSize {
			// Make copy on stack in order to call adjust()
			logCopy := [dynamicTimeoutLogSize]time.Duration{}

        // When - Release session to trigger cleanup
        session.release();

        // Then - Trees should be cleared (we can't directly verify as it's internal,
        // but the cleanup code with synchronized block ensures it happens atomically)
        // The important part is that no exception occurs and the operation is atomic
    }

    /**
     * Test concurrent acquire and release operations.
     */
    @Test

 * </p>
 *
 */
public class DataServiceImpl implements DataService<AccessResultImpl<Long>> {

    /** Counter for generating unique IDs */
    protected static volatile long idCount = 0L;

    /** Lock object for synchronizing access to idCount */
    private static Object idCountLock = new Object();

    /** Helper for managing access result data in memory */
    @Resource
    protected MemoryDataHelper dataHelper;

  @BeforeEach
  fun setUp() {
    if (connectionType == H2) {
      platform.assumeHttp2Support()
    }

    // Sockets on some platforms can have large buffers that mean writes do not block when
    // required. These socket factories explicitly set the buffer sizes on sockets created.
    server = MockWebServer()
    server.serverSocketFactory =

	// Max time between client calls before dropping an async cache listing.
	metacacheMaxClientWait = 3 * time.Minute

	// metacacheBlockSize is the number of file/directory entries to have in each block.
	metacacheBlockSize = 5000

	// metacacheSharePrefix controls whether prefixes on dirty paths are always shared.
	// This will make `test/a` and `test/b` share listings if they are concurrent.

   * ListenableFuture} listeners, should take care not to do so while holding a lock. Additionally,
   * as a further line of defense, prefer not to perform any locking inside a task that will be run
   * under {@code directExecutor}: Not only might the wait for a lock be long, but if the running
   * thread was holding a lock, the listener may deadlock or break lock isolation.
   *
   * <p>This instance is equivalent to:
   *

          headers.value(i) == "trailers"
        ) {
          result.add(Header(name, headers.value(i)))
        }
      }
      return result
    }

    /** Returns headers for a name value block containing an HTTP/2 response. */
    fun readHttp2HeadersList(
      headerBlock: Headers,
      protocol: Protocol,
    ): Response.Builder {
      var statusLine: StatusLine? = null