}
                }
            }
""")

        when:
        run "publish"

        then:
        publishedModule.assertPublished()
        publishedModule.parsedPom.scopes.runtime.assertDependsOn('group:module:1.0')
        publishedModule.parsedModuleMetadata.variants*.name == ["usage"]
        publishedModule.parsedModuleMetadata.variant("usage").files*.name == ["publishTest-1.9.text"]

        main.assertArtifactsPublished("test-1.2-cpp-api-headers.zip", "test-1.2.pom", "test-1.2.module")
        main.artifactFile(classifier: 'cpp-api-headers', type: 'zip').assertIsCopyOf(headersZip)

        main.parsedPom.scopes.isEmpty()

        def mainMetadata = main.parsedModuleMetadata
        mainMetadata.variants.size() == 5
        def api = mainMetadata.variant("api")
        api.dependencies.empty
        api.files.size() == 1

            "java-project-1.0.jar",
            "java-project-1.0-javadoc.jar",
            "java-project-1.0.pom",
            "java-project-1.0.module")
        module.parsedPom.packaging == null
        module.parsedPom.scopes.runtime.assertDependsOn("commons-collections:commons-collections:3.2.2")

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample("maven-publish/customize-identity")

        file('build/libs/publishEar-1.9.ear').assertExists()

        when:
        run "publish"

        then:
        earModule.assertPublishedAsEarModule()
        earModule.parsedPom.scopes.isEmpty()

        and:
        resolveArtifacts(earModule) {
            withModuleMetadata {
                noComponentPublished()
            }
            withoutModuleMetadata {

        expectPublish(module.rootMetaData)

        and:
        succeeds 'publish'

        then:
        module.backingModule.assertPublishedAsJavaModule()
        module.parsedPom.scopes.isEmpty()
    }

    private static void expectPublish(SftpArtifact pom, boolean parentMkdir = false) {
        if (parentMkdir) {
            pom.expectParentMkdir()
        } else {

        moduleMetadata.file.assertDoesNotExist()
    }

    void assertPublished() {
        assert pomFile.assertExists()
        assert parsedPom.groupId == groupId
        assert parsedPom.artifactId == artifactId
        assert parsedPom.version == version
        def checkExtraChecksums = extraChecksums
        Set<String> missingExtra = missingExtraChecksums
        if (getModuleMetadata().file.exists()) {

        module.rootMetaData.expectDownloadMissing()
        expectPublish(module.rootMetaData)

        succeeds 'publish'

        then:
        module.assertPublishedAsJavaModule()
        module.parsedPom.scopes.isEmpty()
    }

    private static void expectPublish(GcsArtifact artifact) {
        artifact.expectUpload()
        artifact.sha1.expectUpload()
        artifact.sha256.expectUpload()

            dependency("group:projectC:1.+")
            dependency("group:projectD:[1.0,2.0)")
            dependency("group:projectE:[1.0]")
            noMoreDependencies()
        }

        mavenModule.parsedPom.scopes.compile.assertDependsOn(
            "group:projectA:RELEASE",
            "group:projectB:LATEST",
            "group:projectC:1.+",
            "group:projectD:[1.0,2.0)",
            "group:projectE:1.0"

			}
			inputReq.URL.RawQuery = q.Encode()
		} else if testCase.inputHeaderKey != "" {
			inputReq.Header.Set(testCase.inputHeaderKey, testCase.inputHeaderValue)
		}
		inputReq.ParseForm()

		actualResult := skipContentSha256Cksum(inputReq)
		if testCase.expectedResult != actualResult {
			t.Errorf("Test %d: Expected the result to `%v`, but instead got `%v`", i+1, testCase.expectedResult, actualResult)

        }
        samples
    }

    MutableModuleComponentResolveMetadata parse(File file) {
        switch (file.parentFile.name) {
            case 'pom':
                return removeSources(parsePom(file))
            case 'ivy':
                return removeSources(parseIvy(file))
            case 'gradle':
                return removeSources(parseGradle(file))
        }