}

    def rendersLinkToParameterizedType() {
        def metaData = type('org.gradle.SomeClass')
        metaData.addTypeArg(type('Type1'))
        metaData.addTypeArg(type('Type2'))

        when:
        def link = renderer.link(metaData, listener)

        then:

     */
    MavenModule publish() {
        moduleDir.mkdirs()

        if (uniqueSnapshots && version.endsWith("-SNAPSHOT")) {
            def metaDataFile = new File(moduleDir, 'maven-metadata.xml')
            metaDataFile.text = """
<metadata>
  <groupId>$groupId</groupId>
  <artifactId>$artifactId</artifactId>
  <version>$version</version>
  <versioning>
    <snapshot>

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package gradlebuild.binarycompatibility.filters

import gradlebuild.binarycompatibility.metadata.KotlinMetadataQueries
import japicmp.filter.BehaviorFilter
import japicmp.filter.ClassFilter
import japicmp.filter.FieldFilter
import javassist.CtBehavior
import javassist.CtClass
import javassist.CtField

/**

    def factory = new OriginMetadataFactory(
        buildInvocationId,
        { it.gradleVersion = "3.0" }
    )
    def buildCacheKey = TestHashCodes.hashCodeFrom(1234)

    def "converts to origin metadata"() {
        def origin = new Properties()
        def writer = factory.createWriter("identity", CacheableEntity, buildCacheKey, Duration.ofMillis(10))
        def baos = new ByteArrayOutputStream()
        writer.execute(baos)

        JApiMethod method = (JApiMethod) member

        def metadata = KotlinMetadataQueries.INSTANCE

        def oldMethod = method.oldMethod.get()
        def newMethod = method.newMethod.get()

        def oldIsOperator = metadata.isKotlinOperatorFunction(oldMethod)
        def newIsOperator = metadata.isKotlinOperatorFunction(newMethod)

        def oldIsInfix = metadata.isKotlinInfixFunction(oldMethod)

            return delegateResult
        }

        then:
        1 * immutableWorkspaceMetadataStore.storeWorkspaceMetadata(temporaryWorkspace, _) >> { File workspace, ImmutableWorkspaceMetadata metadata ->
            metadata.originMetadata == delegateOriginMetadata
        }

        then:
        1 * fileSystemAccess.moveAtomically(temporaryWorkspace.absolutePath, immutableWorkspace.absolutePath) >> { String from, String to ->

        return metaData.incubating || metaData.ownerClass.incubating
    }

    boolean isReplaced() {
        return metaData.replaced
    }

    @Override
    String getReplacement() {
        return metaData.replacement
    }

    Element getDescription() {
        return comment.find { it.nodeName == 'para' }
    }

    List<Element> getComment() {
        return comment
    }

        def output = new ByteArrayOutputStream()

        new TarArchiveOutputStream(output).withCloseable { tar ->
            def metadataBytes = "".bytes
            def metadataEntry = new TarArchiveEntry("METADATA")
            metadataEntry.size = metadataBytes.length
            tar.putArchiveEntry(metadataEntry)
            tar.write(metadataBytes)
            tar.closeArchiveEntry()

        when:
        store.storeWorkspaceMetadata(workspace, metadata)

        then:
        workspace.file("metadata.bin").assertIsFile()

        when:
        def loadedMetadata = store.loadWorkspaceMetadata(workspace)

        then:
        loadedMetadata == metadata
    }

        def fileName = repositoryFile.name
        if (fileName.startsWith('maven-metadata.xml')) {
            if (fileName == 'maven-metadata.xml') {
                return clearLastUpdatedElementOf(repositoryFile.text)
            }
            // Ignore contents of maven-metadata.xml.sha256, etc, because hashes will most likely
            // change between runs due to <lastUpdated /> differences.