cachedMetadata.putProcessedMetadata(metadataProcessor.getRulesHash(), state);
                    localResult.applyTo(result);
                    result.resolved(state);
                    break;
                case Failed:
                    localResult.applyTo(result, metadata -> {
                        // should not be called
                        throw new IllegalStateException();

	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("failed to listen on 127.0.0.1:0")
	}
	defer ln.Close()
	s.Listener = ln
	s.BindPort = ln.Addr().(*net.TCPAddr).Port

	if err := s.ApplyTo(&secureServingInfo, &loopbackClientConfig); err != nil {
		t.Errorf("unexpected error: %v", err)
	}
	if loopbackClientConfig == nil {
		t.Errorf("unexpected empty loopbackClientConfig")
	}

        if (!metadataProvider.isUsable()) {
            applyTo(metadataProvider, result);
            return true;
        }
        return false;
    }

    private static DefaultMetadataProvider createMetadataProvider(ModuleComponentResolveState candidate) {
        return new DefaultMetadataProvider(candidate);
    }

    private static void applyTo(DefaultMetadataProvider provider, ComponentSelectionContext result) {

    public StartParameterInternal convert(ParsedCommandLine parsedCommandLine, BuildLayoutResult buildLayout, AllProperties properties, StartParameterInternal startParameter) throws CommandLineArgumentException {
        buildLayout.applyTo(startParameter);

        welcomeMessageConfigurationCommandLineConverter.convert(parsedCommandLine, properties.getProperties(), startParameter.getWelcomeMessageConfiguration());

}

// ApplyTo fills up CSRSigningController config with options.
func (o *CSRSigningControllerOptions) ApplyTo(cfg *csrsigningconfig.CSRSigningControllerConfiguration) error {
	if o == nil {
		return nil
	}

	cfg.ClusterSigningCertFile = o.ClusterSigningCertFile

	if o == nil {
		return
	}

	fs.StringVar(&o.CoreAPIKubeconfigPath, "kubeconfig", o.CoreAPIKubeconfigPath,
		"kubeconfig file pointing at the 'core' kubernetes server.")
}

func (o *CoreAPIOptions) ApplyTo(config *server.RecommendedConfig) error {
	if o == nil {
		return nil
	}

	// create shared informer for Kubernetes APIs
	var kubeconfig *rest.Config
	var err error
	if len(o.CoreAPIKubeconfigPath) > 0 {

	}
}

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")), ":")
    }

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