}

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

                project.getAttachedArtifacts().stream());
        return artifacts.map(RepositoryUtils::toArtifact);
    }

    private boolean isRegularFile(Artifact artifact) {
        return artifact.getFile() != null && artifact.getFile().isFile();
    }

    private void installIntoProjectLocalRepository(Artifact artifact) {
        Path target = getArtifactPath(artifact);
        try {

                project.getVersion(),
                null,
                "pom",
                null,
                new PomArtifactHandler());
        this.project = project;
        setFile(project.getFile());
        setResolved(true);
    }

    public MavenProject getProject() {
        return project;
    }

    public List<Dependency> getDependencies() {

        this.parent = parent;
    }

    public boolean hasParent() {
        return getParent() != null;
    }

    public File getFile() {
        return file;
    }

    public void setFile(File file) {
        this.file = file;
        this.basedir = file != null ? file.getParentFile() : null;
    }

    /**

    @Override
    public void artifactInstalling(RepositoryEvent event) {
        logger.info("Installing {} to {}", event.getArtifact().getFile(), event.getFile());
    }

    @Override
    public void metadataInstalling(RepositoryEvent event) {
        logger.debug("Installing {} to {}", event.getMetadata(), event.getFile());
    }

    @Override
    public void metadataResolved(RepositoryEvent event) {

                }
            });

            t.transform(project, systemSessionMock, beforePomFile, tempFile);
        }
        XmlAssert.assertThat(afterPomFile.toFile()).and(tempFile.toFile()).areIdentical();
    }

    @Test
    void injectTransformedArtifactsWithoutPomShouldNotInjectAnyArtifacts() throws IOException {
        MavenProject emptyProject = new MavenProject();

            } else if (request.getGlobalToolchainsPath().isPresent()) {
                req.setGlobalToolchainsSource(new org.apache.maven.building.FileSource(
                        request.getGlobalToolchainsPath().get().toFile()));
            }
            if (request.getUserToolchainsSource().isPresent()) {
                req.setUserToolchainsSource(new MappedToolchainsSource(
                        request.getUserToolchainsSource().get()));

                        request.getGlobalSettingsSource().get()));
            }
            if (request.getGlobalSettingsPath().isPresent()) {
                req.setGlobalSettingsFile(request.getGlobalSettingsPath().get().toFile());
            }
            if (request.getUserSettingsSource().isPresent()) {
                req.setUserSettingsSource(
                        new MappedSettingsSource(request.getUserSettingsSource().get()));

        }
    }

    public Result<? extends Model> buildRawModel(Path pomFile, int validationLevel, boolean locationTracking) {
        return buildRawModel(pomFile, validationLevel, locationTracking, null);
    }

    public Result<? extends Model> buildRawModel(
            Path pomFile, int validationLevel, boolean locationTracking, ModelTransformerContext context) {

        File file = new File(getRepository().getBasedir(), path);

        LocalArtifactResult result = new LocalArtifactResult(request);
        if (file.isFile()) {
            result.setFile(file);
            result.setAvailable(true);
        }

        return result;
    }

    public LocalMetadataResult find(RepositorySystemSession session, LocalMetadataRequest request) {