}

    @Nullable
    ModelSource resolve(@Nonnull ModelLocator modelLocator, @Nonnull String relative);

    @Nonnull
    static ModelSource fromPath(@Nonnull Path path) {
        return fromPath(path, null);
    }

    @Nonnull
    static ModelSource fromPath(@Nonnull Path path, @Nullable String location) {
        return new PathSource(nonNull(path, "path cannot be null"), location);
    }

    }

    private Library createLibrary() {
        Library library = new Library(fileReferenceFactory.fromPath('/ant.jar'))
        library.exported = true
        library.nativeLibraryLocation = 'mynative'
        library.accessRules += [new AccessRule('nonaccessible', 'secret**')]
        library.sourcePath = fileReferenceFactory.fromPath("/ant-src.jar")

    }

    @Nonnull
    static SettingsBuilderRequest build(
            @Nonnull Session session, @Nonnull Path globalSettingsPath, @Nonnull Path userSettingsPath) {
        return build(session, Source.fromPath(globalSettingsPath), null, Source.fromPath(userSettingsPath));
    }

    @Nonnull
    static SettingsBuilderRequest build(
            @Nonnull Session session,
            @Nullable Source globalSettingsSource,

        LinkedList<String> fromPath = splitPath(from);
        LinkedList<String> toPath = splitPath(to);
        List<String> relativePath = new ArrayList<String>();

        while (!fromPath.isEmpty() && !toPath.isEmpty() && fromPath.get(0).equals(toPath.get(0))) {
            fromPath.removeFirst();
            toPath.removeFirst();
        }
        for (String ignored : fromPath) {
            relativePath.add("..");

class RelativePathUtilTest extends Specification {

    def "relative path from #fromPath to #toPath is #path"() {
        when:
        def from = new File(fromPath)
        def to = new File(toPath)

        then:
        RelativePathUtil.relativePath(from, to) == path

        where:
        fromPath | toPath  | path
        "a"      | "a/b"   | "b"
        "a"      | "a/b/a" | "b/a"

        Library library = new Library(fileReferenceFactory.fromPath("/somepath"))
        library.exported = true
        return library
    }

    private ProjectDependency createProjectDependency(String path, String publicationPath, Map entryAttributes) {
        def projectDependency = new ProjectDependency(path)
        projectDependency.publication = fileReferenceFactory.fromPath(publicationPath)

                                ? Source.fromPath(globalToolchainsPath)
                                : null)
                .userToolchainsSource(
                        userToolchainsPath != null && Files.exists(userToolchainsPath)
                                ? Source.fromPath(userToolchainsPath)
                                : null)
                .build();
    }

                return ModelSource.fromPath(Paths.get("src/test/resources/consumer/simple/pom.xml"));
            } else if (id.startsWith("org.sonatype.mavenbook.multi:simple-parent:")) {
                return ModelSource.fromPath(Paths.get("src/test/resources/consumer/simple/simple-parent/pom.xml"));
            } else if (id.startsWith("org.my.group:parent:")) {

		log.Errorf("certificate timestamp (%v) could not be parsed: %v", cert.ExpirationTime, err)
		return false
	}
	fromDate, err := time.Parse(time.RFC3339, cert.ValidFrom)
	if err != nil {
		log.Errorf("certificate timestamp (%v) could not be parsed: %v", cert.ValidFrom, err)
		return false
	}
	if today.After(fromDate) && today.Before(expDate) {
		return true
	}
	return false

        expect:
        factory.fromFile(null) == null
    }

    def "creates a reference from a file path"() {
        TestFile file = tmpDir.file("file.txt")

        expect:
        def reference = factory.fromPath(relpath(file))
        reference.file == file
        reference.path == relpath(file)
        !reference.relativeToPathVariable
    }

    def "creates a reference from a jar url"() {