}
    }

    if (failures.isNotEmpty()) {
      for (failure in failures) {
        println(failure)
      }
      throw failures.first()
    }
  }

  private fun testToAscii(
    input: String,
    output: String?,
    comment: String?,
  ) {
    val url = "https://$input/".toHttpUrlOrNull()
    assertThat(url?.host, name = comment ?: input).isEqualTo(output)
  }

    } catch (e: Exception) {
      synchronized(failures) {
        failures.add(e)
      }
    }
  }

  @Throws(UnknownHostException::class)
  private fun throwBestFailure(
    hostname: String,
    failures: List<Exception>,
  ): List<InetAddress> {
    if (failures.isEmpty()) {
      throw UnknownHostException(hostname)
    }

    val failure = failures[0]

    if (failure is UnknownHostException) {

        " the file."
    )
  n_failures = seen[key]
  p.text += f"\nNOTE: Number of failures for this test: {seen[key]}."
  p.text += "\n      Most TF jobs run tests three times to root out flakes."
  if seen[key] == 3:
    p.text += (
        "\n      Since there were three failures, this is not flaky, and it"
    )

public class SuggestWriterResult {
    protected List<Throwable> failures = Collections.synchronizedList(new ArrayList<>());

    public void addFailure(final Throwable t) {
        failures.add(t);
    }

    public boolean hasFailure() {
        return !failures.isEmpty();
    }

    public List<Throwable> getFailures() {
        return failures;
    }

// previous results
func (dt *dynamicTimeout) adjust(entries [dynamicTimeoutLogSize]time.Duration) {
	failures, max := 0, time.Duration(0)
	for _, dur := range entries[:] {
		if dur == maxDuration {
			failures++
		} else if dur > max {
			max = dur
		}
	}

	failPct := float64(failures) / float64(len(entries))

	if failPct > dynamicTimeoutIncreaseThresholdPct {

		"Number of failures in GET requests proxied to replication target",
		bucketL)
	bucketReplProxiedGetRequestsTotalMD = NewCounterMD(bucketReplProxiedGetRequestsTotal,
		"Number of GET requests proxied to replication target",
		bucketL)
	bucketReplProxiedGetTaggingRequestsFailuresMD = NewCounterMD(bucketReplProxiedGetTaggingRequestsFailures,
		"Number of failures in GET tagging requests proxied to replication target",

import java.net.URI
import okhttp3.internal.format

class RecordingProxySelector : ProxySelector() {
  @JvmField val proxies = mutableListOf<Proxy>()

  private val requestedUris = mutableListOf<URI>()
  private val failures = mutableListOf<String>()

  override fun select(uri: URI): List<Proxy> {
    requestedUris.add(uri)
    return proxies
  }

  fun assertRequests(vararg expectedUris: URI?) {

| `minio_cluster_replication_proxied_head_requests_failures` | (_Site Replication Only_)Number of failures in HEAD requests proxied to replication target                          |

        return EventListener.NONE;
      }
    }
  };

  ...
}
```

### Events with Failures

When an operation fails, a failure method is called. This is `connectFailed()` for failures while building a connection to the server, and `callFailed()` when the HTTP call fails permanently. When a failure happens it is possible that a `start` event won’t have a corresponding `end` event.

   * simulate late connection pool failures.
   */
  object DisconnectAfterRequest : SocketPolicy

  /**
   * Half close connection (InputStream for client) after reading the request but before
   * writing the response. Use this to simulate late connection pool failures.
   */
  object HalfCloseAfterRequest : SocketPolicy