return keyGenerator.getAndIncrement();
    }

    @Override
    protected long getBufferAddress(ByteBuffer buffer) {
        // Return a fake address for TCP
        // In real RDMA implementations, this would be the native memory address
        return buffer.hashCode();
    }

        }

        @Test
        @DisplayName("Should generate correct pipe URL with address option")
        void testMakePipeUrl_WithAddressOption() throws Exception {
            lenient().when(mockDcerpcBinding.getOption("server")).thenReturn(null);
            when(mockDcerpcBinding.getOption("address")).thenReturn("192.168.1.1");
            DcerpcPipeHandle handle = createMockedDcerpcPipeHandle();

	globalSite config.Site

	// MinIO local server address (in `host:port` format)
	globalMinioAddr = ""

	// MinIO default port, can be changed through command line.
	globalMinioPort        = GlobalMinioDefaultPort
	globalMinioConsolePort = "13333"

	// Holds the host that was passed using --address
	globalMinioHost = ""
	// Holds the host that was passed using --console-address
	globalMinioConsoleHost = ""

		expectedServerAddr string
		expectedEndpoints  Endpoints
		expectedSetupType  SetupType
		expectedErr        error
	}{
		{"localhost", []string{}, "", Endpoints{}, -1, fmt.Errorf("address localhost: missing port in address")},

		// Erasure Single Drive
		{"localhost:9000", []string{"http://localhost/d1"}, "", Endpoints{}, -1, fmt.Errorf("use path style endpoint for SD setup")},

import okhttp3.internal.connection.RoutePlanner.ConnectResult
import okhttp3.internal.connection.RoutePlanner.Plan
import okhttp3.internal.okHttpName

/**
 * Speculatively connects to each IP address of a target address, returning as soon as one of them
 * connects successfully. This kicks off new attempts every 250 ms until a connect succeeds.
 */
internal class FastFallbackExchangeFinder(
  override val routePlanner: RoutePlanner,

 *
 * Implementations of this interface are not thread-safe. Each instance is thread-confined to the
 * thread executing the call.
 */
interface RoutePlanner {
  val address: Address

  /** Follow-ups for failed plans and plans that lost a race. */
  val deferredPlans: ArrayDeque<Plan>

  fun isCanceled(): Boolean

  /** Returns a plan to attempt. */
  @Throws(IOException::class)

    private final Object group; // RdmaActiveEndpointGroup<DisniRdmaEndpoint>

    /**
     * Create new DiSNI RDMA connection
     *
     * @param remote remote socket address
     * @param local local socket address
     * @param group DiSNI endpoint group
     * @throws IOException if connection creation fails
     */

    /**
     * Challenge
     */
    public byte[] challenge;

    /**
     * Server address
     */
    public UniAddress dc;

    /**
     * Creates a new NTLM challenge with the specified parameters.
     * @param challenge the NTLM challenge bytes
     * @param dc the domain controller address
     */
    public NtlmChallenge(final byte[] challenge, final UniAddress dc) {
        this.challenge = challenge;

echo "done"

# Start MinIO instances
echo -n "Starting MinIO instances ..."
minio server --certs-dir /tmp/certs --address ":9001" --console-address ":10000" /tmp/minio1/{1...4}/disk{1...4} /tmp/minio1/{5...8}/disk{1...4} >/tmp/minio1_1.log 2>&1 &
minio server --certs-dir /tmp/certs --address ":9002" --console-address ":11000" /tmp/minio2/{1...4}/disk{1...4} /tmp/minio2/{5...8}/disk{1...4} >/tmp/minio2_1.log 2>&1 &
echo "done"

        final int nodeType = (src[srcIndex] & 0x60) >> 5;
        srcIndex += 2;
        final int address = readInt4(src, srcIndex);
        if (address != 0) {
            addrEntry[addrIndex] = new NbtAddress(recordName, address, groupName, nodeType);
        } else {
            addrEntry[addrIndex] = null;
        }

        return 6;
    }

    @Override