public static void main(String argv[]) {

    director_basic_MyFoo a = new director_basic_MyFoo();

    if (!a.ping().equals("director_basic_MyFoo::ping()")) {
      throw new RuntimeException("a.ping()");
    }

    if (!a.pong().equals("Foo::pong();director_basic_MyFoo::ping()")) {
      throw new RuntimeException("a.pong()");
    }

    Foo b = new Foo();

    if (!b.ping().equals("Foo::ping()")) {
      throw new RuntimeException("b.ping()");
    }

    if (!b.pong().equals("Foo::pong();Foo::ping()")) {
      throw new RuntimeException("b.pong()");
    }

    A1 a1 = new A1(1, false);
    a1.delete();
  }
Beispiel #2
0
  @Test(groups = {})
  @SpecAssertions({@SpecAssertion(section = BEAN_ARCHIVE_EE, id = "jh")})
  public void test() {
    assertEquals(getCurrentManager().getBeans(Foo.class).size(), 1);
    assertEquals(getCurrentManager().getBeans(Bar.class).size(), 1);

    // Bean in WAR classes can inject bean from WAR library
    assertEquals(foo.ping(), 1);
  }
  @SuppressWarnings({"unchecked", "serial"})
  @Test
  public void testCustomBean(BeanManager beanManager) throws Exception {
    Set<Bean<?>> beans = beanManager.getBeans("bar");
    assertEquals(1, beans.size());
    Bean<Foo> fooBean = (Bean<Foo>) beans.iterator().next();
    assertEquals(Dependent.class, fooBean.getScope());
    Foo foo1 =
        (Foo)
            beanManager.getReference(
                fooBean, Foo.class, beanManager.createCreationalContext(fooBean));
    Foo foo2 =
        (Foo)
            beanManager.getReference(
                fooBean, Foo.class, beanManager.createCreationalContext(fooBean));
    assertFalse(foo1.getId().equals(foo2.getId()));

    beans = beanManager.getBeans(Foo.class, Juicy.Literal.INSTANCE);
    assertEquals(1, beans.size());
    fooBean = (Bean<Foo>) beans.iterator().next();
    Foo foo =
        (Foo)
            beanManager.getReference(
                fooBean, Foo.class, beanManager.createCreationalContext(fooBean));
    foo.ping();

    beans = beanManager.getBeans(Integer.class, Random.Literal.INSTANCE);
    assertEquals(1, beans.size());
    Bean<Integer> randomBean = (Bean<Integer>) beans.iterator().next();
    CreationalContext<Integer> ctx = beanManager.createCreationalContext(randomBean);
    Integer random = (Integer) beanManager.getReference(randomBean, Integer.class, ctx);
    assertNotNull(random);
    assertTrue(random >= 0 && random < 1000);
    randomBean.destroy(random, ctx);
    assertTrue(BuilderExtension.DISPOSED.get());

    beans = beanManager.getBeans(Long.class, AnotherRandom.Literal.INSTANCE);
    assertEquals(1, beans.size());
    Bean<Long> anotherRandomBean = (Bean<Long>) beans.iterator().next();
    Long anotherRandom =
        (Long)
            beanManager.getReference(
                anotherRandomBean,
                Long.class,
                beanManager.createCreationalContext(anotherRandomBean));
    assertNotNull(anotherRandom);
    assertEquals(Long.valueOf(foo.getId() * 2), anotherRandom);

    beans = beanManager.getBeans(Bar.class);
    assertEquals(1, beans.size());
    Bean<Bar> barBean = (Bean<Bar>) beans.iterator().next();
    assertEquals(Dependent.class, barBean.getScope());

    beans =
        beanManager.getBeans(new TypeLiteral<List<String>>() {}.getType(), Juicy.Literal.INSTANCE);
    assertEquals(1, beans.size());
    Bean<List<String>> listBean = (Bean<List<String>>) beans.iterator().next();
    assertEquals(Dependent.class, listBean.getScope());
    List<String> list =
        (List<String>)
            beanManager.getReference(
                listBean,
                new TypeLiteral<List<String>>() {}.getType(),
                beanManager.createCreationalContext(listBean));
    assertNotNull(list);
    assertEquals(1, list.size());
    assertEquals("FOO", list.get(0));

    beans = beanManager.getBeans(VetoedBean.class, Random.Literal.INSTANCE);
    assertEquals(1, beans.size());
    fooBean = (Bean<Foo>) beans.iterator().next();
    assertEquals(Dependent.class, fooBean.getScope());
    Foo randomFoo =
        (Foo)
            beanManager.getReference(
                fooBean, Foo.class, beanManager.createCreationalContext(listBean));
    assertEquals(Long.valueOf(-1), randomFoo.getId());

    beans = beanManager.getBeans(Configuration.class);
    assertEquals(1, beans.size());
    Bean<Configuration> configBean = (Bean<Configuration>) beans.iterator().next();
    assertEquals(Dependent.class, configBean.getScope());
    Configuration configuration =
        (Configuration)
            beanManager.getReference(
                configBean, Configuration.class, beanManager.createCreationalContext(configBean));
    assertEquals(1, configuration.getId());
  }