)
}

class SubprojectTestClassTime(
    val subProject: GradleSubproject,
    testClassTimes: List<TestClassTime> = emptyList()
) {
    val totalTime: Int = testClassTimes.sumOf { it.buildTimeMs }

    override fun toString(): String {
        return "SubprojectTestClassTime(subProject=${subProject.name}, totalTime=$totalTime)"
    }
}

class FunctionalTestBucketGenerator(private val model: CIBuildModel, testTimeDataJson: File) {

    BasicJavadocLexer(JavadocScanner scanner) {
        this.scanner = scanner;
    }

    public void pushText(String rawCommentText) {
        scanner.pushText(rawCommentText);
    }

    @Override
    public void visit(TokenVisitor visitor) {
        while (!scanner.isEmpty()) {
            if (scanner.lookingAt(START_HTML_COMMENT)) {
                skipComment();
                continue;
            }

    private final StringBuilder input = new StringBuilder();
    private int pos;
    private int markPos;

    JavadocScanner(String rawCommentText) {
        pushText(rawCommentText);
    }

    @Override
    public String toString() {
        return input.substring(pos);
    }

    public boolean isEmpty() {
        return pos == input.length();
    }

    public void mark() {
        markPos = pos;

        return classMetaData.deprecated
    }

    boolean isIncubating() {
        return classMetaData.incubating
    }

    boolean isReplaced() {
        return classMetaData.replaced
    }

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

    Collection<PropertyDoc> getClassProperties() { return classProperties }

    void addClassProperty(PropertyDoc propertyDoc) {

import static java.util.Collections.singletonMap;

public class GradleUserManualPlugin implements Plugin<Project> {

    public static final String DOCS_GRADLE_ORG = "https://docs.gradle.org/";

    @Override
    public void apply(Project project) {
        ProjectLayout layout = project.getLayout();
        TaskContainer tasks = project.getTasks();

        val ctMethod = method.newMethod.get()
        ktFile.kotlinDeclarationSatisfies(ctMethod.declaringClass, ctMethod) { ktMember ->
            ktMember.hasModifier(KtTokens.OVERRIDE_KEYWORD)
        }
    }

    fun isSince(version: String, member: JApiCompatibility): (KtFile) -> Boolean = { ktFile ->
        val ctMember = member.newCtMember
        val ctDeclaringClass = ctMember.declaringClass

import jetbrains.buildServer.configs.kotlin.failureConditions.failOnText
import jetbrains.buildServer.configs.kotlin.ui.add
import java.util.Locale

const val pluginPortalUrlOverride = "-Dorg.gradle.internal.plugins.portal.url.override=%gradle.plugins.portal.url%"

fun BuildSteps.customGradle(init: GradleBuildStep.() -> Unit, custom: GradleBuildStep.() -> Unit): GradleBuildStep =
    GradleBuildStep(init)
        .apply(custom)
        .also {

data class PerformanceTestCoverage(
    private val uuid: Int,
    override val type: PerformanceTestType,
    override val os: Os,
    val numberOfBuckets: Int = 40,
    private val oldUuid: String? = null,
    override val withoutDependencies: Boolean = false,
    override val failsStage: Boolean = true
) : PerformanceTestBuildSpec, PerformanceTestProjectSpec {
    override
    fun asConfigurationId(model: CIBuildModel, bucket: String) =

            tagHandlers.add(handler);
        }

        @Override
        void onStartHtmlElement(String name) {
            attributes.clear();
        }

        @Override
        void onHtmlElementAttribute(String name, String value) {
            attributes.put(name, value);
        }

        @Override
        void onStartHtmlElementComplete(String name) {

class IntegrationTestFixturesRule : AbstractAstVisitorRule() {
    override fun getName(): String = "IntegrationTestFixtures"

    override fun getPriority(): Int = 1

    override fun setPriority(priority: Int) {
        throw UnsupportedOperationException()
    }

    override fun setName(name: String?) {
        throw UnsupportedOperationException()
    }