public void accept(PluginResolutionVisitor visitor) {
        visitor.visitDependency(producingProject.getDependencies().create(producingProject));
    }

    @Override
    public void applyTo(PluginManagerInternal pluginManager) {
        pluginManager.apply(pluginId.getId());
    }

    static Optional<PluginResolution> resolvePlugin(GradleInternal gradle, PluginId requestedPluginId) {

		"If true, replace the max-in-flight handler with an enhanced one that queues and dispatches with priority and fairness")
}

func (o *FeatureOptions) ApplyTo(c *server.Config, clientset kubernetes.Interface, informers informers.SharedInformerFactory) error {
	if o == nil {
		return nil
	}

	c.EnableProfiling = o.EnableProfiling
	c.DebugSocketPath = o.DebugSocketPath

        }
        modelRegistry.bind(action.getSubject(), type, action);
    }

    @Override
    public void applyTo(NodePredicate predicate, ModelActionRole role, ModelAction action) {
        modelRegistry.configureMatching(predicate.scope(getPath()), role, action);
    }

    @Override
    public void applyTo(NodePredicate predicate, Class<? extends RuleSource> rules) {

        TestOption(String gradleProperty, CommandLineOptionConfiguration... commandLineOptionConfiguration) {
            super(gradleProperty, commandLineOptionConfiguration)
        }

        @Override
        void applyTo(int value, TestSettings settings, Origin origin) {
            settings.value = value
            settings.origin = origin
        }
    }

    static class TestSettings {
        int value

        def task = new Object() {
            String getPath() { return path }
        }
        return new FixedBuildIdentifierProvider(id()).applyTo(new ProtocolToModelAdapter().builder(Task)).build(task)
    }

    def selector(def object) {
        return new FixedBuildIdentifierProvider(id()).applyTo(new ProtocolToModelAdapter().builder(TaskSelector)).build(object)
    }

    def id() {

        return new File(keyringsRoot, VERIFICATION_KEYRING_ASCII);
    }

    public File getEffectiveKeyringsFile() {
        return effectiveKeyringsFile;
    }

    public PublicKeyService applyTo(PublicKeyService original) {
        if (keyService != null) {
            return PublicKeyServiceChain.of(keyService, original);
        } else {
            return original;
        }
    }

        TestOption(String gradleProperty, CommandLineOptionConfiguration commandLineOptionConfiguration) {
            super(gradleProperty, commandLineOptionConfiguration)
        }

        @Override
        void applyTo(TestSettings settings, Origin origin) {
            settings.flag = true
            settings.origin = origin
        }
    }

    static class TestSettings {
        boolean flag
        Origin origin

        }
        resolutionRules.add(rule);
    }

    @Override
    public PluginRequestInternal applyTo(PluginRequestInternal pluginRequest) {
        DefaultPluginResolveDetails details = new DefaultPluginResolveDetails(pluginRequest);
        if (details.getRequested().getVersion() == null) {

		"The order of plugins in this flag does not matter.")
	fs.StringVar(&a.ConfigFile, "admission-control-config-file", a.ConfigFile,
		"File with admission control configuration.")
}

// ApplyTo adds the admission chain to the server configuration.
// In case admission plugin names were not provided by a cluster-admin they will be prepared from the recommended/default values.

import spock.lang.Issue

class JacocoPluginSpec extends AbstractProjectBuilderSpec {
    def setup() {
        project.apply plugin: 'jacoco'
    }

    def 'jacoco applied to specific JavaExec task'() {
        given:
        JavaExec task = project.tasks.create('exec', JavaExec)
        when:
        project.jacoco.applyTo(task)
        then:
        task.extensions.getByType(JacocoTaskExtension) != null
    }