celMatcher: matcher,
				validationFilter: &fakeCelFilter{
					evaluations: tc.evaluations,
					throwError:  tc.throwError,
				},
				messageFilter: &fakeCelFilter{
					evaluations: tc.messageEvaluations,
					throwError:  tc.throwError,
				},
				auditAnnotationFilter: &fakeCelFilter{
					evaluations: tc.auditEvaluations,
					throwError:  tc.throwError,
				},
			}

		o.currentCorrelation = correlation
	}
}

// Validate validates all x-kubernetes-validations rules in Validator against obj and returns any errors.
// If the validation rules exceed the costBudget, subsequent evaluations will be skipped, the list of errs returned will not be empty, and a negative remainingBudget will be returned.
// Most callers can ignore the returned remainingBudget value unless another validate call is going to be made

	if err != nil {
		b.Fatal(err)
	}

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		// Call authorize may or may not require cel evaluations
		_, _, err = wh.Authorize(context.Background(), attr)
		if err != nil {
			b.Fatal(err)
		}
	}
	b.StopTimer()
}

    }

    def "produces reasonable error message when buildFile evaluation fails with Groovy Exception"() {
        buildFile << """
    createTakk('do-stuff')
"""
        when:
        fails()

        then:
        failure.assertHasDescription("A problem occurred evaluating root project 'ProjectError'.")

        e.cause.message.contains('A problem occurred evaluating initialization script.')

        and:
        failure.assertHasDescription('A problem occurred evaluating initialization script.')
        assertHasConfigureFailedLogging()
    }

    @TargetGradleVersion(">=7.3")
    def "action receives failure when settings evaluation fails"() {
        given:
        settingsFile << '''

        """

        buildFile """
            println("lifecycle: <evaluating> '\${project.path}'")
            subprojects { println("lifecycle: <root>.subprojects '\${it.path}'") }
        """

        groovyFile "a/build.gradle", """
            println("lifecycle: <evaluating> " + project)
        """

        when:
        succeeds("help")

        then:

        failure.assertHasCause("Cannot run Project.afterEvaluate(Action) when the project is already evaluated.")
    }

    @Issue("https://github.com/gradle/gradle/issues/4823")
    @ToBeFixedForIsolatedProjects(because = "evaluationDependsOn is not IP compatible")
    def "evaluationDependsOn deep project forces evaluation of parents"() {
        given:

 */

package org.gradle.declarative.dsl.evaluation

import org.gradle.declarative.dsl.evaluation.AnalysisStatementFilter.AnalyzeEverythingFilter
import org.gradle.declarative.dsl.evaluation.AnalysisStatementFilter.CompositionFilter
import org.gradle.declarative.dsl.evaluation.AnalysisStatementFilter.CompositionFilter.AndFilter
import org.gradle.declarative.dsl.evaluation.AnalysisStatementFilter.CompositionFilter.OrFilter

/**
 * [Lazy] values support Java serialization via a custom `writeReplace` method that forces their evaluation.
 */
class LazyCodecTest : AbstractFunctionalTypeTest() {

    @Test
    fun `forces evaluation of Lazy objects`() {
        assertEagerEvaluationOf(lazy()) {
            value
        }
    }

    @Test
    fun `forces evaluation of dynamic Lazy fields`() {
        assertEagerEvaluationOf(BeanOf(lazy())) {

 */

package org.gradle.internal.declarativedsl.evaluationSchema

import org.gradle.declarative.dsl.evaluation.EvaluationSchema
import org.gradle.declarative.dsl.evaluation.InterpretationSequence
import org.gradle.declarative.dsl.evaluation.InterpretationSequenceStep
import org.gradle.declarative.dsl.evaluation.InterpretationStepFeature
import org.gradle.internal.declarativedsl.evaluator.conversion.EvaluationAndConversionSchema