doLast { task ->
                    assert notified
                    assert gradle.taskGraph.hasTask(task)
                    assert gradle.taskGraph.hasTask(':a')
                    assert gradle.taskGraph.hasTask(a)
                    assert gradle.taskGraph.hasTask(':b')
                    assert gradle.taskGraph.hasTask(b)
                    assert gradle.taskGraph.allTasks == [b, a]
                }
            }

        when:
        populate([d])

        then:
        taskGraph.hasTask(":a")
        taskGraph.hasTask(a)
        taskGraph.hasTask(":b")
        taskGraph.hasTask(b)
        taskGraph.hasTask(":c")
        taskGraph.hasTask(c)
        taskGraph.hasTask(":d")
        taskGraph.hasTask(d)
        taskGraph.allTasks == [a, b, c, d]
    }

            if (!tasks.isEmpty()) {
                return new FixedTaskSelectionResult(tasks);
            }
        } else {
            discoverTasks(project);
            if (hasTask(taskName, project)) {
                return new TaskSelectionResult() {
                    @Override
                    public void collectTasks(Collection<? super Task> tasks) {

            val coupledProjects = listOf(taskOwner)
            reportCrossProjectTaskAccess(coupledProjects, task.path)
        }
    }

    override fun hasTask(task: Task): Boolean {
        checkCrossProjectTaskAccess(task)
        return delegate.hasTask(task)
    }

    override fun getAllTasks(): MutableList<Task> {
        val result = delegate.allTasks
        observingTasksMaybeFromOtherProjects(result)

            name = "localRepo"
            url = uri(layout.buildDirectory.dir("repo"))
        }
    }
}

// tag::conditional-signing[]
signing {
    required { isReleaseVersion && gradle.taskGraph.hasTask("publish") }
    sign publishing.publications.main
}
// end::conditional-signing[]

// Alternative to signing.required
// tag::only-if[]
tasks.withType(Sign) {

            url = uri(layout.buildDirectory.dir("repo"))
        }
    }
}

// tag::conditional-signing[]
signing {
    setRequired({
        (project.extra["isReleaseVersion"] as Boolean) && gradle.taskGraph.hasTask("publish")
    })
    sign(publishing.publications["main"])
}
// end::conditional-signing[]

// Alternative to signing.required
// tag::only-if[]
tasks.withType<Sign>().configureEach {

        "graph.hasTask(':b:bTask')"          | [":b:help"]                      | true
        "graph.hasTask(':b:help')"           | [":b:help"]                      | true
        "graph.hasTask(':help')"             | [":b:help"]                      | false
        "graph.hasTask(':x:unknown')"        | [":b:help"]                      | false

        then:
        result.groupedOutput.task(':helloWorld').output == helloWorldMessage
        result.groupedOutput.task(':byeWorld').output == byeWorldMessage
        hasSilenceTaskOutput == result.groupedOutput.hasTask(':silence')
    }

    def 'failed task result can be rendered'() {
        given:
        buildFile << '''
            task myFailure {
                doLast {
                    assert false

    }

    public int getTransformCount() {
        return transforms.size();
    }

    public boolean hasTask(String taskName) {
        return tasks.containsKey(taskName);
    }

    public GroupedTaskOutputFixture task(String taskName) {
        boolean foundTask = hasTask(taskName);

        if (!foundTask) {

    if (name.endsWith("ToRemoteRepository")) {
        failEarlyIfUrlOrCredentialsAreNotSet(this)
    }
}

fun Project.failEarlyIfUrlOrCredentialsAreNotSet(publish: Task) {
    gradle.taskGraph.whenReady {
        if (hasTask(publish)) {
            if (artifactoryUrl.isEmpty()) {
                throw GradleException("artifactoryUrl is not set!")
            }
            if (artifactoryUserName.isNullOrEmpty()) {