super.describeMismatch(o, description);
        } else {
            final ProjectBuildingResult r = (ProjectBuildingResult) o;
            description.appendText("was a ProjectBuildingResult with locations ");
            String messages = r.getProblems().stream()
                    .map(p -> formatLocation(p.getColumnNumber(), p.getLineNumber()))
                    .collect(joining(", "));

        StandardLocation.SOURCE_OUTPUT        | GeneratedResource.Location.SOURCE_OUTPUT
        StandardLocation.CLASS_OUTPUT         | GeneratedResource.Location.CLASS_OUTPUT
        StandardLocation.NATIVE_HEADER_OUTPUT | GeneratedResource.Location.NATIVE_HEADER_OUTPUT
    }

    def "resources with same path but different location are distinct"() {
        when:

public interface GlobalCacheLocations {

    /**
     * Checks if a given path is inside one of Gradle's global caches.
     */
    boolean isInsideGlobalCache(String path);

    /**
     * Returns the cache locations.
     */
    FileHierarchySet getCacheRoots();

	}
}

// CreateNodes creates graph nodes for all locations in a profile. It
// returns set of all nodes, plus a mapping of each location to the
// set of corresponding nodes (one per location.Line).
func CreateNodes(prof *Profile, o *Options) (Nodes, locationMap) {
	locations := locationMap{make([]Nodes, len(prof.Location)+1), make(map[uint64]Nodes)}
	nm := make(NodeMap, len(prof.Location))
	for _, l := range prof.Location {
		lines := l.Line

     * That means that we would not invalidate the right locations in the virtual file system on macOS.
     * Therefore, we disable file system watching when we try to watch a directory whose parent is a symlink.
     *
     * Note that the project directory is canonicalized by Gradle, so the project directory can always be watched.
     */
    private static void validateLocationToWatch(File location) {
        try {

 * <p>
 * Before task execution ({@link org.gradle.api.internal.tasks.execution.ExecuteTaskBuildOperationType}),
 * the mutations of the task need to be resolved. The mutations of a task are the locations it may modify,
 * e.g. its outputs, destroyables and local state. In order to resolve the mutations, the task input and output
 * properties are detected as well. Since Gradle 7.5, resolving of the mutations happens in a separate node

            doLast { conf.files.each {} }
        }
        """

        when:
        fails 'resolve'

        then:
        failure.assertHasCause """Could not find org:name:1.0.
Searched in the following locations:
  - file:////MISSING/folder/ivy/org/name/1.0/ivy-1.0.xml
"""
        where:
        // '//' - Normal UNC path for use with `new File(String)`
        // 'file:////' - UNC path encoded as a URI, for use with `new File(URI)`

        installRelease.runScriptFile.get().getAsFile().name == OperatingSystem.current().getScriptName("testApp")
    }

    def "output locations are calculated using base name defined on extension"() {
        when:
        project.pluginManager.apply(CppApplicationPlugin)
        project.evaluate()
        project.application.baseName = "test_app"

}

// GetKubeConfigPath can be used to search for a kubeconfig in standard locations
// if and empty string is passed to the function. If a non-empty string is passed
// the function returns the same string.
func GetKubeConfigPath(file string) string {
	// If a value is provided respect that.
	if file != "" {
		return file
	}
	// Find a config in the standard locations using DefaultClientConfigLoadingRules,

        file = new RandomAccessFile(tmpDir.file("test.bin"), "rw")
        input = new ByteInput(file)
    }

    def cleanup() {
        file.close()
    }

    def "can reuse to read from multiple locations in file"() {
        given:
        file.seek(0)
        file.writeInt(123)
        file.writeInt(321)
        file.writeInt(456)

        expect:
        def stream = input.start(0)