problem = problem.capitalize()
        assert problems.contains(problem)
        verified.add(problem)
    }

    private void done() {
        if (verified && !(verified == problems as Set)) {
            throw new AssertionError("Expected ${problems.size()} problems but you only checked ${verified.size()}")
        }
    }

        run("verify")

        then:
        output.contains("verified = ISO-8859-1")
        daemons.daemons.size() == 2
    }

    def "forks new daemon when tmpdir is set to different value via commandline"() {
        setup:
        buildScript """
            task verify {
                doFirst {
                    println "verified = \${File.createTempFile('pre', 'post')}"
                }
            }

     */
    public static final ArtifactStatus DEPLOYED = new ArtifactStatus("deployed", 4);

    /**
     * Trusted, as it has had its data verified by hand.
     */
    public static final ArtifactStatus VERIFIED = new ArtifactStatus("verified", 5);

    private final int rank;

    private final String key;

    private static Map<String, ArtifactStatus> map;

            result.verified(Stub(PGPPublicKey), false)
            result.verified(Stub(PGPPublicKey), false)
        })
        1 * result.failWith(_)
        0 * _
    }

    @Issue("https://github.com/gradle/gradle/issues/19089")
    def "should not fail when custom implementation of ModuleComponentIdentifier is verified"() {

        Set<IvyArtifact> verified = new HashSet<IvyArtifact>();

        for (final IvyArtifact artifact : publication.getAllArtifacts()) {
            checkNotDuplicate(publication, verified, artifact.getName(), artifact.getExtension(), artifact.getType(), artifact.getClassifier());
            verified.add(artifact);
        }

        // Check that ivy.xml isn't duplicated

    private final ModuleComponentIdentifier component;
    private final Consumer<TreeFormatter> causeErrorFormatter;

    /**
     * Creates a new exception when a component cannot be verified - because of some reason.
     *
     * @param component the component which failed the verification
     */
    public ComponentVerificationException(String message, ModuleComponentIdentifier component) {

apiVersion: release-notes/v2
kind: feature
area: security
releaseNotes:
- |
  **Updated** default value of the feature flag `VERIFY_CERT_AT_CLIENT` to true.
  This means server certificates will be automatically verified using the OS CA certificates when not using a DestinationRule caCertificates field.
  If undesired please use the new `compatibilityVersion` feature to fallback to old behavior, or `insecureSkipVerify`

    private void checkNoDuplicateArtifacts(MavenNormalizedPublication publication) {
        Set<MavenArtifact> verified = new HashSet<>();
        for (MavenArtifact artifact : publication.getAllArtifacts()) {
            checkNotDuplicate(publication, verified, artifact.getExtension(), artifact.getClassifier());
            verified.add(artifact);
        }
    }

                            return;
                        }
                        try {
                            boolean verified = SecuritySupport.verify(origin, pgpSignature, pgpPublicKey);
                            if (!verified) {
                                result.failed(pgpPublicKey);
                            } else {

// tag::custom-task-implementation[]
import org.gradle.api.tasks.options.Option;

public class UrlVerify extends DefaultTask {
    private String url;

    @Option(option = "url", description = "Configures the URL to be verified.")
    public void setUrl(String url) {
        this.url = url;
    }

    @Input
    public String getUrl() {
        return url;
    }

    @TaskAction
    public void verify() {