<?xml version="1.0"?>
<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.3//EN" "http://www.puppycrawl.com/dtds/configuration_1_3.dtd">
<module name="Checker">
    <module name="TreeWalker">
        <module name="AvoidStarImport"/>
        <module name="ConstantName"/>
        <module name="EmptyBlock"/>
    </module>

        module.jar.sha1.expectGet()
    }

    void sha1ThenGetRequests() {
        module.ivy.sha1.expectGet()
        module.ivy.expectGet()

        module.jar.sha1.expectGet()
        module.jar.expectGet()
    }

    void headThenSha1Requests() {
        module.ivy.expectHead()
        module.ivy.sha1.expectGet()

        module.jar.expectHead()
        module.jar.sha1.expectGet()
    }

}
"""

        when:
        def module = ivyRepo.module('org.gradle.test', 'publishGcsTest', '1.0')
        module.jar.expectUpload()
        module.jar.sha1.expectUpload()
        module.jar.sha256.expectUpload()
        module.jar.sha512.expectUpload()
        module.ivy.expectUpload()
        module.ivy.sha1.expectUpload()
        module.ivy.sha256.expectUpload()
        module.ivy.sha512.expectUpload()

    def "resolves available-at variant even if transitive dependencies are excluded"() {
        given:
        mavenHttpRepo.module('org', 'moduleB', '1.0')
            .dependsOn(mavenHttpRepo.module("org", "moduleA", "1.0"), exclusions: [[group: '*', module: '*']])
            .publish() // no Gradle Module metadata for this one because we don't support excludes on dependencies
        repository {
            'org:moduleA:1.0' {

        void expectGetMetadata(String group, String module) {
            String id = "$group:$module"
            server.expectGet("/repo/${group.replace('.', '/')}/$module/metadata.json", files[id])
        }

        @Override
        void expectRefresh(String group, String module) {
            String id = "$group:$module"
            server.expectHead("/repo/${group.replace('.', '/')}/$module/metadata.json", files[id])
        }
    }

            root(":", ":test:") {
                module("a:a:1.0") {
                    module("b:b:1.0")
                    module("c:c:1.0")
                }
            }
        }

        where:
        condition             | excludeAttributes
        'non-matching module' | [module: 'other']
        'non-matching module' | [group: 'other']
        'sibling module'      | [module: 'c']
        'sibling group'       | [group: 'c']

                .prepare()

        when:
        module.ivy.expectGet()
        module.getArtifact(classifier: "my-sources").expectGet()
        module.getArtifact(classifier: "my-javadoc").expectGet()

        then:
        checkArtifactsResolvedAndCached()
    }

    def "resolves multiple artifacts of the same type"() {
        given:

        }
    }
"""
        def module = mavenRepo.module('org.gradle', 'snapshotPublish', '1.0-SNAPSHOT')

        when:
        succeeds 'publish'

        then:
        def initialVersion = module.publishArtifactVersion
        def initialArtifacts = ["snapshotPublish-${initialVersion}.module", "snapshotPublish-${initialVersion}.jar", "snapshotPublish-${initialVersion}.pom"]

        t.message == "Cannot set 'module' multiple times for module dependency."

        when:
        container.module("bar").module("org:foo:1.0")

        then:
        t = thrown IllegalDependencyNotation
        t.message == "Cannot set 'module' multiple times for module dependency."

        when:
        container.module("org:foo:1.0").group("bar")

        then:

# Test that go list fails on a go.mod with no module declaration.
cd $WORK/gopath/src/mod
! go list .
stderr '^go: error reading go.mod: missing module declaration. To specify the module path:\n\tgo mod edit -module=example.com/mod$'

# Test that go mod init in GOPATH doesn't add a module declaration
# with a path that can't possibly be a module path, because
# it isn't even a valid import path.