@RequiresInstalledToolChain(SUPPORTS_32)
    @ToBeFixedForConfigurationCache
    def "can have sourcefiles with same base name but different directories"() {
        given:
        def testApp = initTestApp(testAppType)

        when:
        testApp.writeSources(file("src/main"))
        buildFile.text = ""
        testApp.plugins.each { plugin ->

            // Workaround for Android Gradle plugin checking for the presence of these directories at configuration time,
            // which invalidates configuration cache if their presence changes. Create these directories before the first build.

 * limitations under the License.
 */

package org.gradle.api.tasks;

import org.gradle.internal.HasInternalProtocol;

/**
 * Represents the files or directories that represent the local state of a {@link org.gradle.api.Task}.
 * The typical usage for local state is to store non-relocatable incremental analysis between builds.
 * Local state is removed whenever the task is loaded from cache.

 * This is still used when TestKit and TAPI run Gradle in embedded or debug mode.
 * <p>
 * This transformation filters out not yet supported versioned directories of the multi-release JARs.
 */
class MultiReleaseClasspathElementTransformForLegacy extends BaseClasspathElementTransform {

The Groovy plugin assumes the project layout shown in <<#groovylayout,Groovy Layout>>. All the Groovy source directories can contain Groovy _and_ Java code. The Java source directories may only contain Java source code.footnote:[Gradle uses the same conventions as introduced by Russel Winder's link:https://gant.github.io/[Gant tool].] None of these directories need to exist or have anything in them; the Groovy plugin will simply compile whatever it finds.

[[groovylayout]]

		}
	} else {
		dirFormat := r.readLNCTFormat()
		c := buf.uint()
		r.directories = make([]string, c)
		for i := range r.directories {
			dir, _, _, err := r.readLNCT(dirFormat, dwarf64)
			if err != nil {
				return err
			}
			r.directories[i] = dir
		}
		fileFormat := r.readLNCTFormat()
		c = buf.uint()
		r.fileEntries = make([]*LineFile, c)
		for i := range r.fileEntries {

    }

    /**
     * Returns the header directories to be used for compilation.
     */
    @Internal("The paths for include directories are tracked via the includePaths property, the contents are tracked via discovered inputs")
    public ConfigurableFileCollection getIncludes() {
        return includes;
    }

    /**
     * Add directories where the compiler should search for header files.
     */

import java.io.File;

public class SnapshotWatchedDirectoryFinder {

    /**
     * Resolves the directories to watch for a snapshot.
     *
     * For existing files, we watch the parent directory,
     * so we learn if the file itself disappears or gets modified.
     * For directories, we only watch the directory itself, as we get
     * events for that.

 *
 * <ul>
 *     <li>Changes to the path of jar or top level directories.</li>
 *     <li>Changes to timestamps and the order of entries in Jars.</li>
 *     <li>Changes to resources and Jar manifests, including adding or removing resources.</li>

            }
        }?.filter {
            it.value.isNotEmpty()
        } ?: emptyMap()

    /**
     * Returns any temporary directories used to extract resources from jars.
     *
     * These directories will be created as siblings of the randomly assigned test root directories, with the fixed name {@code tmp-extracted-resources}.
     */
    private