import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Indicates that the test runner should only create execution if the nested features are enabled.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Inherited
public @interface RequiredFeatures {

@SelfType(BaseDeprecations)
trait WithAndroidDeprecations {

    void expectFilteredFileCollectionDeprecationWarning() {
        // This warning is emitted by the Kotlin Kapt plugin
        runner.expectLegacyDeprecationWarning(
            "The Configuration.fileCollection(Spec) method has been deprecated. " +
                "This is scheduled to be removed in Gradle 9.0. " +

)
class DeprecationCreationPerformanceTest extends AbstractCrossVersionPerformanceTest {
    def "create many deprecation warnings"() {
        given:
        runner.tasksToRun = ['help']
        runner.minimumBaseVersion = '6.3'
        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

import org.gradle.internal.declarativedsl.evaluator.runner.EvaluationResult.NotEvaluated
import org.gradle.internal.declarativedsl.evaluator.runner.EvaluationResult.NotEvaluated.StageFailure.AssignmentErrors
import org.gradle.internal.declarativedsl.evaluator.runner.EvaluationResult.NotEvaluated.StageFailure.DocumentCheckFailures
import org.gradle.internal.declarativedsl.evaluator.runner.EvaluationResult.NotEvaluated.StageFailure.FailuresInLanguageTree

/**
 * A dummy annotation which is used to trigger validation problems during tests.
 *
 * This is handled via {@link ValidationProblemPropertyAnnotationHandler},
 * a service available globally in the embedded integration test runner only.
 *
 * @see ValidationServicesFixture
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD})
public @interface ValidationProblem {
    Severity value() default Severity.WARNING;

 * limitations under the License.
 */

package org.gradle.testkit.runner

import com.gradle.develocity.testing.annotations.LocalOnly
import org.gradle.initialization.StartParameterBuildOptions
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions
import org.gradle.testkit.runner.fixtures.Debug
import org.gradle.testkit.runner.fixtures.NoDebug

import static org.junit.Assume.assumeTrue

/**
 * Runs tests with fluid dependencies enabled and disabled: when fluid dependencies are enabled, any configuration that
 * is a task input is resolved when constructing the task graph.
 * Test classes that use this runner will have tests run twice, with and without fluid dependencies enabled.
 */
@CompileStatic
class FluidDependenciesResolveInterceptor extends BehindFlagFeatureInterceptor {

        given:
        runner.tasksToRun = ['tasks']
        runner.runs = (runner.testProject == (LARGE_JAVA_MULTI_PROJECT_KOTLIN_DSL.projectName) ? 5 : 10)
        runner.useDaemon = false
        runner.addBuildMutator { invocationSettings ->
            new ClearGradleUserHomeMutator(invocationSettings.gradleUserHome, AbstractCleanupMutator.CleanupSchedule.BUILD)
        }
        runner.addBuildMutator { invocationSettings ->

    def setup() {
        runner.minimumBaseVersion = "6.8"
        runner.warmUpRuns = 3
    }

    def setupGradleOpts() {
        useG1GarbageCollectorOnJava8(runner)
    }

    def "buildSrc abi change"() {
        given:
        setupGradleOpts()
        runner.tasksToRun = ['help']
        runner.runs = determineNumberOfRuns(runner.testProject)

        and:

    final IntegrationTestBuildContext buildContext = new IntegrationTestBuildContext()

    GradleVsMavenPerformanceTestRunner runner

    def setup() {
        runner = new GradleVsMavenPerformanceTestRunner(
            temporaryFolder,
            new GradleVsMavenBuildExperimentRunner(gradleProfilerReporter, outputDirSelector),