def "registerFeature can be used when there is no main SourceSet"() {
        given:
        buildFile << """
            apply plugin: 'java-base'

            sourceSets {
               main211 {}
               main212 {}
            }
            java {
               registerFeature('scala211') {
                  usingSourceSet(sourceSets.main211)
               }

        }
        val sourceSet = mock<NamedDomainObjectProvider<SourceSet>>()
        val sourceSets = mock<SourceSetContainer> {
            on { named(any<String>(), eq(SourceSet::class.java)) } doReturn sourceSet
        }
        val extensions = mock<ExtensionContainerInternal> {
            on { getByName(any()) } doReturn sourceSets
        }
        val constraint = mock<DependencyConstraint>()

                components.java.features {
                    assert size() == 3
                    assert main.sourceSet == sourceSets.main
                    assert foo.sourceSet == sourceSets.foo
                    assert bar.sourceSet == sourceSets.bar
                }
            }
        """

        expect:
        succeeds("verify")
    }

        def resourcefile2 = new File('file5')
        def resourcefile3 = new File('file6')
        def sourceSet = sourceSet(sourcefile1, sourcefile2, sourcefile3)
        def sourceSet3 = resourceSet(resourcefile1, resourcefile2, resourcefile3)
        sourceSets.addAll(sourceSet, sourceSet3)

        when:
        exeBinary.inputs >> sourceSets

        then:

            Iterable<SourceSet> sourceSets = classpath.getSourceSets();

            // for non-java projects there are no source sets configured
            if (sourceSets == null) {
                return pathToSourceSetNames;
            }

            for (SourceSet sourceSet : sourceSets) {
                for (File f : collectClasspathFiles(sourceSet)) {

        outputs.recompiledClasses('B', 'B$NewInner')
        outputs.deletedClasses('B$Inner')
    }

    def "recompilation considers changes from dependent sourceSet"() {
        buildFile << """
sourceSets {
    other {}
    main { compileClasspath += sourceSets.other.output }
}
"""
        if (language == CompiledLanguage.GROOVY) {
            buildFile << """
        dependencies {

        configureTestTaskOrdering(project.getTasks());
        configureDiagnostics(project, javaComponent.getMainFeature());
        configureBuild(project);
    }

    private static JvmFeatureInternal createMainFeature(ProjectInternal project, SourceSetContainer sourceSets) {
        SourceSet sourceSet = sourceSets.create(SourceSet.MAIN_SOURCE_SET_NAME);

        this.sourceSets = sourceSets;
    }

    /**
     * The configurations whose files are to be added as classpath entries.
     * <p>
     * See {@link EclipseClasspath} for an example.
     */
    public Collection<Configuration> getPlusConfigurations() {
        return plusConfigurations;
    }

    public void setPlusConfigurations(Collection<Configuration> plusConfigurations) {

apply plugin: 'java'
apply plugin: 'eclipse'

sourceSets.main.java.srcDirs.each { it.mkdirs() }
sourceSets.main.resources.srcDirs.each { it.mkdirs() }

configurations {
  someConfig
}

dependencies {
  someConfig files('foo.txt')
}

eclipse {

  pathVariables fooPathVariable: projectDir

  classpath {
    sourceSets = []

    plusConfigurations << configurations.someConfig

                    @Override
                    public void execute(SourceSet sourceSet) {
                        if (sourceSet.getName().toLowerCase(Locale.ROOT).contains("test")) {
                            // source sets with 'test' in their name are marked as test on the Eclipse classpath
                            testSourceSetsConvention.add(sourceSet);