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]
    }

        "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

        buildScopeListenerRegistrationListener.onBuildScopeListenerRegistration(
            listener,
            registrationPoint,
            this
        );
    }

    @Override
    public boolean hasTask(Task task) {
        return executionPlan.getContents().getTasks().contains(task);
    }

    @Nullable
    @Override
    public Task findTask(String path) {

            withArguments('-x', excludedTask)
        }

        tasksNotInGraph.each { task ->
            buildFile << """
                gradle.taskGraph.whenReady { graph ->
                    assert !graph.hasTask('$task')
                }
            """
        }

        expect:
        2.times {
            succeeds 'a'
            result.assertTasksExecutedInOrder(expectedExecutedTasks as Object[])

                project.getGradle().getTaskGraph().whenReady(graph -> {
                    if (graph.hasTask(publishTask)) {
                        validateCredentialsSetup(project, publishTask);
                    }
                });
            });

     * Truth. For example:
     *
     * <pre>
     * signing {
     *   required = { gradle.taskGraph.hasTask("publish") }
     * }
     * </pre>
     *
     * Because the task graph is not known until Gradle starts executing, we must use defer the decision. We can do this via using a {@link Closure} (which is a {@link Callable}).

  (CreateXlaDotV2OpFromTfMatMulOp
    $input, $weight, $input_zp, $weight_zp, $matmul, $transpose_a, $transpose_b),
  [(IsInt8ElementType $input),
   (IsInt8ElementType $weight),
   (HasRank $input),
   (HasRank $weight),
   (HasRankOf<0> $input_zp),
   (HasRankOf<0> $weight_zp),
   (IsInt32ElementType $matmul)],
  [], (addBenefit 10)>;

        !mlir::isa<StringType>(output_values.getElementType())) {
      return func.emitError()
             << "Output " << kValues << " should be a string tensor";
    }

    if (input_values.hasRank() && output_values.hasRank() &&
        input_values.getRank() != output_values.getRank()) {
      return func.emitError() << "Input " << kValues << " and output "
                              << kValues << " should have the same rank";

    private final BuildModelController modelController;
    private final StateTransitionController<State> state;
    private final GradleInternal gradle;
    private boolean hasTasks;
    private boolean hasFiredBeforeModelDiscarded;

    public DefaultBuildLifecycleController(
        GradleInternal gradle,
        BuildModelController buildModelController,