}

    @FailsWith(TooManyInvocationsError)
    def "async action fails when start action throws an exception"() {
        Runnable action = Mock()
        def executed = startsAsyncAction()

        when:
        executed.started {
            action.run()
        }

        then:
        0 * action.run()
    }

    @FailsWith(TooManyInvocationsError)

            skipped = true
        }

        void passes() {
            messages = [:]
        }

        void failsWith(Map<String, Severity> messages) {
            this.messages = messages
        }

        void failsWith(String singleMessage, Severity severity) {
            failsWith([(singleMessage): severity])
        }
    }

    void configureValidation(String testedPluginId, String version) {
        validatePlugins {
            if (testedPluginId == 'com.moowork.node') {
                onPlugin('com.moowork.node') {
                    failsWith([
                        (missingAnnotationMessage { type('com.moowork.gradle.node.npm.NpmSetupTask').property('args').missingInputOrOutput().includeLink() }): ERROR,

    }

    @SuppressWarnings('UnnecessaryQualifiedReference')
    protected registerValidationFailure(org.gradle.smoketests.WithPluginValidation.PluginValidation pluginValidation) {
        pluginValidation.failsWith(nestedTypeUnsupported {
            type('org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest')
                    .property('environment')
                    .annotatedType('java.lang.String')

                passing {
                    it !in failingPlugins
                }
                onPlugins(failingPlugins) {
                    failsWith([
                        (missingAnnotationMessage { type('com.android.build.gradle.internal.TaskManager.ConfigAttrTask').property('consumable').missingInputOrOutput().includeLink() }): ERROR,

            return Collections.emptyList();
        }
        return Collections.singletonList(validator);
    }

    private void failWith(String message) {
        failWith(message, null);
    }

    private void failWith(String message, @Nullable String explanation) {
        errors.add(message);
        if (explanation != null) {
            explanations.add(explanation);
        }

                VerificationFailure error = result.asError(publicKeyService);
                builder.failWith(error);
                if (error.isFatal()) {
                    return;
                }
            } else {
                return;
            }
        }
        builder.failWith(new MissingChecksums(file));
    }

            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"() {

 * limitations under the License.
 */
package org.gradle.api.internal.artifacts.verification.verifier;

public interface ArtifactVerificationResultBuilder {
    void failWith(VerificationFailure failure);

                    it.name == name
            }
            if (child == null) {
                failWith("test method suite", name)
            }
            assertSpec(child, testEvents, verifiedEvents, "Test method $name", spec)
        }

        private void failWith(String what, String name) {
            ErrorMessageBuilder err = new ErrorMessageBuilder()