assert ignoreFailures == false
                }
            }
            assertTaskConfiguration('codenarcMain', project.sourceSets.main)
            assertTaskConfiguration('codenarcTest', project.sourceSets.test)
            assertTaskConfiguration('codenarcOther', project.sourceSets.other)
        '''.stripIndent()

        expect:

        task dependsOn()
        task.source.files == project.sourceSets.main.resources.files
        task.destinationDir == project.sourceSets.main.output.resourcesDir

        when:
        task = project.tasks[JvmConstants.COMPILE_JAVA_TASK_NAME] as JavaCompile

        then:
        task dependsOn()
        task.classpath.is(project.sourceSets.main.compileClasspath)

plugins {
    id("gradlebuild.internal.java")
}

description = "Tests are checking Gradle behavior during IDE synchronization process"

val smokeIdeTestSourceSet = sourceSets.create("smokeIdeTest") {
    compileClasspath += sourceSets.main.get().output
    runtimeClasspath += sourceSets.main.get().output
}

addDependenciesAndConfigurations("smokeIde")

val smokeIdeTestImplementation: Configuration by configurations

        });
    }

    @SuppressWarnings("unchecked")
    private void configureForSourceSets(SourceSetContainer sourceSets) {
        sourceSets.all(new Action<SourceSet>() {
            @Override
            public void execute(final SourceSet sourceSet) {
                project.getTasks().register(sourceSet.getTaskName(getTaskBaseName(), null), getCastedTaskType(), new Action<Task>() {
                    @Override

    toolVersion = rootProject.libs.versions.checkStyle.get()
    sourceSets = listOf(project.sourceSets["main"])
  }

  // Animal Sniffer confirms we generally don't use APIs not on Java 8.
  configure<AnimalSnifferExtension> {
    annotation = "okhttp3.internal.SuppressSignatureCheck"
    sourceSets = listOf(project.sourceSets["main"])
  }

  val signature: Configuration by configurations.getting

    }

    test {
        java { srcDirs = ['testSources'] }
        resources { srcDirs = ['testResources'] }
    }

}

idea.module {
    sourceDirs += sourceSets.foo.java.srcDirs
    resourceDirs += sourceSets.foo.resources.srcDirs
}
'''

        projectDir.create {
            mainSources {}
            mainResources {}
            fooSources {}
            fooResources {}

    def sourceSets = Stub(SourceSetContainer)
    def toolchainSpec = TestUtil.newInstance(DefaultToolchainSpec)
    private JavaPluginExtension extension
    private JavaPluginConvention convention

    def setup() {
        project.pluginManager.apply(ReportingBasePlugin)
        extension = TestUtil.newInstance(DefaultJavaPluginExtension.class, project, sourceSets, toolchainSpec)

fun Test.setupPreconditionTesting() {
    // We only want to execute our special tests
    // so we override what classes are going to run
    testClassesDirs = sourceSets.test.get().output.classesDirs
    // All test should have this project's "test" source set on their classpath
    classpath += sourceSets.test.get().output

    // These tests should not be impacted by the predictive selection
    extensions.findByType<DevelocityTestConfiguration>()?.apply {

            include("b")
        """

        javaProject(file("a"), """
            group = "group"

            sourceSets {
               create("feature")
            }

            java {
                registerFeature('feature') {
                    usingSourceSet(sourceSets.feature)
                }
            }

            dependencies {
                implementation project(":b")
            }

import gradlebuild.basics.googleApisJs

plugins {
    id("gradlebuild.internal.java")
}

description = "Collection of test fixtures for performance tests, internal use only"

sourceSets {
    main {
        // Incremental Groovy joint-compilation doesn't work with the Error Prone annotation processor
        errorprone.enabled = false
    }
}

val reports by configurations.creating
val flamegraph by configurations.creating