c.queue.Run(stop)
	controllers.ShutdownAll(c.ingress, c.services, c.classes)
}

func (c *controller) shouldProcessIngress(mesh *meshconfig.MeshConfig, i *knetworking.Ingress) bool {
	var class *knetworking.IngressClass
	if i.Spec.IngressClassName != nil {
		c := c.classes.Get(*i.Spec.IngressClassName, "")
		if c == nil {
			return false

import com.tngtech.archunit.junit.AnalyzeClasses;
import com.tngtech.archunit.junit.ArchTest;
import com.tngtech.archunit.lang.ArchRule;

import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;

@AnalyzeClasses(packages = "org.gradle")
public class NoKotlinStdlibBinaryDependencyTest {
    @ArchTest
    public static final ArchRule schema_types_do_not_have_binary_dependencies_on_kotlin_stdlib =

            ":compileJava",
            ":classes",
            ":jar",
            ":assemble"
        )
        fixture.assertStateStored()

        when:
        configurationCacheRun("assemble")

        then:
        result.assertTasksExecuted(
            ":processResources",
            ":compileJava",
            ":classes",
            ":jar",
            ":assemble"
        )

  </properties>

  <build>
    <directory>${project.basedir}/target</directory>
    <outputDirectory>${project.build.directory}/classes</outputDirectory>
    <finalName>${project.artifactId}-${project.version}</finalName>
    <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>
    <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>

plugins {
    id("gradlebuild.distribution.implementation-java")
    id("gradlebuild.publish-public-libraries")
}

description = "Annotation classes used by the Declarative DSL"

dependencies {
    implementation(projects.stdlibJavaExtensions)

    api(libs.guava)
    api(libs.inject)
    api(libs.jsr305)
    api(libs.maven3Model) {
        because("We use the metadata model classes to create POM metadata files for components")
    }
    api(libs.maven3RepositoryMetadata) {
        because("We use the metadata model classes to create repository metadata files")
    }

    implementation(project(":functional"))
    implementation(project(":hashing"))

  </properties>

  <build>
    <directory>${project.basedir}/target</directory>
    <outputDirectory>${project.build.directory}/classes</outputDirectory>
    <finalName>${project.artifactId}-${project.version}</finalName>
    <testOutputDirectory>${project.build.directory}/test-classes</testOutputDirectory>
    <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>

     * thereby avoiding lazy construction of the FIR class. The visibility rules are tailored specifically for Java classes accessed from
     * Kotlin. They cover the most popular visibilities `private`, `public`, and default (package) visibility for top-level and nested
     * classes.
     *
     * Returns `null` if visibility cannot be decided by the heuristic.
     */

        then:
        failureCauseContains("No tests found for given includes")

        and:
        def expectedClasspath = [
            file('build/classes/java/test'),
            file('build/resources/test'),
            file('build/classes/java/main'),
            file('build/resources/main'),
        ]
        def expectedExecutable = Jvm.current().javaExecutable.absolutePath

            .filter { it.resolveToAnnotation() != null }
            .toSet()
    }

    private fun ClassId.resolveToAnnotation(): KtClass? {
        val classes = declarationProvider.getAllClassesByClassId(this)
        val annotations = classes.filterIsInstanceAnd<KtClass> { it.isAnnotation() }

        return annotations.singleOrNull()
    }
}

class KotlinStandaloneAnnotationsResolverFactory(