repositoryInteractions {
            'org:module:1.0' {
                expectResolve()
            }
        }
        run ':checkDeps'

        then:
        outputContains 'Rule from settings applied on org:module:1.0'
    }

    def "can declare component metadata rules in settings using registar"() {
        settingsFile << """
            dependencyResolutionManagement {
                components.all(LoggingRule)

                println "init script applied" 
            }
        """

        then:
        succeeds "help", '-I', initScript.absolutePath
        output.contains "init script applied" // ensure we actually tested something
    }

    def "buildSrc project.buildFile is non null when does not exist"() {
        given:

        assertThat(
            build("help").output,
            allOf(
                containsString("my-init-plugin applied!"),
                containsString("my-settings-plugin applied!"),
                containsString("my-plugin applied!"),
                containsString("my-other-plugin applied!")
            )
        )
    }

    @Test

        then:
        agentWasApplied()
    }

    def "agent is not applied if disabled in the command-line"() {
        given:
        withoutAgent()
        withDumpAgentStatusTask()

        when:
        succeeds()

        then:
        agentWasNotApplied()
    }

    def "agent is applied to the daemon process running the build"() {
        given:
        withAgent()

            operations << "applied"

            task verify { doLast { assert operations == ['applying', 'withType', 'withId', 'withPlugin', 'applied'] } }

            gradle.buildFinished { loader.close() }
        """

        expect:
        run("verify")
    }

    def "plugin manager with id is fired after the plugin is applied for imperative plugins"() {
        when:

}

/**
 * A list of annotations applied with specified [classId].
 *
 * @see [KaAnnotationList.classIds]
 */
@Deprecated("Use 'annotations' instead.", replaceWith = ReplaceWith("annotations[classId]"))
public fun KaAnnotated.annotationsByClassId(classId: ClassId): List<KaAnnotation> {
    return annotations[classId]
}

/**
 * A list of annotations applied.
 *
 * @see [KaAnnotationList.classIds]
 */

     * Returns the Unix permissions to use for the target files. {@code null} means that existing
     * permissions are preserved. It is dependent on the copy action implementation whether these permissions
     * will actually be applied.
     *
     * @return The file permissions, or {@code null} if existing permissions should be preserved.
     *
     * @deprecated Use {@link #getFilePermissions()} instead. This method is scheduled for removal in Gradle 9.0.

/**
 * Something that can have plugins applied to it.
 * <p>
 * The {@link #getPluginManager() plugin manager} can be used for applying and detecting whether plugins have been applied.
 * <p>
 * For more on writing and applying plugins, see {@link org.gradle.api.Plugin}.
 */
@HasInternalProtocol
public interface PluginAware {

    /**
     * The container of plugins that have been applied to this object.
     * <p>

     * {@link NativeExecutableBinarySpec} when the 'assembler' plugin is applied.
     */
    Tool getAssembler();

    /**
     * The configuration of the C compiler used when compiling C sources for this binary.
     *
     * Valid for {@link SharedLibraryBinarySpec}, {@link StaticLibraryBinarySpec} and
     * {@link NativeExecutableBinarySpec} when the 'c' plugin is applied.
     */
    PreprocessingTool getcCompiler();

    /**

	idx int, portMap model.GatewayPortMap,
) bool {
	for _, rp := range patches[networking.EnvoyFilter_VIRTUAL_HOST] {
		applied := false
		if commonConditionMatch(patchContext, rp) &&
			routeConfigurationMatch(patchContext, routeConfiguration, rp, portMap) &&
			virtualHostMatch(virtualHosts[idx], rp) {
			applied = true
			if rp.Operation == networking.EnvoyFilter_Patch_REMOVE {
				return true