element.setTextContent(normalise(element.getTextContent()))
        }
    }

    static String normalise(String content) {
        content.replace('\t', '    ').stripIndent().replace('\r\n', '\n')
    }

    def transformApiLinks(Document doc) {
        ClassMetaDataRepository<ClassLinkMetaData> linkRepository = new SimpleClassMetaDataRepository<ClassLinkMetaData>()

    inputs.property("jvmOpts", jvmOpts)
    doLast {
        val optsEnvVar = "DEFAULT_JVM_OPTS"
        scriptFile.writeText(scriptFile.readText().replace("$optsEnvVar='", "$optsEnvVar='$jvmOpts "))
        batchScript.writeText(batchScript.readText().replace("set $optsEnvVar=", "set $optsEnvVar=$jvmOpts "))
    }
}

fun Project.wrapperUpdateTask(name: String, label: String) {
    val wrapperTaskName = "${name}Wrapper"

    @Override
    public FileCollectionInternal replace(FileCollectionInternal original, Supplier<FileCollectionInternal> supplier) {
        ImmutableSet.Builder<FileCollectionInternal> newSource = ImmutableSet.builderWithExpectedSize(source.size());
        boolean hasChanges = false;
        for (FileCollectionInternal candidate : source) {
            FileCollectionInternal newCollection = candidate.replace(original, supplier);

            withProblem("Build file 'inc/sub/build.gradle': line 2: registration of listener on 'Gradle.buildFinished' is unsupported".replace('/', File.separator))
            withProblem("Build file 'inc/sub/build.gradle': line 5: invocation of 'Task.project' at execution time is unsupported.".replace('/', File.separator))

    override fun register(name: String): TaskProvider<Task> =
        delegate.register(name)

    override fun replace(name: String): Task =
        delegate.replace(name)

    override fun <T : Task> replace(name: String, type: Class<T>): T =
        delegate.replace(name, type)

    override fun iterator(): MutableIterator<Task> =
        delegate.iterator()

    /**
     * Returns a copy of this collection, with the given collection replaced with the value returned by the given supplier.
     *
     * This is used to deal with the case where a mutable collection may be added to itself. This is intended to become an error at some point.
     */
    FileCollectionInternal replace(FileCollectionInternal original, Supplier<FileCollectionInternal> supplier);

    /**

    }

    URI getUri() {
        return rootDir.toURI()
    }

    MavenModule addModule(String groupId, String artifactId, Object version = '1.0') {
        def artifactDir = new File(rootDir, "${groupId.replace('.', '/')}/$artifactId/$version")
        def module = new MavenModule(artifactDir, groupId, artifactId, version as String)
        module.mavenJarCreator = mavenJarCreator
        modules << module
        return module

            ZipOutputStream(outputStream()).use { zip ->
                val content = "suspicious".toByteArray()
                zip.putNextEntry(ZipEntry("path/../../traversal.txt".replace('/', File.separatorChar)).apply { size = content.size.toLong() })
                zip.write(content)
                zip.closeEntry()
            }
        }

        try {

        then:
        1 * onChange.accept('existing', 'newValue')
        then:
        0 * onChange._
    }

    def "method replace(#key, #oldValue, newValue) changes map"() {
        when:
        def map = getMapUnderTestToWrite()
        def result = map.replace(key, oldValue, 'newValue')

        then:
        result == expectedResult
        map[key] == expectedValue

        where:

        includes.map {
            if (it.endsWith("/**")) {
                Pattern.compile(it.substring(0, it.length - 3).replace("/", "\\.") + "(\\..+)?")
            } else {
                Pattern.compile(it.substring(0, it.length - 2).replace("/", "\\.") + "\\.[^.]+")
            }
        }
    }

    private val excludePackagePatterns = listOf(Pattern.compile(".+\\.internal(\\..+)?"))