@Test
  public void prototypeCreationReevaluatesExpressions() {
    GenericApplicationContext ac = new GenericApplicationContext();
    AnnotationConfigUtils.registerAnnotationConfigProcessors(ac);
    RootBeanDefinition rbd = new RootBeanDefinition(PrototypeTestBean.class);
    rbd.setScope(RootBeanDefinition.SCOPE_PROTOTYPE);
    rbd.getPropertyValues().add("country", "#{systemProperties.country}");
    rbd.getPropertyValues().add("country2", new TypedStringValue("#{systemProperties.country}"));
    ac.registerBeanDefinition("test", rbd);
    ac.refresh();

    try {
      System.getProperties().put("name", "juergen1");
      System.getProperties().put("country", "UK1");
      PrototypeTestBean tb = (PrototypeTestBean) ac.getBean("test");
      assertEquals("juergen1", tb.getName());
      assertEquals("UK1", tb.getCountry());
      assertEquals("UK1", tb.getCountry2());

      System.getProperties().put("name", "juergen2");
      System.getProperties().put("country", "UK2");
      tb = (PrototypeTestBean) ac.getBean("test");
      assertEquals("juergen2", tb.getName());
      assertEquals("UK2", tb.getCountry());
      assertEquals("UK2", tb.getCountry2());
    } finally {
      System.getProperties().remove("name");
      System.getProperties().remove("country");
    }
  }
  /**
   * Assert that the attributes returned from the data connector match the provided attributes.
   *
   * @param dataConnectorName the data connector name
   * @param principalName the principalName
   * @param correctMap the correct attributes
   */
  private void runAttributeDefinitionTest(
      String dataConnectorName,
      String principalName,
      AttributeMap correctMap,
      String attributeDefinitionName) {
    try {
      GenericApplicationContext gContext =
          BaseDataConnectorTest.createSpringContext(RESOLVER_CONFIG);
      ShibbolethResolutionContext ctx = getShibContext(principalName);

      // resolve data connector dependency
      GroupDataConnector gdc = (GroupDataConnector) gContext.getBean(dataConnectorName);
      gdc.resolve(ctx);
      ctx.getResolvedPlugins().put(gdc.getId(), gdc);

      // resolve attribute definition
      AttributeDefinition ad = (AttributeDefinition) gContext.getBean(attributeDefinitionName);
      BaseAttribute attr = ad.resolve(ctx);

      // assert equality
      AttributeMap currentMap = new AttributeMap();
      currentMap.setAttribute(attr);
      LOG.debug("correctMap\n{}", correctMap);
      LOG.debug("currentMap\n{}", currentMap);
      assertEquals(correctMap, currentMap);
    } catch (Exception e) {
      e.printStackTrace();
      throw new RuntimeException(e);
    }
  }
 @Test
 public void testAutowiredFieldResolvesWithMultipleQualifierValuesAndExplicitDefaultValue() {
   GenericApplicationContext context = new GenericApplicationContext();
   ConstructorArgumentValues cavs1 = new ConstructorArgumentValues();
   cavs1.addGenericArgumentValue(JUERGEN);
   RootBeanDefinition person1 = new RootBeanDefinition(Person.class, cavs1, null);
   AutowireCandidateQualifier qualifier =
       new AutowireCandidateQualifier(TestQualifierWithMultipleAttributes.class);
   qualifier.setAttribute("number", 456);
   person1.addQualifier(qualifier);
   ConstructorArgumentValues cavs2 = new ConstructorArgumentValues();
   cavs2.addGenericArgumentValue(MARK);
   RootBeanDefinition person2 = new RootBeanDefinition(Person.class, cavs2, null);
   AutowireCandidateQualifier qualifier2 =
       new AutowireCandidateQualifier(TestQualifierWithMultipleAttributes.class);
   qualifier2.setAttribute("number", 123);
   qualifier2.setAttribute("value", "default");
   person2.addQualifier(qualifier2);
   context.registerBeanDefinition(JUERGEN, person1);
   context.registerBeanDefinition(MARK, person2);
   context.registerBeanDefinition(
       "autowired", new RootBeanDefinition(QualifiedFieldWithMultipleAttributesTestBean.class));
   AnnotationConfigUtils.registerAnnotationConfigProcessors(context);
   context.refresh();
   QualifiedFieldWithMultipleAttributesTestBean bean =
       (QualifiedFieldWithMultipleAttributesTestBean) context.getBean("autowired");
   assertEquals(MARK, bean.getPerson().getName());
 }
 @Test
 public void prototypeCreationIsFastEnough() {
   if (factoryLog.isTraceEnabled() || factoryLog.isDebugEnabled()) {
     // Skip this test: Trace logging blows the time limit.
     return;
   }
   GenericApplicationContext ac = new GenericApplicationContext();
   RootBeanDefinition rbd = new RootBeanDefinition(TestBean.class);
   rbd.setScope(RootBeanDefinition.SCOPE_PROTOTYPE);
   rbd.getConstructorArgumentValues().addGenericArgumentValue("#{systemProperties.name}");
   rbd.getPropertyValues().add("country", "#{systemProperties.country}");
   ac.registerBeanDefinition("test", rbd);
   ac.refresh();
   StopWatch sw = new StopWatch();
   sw.start("prototype");
   System.getProperties().put("name", "juergen");
   System.getProperties().put("country", "UK");
   try {
     for (int i = 0; i < 100000; i++) {
       TestBean tb = (TestBean) ac.getBean("test");
       assertEquals("juergen", tb.getName());
       assertEquals("UK", tb.getCountry());
     }
     sw.stop();
   } finally {
     System.getProperties().remove("country");
     System.getProperties().remove("name");
   }
   assertTrue(
       "Prototype creation took too long: " + sw.getTotalTimeMillis(),
       sw.getTotalTimeMillis() < 6000);
 }
  /**
   * Will load additional settings from the web app config. Creates a map object that contains
   * workflow parameters to be provided as input to the runner
   *
   * @param form form definition of the workflow being run
   * @return a map of the settings
   */
  private static Map<String, String> settingsFromConfig(FormDefinition form) {
    try {
      Map<String, String> settings = new HashMap<String, String>();

      // Get the workspace basedir from application.conf
      String workspace = ConfigFactory.defaultApplication().getString("jython.workspace");

      // Load workflow yaml file to check parameters
      GenericApplicationContext springContext = new GenericApplicationContext();
      YamlBeanDefinitionReader yamlBeanReader = new YamlBeanDefinitionReader(springContext);
      yamlBeanReader.loadBeanDefinitions(loadYamlStream(form.yamlFile), "-");
      springContext.refresh();

      WorkflowConfig workflowConfig = springContext.getBean(WorkflowConfig.class);

      // Create a workspace
      Path path = Paths.get(workspace, "workspace_" + UUID.randomUUID());
      path.toFile().mkdir();

      // If the "workspace" parameter is present in the workflow set it to the path defined in the
      // config
      if (workflowConfig.getParameters().containsKey("workspace")) {
        settings.put("workspace", path.toString());
      }

      return settings;
    } catch (IOException e) {
      throw new RuntimeException("Error creating workspace directory.", e);
    } catch (Exception e) {
      throw new RuntimeException("Error reading yaml file for parameters.", e);
    }
  }
  @Test
  public void testIncrementing() {
    GenericApplicationContext context = new GenericApplicationContext();
    context.registerBeanDefinition(
        "bfpp", new RootBeanDefinition(DefaultConfiguringBeanFactoryPostProcessor.class));
    context.registerBeanDefinition(
        "foo", new RootBeanDefinition(SimpleIncrementingIdGenerator.class));
    context.refresh();
    IdGenerator idGenerator = context.getBean(IdGenerator.class);
    MessageHeaders headers = new MessageHeaders(null);
    assertEquals(0, headers.getId().getMostSignificantBits());
    assertEquals(1, headers.getId().getLeastSignificantBits());
    headers = new MessageHeaders(null);
    assertEquals(0, headers.getId().getMostSignificantBits());
    assertEquals(2, headers.getId().getLeastSignificantBits());
    AtomicLong bottomBits = TestUtils.getPropertyValue(idGenerator, "bottomBits", AtomicLong.class);
    bottomBits.set(0xffffffff);
    headers = new MessageHeaders(null);
    assertEquals(1, headers.getId().getMostSignificantBits());
    assertEquals(0, headers.getId().getLeastSignificantBits());
    headers = new MessageHeaders(null);
    assertEquals(1, headers.getId().getMostSignificantBits());
    assertEquals(1, headers.getId().getLeastSignificantBits());

    context.close();
  }
 @Test
 public void testBeanNameAttrToServiceBeanNameProperty() throws Exception {
   OsgiServiceProxyFactoryBean factory =
       (OsgiServiceProxyFactoryBean) appContext.getBean("&importerWithBeanName");
   Object obj = TestUtils.getFieldValue(factory, "serviceBeanName");
   assertEquals("bean-name attr hasn't been properly parsed", "someBean", obj);
 }
  public void testFilterExactAttribute() {

    try {
      GenericApplicationContext gContext =
          BaseDataConnectorTest.createSpringContext(RESOLVER_CONFIG);
      GroupDataConnector gdc = (GroupDataConnector) gContext.getBean("testFilterExactAttribute");

      Filter filter = gdc.getFilter();

      Set<Group> groups = filter.getResults(grouperSession);

      assertEquals(1, groups.size());

      assertTrue(groups.contains(groupA));
      assertFalse(groups.contains(groupB));
      assertFalse(groups.contains(groupC));

      assertTrue(filter.matches(groupA));
      assertFalse(filter.matches(groupB));
      assertFalse(filter.matches(groupC));
    } catch (Exception e) {
      e.printStackTrace();
      throw new RuntimeException(e);
    }
  }
  @Test
  public void testSimpleReference() throws Exception {
    Object factoryBean = appContext.getBean("&serializable");

    assertTrue(factoryBean instanceof OsgiServiceProxyFactoryBean);
    OsgiServiceProxyFactoryBean proxyFactory = (OsgiServiceProxyFactoryBean) factoryBean;

    Class<?>[] intfs = (Class[]) TestUtils.getFieldValue(proxyFactory, "interfaces");

    assertEquals(1, intfs.length);
    assertSame(Serializable.class, intfs[0]);

    // get the factory product
    Object bean = appContext.getBean("serializable");
    assertTrue(bean instanceof Serializable);
    assertTrue(Proxy.isProxyClass(bean.getClass()));
  }
  @Test
  public void testMultipleInterfaces() throws Exception {
    OsgiServiceProxyFactoryBean factory =
        (OsgiServiceProxyFactoryBean) appContext.getBean("&multi-interfaces");
    Class<?>[] intfs = (Class[]) TestUtils.getFieldValue(factory, "interfaces");
    assertNotNull(intfs);
    assertEquals(2, intfs.length);

    assertTrue(Arrays.equals(new Class<?>[] {Serializable.class, Externalizable.class}, intfs));
  }
 public void testGroupNotFound() {
   try {
     GenericApplicationContext gContext =
         BaseDataConnectorTest.createSpringContext(RESOLVER_CONFIG);
     GroupDataConnector gdc = (GroupDataConnector) gContext.getBean("testAttributesOnly");
     Map<String, BaseAttribute> map = gdc.resolve(getShibContext("notfound"));
     assertTrue(map.isEmpty());
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
 }
 @Test
 public void testDefaultInitAndDestroyMethodsDefined() {
   GenericApplicationContext context = new GenericApplicationContext();
   XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(context);
   reader.loadBeanDefinitions(LOCATION_PREFIX + "defaultInitAndDestroyMethodsTests.xml");
   context.refresh();
   DefaultsTestBean bean = (DefaultsTestBean) context.getBean(TEST_BEAN_NAME);
   assertTrue("bean should have been initialized", bean.isInitialized());
   context.close();
   assertTrue("bean should have been destroyed", bean.isDestroyed());
 }
 @Test
 public void testAutowireNo() {
   GenericApplicationContext context = new GenericApplicationContext();
   XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(context);
   reader.loadBeanDefinitions(LOCATION_PREFIX + "defaultAutowireNoTests.xml");
   context.refresh();
   DefaultsTestBean bean = (DefaultsTestBean) context.getBean(TEST_BEAN_NAME);
   assertNull("no dependencies should have been autowired", bean.getConstructorDependency());
   assertNull("no dependencies should have been autowired", bean.getPropertyDependency1());
   assertNull("no dependencies should have been autowired", bean.getPropertyDependency2());
 }
 @Test
 public void testLazyInitTrue() {
   GenericApplicationContext context = new GenericApplicationContext();
   XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(context);
   reader.loadBeanDefinitions(LOCATION_PREFIX + "defaultLazyInitTrueTests.xml");
   assertTrue("lazy-init should be true", context.getBeanDefinition(TEST_BEAN_NAME).isLazyInit());
   assertEquals("initCount should be 0", 0, DefaultsTestBean.INIT_COUNT);
   context.refresh();
   assertEquals("bean should not have been instantiated yet", 0, DefaultsTestBean.INIT_COUNT);
   context.getBean(TEST_BEAN_NAME);
   assertEquals("bean should have been instantiated", 1, DefaultsTestBean.INIT_COUNT);
 }
 /**
  * Assert that the attributes returned from the data connector match the provided attributes.
  *
  * @param dataConnectorName the data connector name
  * @param group the group
  * @param correctMap the correct attributes
  */
 private void runResolveTest(String dataConnectorName, Group group, AttributeMap correctMap) {
   try {
     GenericApplicationContext gContext =
         BaseDataConnectorTest.createSpringContext(RESOLVER_CONFIG);
     GroupDataConnector gdc = (GroupDataConnector) gContext.getBean(dataConnectorName);
     AttributeMap currentMap = new AttributeMap(gdc.resolve(getShibContext(group.getName())));
     LOG.debug("correctMap\n{}", correctMap);
     LOG.debug("currentMap\n{}", currentMap);
     assertEquals(correctMap, currentMap);
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
 }
	@Test
	public void testPostConstructAndPreDestroyWithApplicationContextAndPostProcessor() {
		GenericApplicationContext ctx = new GenericApplicationContext();
		ctx.registerBeanDefinition("bpp1", new RootBeanDefinition(InitDestroyBeanPostProcessor.class));
		ctx.registerBeanDefinition("bpp2", new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class));
		ctx.registerBeanDefinition("annotatedBean", new RootBeanDefinition(AnnotatedInitDestroyBean.class));
		ctx.refresh();

		AnnotatedInitDestroyBean bean = (AnnotatedInitDestroyBean) ctx.getBean("annotatedBean");
		assertTrue(bean.initCalled);
		ctx.close();
		assertTrue(bean.destroyCalled);
	}
  @Test
  public void testJdk() {
    GenericApplicationContext context = new GenericApplicationContext();
    context.registerBeanDefinition(
        "bfpp", new RootBeanDefinition(DefaultConfiguringBeanFactoryPostProcessor.class));
    context.registerBeanDefinition("foo", new RootBeanDefinition(JdkIdGenerator.class));
    context.refresh();
    MessageHeaders headers = new MessageHeaders(null);
    assertSame(
        context.getBean(IdGenerator.class), TestUtils.getPropertyValue(headers, "idGenerator"));

    context.close();
  }
Exemple #18
0
  /**
   * Create a parent context that initializes a {@link
   * org.apache.camel.spi.PackageScanClassResolver} to exclude a set of given classes from being
   * resolved. Typically this is used at test time to exclude certain routes, which might otherwise
   * be just noisy, from being discovered and initialized.
   *
   * <p>To use this filtering mechanism it is necessary to provide the {@link ApplicationContext}
   * returned from here as the parent context to your test context e.g.
   *
   * <pre>
   * protected AbstractXmlApplicationContext createApplicationContext() {
   *     return new ClassPathXmlApplicationContext(new String[] {&quot;test-context.xml&quot;}, getRouteExcludingApplicationContext());
   * }
   * </pre>
   *
   * This will, in turn, call the template methods <code>excludedRoutes</code> and <code>
   * excludedRoute</code> to determine the classes to be excluded from scanning.
   *
   * @return ApplicationContext a parent {@link ApplicationContext} configured to exclude certain
   *     classes from package scanning
   */
  protected ApplicationContext getRouteExcludingApplicationContext() {
    GenericApplicationContext routeExcludingContext = new GenericApplicationContext();
    routeExcludingContext.registerBeanDefinition(
        "excludingResolver", new RootBeanDefinition(ExcludingPackageScanClassResolver.class));
    routeExcludingContext.refresh();

    ExcludingPackageScanClassResolver excludingResolver =
        (ExcludingPackageScanClassResolver) routeExcludingContext.getBean("excludingResolver");
    List<Class<?>> excluded = CastUtils.cast(Arrays.asList(excludeRoutes()));
    excludingResolver.setExcludedClasses(new HashSet<Class<?>>(excluded));

    return routeExcludingContext;
  }
 @Test
 public void viaBeanRegistration() {
   DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
   bf.registerBeanDefinition(
       "componentScanAnnotatedConfig",
       genericBeanDefinition(ComponentScanAnnotatedConfig.class).getBeanDefinition());
   bf.registerBeanDefinition(
       "configurationClassPostProcessor",
       genericBeanDefinition(ConfigurationClassPostProcessor.class).getBeanDefinition());
   GenericApplicationContext ctx = new GenericApplicationContext(bf);
   ctx.refresh();
   ctx.getBean(ComponentScanAnnotatedConfig.class);
   ctx.getBean(TestBean.class);
   assertThat(
       "config class bean not found",
       ctx.containsBeanDefinition("componentScanAnnotatedConfig"),
       is(true));
   assertThat(
       "@ComponentScan annotated @Configuration class registered "
           + "as bean definition did not trigger component scanning as expected",
       ctx.containsBean("fooServiceImpl"),
       is(true));
 }
  public void testMatchFilterMinus() {
    try {
      GenericApplicationContext gContext =
          BaseDataConnectorTest.createSpringContext(RESOLVER_CONFIG);
      GroupDataConnector gdc = (GroupDataConnector) gContext.getBean("testFilterMinus");

      assertTrue(
          "map should not be empty", !gdc.resolve(getShibContext(groupA.getName())).isEmpty());
      assertTrue("map should be empty", gdc.resolve(getShibContext(groupB.getName())).isEmpty());
      assertTrue("map should be empty", gdc.resolve(getShibContext(groupC.getName())).isEmpty());
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  @Test
  public void stringConcatenationWithDebugLogging() {
    GenericApplicationContext ac = new GenericApplicationContext();
    AnnotationConfigUtils.registerAnnotationConfigProcessors(ac);

    GenericBeanDefinition bd = new GenericBeanDefinition();
    bd.setBeanClass(String.class);
    bd.getConstructorArgumentValues()
        .addGenericArgumentValue("test-#{ T(java.lang.System).currentTimeMillis() }");
    ac.registerBeanDefinition("str", bd);
    ac.refresh();

    String str = ac.getBean("str", String.class);
    assertTrue(str.startsWith("test-"));
  }
 @Test
 public void testAutowiredFieldWithSingleQualifiedCandidate() {
   GenericApplicationContext context = new GenericApplicationContext();
   ConstructorArgumentValues cavs = new ConstructorArgumentValues();
   cavs.addGenericArgumentValue(JUERGEN);
   RootBeanDefinition person = new RootBeanDefinition(Person.class, cavs, null);
   person.addQualifier(new AutowireCandidateQualifier(TestQualifier.class));
   context.registerBeanDefinition(JUERGEN, person);
   context.registerBeanDefinition(
       "autowired", new RootBeanDefinition(QualifiedFieldTestBean.class));
   AnnotationConfigUtils.registerAnnotationConfigProcessors(context);
   context.refresh();
   QualifiedFieldTestBean bean = (QualifiedFieldTestBean) context.getBean("autowired");
   assertEquals(JUERGEN, bean.getPerson().getName());
 }
 private PlaceholderTargetSource createValue(String name, String value) throws Exception {
   String input =
       IOUtils.toString(
           new ClassPathResource(getClass().getSimpleName() + "-context.xml", getClass())
               .getInputStream());
   input =
       input.replace(
           "<!-- INSERT -->", String.format("<property name=\"%s\" value=\"%s\" />", name, value));
   Resource resource = new ByteArrayResource(input.getBytes());
   GenericApplicationContext context = new GenericApplicationContext();
   new XmlBeanDefinitionReader(context).loadBeanDefinitions(resource);
   context.refresh();
   // XmlBeanFactory context = new XmlBeanFactory(resource);
   return (PlaceholderTargetSource) context.getBean("value");
 }
 @Test
 public void testAutowiredMethodParameterWithStaticallyQualifiedCandidate() {
   GenericApplicationContext context = new GenericApplicationContext();
   ConstructorArgumentValues cavs = new ConstructorArgumentValues();
   cavs.addGenericArgumentValue(JUERGEN);
   RootBeanDefinition person = new RootBeanDefinition(QualifiedPerson.class, cavs, null);
   context.registerBeanDefinition(
       JUERGEN,
       ScopedProxyUtils.createScopedProxy(new BeanDefinitionHolder(person, JUERGEN), context, true)
           .getBeanDefinition());
   context.registerBeanDefinition(
       "autowired", new RootBeanDefinition(QualifiedMethodParameterTestBean.class));
   AnnotationConfigUtils.registerAnnotationConfigProcessors(context);
   context.refresh();
   QualifiedMethodParameterTestBean bean =
       (QualifiedMethodParameterTestBean) context.getBean("autowired");
   assertEquals(JUERGEN, bean.getPerson().getName());
 }
 @Test
 public void testAutowiredMethodParameterWithStaticallyQualifiedCandidateAmongOthers() {
   GenericApplicationContext context = new GenericApplicationContext();
   ConstructorArgumentValues cavs = new ConstructorArgumentValues();
   cavs.addGenericArgumentValue(JUERGEN);
   RootBeanDefinition person = new RootBeanDefinition(QualifiedPerson.class, cavs, null);
   ConstructorArgumentValues cavs2 = new ConstructorArgumentValues();
   cavs2.addGenericArgumentValue(MARK);
   RootBeanDefinition person2 = new RootBeanDefinition(Person.class, cavs2, null);
   context.registerBeanDefinition(JUERGEN, person);
   context.registerBeanDefinition(MARK, person2);
   context.registerBeanDefinition(
       "autowired", new RootBeanDefinition(QualifiedMethodParameterTestBean.class));
   AnnotationConfigUtils.registerAnnotationConfigProcessors(context);
   context.refresh();
   QualifiedMethodParameterTestBean bean =
       (QualifiedMethodParameterTestBean) context.getBean("autowired");
   assertEquals(JUERGEN, bean.getPerson().getName());
 }
  @Test
  public void testFullReference() throws Exception {
    OsgiServiceProxyFactoryBean factory =
        (OsgiServiceProxyFactoryBean) appContext.getBean("&full-options");
    factory.getObject(); // required to initialise proxy and hook
    // listeners into the binding process

    OsgiServiceLifecycleListener[] listeners =
        (OsgiServiceLifecycleListener[]) TestUtils.getFieldValue(factory, "listeners");
    assertNotNull(listeners);
    assertEquals(5, listeners.length);

    assertEquals(
        "already registered service should have been discovered", 4, DummyListener.BIND_CALLS);
    assertEquals(0, DummyListener.UNBIND_CALLS);

    listeners[1].bind(null, null);

    assertEquals(6, DummyListener.BIND_CALLS);

    listeners[1].unbind(null, null);
    assertEquals(2, DummyListener.UNBIND_CALLS);

    assertEquals(1, DummyListenerServiceSignature.BIND_CALLS);
    listeners[4].bind(null, null);
    assertEquals(2, DummyListenerServiceSignature.BIND_CALLS);

    assertEquals(0, DummyListenerServiceSignature.UNBIND_CALLS);
    listeners[4].unbind(null, null);
    assertEquals(1, DummyListenerServiceSignature.UNBIND_CALLS);

    assertEquals(1, DummyListenerServiceSignature2.BIND_CALLS);
    listeners[3].bind(null, null);
    assertEquals(2, DummyListenerServiceSignature2.BIND_CALLS);

    assertEquals(0, DummyListenerServiceSignature2.UNBIND_CALLS);
    listeners[3].unbind(null, null);
    assertEquals(1, DummyListenerServiceSignature2.UNBIND_CALLS);
  }
 @Test
 public void testAutowiredFieldResolvesWithDefaultValueAndExplicitDefaultValueOnBeanDefinition() {
   GenericApplicationContext context = new GenericApplicationContext();
   ConstructorArgumentValues cavs1 = new ConstructorArgumentValues();
   cavs1.addGenericArgumentValue(JUERGEN);
   RootBeanDefinition person1 = new RootBeanDefinition(Person.class, cavs1, null);
   // qualifier added, and value matches the default
   person1.addQualifier(
       new AutowireCandidateQualifier(TestQualifierWithDefaultValue.class, "default"));
   ConstructorArgumentValues cavs2 = new ConstructorArgumentValues();
   cavs2.addGenericArgumentValue(MARK);
   RootBeanDefinition person2 = new RootBeanDefinition(Person.class, cavs2, null);
   context.registerBeanDefinition(JUERGEN, person1);
   context.registerBeanDefinition(MARK, person2);
   context.registerBeanDefinition(
       "autowired", new RootBeanDefinition(QualifiedFieldWithDefaultValueTestBean.class));
   AnnotationConfigUtils.registerAnnotationConfigProcessors(context);
   context.refresh();
   QualifiedFieldWithDefaultValueTestBean bean =
       (QualifiedFieldWithDefaultValueTestBean) context.getBean("autowired");
   assertEquals(JUERGEN, bean.getPerson().getName());
 }
  private static DataServiceManager getDataServiceManager(GenericApplicationContext ctx) {

    DataServiceManager mgr = null;

    try {
      String[] beanNames = ctx.getBeanNamesForType(DataServiceManager.class, true, false);
      if (beanNames == null || 1 != beanNames.length) {
        throw new WMRuntimeException(
            com.wavemaker.common.MessageResource.NO_DATA_SERVICE_MGR_BEAN_FOUND,
            Arrays.toString(beanNames));
      }

      mgr = (DataServiceManager) ctx.getBean(beanNames[0]);
    } catch (RuntimeException ex) {
      try {
        ctx.close();
      } catch (Exception ignore) {
      }
      throw ex;
    }

    return new SpringDataServiceManagerWrapper(mgr, ctx);
  }
  @Test
  public void systemPropertiesSecurityManager() {
    GenericApplicationContext ac = new GenericApplicationContext();
    AnnotationConfigUtils.registerAnnotationConfigProcessors(ac);

    GenericBeanDefinition bd = new GenericBeanDefinition();
    bd.setBeanClass(TestBean.class);
    bd.getPropertyValues().add("country", "#{systemProperties.country}");
    ac.registerBeanDefinition("tb", bd);

    SecurityManager oldSecurityManager = System.getSecurityManager();
    try {
      System.setProperty("country", "NL");

      SecurityManager securityManager =
          new SecurityManager() {
            @Override
            public void checkPropertiesAccess() {
              throw new AccessControlException("Not Allowed");
            }

            @Override
            public void checkPermission(Permission perm) {
              // allow everything else
            }
          };
      System.setSecurityManager(securityManager);
      ac.refresh();

      TestBean tb = ac.getBean("tb", TestBean.class);
      assertEquals("NL", tb.getCountry());

    } finally {
      System.setSecurityManager(oldSecurityManager);
      System.getProperties().remove("country");
    }
  }
  private void doTestJaxWsPortAccess(Object... features) throws Exception {
    GenericApplicationContext ac = new GenericApplicationContext();

    GenericBeanDefinition serviceDef = new GenericBeanDefinition();
    serviceDef.setBeanClass(OrderServiceImpl.class);
    ac.registerBeanDefinition("service", serviceDef);

    GenericBeanDefinition exporterDef = new GenericBeanDefinition();
    exporterDef.setBeanClass(SimpleJaxWsServiceExporter.class);
    exporterDef.getPropertyValues().add("baseAddress", "http://localhost:9999/");
    ac.registerBeanDefinition("exporter", exporterDef);

    GenericBeanDefinition clientDef = new GenericBeanDefinition();
    clientDef.setBeanClass(JaxWsPortProxyFactoryBean.class);
    clientDef.getPropertyValues().add("wsdlDocumentUrl", "http://localhost:9999/OrderService?wsdl");
    clientDef.getPropertyValues().add("namespaceUri", "http://jaxws.remoting.springframework.org/");
    clientDef.getPropertyValues().add("username", "juergen");
    clientDef.getPropertyValues().add("password", "hoeller");
    clientDef.getPropertyValues().add("serviceName", "OrderService");
    clientDef.getPropertyValues().add("serviceInterface", OrderService.class);
    clientDef.getPropertyValues().add("lookupServiceOnStartup", Boolean.FALSE);
    if (features != null) {
      clientDef.getPropertyValues().add("webServiceFeatures", features);
    }
    ac.registerBeanDefinition("client", clientDef);

    GenericBeanDefinition serviceFactoryDef = new GenericBeanDefinition();
    serviceFactoryDef.setBeanClass(LocalJaxWsServiceFactoryBean.class);
    serviceFactoryDef
        .getPropertyValues()
        .add("wsdlDocumentUrl", "http://localhost:9999/OrderService?wsdl");
    serviceFactoryDef
        .getPropertyValues()
        .add("namespaceUri", "http://jaxws.remoting.springframework.org/");
    serviceFactoryDef.getPropertyValues().add("serviceName", "OrderService");
    ac.registerBeanDefinition("orderService", serviceFactoryDef);

    ac.registerBeanDefinition("accessor", new RootBeanDefinition(ServiceAccessor.class));
    AnnotationConfigUtils.registerAnnotationConfigProcessors(ac);

    try {
      ac.refresh();

      OrderService orderService = ac.getBean("client", OrderService.class);
      assertTrue(orderService instanceof BindingProvider);
      ((BindingProvider) orderService).getRequestContext();

      String order = orderService.getOrder(1000);
      assertEquals("order 1000", order);
      try {
        orderService.getOrder(0);
        fail("Should have thrown OrderNotFoundException");
      } catch (OrderNotFoundException ex) {
        // expected
      }

      ServiceAccessor serviceAccessor = ac.getBean("accessor", ServiceAccessor.class);
      order = serviceAccessor.orderService.getOrder(1000);
      assertEquals("order 1000", order);
      try {
        serviceAccessor.orderService.getOrder(0);
        fail("Should have thrown OrderNotFoundException");
      } catch (OrderNotFoundException ex) {
        // expected
      }
    } catch (BeanCreationException ex) {
      if ("exporter".equals(ex.getBeanName())
          && ex.getRootCause() instanceof ClassNotFoundException) {
        // ignore - probably running on JDK < 1.6 without the JAX-WS impl present
      } else {
        throw ex;
      }
    } finally {
      ac.close();
    }
  }