resolveResult = artifactResolver.resolveArtifact(session, resolveRequest);
                pomArtifact = resolveResult.getArtifact();
                result.setRepository(resolveResult.getRepository());
            } catch (ArtifactResolutionException e) {
                if (e.getCause() instanceof ArtifactNotFoundException artifactNotFoundException) {

    }

    public static WorkspaceRepository getWorkspace(RepositorySystemSession session) {
        WorkspaceReader reader = session.getWorkspaceReader();
        return (reader != null) ? reader.getRepository() : null;
    }

    public static boolean repositoriesEquals(List<RemoteRepository> r1, List<RemoteRepository> r2) {
        if (r1.size() != r2.size()) {
            return false;
        }

        /**
         * Returns the repository from which the artifact was resolved.
         *
         * @return The {@link Repository} instance.
         */
        Repository getRepository();

        /**
         * Returns the file system path to the resolved artifact.
         *
         * @return The {@link Path} to the artifact.
         */
        Path getPath();

        /**

     */
    @Nonnull
    List<RemoteRepository> getRemoteRepositories();

    /**
     * The repository where this artifact has been downloaded from.
     */
    @Nonnull
    Optional<RemoteRepository> getRepository();

    /**
     * Traverses this node and potentially its children using the specified visitor.
     *
     * @param visitor the visitor to call back, must not be {@code null}

        if (event == null) {
            return null;
        } else {
            String wagon = event.getWagon().getClass().getName();

            ArtifactTransferResource artifact = wrap(event.getWagon().getRepository(), event.getResource());

            ArtifactTransferEvent evt;
            if (event.getException() != null) {

        DeploymentRepository src = source.getRepository();
        if (src != null) {
            DeploymentRepository tgt = target.getRepository();
            if (sourceDominant || tgt == null) {
                tgt = new DeploymentRepository();
                tgt.setLocation("", src.getLocation(""));
                target.setRepository(tgt);

        clone.setDependencyFilter(artifact.getDependencyFilter());
        clone.setDependencyTrail(copyList(artifact.getDependencyTrail()));
        clone.setDownloadUrl(artifact.getDownloadUrl());
        clone.setRepository(artifact.getRepository());

        return clone;
    }

    /**
     * Copy artifact to a collection.
     *
     * @param <T> the target collection type
     * @param from an artifact collection

            "; ${LocalIndexedRepo.PROP_LOCAL_DIR} = '$repoDir'",
        )
        refresh()
        prepareWorkspace()
      }
  }

  private fun Workspace.prepareWorkspace() {
    val repositoryPlugin = getRepository(REPO_NAME)

    // Deploy the bundles in the deployments test directory.
    repositoryPlugin.deployDirectory(testResourceDir / "deployments")
    repositoryPlugin.deployClassPath()
  }

        if (repository instanceof DefaultRemoteRepository defaultRemoteRepository) {
            org.eclipse.aether.repository.RemoteRepository rr = defaultRemoteRepository.getRepository();

            try {
                return mavenRepositorySystem.createRepository(
                        rr.getUrl(),
                        rr.getId(),

    }

    @Override
    public File getFile() {
        return file;
    }

    @Override
    public ArtifactRepository getRepository() {
        return repository;
    }

    @Override
    public void setRepository(ArtifactRepository repository) {
        this.repository = repository;
    }

    // ----------------------------------------------------------------------
    //