expect:
        task.getOnlyIf().isSatisfiedBy(task)

        when:
        task.onlyIf("Always false", spec)

        then:
        !task.getOnlyIf().isSatisfiedBy(task)
        def foundSpec = task.getOnlyIf().findUnsatisfiedSpec(task)
        foundSpec != null
        foundSpec.displayName == "Always false"
    }

        }

        expect:
        task.getOnlyIf().isSatisfiedBy(task)

        when:
        task.setEnabled(false)

        then:
        assertFalse(task.getOnlyIf().isSatisfiedBy(task))

        when:
        task.setEnabled(true)
        condition1.set(false)

        then:
        assertFalse(task.getOnlyIf().isSatisfiedBy(task))

        when:

        Spec<? super TaskInternal> unsatisfiedSpec = null;
        try {
            Spec<? super TaskInternal> onlyIf = task.getOnlyIf();
            // Some third-party plugins override getOnlyIf, returning a generic Spec
            if (onlyIf instanceof DescribingAndSpec) {
                DescribingAndSpec<? super TaskInternal> describingAndSpec = Cast.uncheckedCast(onlyIf);

    def setup() {
        ProjectInternal project = Mock(ProjectInternal)

        task.getProject() >> project
        project.getBuildScriptSource() >> scriptSource
        task.getOnlyIf() >> spec
    }

    void noMoreInteractions() {
        interaction {
            0 * task._
            0 * spec._
            0 * state._
            0 * executionContext._
            0 * scriptSource._

    public File getFile() {
        return generator.get().getOutputs().getFiles().getSingleFile();
    }

    public boolean isEnabled() {
        TaskInternal task = (TaskInternal) generator.get();
        return task.getOnlyIf().isSatisfiedBy(task);
    }

    @Override
    public boolean shouldBePublished() {
        return isEnabled();
    }

     * once they start executing.
     */
    @Internal
    List<InputChangesAwareTaskAction> getTaskActions();

    @Internal
    boolean hasTaskActions();

    @Internal
    Spec<? super TaskInternal> getOnlyIf();

    /**
     * Return the reason for not to track state.
     *
     * Gradle considers the task as untracked if the reason is present.

            ));
    }

    private static boolean isEnabled(Node node) {
        if (node instanceof LocalTaskNode) {
            TaskInternal task = ((LocalTaskNode) node).getTask();
            return task.getOnlyIf().isSatisfiedBy(task);
        }
        return false;
    }

    // In a perfect world, the consumer should depend on the producer.

            return signature.getFile();
        }

        @Override
        public boolean shouldBePublished() {
            return signTask.isEnabled()
                && signTask.getOnlyIf().isSatisfiedBy(signTask);
        }
    }

                return element == AbstractTask.this && enabled;
            }
        }, "Task is enabled");
    }

    @Override
    public Spec<? super TaskInternal> getOnlyIf() {
        return onlyIfSpec;
    }

    @Override
    public void doNotTrackState(String reasonNotToTrackState) {
        if (reasonNotToTrackState == null) {