def "init scripts see the root project before it is evaluated"() {
        given:
        settingsFile << """
            rootProject.name = 'root'
        """
        def initScript = file("init.gradle") << """
            rootProject { root ->
                if (root.state.executed) {
                    throw new IllegalStateException("Root project should not be evaluated too early")
                }
            }
        """

        super("The POM expression: " + expression + " could not be evaluated. Reason: " + message, cause);

        this.expression = expression;
        this.originalMessage = message;
    }

    public ModelInterpolationException(String expression, String message) {
        super("The POM expression: " + expression + " could not be evaluated. Reason: " + message);

        this.expression = expression;

import org.gradle.internal.declarativedsl.language.SingleFailureResult
import org.gradle.internal.declarativedsl.objectGraph.AssignmentTraceElement


sealed interface EvaluationResult<out R : StepResult> {
    class Evaluated<R : StepResult>(val stepResult: R) : EvaluationResult<R>

    class NotEvaluated<R : StepResult>(
        val stageFailures: List<StageFailure>,

 *
 * @since 8.8
 */
@Incubating
public interface GradleLifecycle {
    /**
     * Adds an {@link IsolatedAction isolated action} to be called immediately before a project is evaluated.
     *
     * Any extensions added to the {@code Project} model will be available to build scripts.
     *
     * @param action The action to execute.
     * @see IsolatedAction for the requirements to isolated actions

    evaluate: FailureCollectorContext.() -> ElementResult<T>
): ElementResult<T> {
    val context = FailureCollectorContext()
    return evaluate(context)
}


internal
fun <T> syntacticOrFailure(
    evaluate: FailureCollectorContext.() -> SyntacticResult<T>
): SyntacticResult<T> {
    val context = FailureCollectorContext()
    return evaluate(context)

        then:
        1 * evaluation.evaluate() >> "result"
        result == "result"
    }

    def "fallback value is used when circular evaluation detected"() {
        given:
        def evaluation = Mock(TestEvaluation)

        when:
        def result = context().evaluate(owner) {
            context().tryEvaluate(this.owner, "fallback", evaluation)
        }

        // - `allprojects` executes eagerly before any project has been evaluated, allowing its effects
        //   to be observable from other eager configuration blocks (e.g., `subprojects { ... }`).
        // - `lifecycle.beforeProject` executes just before each project is evaluated. Therefore, its effects
        //   are not observable from eager configuration blocks, which would anyway be incompatible with

@LeaksFileHandles("Kotlin Compiler Daemon working directory")
class PrecompiledScriptPluginAccessorSettingEvaluationTest : AbstractPrecompiledScriptPluginTest() {

    @Test
    fun `settings and init scripts are not evaluated when generating accessors`() {
        // given:
        val evaluationLog = file("evaluation.log")
        withFolders {
            // a precompiled script plugin contributing an extension

 * - in stage 1, the [Buildscript] and [Plugins] programs are executed and their execution
 *   is assumed to affect the classpath available to the stage 2 program;
 * - in stage 2, the remaining [Script] must be evaluated against the dynamically resolved classpath and,
 *   for that reason, [stage 2 programs][Script] can only be specialized after stage 1 executes at least once;
 */
sealed class Program {

    /**

      aggregator = custom_aggregator_op_wrapper.custom_aggregator(
          input_tensor,
          id='1',
          calibration_method=_CalibrationMethod.CALIBRATION_METHOD_MIN_MAX,
      )
      aggregator_output = self.evaluate(aggregator)
      self.assertAllEqual(aggregator_output.output, [1.0, 2.0, 3.0, 4.0, 5.0])
      self.assertEqual(aggregator_output.min, 1.0)
      self.assertEqual(aggregator_output.max, 5.0)