* limitations under the License.
 */

package org.gradle.internal.declarativedsl.evaluator.schema

import org.gradle.declarative.dsl.evaluation.AnalysisStatementFilter
import org.gradle.declarative.dsl.evaluation.EvaluationSchema
import org.gradle.declarative.dsl.evaluation.OperationGenerationId
import org.gradle.declarative.dsl.schema.AnalysisSchema
import org.gradle.internal.declarativedsl.analysis.DefaultOperationGenerationId

    @Test
    fun `defers evaluation of Supplier objects`() {
        assertDeferredEvaluationOf(supplier()) {
            get()
        }
    }

    @Test
    fun `defers evaluation of dynamic Supplier fields`() {
        assertDeferredEvaluationOf(BeanOf(supplier())) {
            value.get()
        }
    }

    @Test
    fun `defers evaluation of static Supplier fields`() {

func (m *CelMetrics) ObserveCompilation(elapsed time.Duration) {
	seconds := elapsed.Seconds()
	m.compilationTime.Observe(seconds)
}

// ObserveEvaluation records a CEL evaluation with the time the evaluation took.
func (m *CelMetrics) ObserveEvaluation(elapsed time.Duration) {
	seconds := elapsed.Seconds()
	m.evaluationTime.Observe(seconds)

    @Test
    fun `defers evaluation of Callable objects`() {
        assertDeferredEvaluationOf(callable()) {
            call()
        }
    }

    @Test
    fun `defers evaluation of dynamic Callable fields`() {
        assertDeferredEvaluationOf(BeanOf(callable())) {
            value.call()
        }
    }

    @Test
    fun `defers evaluation of static Callable fields`() {

    @Test
    fun `defers evaluation of Function objects`() {
        assertDeferredEvaluationOf(function()) {
            invoke()
        }
    }

    @Test
    fun `defers evaluation of dynamic Function fields`() {
        assertDeferredEvaluationOf(BeanOf(function())) {
            value()
        }
    }

    @Test
    fun `defers evaluation of static Function fields`() {

	ctx = WithAuditContext(ctx)
	AddAuditAnnotation(ctx, "before-evaluation", "1")

	// policy evaluated, audit logging enabled
	if ac := AuditContextFrom(ctx); ac != nil {
		ac.RequestAuditConfig.Level = auditinternal.LevelMetadata
	}
	AddAuditAnnotation(ctx, "after-evaluation", "2")

	expected := map[string]string{
		"before-evaluation": "1",
		"after-evaluation":  "2",
	}
	actual := AuditContextFrom(ctx).Event.Annotations

import org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache

class BuildScriptVisibilityIntegrationTest extends AbstractIntegrationSpec {
    @ToBeFixedForConfigurationCache(because = "test expects scripts evaluation")
    def "methods defined in project build script are visible to descendant projects"() {
        createDirs("child1")
        settingsFile << "include 'child1'"
        buildFile """
def doSomething(def value) {

		"GOPACKAGE=" + g.pkg,
		"DOLLAR=" + "$",
	}
	env = base.AppendPATH(env)
	env = base.AppendPWD(env, g.dir)
	g.env = env
}

// split breaks the line into words, evaluating quoted
// strings and evaluating environment variables.
// The initial //go:generate element is present in line.
func (g *Generator) split(line string) []string {
	// Parse line, obeying quoted strings.
	var words []string

 * limitations under the License.
 */

package org.gradle.internal.declarativedsl.evaluator

import org.gradle.declarative.dsl.evaluation.EvaluationSchema
import org.gradle.declarative.dsl.evaluation.InterpretationSequenceStep
import org.gradle.declarative.dsl.evaluation.InterpretationStepFeature
import org.gradle.declarative.dsl.schema.AnalysisSchema

type simpleConfiguration struct {
	evaluators       []quota.Evaluator
	ignoredResources map[schema.GroupResource]struct{}
}

// NewConfiguration creates a quota configuration
func NewConfiguration(evaluators []quota.Evaluator, ignoredResources map[schema.GroupResource]struct{}) quota.Configuration {
	return &simpleConfiguration{
		evaluators:       evaluators,
		ignoredResources: ignoredResources,
	}
}