*
     * @see org.gradle.api.internal.artifacts.ivyservice.moduleconverter.DefaultRootComponentMetadataBuilder.MetadataHolder#tryCached(ComponentIdentifier)
     */
    void reevaluate();

    @Override
    LocalComponentGraphSelectionCandidates getCandidatesForGraphVariantSelection();

    interface LocalComponentGraphSelectionCandidates extends GraphSelectionCandidates {

        /**

  @Test fun get() {
    // These tests wont actually run before Android 8.0 as per
    // https://github.com/mannodermaus/android-junit5
    // Raised https://github.com/mannodermaus/android-junit5/issues/228 to reevaluate
    val androidMorEarlier = Build.VERSION.SDK_INT <= 23

    val clientBuilder = OkHttpClient.Builder()

    if (androidMorEarlier) {
      val cert: X509Certificate =
        """

            MutationValidator.MutationType.ARTIFACTS,
            MutationValidator.MutationType.USAGE,
            MutationValidator.MutationType.HIERARCHY
        ]
    }

    def "does not reevaluate component metadata when #mutationType change"() {
        componentIdentifierFactory.createComponentIdentifier(_) >> {
            new DefaultModuleComponentIdentifier(mid, '1.0')
        }

	tpl, err := file.AsString(filePath)
	if err != nil {
		return "", err
	}
	return Evaluate(tpl, data)
}

// EvaluateOrFail calls Evaluate and fails tests if it returns error.
func EvaluateOrFail(t test.Failer, tpl string, data any) string {
	t.Helper()
	s, err := Evaluate(tpl, data)
	if err != nil {
		t.Fatalf("tmpl.EvaluateOrFail: %v", err)
	}
	return s
}

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

        then:
        0 * evaluation.evaluate()
        result == "fallback"
    }

    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)

        when:
        project.pluginManager.apply(CppApplicationPlugin)
        project.evaluate()

        then:
        project.unitTest.testedComponent.orNull == project.application
    }

    def "registers a component for the test suite"() {
        when:
        project.pluginManager.apply(CppUnitTestPlugin)
        project.evaluate()

        then:
        project.components.test == project.unitTest

    public abstract fun evaluate(expression: KtExpression): KaConstantValue?

    public abstract fun evaluateAsAnnotationValue(expression: KtExpression): KaAnnotationValue?
}

public typealias KtCompileTimeConstantProvider = KaCompileTimeConstantProvider

public interface KaCompileTimeConstantProviderMixIn : KaSessionMixIn {
    /**
     * Tries to evaluate the provided expression.

        given:
        state.configured()

        when:
        evaluate()

        then:
        state.executed
        0 * delegate._

        and:
        operations.empty
    }

    void "nothing happens if project is being configured now"() {
        given:
        state.toBeforeEvaluate()

        when:
        evaluate()

        then:
        state.configuring
        0 * delegate._

// tag::after-evaluate[]
gradle.beforeProject { project ->
    project.ext.set("hasTests", false)
}

gradle.afterProject { project ->
    if (project.ext.has("hasTests") && project.ext.get("hasTests") as Boolean) {
        def projectString = project.toString()
        println "Adding test task to $projectString"
        project.task('test') {
            doLast {
                println "Running tests for $projectString"
            }
        }