final Bean bean1 = new Bean("bean1");
        final Bean bean2 = new Bean("bean2");

        container.addRule("rule1", { s -> if (s == "bean1") { container.add(bean1)} })
        container.addRule("rule2", { s ->
            if (s == "bean2") {
                container.findByName("bean1");
                container.findByName("bean2");
                container.add(bean2);
            }
        })

        expect:

        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();
        private static final AtomicInteger bean2 = new AtomicInteger();

        @Named
        @Singleton

    @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

        @Nested
        public List<?> getBeans() {
            return ImmutableList.of(bean);
        }
    }

    public static class TaskWithNestedBeanWithPrivateClass extends TaskWithAction {
        Bean2 bean = new Bean2();

        @Inject
        public TaskWithNestedBeanWithPrivateClass(File inputFile, File inputFile2) {
            bean.inputFile = inputFile;
            bean.inputFile2 = inputFile2;
        }

    def "getNames"() {
        expect:
        container.getNames().isEmpty()

        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:

        public MyBean2() {
        }

        /**
         * @param num
         * @param text
         * @param bean1
         * @param bean2
         */
        public MyBean2(final int num, final String text, final MyBean bean1, final MyBean2 bean2) {
        }

        /**
         * @param i
         */
        public void setAaa(final int i) {
        }

        /**

                it.addLinkInstance("bean1.bean2", new Bean(name: "bean2 unmodified"))
            }
        }
        registry.root.getLink("bean1").applyToSelf(rules)

        expect:
        // Rule is not applied to scope node
        registry.realize("bean1", Bean).name == "bean1 unmodified"
        // Rule is applied to child of scope node
        registry.realize("bean1.bean2", Bean).name == "bean"

        where:

import static org.apache.commons.io.FileUtils.touch
import static org.gradle.api.internal.project.taskfactory.AnnotationProcessingTasks.Bean
import static org.gradle.api.internal.project.taskfactory.AnnotationProcessingTasks.Bean2
import static org.gradle.api.internal.project.taskfactory.AnnotationProcessingTasks.BrokenTaskWithInputDir
import static org.gradle.api.internal.project.taskfactory.AnnotationProcessingTasks.BrokenTaskWithInputFiles