# it through port 9000.
services:
  minio1:
    <<: *minio-common
    hostname: minio1
    volumes:
      - data1-1:/data1
      - data1-2:/data2

  minio2:
    <<: *minio-common
    hostname: minio2
    volumes:
      - data2-1:/data1
      - data2-2:/data2

  minio3:
    <<: *minio-common
    hostname: minio3
    volumes:
      - data3-1:/data1
      - data3-2:/data2

  minio4:

    assertThat(encoded).isEqualTo("AAABAAABAAAAAAAABmdvb2dsZQNjb20AABwAAQ")
  }

  @Test
  fun testGoogleDotComDecodingFromCloudflare() {
    val encoded =
      decodeAnswers(
        hostname = "test.com",
        byteString =
          (
            "00008180000100010000000006676f6f676c6503636f6d0000010001c00c0001000100000043" +
              "0004d83ad54e"
          ).decodeHex(),
      )

    return x509TrustManager
  }

  internal object DisabledHostnameVerifier : ConscryptHostnameVerifier {
    fun verify(
      hostname: String?,
      session: SSLSession?,
    ): Boolean = true

    override fun verify(
      certs: Array<out X509Certificate>?,
      hostname: String?,
      session: SSLSession?,
    ): Boolean = true
  }

                // State has changed
                return true;
            }

            @Override
            public String getHostname() {
                return "test-hostname";
            }
        };

        FessConfig fessConfig = createTestFessConfig();

        // Register components
        ComponentUtil.register(searchEngineClient, "searchEngineClient");

    @DisplayName("getHostName should return valid hostname or address")
    void testGetHostNameContract() {
        // Given
        String expectedHostName = "server.example.com";
        when(mockAddress.getHostName()).thenReturn(expectedHostName);

        // When
        String hostName = mockAddress.getHostName();

        // Then
        assertEquals(expectedHostName, hostName, "Should return configured hostname");

             */
            if (!addrFound && this.queryAddress.hostName.hexCode == hexCode
                    && (this.queryAddress.hostName.isUnknown() || this.queryAddress.hostName.name.equals(n))) {

                if (this.queryAddress.hostName.isUnknown()) {
                    this.queryAddress.hostName = new Name(this.config, n, hexCode, scope);
                }

    @Test
    void testGetRemoteHostName() {
        // Arrange
        String hostName = "testHost";
        when(smbTransport.getRemoteHostName()).thenReturn(hostName);

        // Act
        String result = smbTransport.getRemoteHostName();

        // Assert
        assertNotNull(result, "Remote host name should not be null");
        assertEquals(hostName, result, "Returned remote host name should be the mocked host name");

                 */
                if (!addrFound && queryAddress.hostName.hexCode == hexCode
                        && (queryAddress.hostName == NbtAddress.UNKNOWN_NAME || queryAddress.hostName.name.equals(n))) {

                    if (queryAddress.hostName == NbtAddress.UNKNOWN_NAME) {
                        queryAddress.hostName = new Name(n, hexCode, scope);
                    }

        final String hostname = ComponentUtil.getSystemHelper().getHostname();
        final String targetName = ComponentUtil.getFessConfig().getSchedulerTargetName();

        final String body = toJson(Map.of( //
                "type", TYPE_HEARTBEAT, //
                "instanceId", instanceId, //
                "hostname", hostname, //

  private val dnsServers: List<InetAddress>,
) : Dns {
  @Throws(UnknownHostException::class)
  override fun lookup(hostname: String): List<InetAddress> {
    if (this.dnsHostname != hostname) {
      throw UnknownHostException(
        "BootstrapDns called for $hostname instead of $dnsHostname",
      )
    }

    return dnsServers
  }