when:
        container.add(bean1);
        container.add(bean2);
        container.add(bean3);

        then:
        container.withType(Bean) as List == [bean1, bean2, bean3]
        container.withType(BeanSub1) as List == [bean2]
    }

    def canChainFilteredCollections() {
        final Bean bean = new Bean("b1");
        final Bean bean2 = new Bean("b2");

     */
    @Test
    public void testCopyBeanToBean_converter() throws Exception {
        final Bean bean = new Bean();
        bean.aaa = "1,000";
        final Bean2 bean2 = new Bean2();
        BeanUtil.copyBeanToBean(bean, bean2, converter(new NumberConverter("#,##0")));
        assertThat(bean2.aaa, is(new Integer(1000)));
    }

    /**
     * @throws Exception
     */
    @Test

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

import org.codelibs.core.beans.BeanDesc;
import org.codelibs.core.beans.FieldDesc;
import org.codelibs.core.beans.MethodDesc;
import org.codelibs.core.beans.ParameterizedClassDesc;
import org.codelibs.core.beans.PropertyDesc;
import org.codelibs.core.beans.factory.BeanDescFactory;
import org.codelibs.core.exception.MethodNotFoundRuntimeException;
import org.junit.Test;

        TaskWithNestedBean                 | 'bean'     | [null]                | Bean.class
        TaskWithNestedObject               | 'bean.key' | [['key': new Bean()]] | Bean.class
        TaskWithNestedIterable             | 'beans.$0' | [new Bean()]          | Bean.class
        TaskWithNestedBeanWithPrivateClass | 'bean'     | [null, null]          | Bean2.class
    }

        registry
            .registerInstance("foo", new Bean())
            .mutate {
                it.path("foo").type(Bean).action("beans.element.mutable", ModelType.of(MutableValue)) { Bean subject, MutableValue input ->
                    subject.value = input.value
                }
            }
            .registerModelMap("beans", Bean) { it.registerFactory(Bean) { new Bean(name: it) } }

                @Nested
                abstract DomainObjectSet<Bean> getBeans()

                @TaskAction
                void go() {
                    println("beans = \${beans.collect { it.prop } }")
                }
            }

            tasks.create("thing", MyTask) {
                beans.add(new Bean(prop: '1'))
                beans.add(new Bean(prop: '2'))
            }
        """

        when:

                Object bean

                @OutputFile
                final RegularFileProperty outputFile = project.objects.fileProperty()

                @TaskAction
                void writeInputToFile() {
                    outputFile.getAsFile().get().text = bean == null ? 'null' : bean.toString()
                    if (bean != null) {
                        bean.doStuff()
                    }

        1 * visitor.visitInputProperty('bean', { it.call().implementationClassIdentifier == NestedBean.name }, false)
        1 * visitor.visitInputProperty('bean.nestedInput', { it.call() == 'nested' }, false)
        1 * visitor.visitInputFileProperty('bean.inputDir', _, _, _, _, _, _, InputFilePropertyType.DIRECTORY)

    @Test
    fun `can handle mix of Serializable and plain beans`() {

        val bean = Pair(42, "42")

        verifyRoundtripOf({
            // A plain bean that holds a reference to a serializable object
            // sharing a reference to another plain bean.
            Pair(SerializableWriteObjectBean(bean), bean)
        }) { (decodedSerializable, decodedBean) ->

            dest.put(destPropertyName, convertedValue);
        }
    }

    /**
     * コピー元のBeanを新しいBeanのインスタンスにコピーして返します。
     *
     * @param <T> コピー先となるBeanの型
     * @param src コピー元のBean。{@literal null}であってはいけません
     * @param destClass コピー先となるBeanの型。{@literal null}であってはいけません
     * @return コピーされた新しいBean
     */
    public static <T> T copyBeanToNewBean(final Object src, final Class<T> destClass) {