val shortenedSubprojectName = subProjectName.replace("internal", "i").replace("Testing", "T")
        if (shortenedSubprojectName.length + prefix.length <= 80) {
            return shortenedSubprojectName
        }
        return shortenedSubprojectName.replace(Regex("[aeiou]"), "")
    }

    fun asName(): String =

        return execResult.stdout
    }

    static List<String> branchesOf(String commit) {
        return getStdout("git branch -r --contains $commit")
            .readLines()
            .collect { it.replace("*", "") } // remove the * from the current branch, e.g. * master -> master
            .collect { it.trim() }
            .grep { !it.isEmpty() }
    }

    static List<String> parentCommitsOf(String commit) {

errorproneExtension.disabledChecks.addAll(
    // DISCUSS
    "EqualsGetClass", // Let's agree if we want to adopt Error Prone's idea of valid equals()
    "JdkObsolete", // Most of the checks are good, but we do not want to replace all LinkedLists without a good reason

    // NEVER
    "MissingSummary", // We have another mechanism to check Javadocs on public API
    "InjectOnConstructorOfAbstractClass", // We use abstract injection as a pattern

        performanceTests.forEach { performanceTestTrigger ->
            // The space removal is necessary - otherwise it doesn't show
            val artifactDirName = performanceTestTrigger.name.replace(" ", "")
            performancePartialTrigger.dependencies {
                artifacts(performanceTestTrigger) {

private
fun <T : NodeWithSimpleName<*>> T.matchesName(candidateName: String) =
    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

    def overrideAnnotation = Stub(JApiAnnotation)
    def injectAnnotation = Stub(JApiAnnotation)

    def setup() {
        new File(tmp, "org/gradle/api").mkdirs()
        sourceFile = new File(tmp, "${TEST_INTERFACE_NAME.replace('.', '/')}.java").tap { text = "" }

        jApiClassifier.fullyQualifiedName >> TEST_INTERFACE_NAME
        jApiField.name >> 'field'
        jApiField.jApiClass >> jApiClassifier
        jApiMethod.name >> 'method'

            .withTemplate(templateFolder.template("$templateFragment.adoc"))
            .withTarget(settings.target.file("../README.adoc").asFile)
            .withBinding("language", descriptor.language.toString().replace("C++", "{cpp}"))
            .withBinding("languageLC", descriptor.language.getName().toLowerCase())
            .withBinding("languageExtension", descriptor.language.extension)

        "void" -> "Unit"
        "?" -> "*"
        in mappedTypeStrings.keys -> mappedTypeStrings[binaryName]!!
        in primitiveTypeStrings.keys -> primitiveTypeStrings[binaryName]!!
        else -> binaryName.replace('$', '.')
    }


/**
 * See https://kotlinlang.org/docs/reference/java-interop.html#mapped-types
 */
private
val mappedTypeStrings =
    mapOf(
        // Built-ins

        // >   begin with a literal "!", for example, `"\!important!.txt"`.
        .replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, '!')
        // > Put a backslash ("\") in front of the first hash for patterns that
        // >   begin with a hash.
        .replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, '#')

    const regex = makeRegex(pattern, ignoreCase)

    return new IgnoreRule(

            Path upgradedPropertiesJson = fs.getPath(UPGRADED_PROPERTIES_FILE);
            if (Files.exists(upgradedPropertiesJson)) {
                Files.copy(upgradedPropertiesJson, to.getAsFile().get().toPath(), StandardCopyOption.REPLACE_EXISTING);
            } else {
                to.getAsFile().get().delete();
            }
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }