private int getMaxChannelsFromConfig(Configuration config) {
        // In a real implementation, this would read from configuration
        return 4; // Default to 4 channels
    }

    private LoadBalancingStrategy getLoadBalancingStrategyFromConfig(Configuration config) {
        // In a real implementation, this would read from configuration
        return LoadBalancingStrategy.ROUND_ROBIN;
    }

# This ensures that previous jobs for the PR are canceled when the PR is
# updated.
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref }}
  cancel-in-progress: true

permissions:
  contents: read

jobs:
  mint-test:
    runs-on: mint
    timeout-minutes: 120
    steps:
      - name: cleanup #https://github.com/actions/checkout/issues/273
        run: |
          sudo -S rm -rf ${GITHUB_WORKSPACE}

 *  Fix: Honor interceptors' changes to connect and read timeouts.

 *  Fix: Recover gracefully when a cached response is corrupted on disk.

 *  Fix: Don't leak file handles when a cache disk write fails.

 *  Fix: Don't hang when the public suffix database cannot be loaded. We had a bug where a failure
    reading the public suffix database would cause subsequent reads to hang when they should have
    crashed.

    /**
     * Unspecified session ID value
     */
    public static final long UNSPECIFIED_SESSIONID = 0xFFFFFFFFFFFFFFFFL;

    /**
     * SMB2 Channel constant for RDMA V1
     * Used in SMB2 READ and WRITE requests to indicate RDMA channel
     */
    public static final int SMB2_CHANNEL_RDMA_V1 = 0x00000001;

    /**
     * SMB2 Channel constant for RDMA V1 invalidate

        bufferIndex += 2;
        reserved1 = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        reserved2 = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // Read the transform (only expecting one)
        if (transformCount > 0) {
            rdmaTransformId = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;

    // `value` does not need to be volatile; visibility piggy-backs on volatile read of `delegate`.
    private @Nullable T value;

    NonSerializableMemoizingSupplier(Supplier<T> delegate) {
      this.delegate = checkNotNull(delegate);
    }

    @Override
    @ParametricNullness
    public T get() {
      // Because Supplier is read-heavy, we use the "double-checked locking" pattern.
      if (delegate != null) {

    checkNotNull(reason);
    /*
     * All elements of `futures` are completed, or this future has already completed and read
     * `futures` into a local variable (in preparation for propagating cancellation to them). In
     * either case, no one needs to read `futures` for cancellation purposes later. (And
     * cancellation purposes are the main reason to access `futures`, as discussed in its docs.)
     */

/**
 * TCP fallback RDMA provider.
 *
 * This provider uses regular TCP connections but maintains the RDMA
 * interface for compatibility. It only supports send/receive operations
 * and does not provide true RDMA read/write capabilities.
 */
public class TcpRdmaProvider implements RdmaProvider {

    /**
     * Creates a new TCP RDMA provider instance
     */
    public TcpRdmaProvider() {
        // Default constructor

                0xA5A5A5A5, fileId);
        byte[] packet = buildPacket(header, body, null, null);

        int read = resp.decode(packet, 0, false);
        assertTrue(read >= SMB2_HEADER_LENGTH + body.length, "Should decode at least header+body");

        // Validate simple getters
        assertEquals((byte) 0x7, resp.getOplockLevel());

        assertEquals(0, result);

        result = response.writeDataWireFormat(null, 0);
        assertEquals(0, result);
    }

    @Test
    @DisplayName("Test all read methods with null buffer")
    void testReadMethodsWithNullBuffer() {
        // Even with null buffer, methods should return 0 without throwing exception
        int result = response.readSetupWireFormat(null, 0, 0);