if (repositories != null && selector != null) {
            for (ArtifactRepository repository : repositories) {
                repository.setAuthentication(getAuthentication(selector, repository));
            }
        }
    }

    private Authentication getAuthentication(AuthenticationSelector selector, ArtifactRepository repository) {
        if (selector != null) {

         */
        if (deploymentRepository instanceof DefaultArtifactRepository
                && deploymentRepository.getAuthentication() == null) {
            RemoteRepository.Builder builder = new RemoteRepository.Builder(remoteRepo);
            builder.setAuthentication(session.getAuthenticationSelector().getAuthentication(remoteRepo));
            builder.setProxy(session.getProxySelector().getProxy(remoteRepo));

                    authentication.setPassphrase(server.getPassphrase());

                    repository.setAuthentication(authentication);
                } else {
                    repository.setAuthentication(null);
                }
            }
        }
    }

    private Authentication getAuthentication(RepositorySystemSession session, ArtifactRepository repository) {
        if (session != null) {

        return Collections.emptyList();
    }

    public boolean isProjectAware() {
        return false;
    }

    public Authentication getAuthentication() {
        return authentication;
    }

    public void setAuthentication(Authentication authentication) {
        this.authentication = authentication;
    }

    public Proxy getProxy() {
        return proxy;
    }

    /**
     * @param authentication authentication
     * @since 3.0-alpha-3
     */
    void setAuthentication(Authentication authentication);

    /**
     * @return repository authentication
     * @since 3.0-alpha-3
     */
    Authentication getAuthentication();

    /**
     * @param proxy proxy
     * @since 3.0-alpha-3
     */
    void setProxy(Proxy proxy);

                org.eclipse.aether.repository.Authentication auth = selector.getAuthentication(repo);
                if (auth != null) {
                    repo = new RemoteRepository.Builder(repo)
                            .setAuthentication(auth)
                            .build();
                    AuthenticationContext authCtx = AuthenticationContext.forRepository(session, repo);

            return Collections.emptyList();
        }

        public boolean isProjectAware() {
            return false;
        }

        public void setAuthentication(Authentication authentication) {}

        public Authentication getAuthentication() {
            return null;
        }

        public void setProxy(Proxy proxy) {}

        public Proxy getProxy() {
            return null;

    }

    protected static <T> boolean eq(T s1, T s2) {
        return Objects.equals(s1, s2);
    }

    public Authentication getAuthentication() {
        return authentication;
    }

    public void setAuthentication(Authentication authentication) {
        this.authentication = authentication;
    }

    public Proxy getProxy() {
        return proxy;
    }

            builder.setSnapshotPolicy(toPolicy(repo.getSnapshots()));
            builder.setReleasePolicy(toPolicy(repo.getReleases()));
            builder.setAuthentication(toAuthentication(repo.getAuthentication()));
            builder.setProxy(toProxy(repo.getProxy()));
            builder.setMirroredRepositories(toRepos(repo.getMirroredRepositories()));
            builder.setBlocked(repo.isBlocked());

        repositorySystem.injectAuthentication(Arrays.asList(repository), Arrays.asList(server));
        Authentication authentication = repository.getAuthentication();
        assertNotNull(authentication);
        assertEquals("jason", authentication.getUsername());
        assertEquals("abc123", authentication.getPassword());
    }