import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static java.util.Arrays.asList;
import static java.util.Collections.singletonList;
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) {

}

data class GradleSubproject(val name: String, val path: String, val unitTests: Boolean = true, val functionalTests: Boolean = true, val crossVersionTests: Boolean = false) {
    fun hasTestsOf(testType: TestType) = (unitTests && testType.unitTests) || (functionalTests && testType.functionalTests) || (crossVersionTests && testType.crossVersionTests)
}

data class Stage(
    val stageName: StageName,

import javax.annotation.Nullable
import java.lang.annotation.Annotation
import java.lang.reflect.Proxy

@CompileStatic
class NullabilityBreakingChangesRule extends AbstractGradleViolationRule {

    private static final List<Class<? extends Annotation>> NULLABLE_ANNOTATIONS = [Nullable, org.jetbrains.annotations.Nullable]

    NullabilityBreakingChangesRule(Map<String, Object> params) {

- **Size of Serialized Data:** Java serialization tends to produce larger serialized objects because it includes class metadata and other overhead.

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

@ExtendWith(MockKExtension::class)
class ApplyDefaultConfigurationTest {
    @MockK(relaxed = true)
    lateinit var buildType: BaseGradleBuildType

    private
    val steps = BuildSteps()

    private
    val buildModel = CIBuildModel(

 */

package promotion

import common.VersionedSettingsBranch
import jetbrains.buildServer.configs.kotlin.triggers.schedule
import model.StageName
import vcsroots.gradlePromotionBranches

class PublishNightlyDocumentation(branch: VersionedSettingsBranch) : PublishGradleDistributionFullBuild(
    promotedBranch = branch.branchName,
    promoteTask = "publishBranchDocs",
    triggerName = StageName.PULL_REQUEST_FEEDBACK.uuid,

import model.CIBuildModel
import model.FunctionalTestBucketProvider
import model.Stage
import model.StageName
import model.StatisticsBasedPerformanceTestBucketProvider
import java.io.File

class CheckProject(
    model: CIBuildModel,
    functionalTestBucketProvider: FunctionalTestBucketProvider
) : Project({
    id("Check")
    name = "Check"

import jetbrains.buildServer.configs.kotlin.BuildSteps
import jetbrains.buildServer.configs.kotlin.FailureAction
import jetbrains.buildServer.configs.kotlin.RelativeId
import vcsroots.gradlePromotionMaster

abstract class BasePublishGradleDistribution(
    // The branch to be promoted
    val promotedBranch: String,
    val prepTask: String?,
    val triggerName: String,
    val gitUserName: String = "bot-teamcity",

            rootVariant?.let { computeExternalDependenciesNotAccessibleFromProjectDependencies(rootComponent, it) } ?: emptySet()
        }.get()
    }
    val classpathManifest = tasks.register("classpathManifest", ClasspathManifest::class) {
        this.projectDependencies.from(runtimeClasspath.incoming.artifactView {
            componentFilter {
                it is ProjectComponentIdentifier
            }
        }.files)

import static gradlebuild.binarycompatibility.upgrades.UpgradedProperties.OLD_ACCESSORS_OF_UPGRADED_PROPERTIES;
import static gradlebuild.binarycompatibility.upgrades.UpgradedProperties.SEEN_OLD_ACCESSORS_OF_UPGRADED_PROPERTIES;

public class UpgradePropertiesRuleSetup implements SetupRule {

    private static final String CURRENT_UPGRADED_PROPERTIES_KEY = "currentUpgradedProperties";