definition.severity == Severity.WARNING
        }
    }

    def "notCompatibleWithConfigurationCache task problems are reported as Advice"() {
        given:
        buildFile """
            task run {
                notCompatibleWithConfigurationCache("because")
                doLast {
                    println(project.name)
                }
            }
        """

private
const val maxCauses = 5


internal
enum class ProblemSeverity {
    Info,
    Failure,

    /**
     * A problem produced by a task marked as [notCompatibleWithConfigurationCache][Task.notCompatibleWithConfigurationCache].
     */
    Suppressed
}


/**
 * This class is thread-safe.
 */
internal
class ConfigurationCacheProblemsSummary(

    private

        }
    }

    private addTasksWithoutProblems() {
        buildFile """
            tasks.register('declared') {
                notCompatibleWithConfigurationCache("not really")
                doLast {
                }
            }
        """
    }

    private addTasksWithProblems(String brokenFieldValue = 'project.configurations') {

                println("Materialized task \${task.name} from project \${task.project.name}")
            }

            tasks.register("offender") {
                notCompatibleWithConfigurationCache("calls getProject")
                // This task reaches out to other task at execution time and triggers its configuration.
                doLast { task ->

        // and that usage can be benign. This is especially important when the currently running task is
        // marked as `notCompatibleWithConfigurationCache` - attributing the error to `task` will cause
        // the build to fail when it really shouldn't.
        val contextTask = runningTask ?: task
        val isExecutingOtherTask = contextTask != task

    val task = getProject(projectPath).tasks.createWithoutConstructor(taskName, taskClass, uniqueId) as TaskInternal
    if (incompatibleReason != null) {
        task.notCompatibleWithConfigurationCache(incompatibleReason)
    }
    return task
}


private
inline fun IsolateContext.withTaskReferencesAllowed(action: () -> Unit) {
    val ownerTask = isolate.owner as IsolateOwners.OwnerTask

    public Optional<String> getReasonNotToTrackState() {
        return Optional.ofNullable(reasonNotToTrackState);
    }

    @Override
    public void notCompatibleWithConfigurationCache(String reason) {
        taskMutator.mutate("Task.notCompatibleWithConfigurationCache(String)", () -> {
            reasonIncompatibleWithConfigurationCache = reason;
        });
    }

    @Override

     * could still cause the build to fail.
     * </p>
     *
     * @since 7.4
     */
    void notCompatibleWithConfigurationCache(String reason);

    /**
     * <p>Execute the task only if the given spec is satisfied. The spec will be evaluated at task execution time, not