val session = FakeSSLSession()
    assertThat(verifier.verify("localhost", session)).isFalse()
  }

  @Test fun verifyCn() {
    // CN=foo.com
    val session =
      session(
        """
        -----BEGIN CERTIFICATE-----
        MIIERjCCAy6gAwIBAgIJAIz+EYMBU6aQMA0GCSqGSIb3DQEBBQUAMIGiMQswCQYD
        VQQGEwJDQTELMAkGA1UECBMCQkMxEjAQBgNVBAcTCVZhbmNvdXZlcjEWMBQGA1UE

        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

import java.lang.annotation.Target;

/**
 * <p>Marks a property as specifying a nested bean, whose properties should be checked for annotations.</p>
 *
 * <p>This annotation should be attached to the getter method in Java or the property in Groovy.
 * Annotations on setters or just the field in Java are ignored.</p>
 *
 * <p>Gradle will attempt to instantiate a nested bean on abstract getter methods annotated with this annotation.

  SmallVector<Value, 4> operands;
  operands.reserve(operands_size);
  operands.append(while_op.getOperands().begin(), while_op.getOperands().end());
  operands.append(extra_operands.begin(), extra_operands.end());
  SmallVector<Type, 4> new_types;
  new_types.reserve(operands_size);
  new_types.append(while_op.getResultTypes().begin(),
                   while_op.getResultTypes().end());
  for (auto extra_operand : extra_operands)

                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
                }

      : $for j, [[g$(j)_(g$j)]] {}
  virtual ~CartesianProductGenerator$i() {}

  virtual ParamIteratorInterface<ParamType>* Begin() const {
    return new Iterator(this, $for j, [[g$(j)_, g$(j)_.begin()]]);
  }
  virtual ParamIteratorInterface<ParamType>* End() const {
    return new Iterator(this, $for j, [[g$(j)_, g$(j)_.end()]]);
  }

 private:

        val bean = beanReader.run { newBeanWithId(generated, id) }
        val effectiveBeanType = bean.javaClass
        val effectiveBeanReader =
            if (beanType === effectiveBeanType) beanReader
            else beanStateReaderFor(effectiveBeanType)
        effectiveBeanReader.run {
            readStateOf(bean)
        }
        return bean
    }

            }

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