withDefaultSettingsIn("build-logic")
            .appendText("""rootProject.name = "build-logic"""")
        withKotlinDslPluginIn("build-logic")
        withFile("build-logic/src/main/kotlin/my-plugin.gradle.kts", "")
        val className = kotlinClassSourceFile("build-logic", """
            inline fun foo() { println("bar") }
        """)

        where:
        description                                        | configuration
        "build logic does not define any additional tasks" | ""
        "build logic defines default tasks"                | "defaultTasks = ['broken']"
        "build logic injects tasks into start param"       | "gradle.startParameter.taskNames = ['broken']"
    }

    // older versions do not run any tasks

        def configurationCache = newConfigurationCacheFixture()
        def fixture = scriptChangeSpec.fixtureForProjectDir(file('build-logic'), testDirectory)
        fixture.setup()
        def build = { configurationCacheRunLenient(*fixture.buildArguments) }
        settingsFile << """
            includeBuild 'build-logic'
        """

        when:
        build()

        then:
        outputContains fixture.expectedOutputBeforeChange

// effects and wraps it in a TFL::ControlNodeOp, which is made to depend on the
// control token generated by the most recent preceding such operation, if
// any. This copies the logic that is currently executed at runtime (in
// tensorflow/lite/core/subgraph). That runtime logic will now be a no-op for
// models that were generated with this pass.
//
// For purposes of this pass, an operator is considered to have/depend on side
// effects if

plugins {
    id("gradlebuild.build-logic.kotlin-dsl-gradle-plugin")
    id("gradlebuild.build-logic.groovy-dsl-gradle-plugin")
}

description = "Provides a plugin to generate Gradle's DSL reference, User Manual and Javadocs"

dependencies {
    implementation("gradlebuild:basics")
    implementation("gradlebuild:module-identity")

    implementation(project(":build-update-utils"))

    implementation("com.github.javaparser:javaparser-core")

database "External Repository" {
  [Spring Boot\nFramework] as SpringBoot
  [Android\nFramework] as Android
}

package "Application Layer" {
  [server-application]
  [android-app]
}

package "Business Logic Layer" {
  [user-feature]
  [admin-feature]
}

package "Domain Model Layer" {
  [domain-model] <-right- [state]
}

[server-application] -down-> [user-feature]
[server-application] -down-> [admin-feature]

                    }
                }
            }
        """

        file(extensionFile) << extensionCode

        file("build-logic/src/main/java/com/example/restricted/SoftwareTypeRegistrationPlugin.java") << defineSettingsPluginRegisteringSoftwareTypeProvidingPlugin()
        file("build-logic/src/main/java/com/example/restricted/RestrictedPlugin.java") << """
            package com.example.restricted;

import org.jetbrains.kotlin.analysis.api.symbols.KaTypeParameterSymbol
import org.jetbrains.kotlin.analysis.api.types.KaSubstitutor
import org.jetbrains.kotlin.analysis.api.types.KaType

/**
 * A [KaSubstitutor] which substitution logic can be represented as a [Map] from a [KaTypeParameterSymbol] to corresponding [KaType]
 * This is an implementation details and Analysis API clients should not depend on the fact if some [KaSubstitutor] is [KaMapBackedSubstitutor] or not.

	if strings.Contains(fc, "gfortran") {
		// TODO: This duplicates but also diverges from logic from cmd/go
		// itself. For example, cmd/go merely adds -lgfortran without the extra
		// library path work. If this is what's necessary to run gfortran, we
		// should reconcile the logic here and in cmd/go.. Maybe this should
		// become a cmd/go script test to share that logic.

		// Add -m32 if we're targeting 386, in case this is a cross-compile.

# Lifespan Events

You can define logic (code) that should be executed before the application **starts up**. This means that this code will be executed **once**, **before** the application **starts receiving requests**.

The same way, you can define logic (code) that should be executed when the application is **shutting down**. In this case, this code will be executed **once**, **after** having handled possibly **many requests**.