assertTrue(updateCheckManager.isUpdateRequired(a, remoteRepository));

        updateCheckManager.touch(a, remoteRepository, null);

        assertFalse(updateCheckManager.isUpdateRequired(a, remoteRepository));

        assertFalse(file.exists());
        assertNotNull(
                updateCheckManager.readLastUpdated(touchFile, updateCheckManager.getRepositoryKey(remoteRepository)));
    }

    @Test

    List<org.apache.maven.artifact.repository.ArtifactRepository> toArtifactRepositories(
            List<RemoteRepository> repositories);

    org.apache.maven.artifact.repository.ArtifactRepository toArtifactRepository(RemoteRepository repository);

    MavenSession getMavenSession();

            private final RemoteRepository repository;
            private final Collection<ProducedArtifact> artifacts;
            private final int retryFailedDeploymentCount;

            DefaultArtifactDeployerRequest(
                    @Nonnull Session session,
                    @Nonnull RemoteRepository repository,
                    @Nonnull Collection<ProducedArtifact> artifacts,

            throws TransferFailedException {
        File file =
                new File(localRepo.getBasedir(), localRepo.pathOfLocalRepositoryMetadata(metadata, remoteRepository));

        try {
            wagonManager.getArtifactMetadataFromDeploymentRepository(
                    metadata, remoteRepository, file, ArtifactRepositoryPolicy.CHECKSUM_POLICY_WARN);

    }

    private static void removeMatchingRepository(Iterable<RemoteRepository> repositories, final String id) {
        Iterator<RemoteRepository> iterator = repositories.iterator();
        while (iterator.hasNext()) {
            RemoteRepository remoteRepository = iterator.next();
            if (remoteRepository.getId().equals(id)) {
                iterator.remove();
            }
        }
    }

    }

    public static List<RemoteRepository> toRepos(List<ArtifactRepository> repos) {
        return Optional.ofNullable(repos).orElse(Collections.emptyList()).stream()
                .map(RepositoryUtils::toRepo)
                .collect(Collectors.toList());
    }

    public static RemoteRepository toRepo(ArtifactRepository repo) {
        RemoteRepository result = null;
        if (repo != null) {

            throws RepositoryMetadataResolutionException {
        RepositoryMetadata metadata = new SnapshotArtifactRepositoryMetadata(artifact);

        getLogger().info("Retrieving previous build number from " + remoteRepository.getId());
        repositoryMetadataManager.resolveAlways(metadata, localRepository, remoteRepository);

        int buildNumber = 0;

            artifactDeployer.deploy(file, artifact, remoteRepository(), localRepository());

            ArtifactRepository remoteRepository = remoteRepository();
            File deployedFile = new File(remoteRepository.getBasedir(), remoteRepository.pathOf(artifact));
            assertTrue(deployedFile.exists());

        return new DefaultArtifact(artifact.getGroupId(), artifact.getArtifactId(), "pom", artifact.getVersion());
    }

    public static RemoteRepository toRemoteRepository(Repository repository) {
        RemoteRepository.Builder builder =
                new RemoteRepository.Builder(repository.getId(), repository.getLayout(), repository.getUrl());
        builder.setSnapshotPolicy(toRepositoryPolicy(repository.getSnapshots()));

                runtimeInformation);
    }

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

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