- commit
  - comment_added

automations:

  # If a PR is very complex, require 2 approvals
  complex_changes:
    if:
      - {{ ('complex_changes' | isEnabledAutomation(pr)) }}
      - {{ branch | estimatedReviewTime >= 40 }}
      - {{ files | length >= 35 }}
      - {{ includes_src_changes }}
    run:
      - action: set-required-approvals@v1
        args:
          approvals: 2

    private
    fun buildErrorMessage(formattedMismatches: String): String {
        return "API changes in file '${apiChangesFile.get().asFile.name}' should be in alphabetical order (by type and member), yet these changes were not:\n" +
            "$formattedMismatches\n" +
            "\n" +
            "To automatically alphabetize these changes run: 'gradlew :architecture-test:sortAcceptedApiChanges'"
    }

import com.google.gson.Gson
import com.google.gson.GsonBuilder
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.TaskAction


/**
 * This [Task][org.gradle.api.Task] reorders the changes in an accepted API changes file
 * so that they are alphabetically sorted (by type, then member).
 */
@CacheableTask
abstract class SortAcceptedApiChangesTask : AbstractAcceptedApiChangesMaintenanceTask() {

    @TaskAction

and test another isolated pipeline from any branch. 

We'll explain everything via an example. Let's say you make some changes on your branch `myTestBranch`
(we highly recommend to name this branch without prefix and hyphen (`-`) because it's used to generate build type ID) and want to
test these changes without affecting `master`/`release` pipeline. Here are the instructions.

import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity


/**
 * Abstract base class for [Task][org.gradle.api.Task]s that verify and manipulate the given accepted API changes file.
 */
@CacheableTask
abstract class AbstractAcceptedApiChangesMaintenanceTask : DefaultTask() {
    @get:InputFile
    @get:PathSensitive(PathSensitivity.NONE)
    abstract val apiChangesFile: RegularFileProperty

    else -> actualBranch
}

/**
 * The build environment.
 *
 * WARNING: Every val in here must not change for they same daemon. If it does, changes will go undetected,
 *          since this whole object is kept in the classloader between builds.
 *          Anything that changes must be in a val with a get() method that recomputes the value each time.
 */
object BuildEnvironment {

    /**

) {
    init {
        id("Promotion_SnapshotFromQuickFeedbackStepUpload")
        name = "Nightly Snapshot (from QuickFeedback) - Upload"
        description = "Builds and uploads the latest successful changes on '${branch.branchName}' from Quick Feedback as a new distribution"

        steps {
            buildStep(
                ******@****.***arameters,

The "build process state" holds the global state of the build process and manages all the other state.

The build process state also includes state that is tied to a particular Gradle user home directory.
When that directory changes between Gradle invocations, the state is discarded and recreated.
Typically, the Gradle user home directory does not change for a given process, so this is effectively process state.

                            AcceptedApiChanges.parse("{acceptedApiChanges:[]}"),
                            rootProject.files("$sourceRoots"),
                            "2.0",
                            file("test-api-changes.json"),
                            rootProject.layout.projectDirectory,
                            newUpgradedPropertiesFile.get().asFile,
                            oldUpgradedPropertiesFile.get().asFile

import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test


class SortAcceptedApiChangesTaskIntegrationTest : AbstractAcceptedApiChangesMaintenanceTaskIntegrationTest() {
    @Test
    fun `verify misordered changes can be sorted`() {
        //language=JSON
        acceptedApiChangesFile.writeText(
            """
                {
                    "acceptedApiChanges": [
                        {