def "can run Gradle sanityCheck with configuration cache enabled"() {
        given:
        // This is an approximation, running the whole build lifecycle 'sanityCheck' is too expensive
        // See build-logic/lifecycle/src/main/kotlin/gradlebuild.lifecycle.gradle.kts
        def tasks = [
            ":configuration-cache:sanityCheck",
            ":docs:checkstyleApi",
            ":internal-build-reports:allIncubationReportsZip",

import static org.gradle.testkit.runner.TaskOutcome.SUCCESS

/**
 * Abstract base class for testing the Kotlin plugin with Android projects.
 *
 * This test exists to avoid duplicating test logic for Groovy and Kotlin DSLs.
 */
@LocalOnly(because = "Needs Android environment")
abstract class AbstractKotlinPluginAndroidSmokeTest extends AbstractSmokeTest implements RunnerFactory {
    abstract String getSampleName()

# Gradle runtimes

Gradle is made up of the following processes that work together to "run the build":

- Gradle daemon. This is the process that actually runs the build. It hosts build logic and coordinates the lifecycle of the build. It is a long-running daemon process.
- CLI client. This is the `gradle` or `gradlew` command, and is responsible for locating, starting and interacting with the Gradle daemon, potentially downloading the Gradle distribution. 

        }

        CodeBlock logic = isSetter
            ? getSetCall(propertyGetterName, implementationExtra, upgradedPropertyType)
            : getGetCall(propertyGetterName, returnType, upgradedPropertyType);

        return codeBlockBuilder.addStatement(logic).build();
    }

        if (!value.hasBeenObtained()) {
            // source has **NOT** been used as build logic input:
            // serialize the source
            writeBoolean(true)
            encodeValueSource(value)
        } else {
            // source has been used as build logic input:
            // serialize the value directly as it will be part of the
            // cached state fingerprint.

		InheritFlags: []string{
			options.CfgPath,
			options.ImageRepository,
			options.NodeCRISocket,
			options.IgnorePreflightErrors,
			options.DryRun,
		},
	}
}

// runPreflight executes preflight checks logic.
func runPreflight(c workflow.RunData) error {
	data, ok := c.(InitData)
	if !ok {
		return errors.New("preflight phase invoked with an invalid data struct")
	}

	fmt.Println("[preflight] Running pre-flight checks")

 *
 * Hence, [KotlinDeclarationProvider]s cannot just be combined by combining the scopes of all declaration providers and calling
 * [createDeclarationProvider]. [KotlinDeclarationProviderMerger] should implement proper merging logic that takes these concerns into
 * account.
 */
public abstract class KotlinDeclarationProviderMerger : KotlinComposableProviderMerger<KotlinDeclarationProvider>, KotlinPlatformComponent {
    public companion object {

    /**
     * Calculates the execution time value of this file collection. The resulting value is serialized to the configuration cache
     * and deserialized at execution time, utilizing the logic encapsulated within the value.
     */
    default Optional<FileCollectionExecutionTimeValue> calculateExecutionTimeValue() {
        return Optional.empty();
    }

    /**

### Debugging Gradle

You can debug Gradle by adding `-Dorg.gradle.debug=true` to the command-line. Gradle will wait for you to attach a debugger at `localhost:5005` by default.

If you made changes to build logic in the `build-logic` included build, you can run its tests by executing `./gradlew :build-logic:check`.

### Fixing DCO failures/Signing Off Commits After Submitting a Pull Request

	req.Header.Set("Content-Type", contentTypeHdr)
	req.Header.Set("User-Agent", "Mozilla")

	// Since `apiRouter` satisfies `http.Handler` it has a ServeHTTP to execute the logic of the handler.
	// Call the ServeHTTP to execute the handler.
	apiRouter.ServeHTTP(rec, req)

	ctx, cancel := context.WithCancel(GlobalContext)
	defer cancel()