.replace("\"sha1\":\\s+\"\\w+\"".toRegex(), "\"sha1\": \"\"")
                    .replace("\"sha256\":\\s+\"\\w+\"".toRegex(), "\"sha256\": \"\"")
                    .replace("\"md5\":\\s+\"\\w+\"".toRegex(), "\"md5\": \"\"")
                it.writeText(content)
            }
        }
    }

    // For local consumption by tests

                .replace("\"sha1\":\\s+\"\\w+\"".toRegex(), "\"sha1\": \"\"")
                .replace("\"sha256\":\\s+\"\\w+\"".toRegex(), "\"sha256\": \"\"")
                .replace("\"md5\":\\s+\"\\w+\"".toRegex(), "\"md5\": \"\"")
            it.writeText(content)
        }
    }
}

            }
            else -> false
        }
    }
}


private
val propertyGetterNameRegex = "^get[A-Z].*$".toRegex()


private
val propertyIsGetterNameRegex = "^is[A-Z].*$".toRegex()


private
val propertySetterNameRegex = "^set[A-Z].*$".toRegex()


private
val JApiCompatibility.newCtMember: CtClassOrCtMember
    get() = when (this) {
        is JApiClass -> newClass.get()

     */
    private
    fun adjustIndentation(initalJsonString: String): String {
        val indentationRegex = """^\s+""".toRegex(RegexOption.MULTILINE)
        return indentationRegex.replace(initalJsonString) { m ->
            " ".repeat(m.value.length * 2)
        }
    }

        "-SNAP\\d+",
        "-SNAPSHOT",
        "-alpha.*\\d+",
        "-beta.*\\d+",
        "-dev-?\\d+",
        "-dev-\\d+-\\d+",
        "-rc-?\\d+",
        "-M.+",
        "-eap-?\\d+"
    ).map { it.toRegex(RegexOption.IGNORE_CASE) }

    @get:Internal
    abstract val libraryVersionFile: RegularFileProperty

    @TaskAction
    fun updateInitPluginTemplateVersionFile() {
        val versionProperties = Properties()

        private
        const val RELEASE_BRANCH = "release"

        private
        const val EXPERIMENTAL_BRANCH = "experimental"

        private
        val OLD_RELEASE_PATTERN = "release(\\d+)x".toRegex()

        fun fromDslContext(): VersionedSettingsBranch {
            return VersionedSettingsBranch(DslContext.getParameter("Branch", "placeholder"))
        }

        get() = fullyQualifiedName
            .replace(".", "/")
            .replace(innerClassesPartRegex, "") + ".java"

    private
    val innerClassesPartRegex =
        "\\$.*".toRegex()

    private
    val JApiClass.kotlinSourceFilePath: String
        get() = "$packagePath/$bytecodeSourceFilename"

    private
    val JApiClass.bytecodeSourceFilename: String

import org.gradle.api.specs.Spec
import org.gradle.kotlin.dsl.*
import org.gradle.util.GradleVersion
import java.io.File


private
val dirVersionPattern = "\\d+\\.\\d+(\\.\\d+)?(-\\w+)*(-\\d{14}[+-]\\d{4})?".toRegex()


val logger = Logging.getLogger("gradlebuild.cleanup")


/**
 * Removes state for versions that we're unlikely to ever need again, such as old snapshot versions.
 */

                && versionUnderTest < GradleVersion.version(endVersionExclusive)
        }

        private
        fun extractTestTaskGradleVersion(name: String): String? = "gradle(.+)CrossVersionTest".toRegex().find(name)?.groupValues?.get(1)
    }

    class IncludeTestClassProvider(private val includeTestClasses: Map<String, List<String>>) : BuildBucketProvider {

    matchesName(name.asString(), candidateName)


private
fun matchesName(name: String, candidateName: String) =
    name == candidateName.replace(".*\\$".toRegex(), "") // strip outer class names


private
fun BodyDeclaration<*>.isSince(version: String): Boolean =
    comment?.orElse(null)?.content?.contains("@since $version") == true


private