.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),

    }

    // 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

                    ).joinToString(separator = " ")
                skipConditionally()
            }
        }

        fun BuildSteps.adHocPerformanceTest(tests: List<String>) {
            gradleStep(
                listOf(
                    "clean",
                    "performance:${testProject}PerformanceAdHocTest",
                    tests.map { """--tests "$it"""" }.joinToString(" "),

                parameters = null,
              ),
            issuer =
              listOf(
                listOf(
                  AttributeTypeAndValue(
                    type = countryName,
                    value = "US",
                  ),
                ),
                listOf(
                  AttributeTypeAndValue(
                    type = organizationName,

        this.description = stage.stageName.description
    }) {
    val specificBuildTypes: List<OsAwareBaseGradleBuildType>

    val performanceTests: List<PerformanceTestsPass>

    val functionalTests: List<OsAwareBaseGradleBuildType>

    val crossVersionTests: List<OsAwareBaseGradleBuildType>

    val docsTestTriggers: List<OsAwareBaseGradleBuildType>

    init {
        features {

            functionalTestExtraParameters(
                listOf("FlakyTestQuarantine"),
                os,
                arch,
                testCoverage.testJvmVersion.major.toString(),
                testCoverage.vendor.name.lowercase(),
            )
        val parameters =
            (
                buildToolGradleParameters() +
                    listOf(
                        "-PflakyTests=only",

            object : CookieManager() {
              override fun get(
                uri: URI,
                requestHeaders: Map<String, List<String>>,
              ) = mapOf(
                "COOKIE" to listOf("Bar=bar"),
                "cooKIE2" to listOf("Baz=baz"),
              )
            },
          ),
        ).build()
    server.enqueue(MockResponse())
    get(server.url("/"))

    val stageName: StageName,
    val specificBuilds: List<SpecificBuild> = emptyList(),
    val functionalTests: List<TestCoverage> = emptyList(),
    val docsTests: List<DocsTestCoverage> = emptyList(),
    val performanceTests: List<PerformanceTestCoverage> = emptyList(),
    val performanceTestPartialTriggers: List<PerformanceTestPartialTrigger> = emptyList(),
    val flameGraphs: List<FlameGraphGeneration> = emptyList(),

    val handshake =
      Handshake.get(
        tlsVersion = TlsVersion.TLS_1_3,
        cipherSuite = CipherSuite.TLS_AES_128_GCM_SHA256,
        peerCertificates = listOf(serverCertificate.certificate, serverIntermediate.certificate),
        localCertificates = listOf(),
      )

    assertThat(handshake.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    assertThat(handshake.cipherSuite).isEqualTo(CipherSuite.TLS_AES_128_GCM_SHA256)

    assertThat(listOf(clientCertificate.certificate, clientIntermediate.certificate))
      .isEqualTo(serverHandshake.peerCertificates)
    assertThat(listOf(serverCertificate.certificate, serverIntermediate.certificate))
      .isEqualTo(serverHandshake.localCertificates)
    val clientHandshake = clientHandshakeFuture.get()
    assertThat(listOf(serverCertificate.certificate, serverIntermediate.certificate))