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,

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

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

            for (EdgeState incomingEdge : incomingEdges) {
                ComponentSelector selector = incomingEdge.getSelector().getSelector();
                incomingEdge.failWith(new ModuleVersionResolveException(selector, () ->
                    String.format("Could not resolve %s: Resolution strategy disallows usage of dynamic versions", selector)));
            }
        }
    }

     * done when a failure is caused by graph validation. In that case we want to
     * perform as much resolution as possible, still have a valid graph, but in the
     * end fail resolution.
     */
    void failWith(Throwable err) {
        targetNodeSelectionFailure = new ModuleVersionResolveException(dependencyState.getRequested(), err);
    }


    public void restart() {
        if (from.isSelected()) {