an "enumerated type", the value is case sensitive. - In elements that specify a pathname to a file within the same JAR file, relative filenames (i.e., those not starting with "/") are considered relative to the root of the JAR file's namespace. Absolute filenames (i.e., those starting with "/") also specify names in the root of the JAR file's namespace. In general, relative names are preferred. The exception is .war files where absolute names are preferred for consistency with the servlet API. -->...

 * limitations under the License.
 */

package org.gradle.internal.file;

/**
 * Resolves a path object relative to some base directory.
 */
public interface RelativeFilePathResolver {
    /**
     * Converts the given path to a relative path.
     */
    String resolveAsRelativePath(Object path);

    /**

    /**
     * Returns a new source identified by a relative path. Implementation <strong>MUST</strong>
     * be able to accept <code>relative</code> parameter values that
     * <ul>
     * <li>use either / or \ file path separator,</li>
     * <li>have .. parent directory references,</li>
     * <li>point either at file or directory.</li>
     * </ul>
     *
     * @param relative is the path of the requested source relative to this source

        /**
         * Relative to the build setting {@code SDKROOT}.
         */
        SDKROOT("SDKROOT"),

        /**
         * Relative to the directory containing the project file {@code SOURCE_ROOT}.
         */
        SOURCE_ROOT("SOURCE_ROOT"),

        /**
         * Relative to the Developer content directory inside the Xcode application
         * (e.g. {@code /Applications/Xcode.app/Contents/Developer}).

    /**
     * Returns a {@link Directory} whose value is the given path resolved relative to the value of this directory.
     *
     * @param path The path. Can be absolute.
     * @return The directory.
     */
    Provider<Directory> dir(String path);

    /**
     * Returns a {@link Directory} whose value is the given path resolved relative to the value of this directory.
     *

        file('foo/c/2').mkdir()
        execute("taskWithInputs")

        then:
        executedAndNotSkipped(":taskWithInputs")

        where:
        [api, pathSensitivity] << [Api.values(), [PathSensitivity.RELATIVE, PathSensitivity.ABSOLUTE, PathSensitivity.NAME_ONLY]].combinations()
    }

    def "input directories ignore empty directories by default (#api)"() {
        buildFile """
            @CacheableTask

}

// A PosBase represents the base for relative position information:
// At position pos, the relative position is filename:line:col.
type PosBase struct {
	pos       Pos
	filename  string
	line, col uint32
	trimmed   bool // whether -trimpath has been applied
}

// NewFileBase returns a new PosBase for the given filename.
// A file PosBase's position is relative to itself, with the
// position being filename:1:1.

// position base ("absolute" file position).
//
// The position base is used to determine the "relative" position, that is the
// filename and line number relative to the position base. If the base refers
// to the current file, there is no difference between absolute and relative
// positions. If it refers to a //line directive, a relative position is relative
// to that directive. A position base in turn contains the position at which it

    def "returns canonical path where file outside of root"() {
        expect:
        transform(relative, file) == normaliseFileSeparators(file.canonicalPath)

        where:
        relative                                          | file
        new File(rootDir, "current")                      | new File("file/outside")

        path.relativePath(':sub:path') == 'path'
        path.relativePath(':sub2:path') == ':sub2:path'
        path.relativePath(':other:path') == ':other:path'
    }

    def 'converts relative path to relative path'() {
        def path = path(':')

        expect:
        path.relativePath('path') == 'path'
    }

    def "appends path"() {
        expect: