@Test public void testInstance(Consumer consumer) throws Throwable { Instance<Cow> instance = consumer.getCow(); Instance<Cow> instance1 = Utils.deserialize(Utils.serialize(instance)); Assert.assertTrue(checkInstance(instance1)); Assert.assertTrue(checkEquality(instance, instance1)); }
@Test public void testEvent(Consumer consumer, CowEventObserver observer) throws Throwable { Event<Cow> event = consumer.getEvent(); Event<Cow> event1 = Utils.deserialize(Utils.serialize(event)); Assert.assertTrue(checkEvent(event1, observer)); Assert.assertTrue(checkEquality(event, event1)); }
@Test public void testMethodInjectionPoint(MethodInjectionPointConsumer consumer) throws Throwable { Dog.reset(); consumer.ping(); InjectionPoint injectionPoint = Dog.getInjectionPoint(); InjectionPoint injectionPoint1 = Utils.deserialize(Utils.serialize(injectionPoint)); Assert.assertTrue(checkInjectionPoint(injectionPoint1, MethodInjectionPointConsumer.class)); Assert.assertTrue(checkEquality(injectionPoint, injectionPoint1)); }
@Test public void testDestroyDoesntTryToRemoveSLSB() { Bean<BeanLocal> bean = Utils.getBean(beanManager, BeanLocal.class); Assert.assertNotNull("Expected a bean for stateless session bean BeanLocal", bean); CreationalContext<BeanLocal> creationalContext = beanManager.createCreationalContext(bean); BeanLocal instance = bean.create(creationalContext); bean.destroy(instance, creationalContext); }
@Test public void test() { FooDisposer.reset(); FooProducer.reset(); Bean<Foo> bean = Utils.getBean(beanManager, Foo.class); CreationalContext<Foo> ctx = beanManager.createCreationalContext(bean); Foo instance = bean.create(ctx); Assert.assertEquals("foo!", instance.getBlah()); bean.destroy(instance, ctx); Assert.assertFalse(FooDisposer.isDisposed()); Assert.assertTrue(FooProducer.isDisposed()); }
/** * When the create() method of a Bean object that represents a stateful session bean that is * called, the container creates and returns a session bean proxy, as defined in Section 3.3.9, * "Session bean proxies". */ @Test public void testCreateSFSB(GrossStadt frankfurt) { Bean<KleinStadt> stadtBean = Utils.getBean(beanManager, KleinStadt.class); Assert.assertNotNull("Expected a bean for stateful session bean Kassel", stadtBean); CreationalContext<KleinStadt> creationalContext = new MockCreationalContext<KleinStadt>(); KleinStadt stadtInstance = stadtBean.create(creationalContext); Assert.assertNotNull("Expected instance to be created by container", stadtInstance); Assert.assertTrue( "PostConstruct should be invoked when bean instance is created", frankfurt.isKleinStadtCreated()); frankfurt.resetCreatedFlags(); // Create a second one to make sure create always does create a new session bean KleinStadt anotherStadtInstance = stadtBean.create(creationalContext); Assert.assertNotNull("Expected second instance of session bean", anotherStadtInstance); Assert.assertTrue(frankfurt.isKleinStadtCreated()); Assert.assertNotSame( "create() should not return same bean as before", anotherStadtInstance, stadtInstance); // Verify that the instance returned is a proxy by checking for all local interfaces Assert.assertTrue(stadtInstance instanceof KleinStadt); Assert.assertTrue(stadtInstance instanceof SchoeneStadt); }
@Test public void testBeanManagerBean(BeanManager beanManager) throws Throwable { BeanManager beanManager1 = Utils.deserialize(Utils.serialize(beanManager)); Assert.assertTrue(checkBeanManager(beanManager1)); Assert.assertTrue(checkEquality(beanManager, beanManager1)); }
@Test public void testUserTransactionBean(UserTransaction userTransaction) throws Throwable { UserTransaction userTransaction1 = Utils.deserialize(Utils.serialize(userTransaction)); Assert.assertTrue(checkUserTransaction(userTransaction1)); }
@Test @Category({Integration.class, Broken.class}) public void testPrincipal(Principal principal) throws Throwable { Principal principal1 = Utils.deserialize(Utils.serialize(principal)); Assert.assertTrue(checkPrincipal(principal1)); }
@Test public void testDefaultValidatorFactoryBean(ValidatorFactory validatorFactory) throws Throwable { ValidatorFactory validatorFactory1 = Utils.deserialize(Utils.serialize(validatorFactory)); Assert.assertTrue(checkValidatorFactory(validatorFactory1)); }
@Test public void testDefaultValidatorBean(Validator validator) throws Throwable { Validator validator1 = Utils.deserialize(Utils.serialize(validator)); Assert.assertTrue(checkValidator(validator1)); }
@Test public void testAllOnBean(Consumer consumer) throws Throwable { consumer.check(); Consumer consumer1 = Utils.deserialize(Utils.serialize(consumer)); consumer1.check(); }