void decodesErrorStructureThroughReadBytesWireFormat() throws Exception {
        // For STATUS_INVALID_PARAMETER the override makes isErrorResponseStatus() return false,
        // so readBytesWireFormat() is invoked and must delegate back to readErrorResponse() when it sees size=9.
        byte[] header = buildHeader(NtStatus.NT_STATUS_INVALID_PARAMETER);
        byte[] body = buildErrorBody(2, 3, new byte[] { (byte) 0xAA, (byte) 0xBB, (byte) 0xCC });

 * when there is a specific reason to prioritize memory over CPU.
 *
 * @author Louis Wasserman
 */
@J2ktIncompatible // no support for access-order mode in LinkedHashMap delegate
@GwtIncompatible // not worth using in GWT for now
final class CompactLinkedHashMap<K extends @Nullable Object, V extends @Nullable Object>
    extends CompactHashMap<K, V> {

            assertEquals(SERVER_PRINCIPAL_NAME, ticket.getServerPrincipalName());
            assertNotNull(ticket.getEncData());

            // Also test getters that delegate to KerberosEncData
            assertEquals(USER_PRINCIPAL_NAME, ticket.getUserPrincipalName());
            assertEquals(USER_REALM, ticket.getUserRealm());
        }
    }

        verify(mockResponse, never()).setStatus(any(int.class));
    }

    /**
     * Test case for the instance method doAuthentication.
     * It should just delegate to the static authenticate method.
     * @throws IOException
     */
    @Test
    public void testDoAuthentication() throws IOException {
        // Setup: No "Authorization" header to follow a simple path

    return references.size
  }

  fun scheduleCloser() {
    cleanupQueue.schedule(cleanupTask)
  }

  companion object {
    fun get(connectionPool: ConnectionPool): RealConnectionPool = connectionPool.delegate
  }

  }

  private static class NonNavigableSortedSet extends ForwardingSortedSet<String> {
    private final SortedSet<String> delegate = Sets.newTreeSet();

    @Override
    protected SortedSet<String> delegate() {
      return delegate;
    }
  }

  public void testAsMapSorted() {
    SortedSet<String> strings = new NonNavigableSortedSet();

            assertTrue(transport.isDisconnected(), "Transport should be disconnected initially");

            System.out.println("RDMA transport created successfully with mock delegate");
        }
    }

    @Test
    public void testRdmaStatisticsTracking() throws Exception {
        RdmaStatistics stats = new RdmaStatistics();

        // Simulate various RDMA operations

    void getTreeId_noTree() {
        SmbTreeConnection c = newConn();
        assertEquals(-1, c.getTreeId());
    }

    @Test
    @DisplayName("getTreeType and getConnectedShare delegate to tree")
    void getters_delegateToTree() {
        SmbTreeConnection c = newConn();
        SmbTreeImpl tree = mock(SmbTreeImpl.class);
        when(tree.acquire(false)).thenReturn(tree);

        }
        assertThrows(ClassCastException.class, () -> {
            OtherPipeHandle result = handle.unwrap(OtherPipeHandle.class);
        });
    }

    @Test
    @DisplayName("getPipeType and getPipe delegate to SmbNamedPipe")
    void pipeType_and_getPipe() {
        when(pipe.getPipeType()).thenReturn(12345);
        SmbPipeHandleImpl handle = new SmbPipeHandleImpl(pipe);
        assertEquals(12345, handle.getPipeType());

    stream: Http2Stream? = null,
  ): Sink {
    var result: Sink = this

    if (policy.throttlePeriodNanos > 0L) {
      result =
        ThrottledSink(
          socket = socket,
          delegate = result,
          bytesPerPeriod = policy.throttleBytesPerPeriod,
          periodDelayNanos = policy.throttlePeriodNanos,
        )
    }

    if (socketEffect != null) {
      val halfwayByteCount =