}

    @ToBeFixedForConfigurationCache
    def "build and execute program with non-conventional source layout"() {
        given:
        buildFile << """
model {
    components {
        main(NativeExecutableSpec) {
            sources {
                cpp {
                    source {
                        srcDirs "source"
                        include "**/*.cpp"
                    }

        <executions>
          <execution>
            <id>add-benchmark-sources</id>
            <phase>generate-test-sources</phase>
            <goals><goal>add-test-source</goal></goals>
            <configuration>
              <sources>
                <source>benchmark</source>
              </sources>
            </configuration>
          </execution>
        </executions>
      </plugin>

    apply plugin: 'c'

model {
    components { comp ->
        headersOnly(NativeLibrarySpec) {
            sources {
                c.generatedBy tasks.generateCSources
            }
        }
        main(NativeExecutableSpec) {
            sources {
                c.lib \$.components.headersOnly.sources.c
            }
        }
    }
}
"""

        then:
        executableBuilt(app)
    }

                module.moduleName = it.'@module-name'
                return module
            } else if (it.@type == 'sourceFolder') {
                def source = new ImlSource()
                source.type = it.@type
                source.forTests = it.@forTests
                return source
            } else if (it.@type == 'library') {
                def library = new ImlLibrary()
                library.type = it.@type

            <id>add-slf4j-simple</id>
            <goals>
              <goal>add-source</goal>
            </goals>
            <phase>generate-sources</phase>
            <configuration>
              <sources>
                <source>${project.build.directory}/generated-sources/slf4j-simple</source>
              </sources>
            </configuration>
          </execution>
        </executions>
      </plugin>

    /**
     * Tells how to compile this source directory set.
     * @param taskBuilder the builder for the task which compiles sources
     */
    JvmLanguageSourceDirectoryBuilder compiledBy(Function<DirectoryProperty, TaskProvider<? extends AbstractCompile>> taskBuilder);

    /**
     * Assumes that this source set will contain Java sources and therefore creates a Java

            Source sets
                $languageName source 'myComponent:myComponentSource'
                    srcDir: src${File.separator}myComponent${File.separator}myComponentSource

            Binaries
                $binaryType 'myComponent:myBinary'
                    build using task: :myComponentMyBinary
                    source sets:

    List<ByteSource> sources = Lists.newArrayList();
    int start = 0;
    for (Integer span : spans) {
      sources.add(newByteSource(start, span));
      start += span;
    }
    ByteSource joined = ByteSource.concat(sources);
    assertTrue(newByteSource(0, start).contentEquals(joined));
  }

  public void testReadSingleByte() throws Exception {
    ByteSource source = newByteSource(0, 10);

     * }
     * </pre>
     *
     * @param source The source of the artifact.
     * @param config An action to configure the values of the constructed {@link MavenArtifact}.
     */
    MavenArtifact artifact(Object source, Action<? super MavenArtifact> config);

    /**
     * Clears any previously added artifacts from {@link #getArtifacts} and creates artifacts from the specified sources.

        TreeFormatter formatter = new TreeFormatter();
        formatter.node("Unable to compile generated sources");
        formatter.startChildren();
        for (Diagnostic<? extends JavaFileObject> d : diagnostics) {
            JavaFileObject source = d.getSource();
            String srcFile = source == null ? "unknown" : new File(source.toUri()).getName();