// given
        mockGitOperation(listOf("git", "fetch", "origin", "master", "release"), "")
        mockGitOperation(listOf("git", "merge-base", "origin/master", "HEAD"), "master-fork-point")
        mockGitOperation(listOf("git", "merge-base", "origin/release", "HEAD"), "release-fork-point")
        mockGitOperation(listOf("git", "show", "master-fork-point:version.txt"), "5.1")

    }

    // Should not be pinned:
    certificatePinner.check("uk", listOf(certB1.certificate))
    certificatePinner.check("co.uk", listOf(certB1.certificate))
    certificatePinner.check("anotherexample.co.uk", listOf(certB1.certificate))
    certificatePinner.check("foo.anotherexample.co.uk", listOf(certB1.certificate))
  }

  @Test

        .build()

    certificatePinner.check("example.com", listOf(certA1.certificate))
  }

  @Test fun successfulFindMatchingPins() {
    val certificatePinner =
      CertificatePinner.Builder()
        .add("first.com", certA1Sha256Pin, certB1Sha256Pin)
        .add("second.com", certC1Sha256Pin)
        .build()

    val expectedPins =
      listOf(
        Pin("first.com", certA1Sha256Pin),

    builder.interceptors().addAll(listOf(null) as List<Interceptor>)
    assertFailsWith<IllegalStateException> {
      builder.build()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Null interceptor: [null]")
    }
  }

  @Test fun nullNetworkInterceptorInList() {
    val builder = OkHttpClient.Builder()
    builder.networkInterceptors().addAll(listOf(null) as List<Interceptor>)

sourceSets {
    main {
        java.setSrcDirs(listOf(ant.properties["src.dir"]))
        java.destinationDirectory = file(ant.properties["classes.dir"] ?: layout.buildDirectory.dir("classes"))
    }
}
// end::source-sets[]

// tag::task-dependencies[]
tasks {
    compileJava {
        dependsOn("prepare")  // <1>
    }
    named("package") {
        setDependsOn(listOf(compileJava))  // <2>
    }
    assemble {

                    "-x", ":distributions-integ-tests:configCacheTest"
                ) +
                listOf(extraParameters) +
                functionalTestParameters(os, arch) +
                listOf(buildScanTag(functionalTestTag))
            ).joinToString(separator = " ")
        steps {
            gradleWrapper {

            ),
            result
        )
        assertEquals(
            listOf(ResolutionError(imports[1], ErrorReason.AmbiguousImport(DefaultFqName("a.c", "C")))),
            analysisContext.errorCollector.errors
        )
    }

    @Test
    fun `does not report errors on the same import appearing more than once`() {
        val imports = listOf(
            importOf("a", "b", "C"),
            importOf("a", "b", "C"),

plugins {
    id("org.fmiw.plantuml") version "0.1"
}

defaultTasks = listOf("generateDiagrams")

plantuml {
    options {
        outputDir = file("images")
    }
    diagrams {
        for (diagram in listOf("C4_1_Context", "C4_2_Container", "C4_3_Component")) {
            register(diagram) {
                sourceFile = file("$diagram.puml")
            }
        }
    }

    enableProtocol(Protocol.HTTP_2)

    val request = Request(server1.url("/"))

    server1.enqueue(refusedStream)
    server2.enqueue(bodyResponse)

    dns[server1.hostName] = listOf(ipv6, ipv4)
    socketFactory[ipv6] = server1.inetSocketAddress
    socketFactory[ipv4] = server2.inetSocketAddress

    client =
      client.newBuilder()
        .fastFallback(false)
        .apply {

                    TypedProjectSchema(
                        extensions = listOf(
                            entry<Project, ExtraPropertiesExtension>("extra")
                        ),
                        conventions = listOf(
                            entry<Project, CustomConvention>("customConvention")
                        ),
                        tasks = listOf(
                            entry<TaskContainer, Delete>("delete")