@Transactional
 @Test
 public void testRead() throws Exception {
   itemReader.open(new ExecutionContext());
   Foo foo = itemReader.read();
   assertEquals(2, foo.getId());
   foo = itemReader.read();
   assertEquals(3, foo.getId());
   assertNull(itemReader.read());
 }
  @Test
  public void getDocument_idRevForFoo_success() {
    Response res = client.create(new Foo("Tom"));
    Assert.assertThat(res.getRev(), startsWith("1-"));

    Foo foo = client.getDocument(res.getId(), Foo.class);
    foo.setName("Jerry");
    Response res2 = client.create(foo);
    Assert.assertThat(res2.getRev(), startsWith("2-"));

    {
      Foo fooVersion2 = client.getDocument(res2.getId(), Foo.class);
      Assert.assertNotNull(fooVersion2);
      Assert.assertEquals(res2.getId(), fooVersion2.getId());
      Assert.assertEquals(res2.getRev(), fooVersion2.getRevision());
    }

    {
      Foo fooVersion1 = client.getDocument(res.getId(), res.getRev(), Foo.class);
      Assert.assertNotNull(fooVersion1);
      Assert.assertThat(fooVersion1.getRevision(), startsWith("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());
  }