x.mode = invalid
	}

	return statement
}

// exprList evaluates a list of expressions and returns the corresponding operands.
// A single-element expression list may evaluate to multiple operands.
func (check *Checker) exprList(elist []syntax.Expr) (xlist []*operand) {
	if n := len(elist); n == 1 {
		xlist, _ = check.multiExpr(elist[0], false)

import spock.lang.Specification

import static org.gradle.util.internal.TextUtil.normaliseLineSeparators

class TestExecutionResultEvaluatorTest extends Specification {

    def "evaluate throws exception if no results tracked"() {
        given:
        def ancestryTracker = Mock(BuildOperationAncestryTracker)
        def testExecutionRequest = Mock(TestExecutionRequestAction)

        project.application.cppSource.files == [src] as Set
    }

    def "registers a component for the application"() {
        when:
        project.pluginManager.apply(CppApplicationPlugin)
        project.evaluate()

        then:
        project.components.main == project.application
        project.application.binaries.get().name == ['mainDebug', 'mainRelease']

    }

    @Override
    public ResourceFilter getClasspathResourceFilter() {
        return resourceFilter.evaluate();
    }

    @Override
    public ResourceEntryFilter getManifestAttributeResourceEntryFilter() {
        return manifestAttributeResourceFilter.evaluate();
    }

    @Override
    public Map<String, ResourceEntryFilter> getPropertiesFileFilters() {

}

// SelfSubjectRulesReviewSpec defines the specification for SelfSubjectRulesReview.
type SelfSubjectRulesReviewSpec struct {
	// Namespace to evaluate rules for. Required.
	Namespace string `json:"namespace,omitempty" protobuf:"bytes,1,opt,name=namespace"`
}

// SubjectRulesReviewStatus contains the result of a rules check. This check can be incomplete depending on

    }

    def "error message contains which cacheIf spec failed to evaluate"() {
        when:
        determineNoCacheReason(
            [],
            [cacheableOutputProperty],
            [spec({ throw new RuntimeException() }, "Exception is thrown")],
        )

        then:
        def ex = thrown GradleException
        ex.message == "Could not evaluate spec for 'Exception is thrown'."
    }

    val statement: Statement =
      rule.apply(
        object : Statement() {
          override fun evaluate() {
            called.set(true)
            rule.server.url("/").toUrl().openConnection().connect()
          }
        },
        Description.EMPTY,
      )
    statement.evaluate()
    assertThat(called.get()).isTrue()
    try {
      rule.server.url("/").toUrl().openConnection().connect()

			}
			if c.filter != nil {
				okay, err := c.filter.Evaluate(ctx, instance.Instance.Attributes)
				if err != nil {
					return nil, fmt.Errorf("evaluate filter CEL expression: %w", err)
				}
				if !okay {
					continue
				}
			}
			okay, err := request.Evaluate(ctx, instance.Instance.Attributes)
			if err != nil {
				return nil, fmt.Errorf("evaluate request CEL expression: %w", err)
			}
			if !okay {

    private val controller: ConfigurationCacheFingerprintController
) : ProjectEvaluator {
    override fun evaluate(project: ProjectInternal, state: ProjectStateInternal) {
        controller.runCollectingFingerprintForProject(project.identityPath) {
            delegate.evaluate(project, state)
        }
    }

    ExpectingFailureRuleStatement(Statement next, String feature) {
        this.next = next
        this.feature = feature
    }

    @Override
    void evaluate() throws Throwable {
        try {
            next.evaluate()
            throw new ToBeFixedSpecInterceptor.UnexpectedSuccessException(feature)
        } catch (ToBeFixedSpecInterceptor.UnexpectedSuccessException ex) {
            throw ex