run 'checkDeps'

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("org:bar:1.0")
                module("org:first-level:1.0")
            }
        }
    }

    void "dependency constraint on substituted module is recognized properly"() {
        given:
        def available = featureAvailable()
        repository {
            'org:foo:1.0'()

                    throw new MetaDataParseException("module metadata", resource, String.format("unsupported format version '%s' specified in module metadata. This version of Gradle supports format version %s.", version, FORMAT_VERSION), e);
                }
                throw new MetaDataParseException("module metadata", resource, e);
            }
        });

    private def assertId(ModuleVersionIdentifier moduleId, String group, String name, String version) {
        assert moduleId.group == group
        assert moduleId.name == name
        assert moduleId.version == version
    }

    private def assertId(ModuleComponentIdentifier moduleId, String group, String name, String version) {
        assert moduleId.group == group
        assert moduleId.module == name

        def operand1 = moduleId('root', 'rain')
        def operand2 = moduleId('cover', 'cover')
        def operand3 = moduleId('crib', 'lunchroom')
        def operand4 = moduleId('root', 'sort')
        def operand5 = moduleId('crib', 'building')
        def operand6 = moduleId('fact', 'grass')
        def operand7 = moduleId('crib', 'planes')
        def operand8 = moduleId('stove', 'pull')

        def module = Mock(ModuleComponentIdentifier)
        def localAccess = repo.localAccess

        when:
        def cost = localAccess.estimateMetadataFetchingCost(module)

        then:
        1 * realRemoteAccess.estimateMetadataFetchingCost(module) >> remoteAnswer
        cost == remoteAnswer

        where:

** Once a repository returns a _metadata_ result, following repositories are ignored.
* Metadata for the dependency is retrieved and parsed, if found
** If the module metadata is a POM file that has a parent POM declared, Gradle will recursively attempt to resolve each of the parent modules for the POM.

	path, err := module.UnescapePath(enc)
	if err != nil {
		if testing.Verbose() {
			fmt.Fprintf(os.Stderr, "go proxy_test: %v\n", err)
		}
		http.NotFound(w, r)
		return
	}
	if file == "list" {
		// list returns a list of versions, not including pseudo-versions.
		// If the module has no tagged versions, we should serve an empty 200.
		// If the module doesn't exist, we should serve 404 or 410.

 */
class MavenPublishIssuesIntegTest extends AbstractMavenPublishIntegTest {

    @Issue("GRADLE-2456")
    def "generates SHA1 file with leading zeros"() {
        given:
        def module = mavenRepo.module("org.gradle", "publish", "2")
        byte[] jarBytes = [0, 0, 0, 5]
        def artifactFile = file("testfile.bin")
        artifactFile << jarBytes
        def artifactPath = TextUtil.escape(artifactFile.path)

        if (!(module.getId() instanceof ModuleComponentIdentifier)) {
            return Collections.emptySet();
        }

        ModuleComponentIdentifier moduleId = (ModuleComponentIdentifier) module.getId();
        IvyArtifactName ivyArtifactName = new DefaultIvyArtifactName(moduleId.getModule(), type, "jar", classifier);

    }

    def moduleAvailableViaHttp() {
        module.metaData.expectGet()
        module.pom.expectGet()
        module.artifact.expectGet()
    }

    def moduleAvailableViaHttpWithoutMetaData() {
        module.metaData.expectGetMissing()
        module.pom.expectGet()
        module.artifact.expectGet()
    }