def generatedClass = source """
            package $GENERATED_CLASSES_PACKAGE_NAME;
            ${imports.collect { "import $it.name;" }.join("\n")}
            import org.gradle.internal.deprecation.DeprecationLogger;
            import org.gradle.test.Task;

            @Generated
            public class Task_Adapter {
                ${hasSuppressWarnings ? '@SuppressWarnings({"unchecked", "rawtypes"})' : ''}

    }

    private
    fun <T : Any> InvocationOnMock.executeActionArgument(index: Int, configurationAction: T) {
        getArgument<Action<T>>(index).execute(configurationAction)
    }

    @Suppress("deprecation")
    private
    inline fun <reified T : Any> assertUndecoratedImplicitReceiverOf(fileName: String) {

        givenPrecompiledKotlinScript(
            fileName,
            """

                "https://docs.gradle.org/current/userguide/upgrading_version_8.html#java_convention_deprecation"
        )
        succeeds('help')
    }

    def "changing the role of jvm configurations emits deprecation warnings"() {
        buildFile << """
            plugins {
                id("java-library")
            }

            configurations {
                [apiElements, runtimeElements].each {

            }
        """

        then:
        withBuildCache().succeeds("invalid")
        assertCachingDisabledFor VALIDATION_FAILURE, "Caching has been disabled to ensure correctness. Please consult deprecation warnings for more details.", ":invalid"
    }

    def "cacheability for a cacheable task can be disabled via #condition"() {
        buildFile << """
            task cacheable(type: Cacheable) {

			obj, err := xds.BuildXDSObjectFromStruct(cp.ApplyTo, cp.Patch.Value, true)
			if err != nil {
				errs = validation.AppendValidation(errs, validation.WrapWarning(err))
			}

			// Append any deprecation notices
			if obj != nil {
				// Note: since we no longer import v2 protos, v2 references will fail during BuildXDSObjectFromStruct.
				errs = validation.AppendValidation(errs, validateDeprecatedFilterTypes(obj))

import spock.lang.Issue
import spock.lang.Shared
import spock.lang.Specification

import javax.inject.Inject
import java.lang.annotation.Annotation

import static org.gradle.internal.deprecation.Documentation.userManual
import static org.gradle.internal.execution.model.annotations.ModifierAnnotationCategory.NORMALIZATION

    }

    @Issue("GRADLE-3297")
    @ToBeFixedForConfigurationCache(because = "task uses Configuration API")
    def "using offline flag does not emit deprecation warning when child configuration is explicitly resolved"() {
        def repo = new MavenFileRepository(file("repo"))
        repo.module('org.test', 'moduleA', '1.0').publish()

        buildFile << """

* A build script for one project resolves a configuration in another project during evaluation.
* Project configurations are resolved in the settings file.

Gradle produces a deprecation warning for each unsafe access.
Unsafe access can cause indeterminate errors.
You should <<command_line_interface.adoc#sec:command_line_warnings,fix unsafe access warnings>> in your build.

import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;

import static org.gradle.util.Path.path;

@SuppressWarnings("deprecation")
public class DefaultBuildLifecycleController implements BuildLifecycleController {
    private enum State implements StateTransitionController.State {
        // Configuring the build, can access build model

}

// validate checks that user has not passed invalid flag combinations to test framework.
func validate(s *Settings) error {
	if s.FailOnDeprecation && s.NoCleanup {
		return fmt.Errorf("checking for deprecation occurs at cleanup level, thus flags -istio.test.nocleanup and" +
			" -istio.test.deprecation_failure must not be used at the same time")
	}

	if s.Revision != "" {
		if s.Revisions != nil {