includeBuild('subfolder1/module-b') { name = 'module-b-1' }
            includeBuild('subfolder2/module-b') { name = 'module-b-2' }
        """
        file('subfolder1/module-b').mkdirs()
        file('subfolder2/module-b').mkdirs()

        when:
        def allProjects = withConnection {c -> c.action(new IdeaProjectUtil.GetAllIdeaProjectsAction()).run() }

        // The actual user home dir will be a subfolder using the name of the distribution.
        gradleUserHomeDir = intTestHomeDir
        // The user home dir is not wiped out by clean. Move the daemon working space underneath the build dir so they don't pile up on CI.
        // The actual daemon registry dir will be a subfolder using the name of the distribution.
        daemonRegistry = repoRoot().dir("build/daemon")

        given:
        agent.supportsJmx() >> true
        agent.supportsInclNoLocationClasses() >> true
        agent.jar >> temporaryFolder.file('workingDir/subfolder/fakeagent.jar')
        task.getWorkingDir() >> temporaryFolder.file("workingDir")

        extension.with {
            destinationFile = temporaryFolder.file('build/jacoco/fake.exec')

`src/main/antlr`::
Production ANTLR grammar files. If the ANTLR grammar is organized in packages, the structure in the antlr folder should reflect the package structure. This ensures that the generated sources end up in the correct target subfolder.

`src/test/antlr`::
Test ANTLR grammar files.

`src/__sourceSet__/antlr`::
ANTLR grammar files for the given source set.


[[sec:antlr_dependency_management]]
== Dependency management

fun File.withFolders(folders: FoldersDslExpression) =
    apply { FoldersDsl(this).folders() }


class FoldersDsl(val root: File) {

    operator fun String.invoke(subFolders: FoldersDslExpression): File =
        (+this).withFolders(subFolders)

    operator fun String.unaryPlus(): File =
        canonicalFile(this).apply { mkdirs() }

    fun withFile(fileName: String, content: String = ""): File =

            subFilter:
              name: envoy.filters.http.router
      proxy:
        proxyVersion: ^1\.19.*
  - applyTo: HTTP_FILTER
    match:
      context: SIDECAR_INBOUND
      listener:
        filterChain:
          filter:
            name: envoy.filters.network.http_connection_manager
            subFilter:
              name: envoy.filters.http.router
      proxy:

        def projectBsrcFolder = file('subprojectB/src')
        def srcRootFolder1 = file('src-root')
        def srcRootFolder2 = file('src')
        def srcFolder = file('subprojectA/src')
        projectBsrcSiblingFolder.mkdirs()
        projectBsrcFolder.mkdirs()
        srcFolder.mkdirs()
        srcRootFolder1.mkdirs()
        srcRootFolder2.mkdirs()
        file('subprojectA/build.gradle').text = """
sourceSets {
    main {

    public static boolean isModuleSource(boolean inferModulePath, Iterable<File> sourcesRoots) {
        if (!inferModulePath) {
            return false;
        }
        for (File srcFolder : sourcesRoots) {
            if (isModuleSourceFolder(srcFolder)) {
                return true;
            }
        }
        return false;
    }

    private static boolean isModuleSourceFolder(File folder) {

        new Output("bin")]
    final projectDependency = [customEntries[0]]
    final jreContainer = [customEntries[1]]
    final outputLocation = [customEntries[6]]
    final srcFolder = [customEntries[3]]

    final allDependencies = [customEntries[0], customEntries[2], customEntries[4]]

    private final Classpath classpath = new Classpath(new XmlTransformer(), fileReferenceFactory)

    @Rule

== Run the application

Look inside the `build` folder and you will notice the appearance of an `exe` folder.
By convention, Gradle will place all applications in subfolders named according to the component name.
In this case, you will find your assembled executable in `build/exe/main/debug` and it will be called `${subprojectName.raw}` (or `${subprojectName.raw}.exe` under Windows).