}
    }

    /**
     * Create an {@code NtlmPasswordAuthentication} object with raw password
     * hashes. This is used exclusively by the {@code jcifs.smb1.http.NtlmSsp}
     * class which is in turn used by NTLM HTTP authentication functionality.
     */
    /**
     * Create an NtlmPasswordAuthentication object with raw password hashes.
     *
     * @param domain the authentication domain

                log.debug("Failed to load key from KeyStore: {}", e.getMessage());
            }
        }

        return key;
    }

    /**
     * Get raw key bytes
     *
     * @param sessionId unique session identifier
     * @return raw key bytes, or null if not found
     */
    public byte[] getRawKey(String sessionId) {
        checkNotClosed();

        byte[] key = rawKeys.get(sessionId);

	if len(setSQL) == 0 || len(getSQL) == 0 {
		return
	}

	err := DB.Connection(func(tx *gorm.DB) error {
		if err := tx.Exec(setSQL, expectedName).Error; err != nil {
			return err
		}

		if err := tx.Raw(getSQL).Scan(&actualName).Error; err != nil {
			return err
		}
		return nil
	})
	if err != nil {
		t.Errorf(fmt.Sprintf("WithSingleConnection should work, but got err %v", err))
	}

     * @return an {@link Optional} containing the file path, or empty if not set
     */
    @Nonnull
    Optional<String> logFile();

    /**
     * Returns whether raw streams should be logged.
     *
     * @return a boolean indicating whether raw streams should be logged
     */
    @Nonnull
    Optional<Boolean> rawStreams();

    /**
     * Returns the color setting for console output.
     *

class PostFile {
  private val client = OkHttpClient()

  fun run() {
    val file = File("README.md")

    val request =
      Request(
        url = "https://api.github.com/markdown/raw".toHttpUrl(),
        body = file.asRequestBody(MEDIA_TYPE_MARKDOWN),
      )

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      newCases += case.copy(wire = bytesOut.readByteString())
    }

    testDecoder(story.copy(cases = newCases))
  }

  companion object {
    private val RAW_DATA = arrayOf("raw-data")
  }

            if (x * i == n) return "${factor(x)} × $i"
          }
          return n.toString()
        }
      }

    val request =
      Request(
        url = "https://api.github.com/markdown/raw".toHttpUrl(),
        body = requestBody,
      )

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

   * we wanted to support legacy classes that implement the raw type {@code Comparable} (instead of
   * implementing {@code Comparable<Foo>}) without producing warnings. If so, we would prefer today
   * to produce warnings in that case, and we may change this method to do so in the future. Support
   * for raw {@code Comparable} types in Guava in general is tracked as <a

import java.security.cert.X509Certificate
import javax.net.ssl.SSLPeerUnverifiedException
import javax.net.ssl.X509TrustManager
import okhttp3.internal.platform.Platform

/**
 * Computes the effective certificate chain from the raw array returned by Java's built in TLS APIs.
 * Cleaning a chain returns a list of certificates where the first element is `chain[0]`, each
 * certificate is signed by the certificate that follows, and the last certificate is a trusted CA

### 1. Fetch the root identity

As the initial step, fetch the private key and certificate of the root identity:

```sh
curl -sSL --tlsv1.2 \
     -O 'https://raw.githubusercontent.com/minio/kes/master/root.key' \
     -O 'https://raw.githubusercontent.com/minio/kes/master/root.cert'
```

### 2. Set the MinIO-KES configuration

```sh
export MINIO_KMS_KES_ENDPOINT=https://play.min.io:7373