).dns(dns)
        .build()

    server.enqueue(MockResponse())

    val call =
      client.newCall(
        Request(
          url = "https://url-host.com:${server.port}/".toHttpUrl(),
          headers = headersOf("Host", "header-host"),
        ),
      )
    val response = call.execute()
    assertThat(response.isSuccessful).isTrue()

	for range n {
		l, err := net.Listen("tcp", "127.0.0.1:0")
		if err != nil {
			if l, err = net.Listen("tcp6", "[::1]:0"); err != nil {
				return nil, nil, fmt.Errorf("httptest: failed to listen on a port: %v", err)
			}
		}
		addr := l.Addr()
		hosts = append(hosts, "http://"+addr.String())
		listeners = append(listeners, l)
	}
	return hosts, listeners, err
}

func toAdminAPIErrCode(ctx context.Context, err error) APIErrorCode {
	if errors.Is(err, errErasureWriteQuorum) {
		return ErrAdminConfigNoQuorum
	}
	return toAPIErrorCode(ctx, err)
}

// wraps export error for more context
func exportError(ctx context.Context, err error, fname, entity string) APIError {
	if entity == "" {
		return toAPIError(ctx, fmt.Errorf("error exporting %s with: %w", fname, err))
	}

    calls++

    if (exchange != null) {
      check(exchange.finder.routePlanner.sameHostAndPort(request.url)) {
        "network interceptor ${interceptors[index - 1]} must retain the same host and port"
      }
      check(calls == 1) {
        "network interceptor ${interceptors[index - 1]} must call proceed() exactly once"
      }
    }

    // Call the next interceptor in the chain.

RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

COPY ./app /code/app

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]

# If running behind a proxy like Nginx or Traefik add --proxy-headers
# CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80", "--proxy-headers"]
```

</details>

## コンテナとは何か

          host: InetAddress,
          port: Int,
        ): Socket? = null

        override fun createSocket(
          address: InetAddress,
          port: Int,
          localAddress: InetAddress,
          localPort: Int,
        ): Socket? = null

        override fun createSocket(
          host: String,
          port: Int,
        ): Socket? = null

        // wait for yellow status
        runner.ensureYellow();

        System.setProperty(FesenClient.HTTP_ADDRESS, "localhost:" + runner.node().settings().get("http.port", "9201"));

        super.setUp();

        // logging
        System.setProperty("java.util.logging.SimpleFormatter.format", "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %2$s %5$s%6$s%n");

      }
    }
  }

  private fun doSsl(socket: Socket): SSLSocket {
    val sslSocket =
      sslSocketFactory.createSocket(
        socket,
        socket.inetAddress.hostAddress,
        socket.port,
        true,
      ) as SSLSocket
    sslSocket.useClientMode = false
    Platform.get().configureTlsExtensions(sslSocket, null, listOf(Protocol.HTTP_2))
    sslSocket.startHandshake()
    return sslSocket
  }

        assertEquals("apple, banana, pear", o2);
    }

    @Test
    public void testSubstitution() throws IOException {
        String str = "port = 4141" + LINE_SEPARATOR + "host = localhost"
                + LINE_SEPARATOR + "url = https://${host}:${port}/service"
                + LINE_SEPARATOR;
        MavenProperties properties = new MavenProperties();
        properties.load(new StringReader(str));

    )
    val interceptor =
      Interceptor { chain: Interceptor.Chain ->
        val address = chain.connection()!!.route().address
        val sameHost = address.url.host
        val differentPort = address.url.port + 1
        chain.proceed(
          chain
            .request()
            .newBuilder()
            .url("http://$sameHost:$differentPort/")
            .build(),
        )
      }
    client =