final cacheAccessCoordinator = new ArtifactCacheLockingAccessCoordinatorStub()
    final fileRepository = Mock(FileResourceRepository)
    final cachePolicy = new DefaultExternalResourceCachePolicy()
    final ProducerGuard<URI> producerGuard = Stub() {
        guardByKey(_, _) >> { args ->
            def (key, supplier) = args
            supplier.get()
        }
    }

                expectHeadVersionListing()
            }
        }

        then:
        fails ':checkDeps'

        and:
        // TODO - this failure and the previous failure should report the same urls (whatever that happens to be)
        failureHasCause("""Could not find any version that matches org.utils:api:1.+.
Versions that do not match:
  - 2.1
  - 2.0
Versions rejected by component selection rules:
  - 1.2

        then:
        def e = thrown(MissingResourceException)
        e.location == name.uri

        1 * resourceAccessor.withContent(name, true, _) >> null
        0 * _
    }

    def expectResourceRead(ExternalResourceName name, String content) {
        1 * resourceAccessor.withContent(name, true, _) >> { uri, revalidate, action ->
            action.execute(new ByteArrayInputStream(content.bytes))
        }

        settingsFile << """
    includeBuild '${producer.toURI()}'
"""
        buildFile << """
    apply plugin: 'java'
    repositories {
        maven { url '${mavenRepo.uri}' }
    }

    repositories {
        maven { url '${mavenRepo.uri}' }
    }
    dependencies {
        implementation 'org.test:producer:1.0'
    }
"""
        resolve.prepare("runtimeClasspath")

labels.excludedUrls=Excluded URLs For Crawling
labels.excludedDocPaths=Excluded Paths For Indexing
labels.excludedDocUrls=Excluded URLs For Indexing
labels.hostname=Hostname
labels.id=ID
labels.includedPaths=Included Paths For Crawling
labels.includedUrls=Included URLs For Crawling
labels.includedDocPaths=Included Paths For Indexing
labels.includedDocUrls=Included URLs For Indexing
labels.maxAccessCount=Max Access Count

        mavenRepo.module("test", "a", "1.2").withNoPom().withModuleMetadata().publish()

        given:
        buildFile << """
repositories {
    maven {
        url = '${mavenRepo.uri}'
        metadataSources { gradleMetadata() }
    }
}
configurations { compile }
dependencies {
    compile 'test:a:1.2'
}
"""

        when:
        run("checkDeps")

        then:

		{Name: "experimental-initial-corrupt-check", Value: "true"},
		{Name: "listen-client-urls", Value: fmt.Sprintf("%s,%s", etcdutil.GetClientURLByIP(etcdLocalhostAddress), etcdutil.GetClientURL(endpoint))},
		{Name: "advertise-client-urls", Value: etcdutil.GetClientURL(endpoint)},
		{Name: "listen-peer-urls", Value: etcdutil.GetPeerURL(endpoint)},
		{Name: "initial-advertise-peer-urls", Value: etcdutil.GetPeerURL(endpoint)},

        server.expect(server.get("b").sendFile(file))
        server.expect(server.get("c").send("this is the content"))
        server.start()

        when:
        server.uri("a").toURL().text == ""
        server.uri("b").toURL().text == "123"
        server.uri("c").toURL().text == "this is the content"
        server.stop()

        then:
        noExceptionThrown()
    }

        }

        void verifySignatures() {
            builder.verifySignatures = true
        }

        void keyServer(String uri) {
            builder.addKeyServer(new URI(uri))
        }

        void keyServer(URI uri) {
            builder.addKeyServer(uri)
        }

        void keyRingFormat(String keyRingFormat) {
            builder.setKeyringFormat(keyRingFormat);
        }

        given:
        def repoDeclaration = """
            repositories {
                maven {
                    url("${mavenRepo.uri}")
                }
            }
        """
        def pluginBuild = pluginBuild("build-logic")
        publishSettingsPlugin(pluginBuild.settingsPluginId, repoDeclaration)

        when: