// TeamCity uses a dummy name when first running the DSL
            if (branch.contains("placeholder-1")) {
                return VersionedSettingsBranch(MASTER_BRANCH)
            }
            return VersionedSettingsBranch(branch)
        }

        private fun determineNightlyPromotionTriggerHour(branchName: String) = when (branchName) {
            MASTER_BRANCH -> 0

### Build session state

A "build session" represents a single invocation of Gradle, for example when you run `gradlew build`.
A session runs the build one or more times.
For example, when continuous build is enabled, the session may run the build many times, but when it is disabled, the session will run the build once only.

The build session state is managed by the `BuildSessionState` class.

        val ctDeclaringClass = ctMember.declaringClass
        when {
            ctMember is CtMethod && ctMember.isSynthetic -> true // synthetic members cannot have kdoc
            ctMember is CtClass -> ktFile.ktClassOf(ctMember)?.isDocumentedAsSince(version) == true
            ktFile.ktClassOf(ctDeclaringClass)?.isDocumentedAsSince(version) == true -> true
            else -> when (ctMember) {

        flag(flags)
    }


private
fun KotlinClassMetadata.hasKotlinFlags(memberType: MemberType, jvmSignature: String, predicate: (Flags) -> Boolean): Boolean =
    when (this) {
        is KotlinClassMetadata.Class -> hasClassFlags(this::toKmClass, memberType, jvmSignature, predicate)
        is KotlinClassMetadata.FileFacade -> hasPackageFlags(this::toKmPackage, memberType, jvmSignature, predicate)

fun Directory.parentOrRoot(): Directory = if (this.file("version.txt").asFile.exists()) {
    this
} else {
    val parent = dir("..")
    when {
        parent.file("version.txt").asFile.exists() -> parent
        this == parent -> throw IllegalStateException("Cannot find 'version.txt' file in root of repository")
        else -> parent.parentOrRoot()
    }
}

import japicmp.model.JApiBehavior
import japicmp.model.JApiClass
import japicmp.model.JApiCompatibility
import japicmp.model.JApiField


internal
val JApiCompatibility.jApiClass: JApiClass
    get() = when (this) {
        is JApiClass -> this
        is JApiField -> this.getjApiClass()
        is JApiBehavior -> this.getjApiClass()
        else -> throw IllegalStateException("Unsupported japicmp member type '${this::class}'")

                        when {
                            singleFile.name.endsWith(".tar.gz") -> tarTree(singleFile)
                            else -> zipTree(singleFile)
                        }
                    }
                ) {
                    eachFile {

    override fun onFinish(event: FinishEvent) {
        if (event is TaskFinishEvent && taskPathReports.containsKey(event.descriptor.taskPath)) {
            val taskPath = event.descriptor.taskPath
            when (event.result) {
                is TaskSuccessResult -> {
                    addExecutedTaskPath(taskPath)
                    if (containsFailedTest(taskPath)) {
                        addFailedTaskPath(taskPath)

            timeZone = TimeZone.getTimeZone("UTC")
        }
        val buildTimestampFromProperty = buildTimestampFromGradleProperty.orNull
        val buildTime = when {
            buildTimestampFromProperty != null -> {
                timestampFormat.parse(buildTimestampFromProperty)
            }
            runningInstallTask.get() || runningDocsTestTask.get() || runningOnCi.get() -> {

For example, each process has different supported JVMs and a different set of services available for dependency injection.
While a lot of Gradle source code runs only in the Gradle daemon, not all of it does and so, when working on some source code it is important to be aware of the runtimes in which it will run.

See [Gradle runtimes](runtimes.md) for a list of these runtimes and more details.

## Build state model