Refine search
@Override public UpnpServiceConfiguration getConfiguration() { return configuration.get(); }
/** * <p> * Determines if there is exactly one bean that matches the required type and qualifiers and is eligible for injection * into the class into which the parent <tt>Instance</tt> was injected. * </p> * * @since 2.0 * @return <tt>true</tt> if there is exactly one bean that matches the required type and qualifiers and is eligible for * injection into the class into which the parent <tt>Instance</tt> was injected, or <tt>false</tt> otherwise. */ default boolean isResolvable() { return !isUnsatisfied() && !isAmbiguous(); }
@Override public ContextHandle createContextHandle() { final BeanManagerImpl beanManager = getBeanManager(); return () -> { if (beanManager == null || beanManager.isContextActive(RequestScoped.class)) { return () -> { }; } final RequestContext requestContext = beanManager.instance().select(RequestContext.class, UnboundLiteral.INSTANCE).get(); requestContext.activate(); return () -> { requestContext.invalidate(); requestContext.deactivate(); }; }; }
@Test(dataProvider = ARQUILLIAN_DATA_PROVIDER) @SpecAssertion(section = Sections.PROCESS_BEAN_ATTRIBUTES, id = "bf") public void testAppDeployedAndBeanIsAvailable(Instance<Qux> quxInstance) { Assert.assertFalse(quxInstance.isUnsatisfied()); Assert.assertTrue(quxInstance.get().ping()); }
@Test @SpecAssertion(section = ANNOTATED_CONSTRUCTOR_CONFIGURATOR, id = "e") public void configureAndTestConstructorAnnotatedParams(){ Assert.assertFalse(countrysideInstance.isUnsatisfied()); Countryside countryside = countrysideInstance.get(); Assert.assertEquals(countryside.getWildDog().getName(), "wild dog"); Assert.assertEquals(countryside.getWildCat().getName(), "wild cat"); }
@Test(dataProvider = ARQUILLIAN_DATA_PROVIDER) @SpecAssertion(section = MEMBER_LEVEL_INHERITANCE, id = "baa") public void testSubClassInheritsPostConstructOnSuperclass(Instance<Object> instance) { OrderProcessor.postConstructCalled = false; assertEquals(getBeans(CdOrderProcessor.class).size(), 1); getContextualReference(CdOrderProcessor.class).order(); assertTrue(OrderProcessor.postConstructCalled); assertNotNull(instance); OrderProcessor.postConstructCalled = false; instance.select(CdOrderProcessor.class).get().order(); assertTrue(OrderProcessor.postConstructCalled); }
@Test @SpecAssertions({ @SpecAssertion(section = DYNAMIC_LOOKUP, id = "la"), @SpecAssertion(section = DYNAMIC_LOOKUP, id = "l") }) public void testIsUnsatisfied() { ObtainsInstanceBean injectionPoint = getContextualReference(ObtainsInstanceBean.class); assertFalse(injectionPoint.getAnyPaymentProcessor().isUnsatisfied()); assertTrue(injectionPoint.getPaymentProcessor().select(RemotePaymentProcessor.class).isUnsatisfied()); }
@Test(dataProvider = ARQUILLIAN_DATA_PROVIDER) @SpecAssertion(section = INVOCATIONCONTEXT, id = "ga") public void testReplacingParameters(Instance<Bravo> instance) { ActionSequence.reset(); Bravo bravo = instance.get(); assertNotNull(bravo.getParameter()); assertEquals(BravoInterceptor.NEW_PARAMETER_VALUE, bravo.getParameter().getValue()); assertSequenceDataEquals(BravoInterceptor.class); }
@Test @SpecAssertion(section = NEW, id = "xc") public void testNewBeanNotEnabledWithouInjectionPoint() { assertTrue(getContextualReference(ObtainsNewInstanceBean.class).getIae().isUnsatisfied()); }
@Test @SpecAssertions({ @SpecAssertion(section = DYNAMIC_LOOKUP, id = "ia"), @SpecAssertion(section = DYNAMIC_LOOKUP, id = "ib"), @SpecAssertion(section = DYNAMIC_LOOKUP, id = "la"), @SpecAssertion(section = DYNAMIC_LOOKUP, id = "m") }) public void testAlternatives() { Instance<Common> instance = getContextualReference(ObtainsInstanceBean.class).getCommon(); assertFalse(instance.isAmbiguous()); Iterator<Common> iterator = instance.iterator(); assertTrue(iterator.hasNext()); assertTrue(iterator.next() instanceof Baz); assertFalse(iterator.hasNext()); assertTrue(instance.get().ping()); }
@Test @SpecAssertions({ @SpecAssertion(section = DECORATOR_INVOCATION, id = "acb") }) public void testDecoratorIsInvoked() { assertTrue(instance.isAmbiguous()); Mule mule = instance.get(); assertNotNull(mule); } }
@Test @SpecAssertion(section = BEFORE_BEAN_DISCOVERY, id = "c") public void testQualifierAddition() { Instance<Foo> fooInstance = instance.select(Foo.class, CustomQualifier.CustomQualifierLiteral.INSTANCE); Assert.assertFalse(fooInstance.isUnsatisfied()); Assert.assertNotNull(fooInstance.get()); }
@Test @SpecAssertions({ @SpecAssertion(section = DECLARING_ALTERNATIVE, id = "aa"), @SpecAssertion(section = SPECIALIZE_MANAGED_BEAN, id = "ac") }) public void testNotEnabledAlternativeDoesNotSpecialize() { assertFalse(bean1.getFactory() instanceof AlternativeSpecializedFactory); assertFalse(bean1.getProduct().isUnsatisfied()); assertFalse(bean1.getProduct().isAmbiguous()); assertNotNull(bean1.getProduct().get()); assertFalse(bean2.getFactory() instanceof AlternativeSpecializedFactory); assertFalse(bean2.getProduct().isUnsatisfied()); assertFalse(bean2.getProduct().isAmbiguous()); assertNotNull(bean2.getProduct().get()); }
@Test(dataProvider = ARQUILLIAN_DATA_PROVIDER) @SpecAssertions({ @SpecAssertion(section = DYNAMIC_LOOKUP, id = "o") }) public void testContextDestroyCalled( Instance<AlterableComponent> instance) { AlterableComponent component = instance.get(); CustomAlterableContext.reset(); instance.destroy(component); assertTrue(CustomAlterableContext.isDestroyCalled()); }
public DependentContext getDependentContext() { return Container.instance().deploymentManager().instance().select(DependentContext.class).get(); }
@Test(dataProvider = ARQUILLIAN_DATA_PROVIDER) @SpecAssertion(section = BUILTIN_INSTANCE, id = "g") public void testInstanceIsPassivationCapable(Field field) throws Exception { assertNotNull(field); Object object = activate(passivate(field)); assert field.getInstance().get() instanceof Cow; assert object instanceof Field; Field field2 = (Field) object; assert field2.getInstance().get() instanceof Cow; } }
@Test(dataProvider = ARQUILLIAN_DATA_PROVIDER) @SpecAssertion(section = Sections.TRIMMED_BEAN_ARCHIVE, id = "a") public void testDiscoveredBeanWithStereoType(Instance<Segway> segwayInstance) { Assert.assertFalse(segwayInstance.isUnsatisfied()); } }
@Test @SpecAssertions({ @SpecAssertion(section = "5.6", id = "da"), @SpecAssertion(section = "5.6.1", id = "m") }) public void testIsAmbiguous() { ObtainsInstanceBean injectionPoint = getInstanceByType(ObtainsInstanceBean.class); assert injectionPoint.getAnyPaymentProcessor().isAmbiguous(); assert !injectionPoint.getPaymentProcessor().isAmbiguous(); } }