}

    abstract protected String getPath();

    abstract void expectGet()

    abstract void expectGetBroken()

    abstract void expectGetUnauthorized()

    abstract void expectGetMissing()

    abstract void expectGetRevalidate()

    abstract void expectHead()

    abstract void expectHeadBroken()

    abstract void expectHeadMissing()

    abstract void expectHeadRevalidate()

        server.expectGetDirectoryListing(path, directory)
    }

    public void allowGet() {
        server.allowGetDirectoryListing(path, directory)
    }

    @Override
    public void expectGetMissing() {
        server.expectGetMissing(path)
    }

    @Override
    public void expectGetBroken() {
        server.expectGetBroken(path)
    }

    @Override
    void expectGetUnauthorized() {

        server.expectGetUnauthorized(getPath())
    }

    void expectGetBlocking() {
        server.expectGetBlocking(getPath())
    }

    void expectGetMissing(PasswordCredentials credentials = null) {
        server.expectGetMissing(getPath(), credentials)
    }

    @Override
    void expectGetRevalidate() {
        server.expectGetRevalidate(getPath(), file)
    }

    void expectHead() {

        module.artifact.sha1.expectPut()
        module.artifact.sha256.expectPutBroken()
        module.artifact.sha512.expectPutBroken()
        module.artifact.md5.expectPut()
        module.rootMetaData.expectGetMissing()
        module.rootMetaData.expectPut()
        module.rootMetaData.sha1.expectPut()
        module.rootMetaData.sha256.expectPutBroken()
        module.rootMetaData.sha512.expectPutBroken()

                }
            }
"""

        when:
        def m1 = mavenHttpRepo.module("test", "test1", "1.2")
        m1.pom.expectGetMissing()
        def m2 = mavenHttpRepo.module("test", "test2", "1.2")
        m2.pom.expectGetUnauthorized()
        def m3 = mavenHttpRepo.module("test", "test3", "1.2").publish()
        m3.pom.expectGet()

    compile 'org:test:1.0+'
    compile 'org:test2:2.0'
}

${showFailuresTask(expression)}
"""

        given:
        mavenHttpRepo.getModuleMetaData('org', 'test').expectGetMissing()
        mavenHttpRepo.directory('org', 'test').expectGetMissing()
        def m = mavenHttpRepo.module('org', 'test2', '2.0').publish()
        m.pom.expectGetBroken()

        when:
        fails 'show'

        then:

    }

    def "reports read of missing uri resource"() {
        given:
        def uuid = UUID.randomUUID()
        server.expectGetMissing("/myConfig-${uuid}.txt")
        server.start()
        buildFile << """
            text.text = resources.text.fromUri("${server.uri}/myConfig-${uuid}.txt")
"""

        expect:
        fails("text")

        server.stop()
    }

    @Override
    void expectPluginMarkerMissing(String pluginId, String pluginVersion) {
        module(pluginId, pluginId + PLUGIN_MARKER_SUFFIX, pluginVersion).with {
            pom.expectGetMissing()
            artifact.expectHeadMissing()
        }
    }

    @Override
    void expectPluginMarkerBroken(String pluginId, String pluginVersion) {

    compile 'org:test2:2.0'
}

task show {
    doLast {
        ${expression}.collect { it.name }
    }
}
"""

        given:
        mavenHttpRepo.getModuleMetaData('org', 'test').expectGetMissing()
        def m = mavenHttpRepo.module('org', 'test2', '2.0').publish()
        m.pom.expectGetBroken()

        when:
        maybeExpectDeprecation(expression)
        fails 'show'

        then:

            name = 'my-test-artifact'
            extension = 'jar'
            type = 'jar'
        }
    }
}
"""
        resolve.prepare()

        when:
        dep.ivy.expectGetMissing()
        dep.getArtifact(name: 'my-test-artifact').expectHead()
        dep.getArtifact(name: 'my-test-artifact').expectGet()

        then:
        succeeds "checkDeps"
        resolve.expectGraph {