/**
     * 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

            remove(1)
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == checkable(['foo', 'baz'])
    }

    def "can add using index"() {
        when:
        mutate {
            add 'foo'
            add(0, 'bar')
        }

        then:
        def list = registry.realize(collectionPath, collectionType)
        list == ['bar', 'foo']

    }

// 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:

                    <mxGeometry relative="1" as="geometry">
                        <Array as="points">
                            <mxPoint x="800" y="521"/>
                            <mxPoint x="800" y="560"/>
                        </Array>

                    <mxGeometry relative="1" as="geometry">
                        <Array as="points">
                            <mxPoint x="800" y="521"/>
                            <mxPoint x="800" y="560"/>
                        </Array>

    List<String> getDefaultJvmOpts();

    /**
     * The classpath, relative to the application home directory.
     */
    List<String> getClasspath();

    /**
     * The module path, relative to the application home directory.
     *
     * @since 6.4
     */
    List<String> getModulePath();

    /**
     * The path of the script, relative to the application home directory.
     */
    String getScriptRelPath();

                result = file.getPath();
            } else if (file.getPath().startsWith(File.separator)) {
                // drive-relative Windows path, don't align with project directory but with drive root
                result = file.getAbsolutePath();
            } else {
                // an ordinary relative path, align with project directory
                result = basedir.resolve(path).normalize().toString();
            }
        }