if [ $? -ne 0 ]; then
	echo "listing failed, 'minioadmin' should be enabled"
	exit 1
fi

killall -9 minio

rm -rf /tmp/multisitea/
rm -rf /tmp/multisiteb/

echo "Setup site-replication and then disable root credentials"

minio server --address 127.0.0.1:9001 "http://127.0.0.1:9001/tmp/multisitea/data/disterasure/xl{1...4}" \
	"http://127.0.0.1:9002/tmp/multisitea/data/disterasure/xl{5...8}" >/tmp/sitea_1.log 2>&1 &

    // and should not be modeled as one.
    public void addDependencyLockingFailures(long rootId, Set<UnresolvedDependency> extraFailures) {
        DefaultResolvedComponentResult root = components.get(rootId);
        for (UnresolvedDependency failure : extraFailures) {
            ModuleVersionSelector failureSelector = failure.getSelector();

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

        if (isExplodedModularRuntime(jdkHome)) {
            try {
                try (DirectoryStream<Path> roots = Files.newDirectoryStream(jdkHome.resolve("modules"))) {
                    for (Path root : roots) {
                        result.add(getUrlForLibraryRoot(root));
                    }
                }
            }
            catch (IOException ignore) {
            }
        }

    variantImplementation[style=dashed, label=<main<i>Variant</i>Implementation<br/>(configuration)>]
  }

  subgraph secondLine {
    includeRoot[style="rounded,filled", fillcolor="#bfffbf", label="Compilation include roots"]
  }

  subgraph thirdLine {
    {rank=same sourceFiles compileVariantCpp outputDirectory}
    includeRoot -> compileVariantCpp
    sourceFiles -> compileVariantCpp
    compileVariantCpp -> outputDirectory

            }
            if (rootId != null && candidatesForConflict.size() > 1) {
                // This is a special case for backwards compatibility: it is possible to have
                // a cycle where the root component depends on a library which transitively
                // depends on a different version of the root module. In this case, we effectively
                // allow 2 modules to have the same capability, so we filter the nodes coming

	// Default path prefix for all keys on etcd, other than CoreDNSPath.
	cfg.PathPrefix = env.Get(EnvEtcdPathPrefix, kvs.Get(PathPrefix))
	if etcdSecure {
		cfg.TLS = &tls.Config{
			RootCAs: rootCAs,
		}
		// This is only to support client side certificate authentication
		// https://coreos.com/etcd/docs/latest/op-guide/security.html
		etcdClientCertFile := env.Get(EnvEtcdClientCert, kvs.Get(ClientCert))

  }

  @Test
  fun testBasicAuth() {
    fakeDns["server"] = listOf(InetAddress.getLocalHost())

    val route = factory.newRoute()

    val request =
      Request.Builder()
        .url("https://server/robots.txt")
        .build()
    val response =
      Response.Builder()
        .request(request)
        .code(401)
        .header("WWW-Authenticate", "Basic realm=\"User Visible Realm\"")
        .protocol(HTTP_2)

        def textFile = file('text-file.txt')
        textFile.text = "text file as root"

        expect:
        fails language.compileTaskName
        failure.assertHasCause(
            'Unable to infer source roots. ' +
                'Incremental Groovy compilation requires the source roots. ' +
                'Change the configuration of your sources or disable incremental Groovy compilation.')
    }

        textFile.text = "text file as root"

        outputs.snapshot { run language.compileTaskName }

        when:
        file("extra/B.${language.name}").text = "class B { String change; }"
        executer.withArgument "--info"
        run language.compileTaskName

        then:
        outputs.recompiledClasses("A", "B", "C")