}

            File pomFile = pomArtifact.getFile();
            if (pomFile != null && pomFile.canRead()) {
                this.length = pomFile.length();
                this.timestamp = pomFile.lastModified();
            } else {
                this.length = -1;
                this.timestamp = -1;
            }

    public File getPomFile() {
        return pomFile;
    }

    @Override
    public DefaultModelBuildingRequest setPomFile(File pomFile) {
        this.pomFile = (pomFile != null) ? pomFile.getAbsoluteFile() : null;

        return this;
    }

    @Override
    public synchronized ModelSource getModelSource() {
        if (modelSource == null && pomFile != null) {

        Model model;

        if (modelSource == null) {
            if (pomFile != null) {
                modelSource = new FileModelSource(pomFile);
            } else {
                throw new NullPointerException("neither pomFile nor modelSource can be null");
            }
        }

        problems.setSource(modelSource.getLocation());
        try {

    private Dependency dependency;

    public InvalidDependencyVersionException(
            String projectId, Dependency dependency, File pomFile, InvalidVersionSpecificationException cause) {
        super(projectId, formatLocationInPom(dependency), dependency.getVersion(), pomFile, cause);
        this.dependency = dependency;
    }

    private static String formatLocationInPom(Dependency dependency) {

        this(projectId, message, new File(pomLocation), validationResult);
    }

    public InvalidProjectModelException(
            String projectId, String message, File pomFile, ModelValidationResult validationResult) {
        super(projectId, message, pomFile);

        this.validationResult = validationResult;
    }

    /**
     * @param projectId
     * @param pomLocation absolute path of the pom file

    public ModelSource resolveModel(String groupId, String artifactId, String version)
            throws UnresolvableModelException {
        File pomFile = null;

        if (modelPool != null) {
            pomFile = modelPool.get(groupId, artifactId, version);
        }

        if (pomFile == null) {
            Artifact pomArtifact = new DefaultArtifact(groupId, artifactId, "", "pom", version);

            try {

            String projectId,
            String locationInPom,
            String offendingVersion,
            File pomFile,
            InvalidVersionSpecificationException cause) {
        super(projectId, formatMessage(projectId, locationInPom, offendingVersion, cause), pomFile, cause);
        this.locationInPom = locationInPom;
        this.offendingVersion = offendingVersion;
    }

    private final Map<CacheKey, File> pomFiles = new HashMap<>();

    public File get(String groupId, String artifactId, String version) {
        return pomFiles.get(new CacheKey(groupId, artifactId, version));
    }

    public void put(String groupId, String artifactId, String version, File pomFile) {
        pomFiles.put(new CacheKey(groupId, artifactId, version), pomFile);
    }

    private static final class CacheKey {

    }

    @Override
    public File getPomFile() {
        return request.getPomFile();
    }

    @Override
    public FilterModelBuildingRequest setPomFile(File pomFile) {
        request.setPomFile(pomFile);

        return this;
    }

    @Override
    public ModelSource getModelSource() {
        return request.getModelSource();
    }

    @Override

                new SimpleLocalRepositoryManagerFactory().newInstance(repoSession, localRepo));
        config.setRepositorySession(repoSession);

        return new PomTestWrapper(pomFile, projectBuilder.build(pomFile, config).getProject());
    }

    private static Settings readSettingsFile(File settingsFile) throws IOException, XMLStreamException {