inFrames.add(inFrame)
      }
    }
  }

  fun openSocket(): Socket = Socket("localhost", port)

  @Synchronized override fun close() {
    executor.shutdown()
    socket?.closeQuietly()
    serverSocket?.closeQuietly()
  }

  override fun toString(): String = "MockHttp2Peer[$port]"

  private class OutFrame(
    val sequence: Int,
    val start: Long,
    val truncated: Boolean,

    /**
     * Connect to a remote RDMA endpoint
     *
     * @param hostname remote hostname or IP address
     * @param port remote port number
     * @return established RDMA connection
     * @throws IOException if connection fails
     */
    RdmaConnection connect(String hostname, int port) throws IOException;

    /**
     * Register memory region for RDMA operations
     *
     * @param buffer memory buffer to register

      ?: throw TestAbortedException()

    serverIpv4 = MockWebServer()
    serverIpv4.start(localhostIpv4, 0) // Pick any available port.

    serverIpv6 = MockWebServer()
    serverIpv6.start(localhostIpv6, serverIpv4.port) // Pick the same port as the IPv4 server.

    dnsResults =
      listOf(
        localhostIpv4,
        localhostIpv6,
      )

    client =
      clientTestRule

                                                                test="${data.port==null||data.port==''}">
                                                            <la:message key="labels.webauth_any"/>
                                                        </c:if> ${f:h(data.port)}</td>
                                                        <td>${f:h(data.webConfig.name)}</td>

  var host = ""
  var port = ""
  var path = ""
  var query = ""
  var fragment = ""

  fun expectParseFailure() = scheme.isEmpty()

  private operator fun set(
    name: String,
    value: String,
  ) {
    when (name) {
      "s" -> scheme = value
      "u" -> username = value
      "pass" -> password = value
      "h" -> host = value
      "port" -> port = value
      "p" -> path = value

    /**
     * The default HTTPS port (<code>443</code>).
     */
    public static final int DEFAULT_HTTPS_PORT = 443;

    /**
     * Default constructor for SMB1 HTTPS URL handler.
     */
    public Handler() {
    }

    /**
     * Returns the default HTTPS port.
     *
     * @return An <code>int</code> containing the default HTTPS port.
     */
    @Override

# `auditlog-echo`: A tool to view MinIO Audit logs on the console

1. Run the tool with:

```
go run docs/auditlog/auditlog-echo.go
```

The listen port has a default value (8080), but can be set with the `-port` flag.

2. Configure audit logging in MinIO with for example:

```
mc admin config set myminio audit_webhook enable=on endpoint=http://localhost:8080
```

  @Test
  @Throws(IOException::class)
  fun multipleDnsLookupsForSingleCall() {
    server!!.enqueue(
      MockResponse(
        code = 301,
        headers = headersOf("Location", "http://www.fakeurl:" + server!!.port),
      ),
    )
    server!!.enqueue(MockResponse())
    val dns = FakeDns()
    dns["fakeurl"] = client.dns.lookup(server!!.hostName)
    dns["www.fakeurl"] = client.dns.lookup(server!!.hostName)
    client =

            }
            PROTOCOL_HANDLERS.clear();
            Handler.factory = factory;
        }
    }

    /**
     * Returns the default HTTP port.
     *
     * @return An <code>int</code> containing the default HTTP port.
     */
    @Override
    protected int getDefaultPort() {
        return DEFAULT_HTTP_PORT;
    }

    @Override

    @DisplayName("Should default to port 445 when port <= 0")
    void testDefaultPort(int invalidPort) throws Exception {
        // Given: Create a new pool for this test to ensure isolation
        SmbTransportPoolImpl testPool = new SmbTransportPoolImpl();
        when(ctx.getTransportPool()).thenReturn(testPool);

        // Connection with invalid port