return Platform.get().newSSLContext().apply {
      init(arrayOf<KeyManager>(keyManager), arrayOf<TrustManager>(trustManager), SecureRandom())
    }
  }

  class Builder {
    private var heldCertificate: HeldCertificate? = null
    private var intermediates: Array<X509Certificate>? = null
    private val trustedCertificates = mutableListOf<X509Certificate>()
    private val insecureHosts = mutableListOf<String>()

    /**

		Endpoint  string
		ItemState madmin.ItemState
	}

	var wg sync.WaitGroup
	results := make([]Result, len(c.client.Endpoints))
	for i := range c.client.Endpoints {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()

			client := kes.Client{
				Endpoints:  []string{c.client.Endpoints[i]},
				HTTPClient: c.client.HTTPClient,
			}

			var item madmin.ItemState
			if _, err := client.Status(ctx); err == nil {

                                            </tr>
                                            </thead>
                                            <tbody>
                                            <c:forEach var="logFile" varStatus="s"
                                                       items="${logFileItems}">
                                                <tr

import okio.Buffer

class FakeDns : Dns {
  private val hostAddresses: MutableMap<String, List<InetAddress>> = mutableMapOf()
  private val requestedHosts: MutableList<String> = mutableListOf()
  private var nextAddress = 0xff000064L // 255.0.0.100 in IPv4; ::ff00:64 in IPv6.

  /** Sets the results for `hostname`.  */
  operator fun set(
    hostname: String,
    addresses: List<InetAddress>,
  ): FakeDns {

            "",
            display = ParameterDisplay.NORMAL,
            allowEmpty = true,
            description = "Set to 'true' if you want to skip all dependency builds"
        )
    }

    var prevStage: Stage? = null
    val previousPerformanceTestPasses: MutableList<PerformanceTestsPass> = mutableListOf()
    val previousCrossVersionTests: MutableList<BaseGradleBuildType> = mutableListOf()

		return nil, fmt.Errorf("failed to get dynamic listener dump: %s", err)
	}

	return &Analyzer{listenerDump: listeners}, nil
}

// Print print the analysis results.
func (a *Analyzer) Print(writer io.Writer) {
	var listeners []*listener.Listener
	for _, l := range a.listenerDump.DynamicListeners {
		listenerTyped := &listener.Listener{}
		// Support v2 or v3 in config dump. See ads.go:RequestedTypes for more info.

					},
					LastUpdated: timestamppb.Now(),
				},
				ClientStatus: 453,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var buf bytes.Buffer
			a.Print(&buf)
			expectedOutput := "ACTION   AuthorizationPolicy   RULES\n"
			actualOutput := buf.String()
			if !reflect.DeepEqual(expectedOutput, actualOutput) {

		endpoints, err := expandEndpoints(rawEndpoint)
		if err != nil {
			return nil, err
		}

		key, err := kms.ParseAPIKey(env.Get(EnvKMSAPIKey, ""))
		if err != nil {
			return nil, err
		}

		var rootCAs *x509.CertPool
		if opts != nil && opts.CADir != "" {
			rootCAs, err = certs.GetRootCAs(opts.CADir)
			if err != nil {
				return nil, err
			}
		}

		client, err := kms.NewClient(&kms.Config{

// Returns nil, nil if no checksum.
func GetContentChecksum(h http.Header) (*Checksum, error) {
	if trailing := h.Values(xhttp.AmzTrailer); len(trailing) > 0 {
		var res *Checksum
		for _, header := range trailing {
			var duplicates bool
			switch {
			case strings.EqualFold(header, ChecksumCRC32C.Key()):
				duplicates = res != nil
				res = NewChecksumWithType(ChecksumCRC32C|ChecksumTrailing, "")

      GzipSource(resource).buffer().use { source ->
        val length = source.readInt()
        buffer.write(source, length.toLong())
      }
    }
    while (!buffer.exhausted()) {
      var publicSuffix = buffer.readUtf8LineStrict()
      if (publicSuffix.contains("*")) {
        // A wildcard rule, let's replace the wildcard with a value.
        publicSuffix = publicSuffix.replace("\\*".toRegex(), "square")