/**
 * Applies the given plugin or script.
 *
 * @param from a script to apply, evaluated as per [Project.file]
 * @param plugin a id of the plugin to apply
 * @param to the plugin target object or collection of objects, target is self when null
 * @see [PluginAware.apply]
 */
fun PluginAware.apply(from: Any? = null, plugin: String? = null, to: Any? = null) {

	}
}

func TestRestOptionsStorageObjectCountTracker(t *testing.T) {
	serverConfig := server.NewConfig(codecs)
	etcdOptions := &EtcdOptions{}
	if err := etcdOptions.ApplyTo(serverConfig); err != nil {
		t.Fatalf("Failed to apply etcd options error: %v", err)
	}
	restOptions, err := serverConfig.RESTOptionsGetter.GetRESTOptions(schema.GroupResource{Group: "", Resource: ""})
	if err != nil {
		t.Fatal(err)
	}

        FixedBuildIdentifierProvider identifierProvider = new FixedBuildIdentifierProvider(projectIdentifier);
        identifierProvider.applyTo(viewBuilder);
        viewBuilder.mixInTo(IdeaProject.class, IdeaProjectJavaLanguageSettingsMixin.class);
        viewBuilder.mixInTo(IdeaDependency.class, IdeaModuleDependencyTargetNameMixin.class);

        then:
        params.tasks == [':a', ':b', ':lib:b']
        params.launchables == null
    }

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

    def id() {
        return new DefaultProjectIdentifier(new DefaultBuildIdentifier(new File("foo")), ":")
    }

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

        }
        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) {

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

		"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

        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() {

        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