}

    def canConfigureObjectPropertyUsingMap() {
        given:
        Bean obj = new Bean()

        when:
        ConfigureUtil.configureByMap(obj, prop: 'value')

        then:
        obj.prop == "value"

        when:
        ConfigureUtil.configureByMap(obj, method: 'value2')

        then:
        obj.prop == 'value2'
    }

    def canConfigureAndValidateObjectUsingMap() {
        given:

import org.gradle.internal.service.ServiceRegistry
import org.gradle.kotlin.dsl.accessors.ProjectAccessorsClassPathGenerator

import org.gradle.kotlin.dsl.invoke

import org.gradle.util.internal.ConfigureUtil.configureByMap
import java.io.File


class KotlinScriptHost<out T : Any> internal constructor(
    val target: T,
    val scriptSource: ScriptSource,
    internal val scriptHandler: ScriptHandler,

import javax.annotation.Nullable;
import java.util.Collection;
import java.util.Map;

import static org.gradle.util.internal.CollectionUtils.toStringList;

public class ConfigureUtil {

    public static <T> T configureByMap(Map<?, ?> properties, T delegate) {
        if (properties.isEmpty()) {
            return delegate;
        }
        DynamicObject dynamicObject = DynamicObjectUtil.asDynamicObject(delegate);

        configAction.execute();
    }

    @Override
    public void apply(Map<String, ?> options) {
        DefaultObjectConfigurationAction action = createObjectConfigurationAction();
        ConfigureUtil.configureByMap(options, action);
        action.execute();
    }

    @Override
    public PluginContainer getPlugins() {
        return getPluginManager().getPluginContainer();
    }

    @Override
    @Inject

        this.properties = properties;
        this.mandatoryProperties = mandatoryProperties;
    }

    @Override
    public void execute(T thing) {
        ConfigureUtil.configureByMap(properties, thing, mandatoryProperties);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

 *
 * @deprecated Will be removed in Gradle 9.0.
 */
@Deprecated
public class ConfigureUtil {

    public static <T> T configureByMap(Map<?, ?> properties, T delegate) {
        logDeprecation();
        return configureByMapInternal(properties, delegate);
    }

    private static <T> T configureByMapInternal(Map<?, ?> properties, T delegate) {

                    FilterReader result = constructor.newInstance(original);

                    if (properties != null) {
                        ConfigureUtil.configureByMap(properties, result);
                    }
                    return result;
                } catch (Throwable th) {

            throw UncheckedException.throwAsUncheckedException(e);
        } catch (InvocationTargetException e) {
            throw UncheckedException.unwrapAndRethrow(e);
        }

        ConfigureUtil.configureByMap(mutableValues, result);
        return result;
    }

    @Nullable
    protected String get(Map<String, Object> args, String key) {
        Object value = args.get(key);

     *
     * @param args A map that must contain a 'name' and 'version' key with corresponding values.
     */
    public void facet(Map<String, ?> args) {
        Facet newFacet = ConfigureUtil.configureByMap(args, new Facet());
        List<Facet> newFacets;
        if ("jst.ejb".equals(newFacet.getName())) {
            newFacets = Arrays.asList(new Facet(Facet.FacetType.fixed, "jst.ejb", null), newFacet);
        } else {

        action.execute();
    }

    @Override
    public void apply(Map options) {
        DefaultObjectConfigurationAction action = createObjectConfigurationAction();
        ConfigureUtil.configureByMap(options, action);
        action.execute();
    }

    @Override
    public ScriptHandler getBuildscript() {
        return scriptServices.get(ScriptHandler.class);
    }

    @Override