}

    boolean apply(@CheckForNull Object key, @ParametricNullness V value) {
      // This method is called only when the key is in the map (or about to be added to the map),
      // implying that key is a K.
      @SuppressWarnings({"unchecked", "nullness"})
      K k = (K) key;
      return predicate.apply(Maps.immutableEntry(k, value));
    }

    @Override
    @CheckForNull

        when:
        run(":printTestSoftwareTypeExtensionConfiguration")

        then:
        assertThatDeclaredValuesAreSetProperly()

        and:
        outputContains("Applying SoftwareTypeImplPlugin")
        outputDoesNotContain("Applying AnotherSoftwareTypeImplPlugin")
    }

    def 'can declare and configure a custom software type from published plugin'() {
        given:

Applying Android application plugin

        String msg = indent + artifact;
        msg += " (";
        if (replacement.getVersion() != null) {
            msg += "applying version: " + replacement.getVersion() + ";";
        }
        if (replacement.getScope() != null) {
            msg += "applying artifactScope: " + replacement.getScope();
        }
        msg += ")";
        logger.debug(msg);
    }

        fails("verify")
        failure.assertThatDescription(startsWith("An exception occurred applying plugin request [id: 'org.my.myplugin', version: '1.0']"))
        failure.assertHasLineNumber(3)
        failure.assertHasCause("Could not create plugin of type 'TestPlugin'.")
        failure.assertHasCause("broken plugin")
    }

    def "error applying plugin"() {
        pluginBuilder.addPlugin("throw new Exception('throwing plugin')", PLUGIN_ID)

        /**
         * Causes the target scope to be closed by applying a default set of plugin requests that includes
         * the set of [auto-applied plugins][org.gradle.plugin.management.internal.autoapply.AutoAppliedPluginHandler].
         */
        object ApplyDefaultPluginRequests : StageTransition, Instruction()

        /**
         * Causes the target scope to be closed by applying the plugin requests collected during the execution

import java.util.Map;

/**
 * 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 {

    /**

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedVariant;
import org.gradle.api.internal.attributes.ImmutableAttributes;

/**
 * Represents a variant which is produced as the result of applying an artifact transform chain
 * to a root producer variant.
 */
public class TransformedVariant implements HasAttributes {
    private final ResolvedVariant root;
    private final VariantDefinition chain;

include::sample[dir="groovy",files="library-a/build.gradle[];library-b/build.gradle[]"]
====

Note how applying a convention plugin to a subproject effectively declares its type.
By applying `myproject.java-conventions` plugin we state: this is a "Java" project.
By applying `myproject.library-conventions` plugin we state: this is a "Library" project.

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

/**
 * Verifies that we can use test fixtures without applying other plugins. This is
 * important for integration with other ecosystems, for example, if a Kotlin or
 * Android project wants to use Java test fixtures without applying the Java plugin.
 */
class StandaloneTestFixturesIntegrationTest extends AbstractIntegrationSpec {

    def "can compile test fixtures"() {