import assertk.assertions.isNotSameAs
import assertk.assertions.isNull
import assertk.assertions.isTrue
import assertk.assertions.matches
import assertk.assertions.prop
import assertk.assertions.startsWith
import assertk.fail
import java.io.FileNotFoundException
import java.io.IOException
import java.io.InterruptedIOException
import java.net.CookieManager
import java.net.CookiePolicy
import java.net.HttpCookie

    protected void interruptTask() {
      assertFalse(interruptTaskWasCalled);
      interruptTaskWasCalled = true;
    }
  }

  private static boolean isWindows() {
    return OS_NAME.value().startsWith("Windows");
  }

                final Header locationHeader = response.getFirstHeader("location");
                if (locationHeader != null) {
                    final String redirectLocation;
                    if (locationHeader.getValue().startsWith("/")) {
                        redirectLocation = constructRedirectLocation(url, locationHeader.getValue());
                    } else {
                        redirectLocation = locationHeader.getValue();

                if (destPath.startsWith("\\")) {
                    destPath = destPath.substring(1);
                }

                // Open the source file for renaming
                // Use share-relative path for consistency with destination path handling
                String sourcePath = getUncPath();
                if (sourcePath.startsWith("\\")) {

      // used in this graph
      for (const auto& pair : g->name_map) {
        const string& name = pair.first;
        if ((name == prefix) || absl::StartsWith(name, prefix_cmp)) {
          status->status = InvalidArgument(
              "prefix [", prefix,
              "] conflicts with existing node in the graph named [", name, "]");
          return;
        }

    checkNotNull(hostAddr);

    // Decide if this should be an IPv6 or IPv4 address.
    String ipString;
    int expectBytes;
    if (hostAddr.startsWith("[") && hostAddr.endsWith("]")) {
      ipString = hostAddr.substring(1, hostAddr.length() - 1);
      expectBytes = 16;
    } else {
      ipString = hostAddr;
      expectBytes = 4;
    }

        putEnv(env, Context.PROVIDER_URL, providerUrl);
        putEnv(env, Context.SECURITY_PRINCIPAL, principal);
        putEnv(env, Context.SECURITY_CREDENTIALS, credntials);
        if (providerUrl != null && providerUrl.startsWith("ldaps://")) {
            putEnv(env, Context.SECURITY_PROTOCOL, "ssl");
        }
        return env;
    }

    /**
     * Puts a key-value pair to the environment.
     *

    assertThat(call).contains("protocol=http")
    assertThat(call.lowercase(Locale.US)).contains("scheme=basic")
  }

  private fun authCallsForHeader(authHeader: String): List<String> {
    val proxy = authHeader.startsWith("Proxy-")
    val responseCode = if (proxy) 407 else 401
    val authenticator = RecordingAuthenticator(null)
    java.net.Authenticator.setDefault(authenticator)
    server.enqueue(
      MockResponse

labels.ldap_account_filter=Kontofilter
labels.ldap_group_filter=Gruppenfilter
labels.ldap_memberof_attribute=memberOf-Attribut
labels.notification_login=Anmeldeseite
labels.notification_search_top=Such-Startseite
labels.storage_endpoint=Endpunkt
labels.storage_access_key=Zugriffsschlüssel
labels.storage_secret_key=Geheimer Schlüssel
labels.storage_bucket=Bucket
labels.send_testmail=Test-E-Mail senden