*/
public interface ExecutionInputState {
    /**
     * The main implementation snapshots.
     */
    ImplementationSnapshot getImplementation();

    /**
     * Used only for tasks to return all the task actions.
     */
    ImmutableList<ImplementationSnapshot> getAdditionalImplementations();

    /**
     * The non-file inputs.
     */

        this.inputProperties = inputProperties;
        this.inputFileProperties = inputFileProperties;
    }

    @Override
    public ImplementationSnapshot getImplementation() {
        return implementation;
    }

    @Override
    public ImmutableList<ImplementationSnapshot> getAdditionalImplementations() {
        return additionalImplementations;
    }

    @Override

        return requirement;
    }

    public void setRequirement(Requirement requirement) {
        this.requirement = requirement;
    }

    public String getImplementation() {
        return implementation;
    }

    public void setImplementation(String implementation) {
        this.implementation = implementation;
    }

    public String getSince() {
        return since;
    }

        assertTrue(md.isProjectRequired());
        assertFalse(md.isThreadSafe());
        assertEquals("package", md.getPhase());
        assertEquals("org.apache.maven.plugin.jar.JarMojo", md.getImplementation());
        assertEquals("antrun", md.getComponentConfigurator());
        assertEquals("java", md.getLanguage());
        assertEquals("per-lookup", md.getInstantiationStrategy());

        work.visitImplementations(implementationsBuilder);
        ImplementationSnapshot implementation = implementationsBuilder.getImplementation();
        ImmutableList<ImplementationSnapshot> additionalImplementations = implementationsBuilder.getAdditionalImplementations();

        if (LOGGER.isDebugEnabled()) {

        store.put(key, new DefaultPreviousExecutionState(
            executionState.getOriginMetadata(),
            executionState.getCacheKey(),
            executionState.getImplementation(),
            executionState.getAdditionalImplementations(),
            executionState.getInputProperties(),
            prepareForSerialization(executionState.getInputFileProperties()),

        def spec = TestUtil.objectFactory().newInstance(DefaultToolchainSpec)
        spec.getLanguageVersion().set(JavaLanguageVersion.of(javaVersion.getMajorVersion()))
        spec.getVendor().set(vendor)
        spec.getImplementation().set(implementation)

        then:
        new JvmInstallationMetadataMatcher(spec).test(metadata)

        where:

                    api.fromDependencyCollector(getRestricted().getDependencies().getApi());
                    implementation.fromDependencyCollector(getRestricted().getDependencies().getImplementation());
                }
            }
        """
        file("build-logic/build.gradle") << defineRestrictedPluginBuild()

        and: "a build script that adds dependencies using the custom extension"

        executionHistory.put(key, new DefaultPreviousExecutionState(
            executionState.getOriginMetadata(),
            executionState.getCacheKey(),
            executionState.getImplementation(),
            executionState.getAdditionalImplementations(),
            executionState.getInputProperties(),
            prepareForSerialization(executionState.getInputFileProperties()),

        this.jvmImplementation = jvmImplementation;
    }

    public JvmInstallationMetadataMatcher(JavaToolchainSpec spec) {
        this(spec.getLanguageVersion().get(), spec.getVendor().get(), spec.getImplementation().get());
    }

    @Override
    public boolean test(JvmInstallationMetadata metadata) {
        Predicate<JvmInstallationMetadata> predicate = languagePredicate().and(vendorPredicate()).and(this::implementationTest);