<id>add-source-config</id>
                            <phase>generate-sources</phase>
                            <goals>
                                <goal>add-source</goal>
                            </goals>
                            <configuration>
                                <sources>
                                    <source>.</source>
                                </sources>

			sources:     []string{""},
			errExpected: false,
			sourcesLen:  0,
		},
		{
			name:        "file and apiserver source",
			sources:     []string{FileSource, ApiserverSource},
			errExpected: false,
			sourcesLen:  2,
		},
		{
			name:        "all source",
			sources:     []string{AllSource},
			errExpected: false,
			sourcesLen:  3,
		},
		{
			name:        "unknown source",

        def exe = components.exe
        exe.sources instanceof ModelMap
        exe.sources.asm instanceof AssemblerSourceSet
        exe.sources.asm.source.srcDirs == [project.file("src/exe/asm")] as Set

        and:
        def sources = realizeSourceSets()
        sources as Set == exe.sources as Set
    }

    def "can configure source set locations"() {
        given:
        dsl {

                            source.srcDir "src/main/linux"
                            lib m.sources.c
                        }
                    } else if (targetPlatform.operatingSystem.macOsX) {
                        platformMacOSX(CSourceSet) {
                            source.srcDir "src/main/mac"
                            lib m.sources.c
                        }
                    }
                }

  </fileSets>

  <files>
    <file>
      <sources>
        <source>src/assembly/shared/validate.cmd</source>
        <source>src/assembly/shared/mvnvalidate.cmd</source>
        <source>src/assembly/shared/init.cmd</source>
        <source>src/assembly/shared/mvnlauncher.cmd</source>
        <source>src/assembly/shared/run.cmd</source>
      </sources>
      <destName>mvn.cmd</destName>

        generatedInnerClassHeaderFile.assertDoesNotExist()
        file("build/generated/sources/headers/java/main/Bar.h").assertExists()
    }

    def "reports source type that does not support detection of source root"() {
        given:
        buildFile << "${language.compileTaskName}.source([file('extra'), file('other'), file('text-file.txt')])"

        source("class A extends B {}")
        file("extra/B.${language.name}") << "class B {}"

    }

    @Override
    public FileCollectionInternal resolvingLeniently(Object sources) {
        return resolving(ProviderResolutionStrategy.ALLOW_ABSENT, sources);
    }

    private FileCollectionInternal resolving(ProviderResolutionStrategy providerResolutionStrategy, Object sources) {
        if (sources instanceof FileCollectionInternal) {
            return (FileCollectionInternal) sources;
        }

            }
        });
        encoder.writeSmallInt(0); // end of sources
    }

    private int assertValidId(int codecId) {
        assert codecId >= 0 : "Module source must have a strictly positive source id";
        return codecId;
    }

    @Override
    public ModuleSources read(Decoder decoder) throws IOException {
        MutableModuleSources sources = new MutableModuleSources();
        int codecId;

        when:
        compile(source('A', 'public class A {}'), source('B', 'public class B {}'))

        then:
        assertCompiled 'A', 'B'
    }

    def "reports compilation errors"() {
        when:
        compile(source('A', 'public class Broken'))

        then:
        GeneratedClassCompilationException ex = thrown()

        main(NativeExecutableSpec) {
            sources {
                cpp1(CppSourceSet)
            }
        }
    }
}
"""
    }

    @ToBeFixedForConfigurationCache
    def "library dependency of binary is available when linking all source sets"() {
        given:
        buildFile << """
model {
    components {
        main {
            sources {
                other(CppSourceSet) {