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

	// The following fields are exclusive. Only the topmost non-zero field is used.

	// Quantity is a quantity associated with the signal that is evaluated against the specified operator.
	Quantity *resource.Quantity
	// Percentage represents the usage percentage over the total resource that is evaluated against the specified operator.
	Percentage float32
}

// Threshold defines a metric for when eviction should occur.
type Threshold struct {

    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate"), Pattern.compile("^(.+)\\.kts$"), null, true);
  }

  @Nested
  @TestMetadata("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/incompleteCode")
  @TestDataPath("$PROJECT_ROOT")
  public class IncompleteCode {
    @Test

// Need to have at least one configuration declared, otherwise the rules are never evaluated
val conf by configurations.creating

// tag::module_to_project_substitution[]
configurations.all {
    resolutionStrategy.dependencySubstitution {
        substitute(module("org.utils:api"))
            .using(project(":api")).because("we work with the unreleased development version")
        substitute(module("org.utils:util:2.5")).using(project(":util"))
    }
}

        project.evaluate()

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

    @Requires(UnitTestPreconditions.MacOs)
    def "registers a test bundle for the test suite on macOS"() {
        when:
        project.pluginManager.apply(XCTestConventionPlugin)
        project.evaluate()

        then:

        def thread = Thread.start {
            // expect:
            conditions.evaluate { ref.get() == null }

            // when:
            ref.set(op)

            // then:
            conditions.evaluate { ref.get().is(op) }

            // when:
            ref.clear()

            // then:
            conditions.evaluate { ref.get() == null }
        }

        then:
        conditions.await()

    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate"), Pattern.compile("^(.+)\\.kts$"), null, true);
  }

  @Nested
  @TestMetadata("analysis/analysis-api/testData/components/compileTimeConstantProvider/evaluate/incompleteCode")
  @TestDataPath("$PROJECT_ROOT")
  public class IncompleteCode {
    @Test

// 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"
            }
        }

                if (evaluator instanceof TypeAwareExpressionEvaluator) {
                    result = ((TypeAwareExpressionEvaluator) evaluator).evaluate(value, type);
                } else {
                    result = evaluator.evaluate(value);
                }
            }
            if (null == result && configuration.getChildCount() == 0) {
                value = configuration.getAttribute("default-value");

import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
import org.jetbrains.kotlin.types.TypeUtils


internal class KaFe10CompileTimeConstantProvider(
    override val analysisSession: KaFe10Session
) : KaCompileTimeConstantProvider(), KaFe10SessionComponent {
    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun evaluate(expression: KtExpression): KaConstantValue? {