ReadResolve,
        WriteObject,
        ReadObject,
        SerializedLambda
    }

    private
    fun readResolve(bean: Any): Any =
        when (val readResolve = readResolveMethod.forObject(bean)) {
            null -> bean
            else -> readResolve.invoke(bean)
        }

    /**
     * Caches the computed `readObject` method hierarchies during decoding because [ReadContext.decode] might

        SomeBean bean = new SomeBean();

        Xpp3Dom config = toConfig("<file>test</file>");

        DefaultBeanConfigurationRequest request = new DefaultBeanConfigurationRequest();
        request.setBean(bean).setConfiguration(config);

        configurator.configureBean(request);

        assertEquals(new File("test"), bean.file);
    }

    @Test

                private final SomeBean bean = new SomeBean()
                private final ${type} value

                SomeTask() {
                    value = ${reference}
                    bean.value = ${reference}
                }

                @TaskAction
                void run() {
                    println "this.value = " + value
                    println "bean.value = " + bean.value
                }

        when:
        ConfigureUtil.configureByMap(bean, method: "foo")

        then:
        bean.prop == "foo"
    }

    static class Bean {
        String prop
        def method(String value) {
            prop = value
        }
    }

import java.util.List;
import java.util.Map;

import org.codelibs.core.beans.Converter;
import org.codelibs.core.beans.converter.DateConverter;
import org.codelibs.core.beans.converter.NumberConverter;
import org.codelibs.core.beans.converter.SqlDateConverter;
import org.codelibs.core.beans.converter.TimeConverter;
import org.codelibs.core.beans.converter.TimestampConverter;
import org.codelibs.core.convert.DateConversionUtil;

                }
            }

            class SomeTask extends DefaultTask {
                private final SomeBean bean = new SomeBean()

                @TaskAction
                void run() {
                    println "bean = " + bean
                    println "bean.value = " + bean.value
                }
            }

            task ok(type: SomeTask)
        """

        when:

            }

            class Bean {
                @InputFiles FileCollection files
            }

            abstract class Test extends DefaultTask {
                @Nested abstract Property<Bean> getBean()
                @TaskAction def test() { assert false }
            }

            tasks.register('test', Test) {
                bean = new Bean().tap {

 */

package org.gradle.api.internal.tasks.properties.bean

import org.gradle.internal.properties.bean.ImplementationResolver
import org.gradle.internal.snapshot.impl.ImplementationValue

class TestImplementationResolver implements ImplementationResolver {
    @Override
    ImplementationValue resolveImplementation(Object bean) {
        new ImplementationValue(bean.getClass().getName(), bean)
    }

        buildFile  """
            class Bean {
                String name

                Bean(String name, ObjectFactory factory) {
                    println(factory != null ? "got it" : "NOT IT")
                    this.name = name

                    // is not generated
                    assert getClass() == Bean
                }
            }

        given:
        Bean obj = new Bean()

        when:
        action(prop: 'value').execute(obj)

        then:
        obj.prop == "value"

        when:
        action(method: 'value2').execute(obj)

        then:
        obj.prop == 'value2'
    }

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

        when: