if err := options.ValidateKubeletServer(s); err != nil {
		return err
	}

	// Warn if MemoryQoS enabled with cgroups v1
	if utilfeature.DefaultFeatureGate.Enabled(features.MemoryQoS) &&
		!isCgroup2UnifiedMode() {
		klog.InfoS("Warning: MemoryQoS feature only works with cgroups v2 on Linux, but enabled with cgroups v1")
	}
	// Obtain Kubelet Lock File
	if s.ExitOnLockContention && s.LockFilePath == "" {

            }
        }
    }
    tasks.named("publishLocalPublicationToRemoteRepository") {
        enabled = false // don't publish normalized local version to remote repository when using 'publish' lifecycle task
    }
    tasks.named("publishGradleDistributionPublicationToLocalRepository") {
        enabled = false // this should not be used so we disable it to avoid confusion when using 'publish' lifecycle task
    }

	ambientPod, err := s.getPodWithRetry(log, addCmd.PodName, addCmd.PodNamespace)
	if err != nil {
		return err
	}
	log.Debugf("Pod: %s in ns: %s is enabled for ambient, adding to mesh.", addCmd.PodName, addCmd.PodNamespace)

	var podIps []netip.Addr
	for _, configuredPodIPs := range addCmd.IPs {
		// net.ip is implicitly convertible to netip as slice

public interface AgentStatus {
    /**
     * Checks if the agent-based bytecode instrumentation is enabled for the current JVM process.
     *
     * @return {@code true} if the agent instrumentation should be used
     */
    boolean isAgentInstrumentationEnabled();

    /**
     * Returns an AgentStatus instance that enables instrumentation if the agent is available.
     */
    static AgentStatus allowed() {

    private final AgentStatus agentStatus;

    public AgentInitializer(AgentStatus agentStatus) {
        this.agentStatus = agentStatus;
    }

    /**
     * Sets up the agent-based instrumentation if it is enabled for the process.
     */
    public void maybeConfigureInstrumentationAgent() {
        if (agentStatus.isAgentInstrumentationEnabled()) {
            DefaultClassFileTransformer.tryInstall();
        }
    }

import org.gradle.testkit.runner.TaskOutcome

class GradleBuildCrossVersionTestConfigurationCacheSmokeTest extends AbstractGradleBuildConfigurationCacheSmokeTest {
    def "can run Gradle cross-version tests with configuration cache enabled"() {

        given:
        def tasks = [
            ':configuration-cache:embeddedCrossVersionTest',
            '--tests=org.gradle.internal.cc.impl.ConfigurationCacheCrossVersionTest'
        ]

        when:

import org.gradle.testkit.runner.TaskOutcome

class GradleBuildUnitTestConfigurationCacheSmokeTest extends AbstractGradleBuildConfigurationCacheSmokeTest {
    def "can run Gradle unit tests with configuration cache enabled"() {

        given:
        def supportedTasks = [
            ":tooling-api:publishLocalPublicationToLocalRepository",
            ":stdlib-java-extensions:test", "--tests=org.gradle.api.JavaVersionSpec"
        ]

import org.gradle.testkit.runner.TaskOutcome

class GradleBuildIntegTestConfigurationCacheSmokeTest extends AbstractGradleBuildConfigurationCacheSmokeTest {
    def "can run Gradle integ tests with configuration cache enabled"() {
        given: "tasks whose configuration can only be loaded in the original daemon"
        def supportedTasks = [
            ":configuration-cache:embeddedIntegTest",

// It is important to have the agent appended to the classpath of all integration tests.
class AgentApplicationTest extends AbstractIntegrationSpec {
    def "agent is enabled by default"() {
        given:
        withDumpAgentStatusTask()

        when:
        succeeds()

        then:
        agentWasApplied()
    }

  gocritic:
    # Disable all checks.
    # Default: false
    disable-all: true
    # Which checks should be enabled in addition to default checks. Since we don't want
    # all of the default checks, we do the disable-all first.
    enabled-checks:
      - appendCombine
      - argOrder
      - assignOp
      - badCond
      - boolExprSimplify
      - builtinShadow