if (key == null) {
            throw new IllegalArgumentException("key cannot be null");
        }
    }

    protected void assertArtifactFileNotNull(File artifactFile) {
        if (artifactFile == null) {
            throw new IllegalArgumentException("artifactFile cannot be null");
        }
    }

    public void clear(final K key) {
        assertKeyNotNull(key);

        run 'retrieve'

        then:
        succeeds 'retrieve'

        and:
        localModule.artifactFile.assertIsDifferentFrom(module.artifactFile)
        localModule.pomFile.assertIsDifferentFrom(module.pomFile)
        file("libs/test-${artifactVersion}.jar").assertIsCopyOf(module.artifactFile)
    }

    @Override
    String getRepositoryPath() {
        return '/maven/snapshot/'
    }

        moduleDescriptorFile = new File(testDirectoryProvider.testDirectory, "module-file")
        artifactFile = new File(testDirectoryProvider.testDirectory, "artifact-file")
        artifactFile << "some content"
    }

    def "name property is passed through"() {
        when:
        def publication = createPublication()

        then:
        publication.name == "pub-name"
    }

        def m1 = mavenRepo.module("test", "test", "1.3").publish()
        m1.artifactFile.text = "1234"
        def m2 = mavenRepo.module("test", "test2", "2.3").publish()
        m2.artifactFile.text = "12"
        def m3 = mavenRepo.module("test", "test3", "3.3").publish()
        m3.artifactFile.text = "123"

        given:

        buildFile << """
            repositories {

            server.allowGetOrHead('/repo1/my-group/my-module/1.0/my-module-1.0.jar', 'user', 'secret', module.artifactFile)
        } else {
            server.allowGetOrHead('/repo1/my-group/my-module/1.0/my-module-1.0.pom', module.pomFile)
            server.allowGetOrHead('/repo1/my-group/my-module/1.0/my-module-1.0.jar', module.artifactFile)
        }
    }

    @Override
    protected String getRepoType() {
        return "maven"

    def file = new File("foo")
    def artifactFile = new File("foo-artifact")
    def artifactId = Stub(ComponentArtifactIdentifier)
    def source = Stub(CalculatedValue) {
        isFinalized() >> true
        getValue() >> Try.successful(file)
    }
    def artifact = Stub(ResolvableArtifact) {
        getId() >> artifactId
        getFileSource() >> source
        getFile() >> artifactFile
    }

        remoteModule.artifact.sha1.expectGet()

        when:
        using m2
        run 'retrieve'

        then:
        file('build/foo-1.0.jar').assertIsCopyOf(m2Module.artifactFile)
    }

    def "does not reuse cached artifacts from maven local cache when they are different to those in the remote repository"() {
        given:

        // The implementation jar module.
        def module = mavenRepo.module(group, artifact, version)
        def pluginModule = module.publish()
        def artifactFile = module.getArtifactFile()

        def markerModules = new ArrayList<Module>()

        pluginIds.keySet().each { id ->
            // The marker files for each plugin.

    }

    @Override
    public Artifact find(Artifact artifact) {
        File artifactFile = new File(localRepository.getBasedir(), pathOf(artifact));

        // We need to set the file here or the resolver will fail with an NPE, not fully equipped to deal
        // with multiple local repository implementations yet.
        artifact.setFile(artifactFile);

        return artifact;
    }

    @Override
    public String getId() {

     *  @param key The key to cache this resolution under in the index. Cannot be null.
     * @param artifactFile The artifact file in the persistent file store. Cannot be null
     * @param moduleDescriptorHash The checksum (SHA1) of the related moduledescriptor.
     */
    void store(ArtifactAtRepositoryKey key, File artifactFile, HashCode moduleDescriptorHash);

    /**
     * Record that the artifact with the given key was missing.