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);

        return getBeforeExecutionState()
            .map(ExecutionInputState::getImplementation)
            .map(BaseSnapshotInputsBuildOperationResult::getClassLoaderHashBytesOrNull)
            .orElse(null);
    }

    @Nullable
    public String getImplementationClassName() {
        return getBeforeExecutionState()
            .map(ExecutionInputState::getImplementation)
            .map(ImplementationSnapshot::getClassIdentifier)

        this.setOnlineRequired(md.isOnlineRequired());
        this.setProjectRequired(md.isProjectRequired());
        this.setSince(md.getSince());
        this.setThreadSafe(true);
        this.setImplementation(md.getImplementation());
        try {
            this.setParameters(md.getParameters().stream().map(Parameter::new).collect(Collectors.toList()));
        } catch (DuplicateParameterException e) {

            getLanguageVersion() >> JavaLanguageVersion.of(languageVersion)
            getVendor() >> DefaultJvmVendorSpec.any().toString()
            getImplementation() >> JvmImplementation.VENDOR_SPECIFIC.toString()
        }, false)
        then:
        javaToolchain.languageVersion.asInt() == languageVersion
        javaToolchain.javaRuntimeVersion == runtimeVersion

    }

    def createDependenciesAndConfiguration() {
        """
            abstract class MyDependencies implements Dependencies {
                abstract DependencyCollector getImplementation()

                void call(Closure closure) {
                    ${ConfigureUtil.class.name}.configure(closure, this)
                }
            }

            throw new DuplicateMojoDescriptorException(
                    getGoalPrefix(),
                    mojoDescriptor.getGoal(),
                    existing.getImplementation(),
                    mojoDescriptor.getImplementation());
        } else {
            addComponentDescriptor(mojoDescriptor);
        }
    }

    public String getGroupId() {
        return groupId;
    }