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");

        assertNotNull(b2a);
        SingletonContainer.Bean2 b2b = injector.getInstance(SingletonContainer.Bean2.class);
        assertNotNull(b2b);
        assertNotEquals(b2a.num, b2b.num);
    }

    static class SingletonContainer {
        private static final AtomicInteger bean1 = new AtomicInteger();

     */
    @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

            return bean.getInputFile();
        }
    }

    public static class TaskWithOptionalNestedBean extends TaskWithAction {
        private final Bean bean;

        @Inject
        public TaskWithOptionalNestedBean(Bean bean) {
            this.bean = bean;
        }

        @Nested
        @Optional
        public Bean getBean() {
            return bean;
        }

        when:
        container.add(new Bean("bean1"))
        container.add(new Bean("bean2"))
        container.add(new Bean("bean3"))
        then:
        container.names == ["bean1", "bean2", "bean3"] as SortedSet
    }

    def "returns null element with name is not present and there are no rules to create it"() {
        expect:
        container.findByName("bean") == null
    }

        registry.registerInstance("bean1", new Bean(name: "bean1 unmodified"))
        registry.registerInstance("beans", new Bean(name: "beans"))
        registry.registerModelMap("otherBeans", Bean) { it.registerFactory(Bean) { new Bean(name: it + " unmodified") } }
        registry.mutate {
            it.path "otherBeans" type mmType action { beans ->
                beans.create("bean3")
            }
        }

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
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.snapshot.impl

class Bean implements Serializable {
    String prop

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