if (MemoryUtil.getUsedMemory() < current + margin) {
                break;
            }
            System.gc();
            Thread.sleep(1000L);
        }
        final long usedMemory = MemoryUtil.getUsedMemory();
        assertTrue(usedMemory + " < " + current + " + " + margin + ", " + MemoryUtil.getMemoryUsageLog(), usedMemory < current + margin);
    }

_2018-07-12_

Added a new extra strict RESTRICTED_TLS configuration inspired by [Google Cloud’s similar policy][googlecloud_ssl_policy]. It is appropriate when both the host platform
(JVM/Conscrypt/Android) and target webserver are current.

##### RESTRICTED_TLS cipher suites

 * TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
 * TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
 * TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
 * TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384

  private val parameterNamesAndValues: Array<String>,
) {
  /**
   * Returns the charset of this media type, or [defaultValue] if either this media type doesn't
   * specify a charset, or if its charset is unsupported by the current runtime.
   */
  @JvmOverloads
  fun charset(defaultValue: Charset? = null): Charset? {
    val charset = parameter("charset") ?: return defaultValue
    return try {
      Charset.forName(charset)

     * @return true if successful (return code is ERROR_SUCCESS)
     */
    public boolean isSuccess() {
        return returnCode == ERROR_SUCCESS;
    }

    /**
     * Gets the error message for the current return code.
     *
     * @return a human-readable error message
     */
    public String getErrorMessage() {
        switch (returnCode) {
        case ERROR_SUCCESS:
            return "Success";

// a byte slice.
// Unlike a [Buffer], a Reader is read-only and supports seeking.
// The zero value for Reader operates like a Reader of an empty slice.
type Reader struct {
	s        []byte
	i        int64 // current reading index
	prevRune int   // index of previous rune; or < 0
}

// Len returns the number of bytes of the unread portion of the
// slice.
func (r *Reader) Len() int {
	if r.i >= int64(len(r.s)) {
		return 0

// a io.Reader compatible interface.
type DecryptBlocksReader struct {
	// Source of the encrypted content that will be decrypted
	reader io.Reader
	// Current decrypter for the current encrypted data block
	decrypter io.Reader
	// Start sequence number
	startSeqNum uint32
	// Current part index
	partIndex int
	// Parts information
	parts []ObjectPartInfo

	objectEncryptionKey                []byte

     */
    protected String getVirtualHostBasePath(final String s, final HtmlNext page) {
        return StringUtil.isBlank(s) ? StringUtil.EMPTY : "/" + s;
    }

    /**
     * Gets the virtual host key from the current request.
     * The key is determined by matching HTTP headers against configured virtual hosts.
     *
     * @return The virtual host key, or empty string if no match found
     */
    public String getVirtualHostKey() {

### GNU/Linux and macOS

```sh
docker-compose pull

 *
 * If your authentication may be flaky and requires retries you should apply some policy
 * to limit the retries by the class of errors and number of attempts.  To get the number of
 * attempts to the current point use this function.
 *
 * ```java
 * private int responseCount(Response response) {
 *   int result = 1;
 *   while ((response = response.priorResponse()) != null) {
 *     result++;
 *   }

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import junit.framework.TestCase;
import org.jspecify.annotations.Nullable;

/**
 * Abstract test case parent for anything implementing {@link ListenableFuture}. Tests the two get
 * methods and the addListener method.
 *
 * @author Sven Mawson
 * @since 10.0
 */
@GwtIncompatible