Index: src/test/java/org/jboss/test/metadata/ejb/JBoss60EverythingUnitTestCase.java =================================================================== --- src/test/java/org/jboss/test/metadata/ejb/JBoss60EverythingUnitTestCase.java (revision 0) +++ src/test/java/org/jboss/test/metadata/ejb/JBoss60EverythingUnitTestCase.java (revision 0) @@ -0,0 +1,1353 @@ +/* +* JBoss, Home of Professional Open Source +* Copyright 2010, JBoss Inc., and individual contributors as indicated +* by the @authors tag. See the copyright.txt in the distribution for a +* full listing of individual contributors. +* +* This is free software; you can redistribute it and/or modify it +* under the terms of the GNU Lesser General Public License as +* published by the Free Software Foundation; either version 2.1 of +* the License, or (at your option) any later version. +* +* This software is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this software; if not, write to the Free +* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA +* 02110-1301 USA, or see the FSF site: http://www.fsf.org. +*/ +package org.jboss.test.metadata.ejb; + +import junit.framework.Test; +import org.jboss.metadata.common.jboss.LoaderRepositoryConfigMetaData; +import org.jboss.metadata.common.jboss.LoaderRepositoryMetaData; +import org.jboss.metadata.common.jboss.WebserviceDescriptionMetaData; +import org.jboss.metadata.common.jboss.WebserviceDescriptionsMetaData; +import org.jboss.metadata.ejb.jboss.CacheConfigMetaData; +import org.jboss.metadata.ejb.jboss.ClusterConfigMetaData; +import org.jboss.metadata.ejb.jboss.CommitOption; +import org.jboss.metadata.ejb.jboss.ContainerConfigurationMetaData; +import org.jboss.metadata.ejb.jboss.ContainerConfigurationsMetaData; +import org.jboss.metadata.ejb.jboss.InvokerBindingMetaData; +import org.jboss.metadata.ejb.jboss.InvokerBindingMetaData.EjbRef; +import org.jboss.metadata.ejb.jboss.InvokerBindingsMetaData; +import org.jboss.metadata.ejb.jboss.InvokerProxyBindingMetaData; +import org.jboss.metadata.ejb.jboss.InvokerProxyBindingsMetaData; +import org.jboss.metadata.ejb.jboss.JBoss60DTDMetaData; +import org.jboss.metadata.ejb.jboss.JBoss60MetaData; +import org.jboss.metadata.ejb.jboss.JBossAssemblyDescriptorMetaData; +import org.jboss.metadata.ejb.jboss.JBossEnterpriseBeanMetaData; +import org.jboss.metadata.ejb.jboss.JBossEnterpriseBeansMetaData; +import org.jboss.metadata.ejb.jboss.JBossEntityBeanMetaData; +import org.jboss.metadata.ejb.jboss.JBossMessageDrivenBeanMetaData; +import org.jboss.metadata.ejb.jboss.JBossMetaData; +import org.jboss.metadata.ejb.jboss.JBossMetaDataWrapper; +import org.jboss.metadata.ejb.jboss.JBossSessionBeanMetaData; +import org.jboss.metadata.ejb.jboss.PoolConfigMetaData; +import org.jboss.metadata.ejb.jboss.ResourceManagerMetaData; +import org.jboss.metadata.ejb.jboss.ResourceManagersMetaData; +import org.jboss.metadata.ejb.jboss.WebservicesMetaData; +import org.jboss.metadata.ejb.spec.SecurityIdentityMetaData; +import org.jboss.metadata.javaee.spec.MessageDestinationMetaData; +import org.jboss.metadata.javaee.spec.ResourceInjectionMetaData; +import org.jboss.metadata.javaee.spec.SecurityRoleMetaData; +import org.w3c.dom.Element; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; + +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + + +/** + * JBoss60EverythingUnitTestCase. + * + */ +public class JBoss60EverythingUnitTestCase extends AbstractEJBEverythingTest +{ + /** Is there a standardjboss.xml default available */ + private boolean hasStandardJBoss = false; + + public static Test suite() + { + return suite(JBoss60EverythingUnitTestCase.class); + } + + static Element getElement(String name, Element parent) + { + NodeList elements = parent.getElementsByTagName(name); + Element element = (Element) elements.item(0); + return element; + } + + static String getElementText(String name, Element parent) + { + Element element = getElement(name, parent); + NodeList children = element.getChildNodes(); + String result = ""; + for (int i = 0; i < children.getLength(); i++) + { + if (children.item(i).getNodeType() == Node.TEXT_NODE || children.item(i).getNodeType() == Node.CDATA_SECTION_NODE) + { + result += children.item(i).getNodeValue(); + } + else if (children.item(i).getNodeType() == Node.COMMENT_NODE) + { + // Ignore comment nodes + } + else + { + result += children.item(i).getFirstChild(); + } + } + return result.trim(); + } + + public JBoss60EverythingUnitTestCase(String name) + { + super(name); + } + + protected JBoss60DTDMetaData unmarshal() throws Exception + { + return unmarshal(JBoss60DTDMetaData.class); + } + + public void testEverything() throws Exception + { + JBoss60MetaData jbossMetaData = unmarshal(JBoss60MetaData.class); + hasStandardJBoss = false; + assertEverything(jbossMetaData, Mode.JBOSS); + } + + public void testEverythingDTD() throws Exception + { + //enableTrace("org.jboss.xb"); + //enableTrace("org.jboss.xb.builder"); + JBoss60DTDMetaData jbossMetaData = unmarshal(); + hasStandardJBoss = false; + assertEverything(jbossMetaData, Mode.JBOSS_DTD); + } + + public void testStandard() throws Exception + { + //enableTrace("org.jboss.xb"); + //enableTrace("org.jboss.xb.builder"); + JBoss60DTDMetaData stdMetaData = unmarshal(); + JBoss60DTDMetaData jbossMetaData = unmarshal("JBoss60Everything_testEverythingDTD.xml", JBoss60DTDMetaData.class, null); + JBossMetaDataWrapper wrapper = new JBossMetaDataWrapper(jbossMetaData, stdMetaData); + hasStandardJBoss = true; + assertEverything(wrapper, Mode.JBOSS_DTD); + } + + /** + * + * @throws Exception + */ + public void testOverride() throws Exception + { + JBoss60DTDMetaData overrideData = unmarshal(); + JBoss60DTDMetaData baseData = unmarshal("JBoss60xEverything_testBaseData.xml", JBoss60DTDMetaData.class, null); + // Override JBoss60Everything_testBaseData.xml with JBoss60Everything_testOverride.xml + JBossMetaDataWrapper jbossMetaData = new JBossMetaDataWrapper(overrideData, baseData); + + // jmx-name + assertEquals("jboss-jmx-name-override", jbossMetaData.getJmxName()); + // security-domain + assertEquals("jboss-security-domain-override", jbossMetaData.getSecurityDomain()); + // missing-method-permissions-excluded-mode + assertTrue(jbossMetaData.isExcludeMissingMethods()); + // unauthenticated-principal + assertEquals("jboss-unauthenticated-principal-override", jbossMetaData.getUnauthenticatedPrincipal()); + // exception-on-rollback + assertFalse(jbossMetaData.isExceptionOnRollback()); + // loader-repository + LoaderRepositoryMetaData lrmd = jbossMetaData.getLoaderRepository(); + //assertEquals("loaderRepository-id-override", lrmd.getId()); + assertEquals("loaderRepositoryClass-override", lrmd.getLoaderRepositoryClass()); + assertEquals("loaderRepositoryName-override", lrmd.getName()); + Set lrmdConfigs = lrmd.getLoaderRepositoryConfig(); + assertEquals(1, lrmdConfigs.size()); + LoaderRepositoryConfigMetaData lrmdConfig = lrmdConfigs.iterator().next(); + //assertEquals("loaderRepositoryConfig1-id", lrmdConfig.getId()); + assertEquals("loaderRepositoryConfig1-override", lrmdConfig.getConfig()); + assertEquals("loaderRepositoryConfigParserClass1-override", lrmdConfig.getConfigParserClass()); + // webservices + // enterprise-beans + // assembly-descriptor + // resource-managers + // invoker-proxy-bindings + InvokerProxyBindingMetaData ipbmd1 = jbossMetaData.getInvokerProxyBinding("invokerProxyBinding1Name"); + assertNotNull(ipbmd1); + //assertEquals("invokerProxyBinding1-id", ipbmd1.getId()); + assertEquals("invokerProxyBinding1InvokerMBean", ipbmd1.getInvokerMBean()); + assertEquals("invokerProxyBinding1Name", ipbmd1.getInvokerProxyBindingName()); + assertEquals("invokerProxyBinding1ProxyFactory", ipbmd1.getProxyFactory()); + InvokerProxyBindingMetaData ipbmd1Override = jbossMetaData.getInvokerProxyBinding("invokerProxyBinding1Name-override"); + assertNotNull(ipbmd1Override); + //assertEquals("invokerProxyBinding1-id-override", ipbmd1Override.getId()); + assertEquals("invokerProxyBinding1InvokerMBean-override", ipbmd1Override.getInvokerMBean()); + assertEquals("invokerProxyBinding1Name-override", ipbmd1Override.getInvokerProxyBindingName()); + assertEquals("invokerProxyBinding1ProxyFactory-override", ipbmd1Override.getProxyFactory()); + // container-configurations + ContainerConfigurationMetaData sssb = jbossMetaData.getContainerConfiguration("Standard Stateless SessionBean"); + assertEquals(null, sssb.getExtendsName()); + assertEquals("containerConfiguration1InstanceCache-override", sssb.getInstanceCache()); + Set invokerNames = sssb.getInvokerProxyBindingNames(); + HashSet expectedInvokerNames = new HashSet(); + expectedInvokerNames.add("containerConfiguration1InvokerProxyBindingName1-override"); + expectedInvokerNames.add("containerConfiguration1InvokerProxyBindingName2-override"); + assertEquals(expectedInvokerNames, invokerNames); + ContainerConfigurationMetaData session2Configuration = jbossMetaData.getContainerConfiguration("session2ConfigurationName"); + assertNotNull(session2Configuration); + assertEquals("Standard Stateless SessionBean", session2Configuration.getExtendsName()); + invokerNames = session2Configuration.getInvokerProxyBindingNames(); + expectedInvokerNames.clear(); + expectedInvokerNames.add("containerConfiguration1InvokerProxyBindingName1-override1"); + expectedInvokerNames.add("containerConfiguration1InvokerProxyBindingName2-override1"); + assertEquals(expectedInvokerNames, invokerNames); + + ContainerConfigurationMetaData containerConfiguration1 = jbossMetaData.getContainerConfiguration("containerConfiguration1Name-override"); + assertNotNull(containerConfiguration1); + // Should be from the containerConfiguration1 + assertEquals("containerConfiguration1InstancePool", containerConfiguration1.getInstancePool()); + ClusterConfigMetaData ccmd = containerConfiguration1.getClusterConfig(); + assertNotNull(ccmd); + assertEquals("containerConfiguration1ClusterConfigBeanLoadBalancePolicy", ccmd.getBeanLoadBalancePolicy()); + assertEquals("containerConfiguration1ClusterConfigHomeLoadBalancePolicy", ccmd.getHomeLoadBalancePolicy()); + assertEquals("containerConfiguration1ClusterConfigPartitionName", ccmd.getPartitionName()); + assertEquals("containerConfiguration1ClusterConfigSessionStateManagerJndiName", ccmd.getSessionStateManagerJndiName()); + // Should be overriden + invokerNames = containerConfiguration1.getInvokerProxyBindingNames(); + expectedInvokerNames.clear(); + expectedInvokerNames.add("containerConfiguration1InvokerProxyBindingName1-override"); + expectedInvokerNames.add("containerConfiguration1InvokerProxyBindingName2-override"); + assertEquals(expectedInvokerNames, invokerNames); + } + + public void testClusterConfigOverride() throws Exception + { + JBoss60DTDMetaData overrideData = unmarshal(); + JBoss60DTDMetaData baseData = unmarshal("JBoss60Everything_testClusterConfigBase.xml", JBoss60DTDMetaData.class, null); + // Override JBoss60Everything_testBaseData.xml with JBoss60Everything_testOverride.xml + JBossMetaDataWrapper jbossMetaData = new JBossMetaDataWrapper(overrideData, baseData); + + JBossEnterpriseBeansMetaData enterpriseBeansMetaData = jbossMetaData.getEnterpriseBeans(); + assertNotNull(enterpriseBeansMetaData); + assertEquals(4, enterpriseBeansMetaData.size()); + + String beanId = "bean1"; + JBossSessionBeanMetaData session = assertJBossSessionBean(beanId, jbossMetaData); + ClusterConfigMetaData config = session.determineClusterConfig(); + + assertPartitionName(config, "bean"); + assertHomeLoadBalancePolicy(config, "container"); + assertBeanLoadBalancePolicy(config, "standard"); + assertSessionStateManagerJndiName(config, null); + + beanId = "bean2"; + session = assertJBossSessionBean(beanId, jbossMetaData); + config = session.determineClusterConfig(); + assertPartitionName(config, "container"); + assertHomeLoadBalancePolicy(config, "standard"); + assertBeanLoadBalancePolicy(config, null); + assertSessionStateManagerJndiName(config, "bean"); + + beanId = "bean3"; + session = assertJBossSessionBean(beanId, jbossMetaData); + config = session.determineClusterConfig(); + assertPartitionName(config, "standard"); + assertHomeLoadBalancePolicy(config, null); + assertBeanLoadBalancePolicy(config, "bean"); + assertSessionStateManagerJndiName(config, "container"); + + beanId = "bean4"; + session = assertJBossSessionBean(beanId, jbossMetaData); + config = session.determineClusterConfig(); + assertPartitionName(config, null); + assertHomeLoadBalancePolicy(config, "bean"); + assertBeanLoadBalancePolicy(config, "container"); + assertSessionStateManagerJndiName(config, "standard"); + } + + public void testCreateDestination() throws Exception + { + JBossMetaData metaData = unmarshal(JBoss60MetaData.class); + JBossMessageDrivenBeanMetaData mdb = (JBossMessageDrivenBeanMetaData) metaData.getEnterpriseBean("MessageDriven"); + assertTrue(mdb.isCreateDestination()); + } + + public void assertCacheConfig(String prefix, int num, CacheConfigMetaData cacheConfig) + { + assertNotNull(prefix, cacheConfig); + assertEquals(prefix + "CacheClass", cacheConfig.getValue()); + assertEquals(10 * num, (int) cacheConfig.getMaxSize()); + assertEquals(11 * num, (int) cacheConfig.getIdleTimeoutSeconds()); + assertEquals(12 * num, (int) cacheConfig.getRemoveTimeoutSeconds()); + assertEquals(prefix + "CacheName", cacheConfig.getName()); + assertEquals(prefix + "PersistenceManager", cacheConfig.getPersistenceManager()); + } + + public void assertEverything(JBossMetaData jbossMetaData, Mode mode) + { + assertVersion(jbossMetaData); + if(mode != Mode.JBOSS_DTD) + { + assertId("jboss", jbossMetaData); + assertDescriptionGroup("jboss", jbossMetaData.getDescriptionGroup()); + } + assertLoaderRepository(jbossMetaData.getLoaderRepository(), mode); + assertEquals("jboss-jmx-name", jbossMetaData.getJmxName()); + assertEquals("jboss-security-domain", jbossMetaData.getSecurityDomain()); + assertFalse(jbossMetaData.isExcludeMissingMethods()); + assertEquals("jboss-unauthenticated-principal", jbossMetaData.getUnauthenticatedPrincipal()); + assertTrue(jbossMetaData.isExceptionOnRollback()); + assertWebservices(jbossMetaData.getWebservices(), mode); + assertJBossEnterpriseBeans(jbossMetaData, mode); + assertAssemblyDescriptor(jbossMetaData, mode); + assertResourceManagers(jbossMetaData.getResourceManagers(), mode); + assertResourceManager("resourceManager1", true, jbossMetaData.getResourceManager("resourceManager1Name"), mode); + assertResourceManager("resourceManager2", false, jbossMetaData.getResourceManager("resourceManager2Name"), mode); + if(mode == Mode.JBOSS_DTD) + { + if(hasStandardJBoss == false) + assertInvokerProxyBindings(jbossMetaData.getInvokerProxyBindings(), mode); + assertInvokerProxyBinding("invokerProxyBinding1", 1, jbossMetaData.getInvokerProxyBinding("invokerProxyBinding1Name"), mode); + assertInvokerProxyBinding("invokerProxyBinding2", 2, jbossMetaData.getInvokerProxyBinding("invokerProxyBinding2Name"), mode); + assertContainerConfigurations(jbossMetaData, mode); + } + } + + private void assertVersion(JBossMetaData jbossMetaData) + { + assertEquals("6.0", jbossMetaData.getVersion()); + } + + private void assertLoaderRepository(LoaderRepositoryMetaData loaderRepositoryMetaData, Mode mode) + { + assertNotNull(loaderRepositoryMetaData); + if(mode != Mode.JBOSS_DTD) + assertId("loaderRepository", loaderRepositoryMetaData); + assertEquals("loaderRepositoryClass", loaderRepositoryMetaData.getLoaderRepositoryClass()); + assertEquals("loaderRepositoryName", trim(loaderRepositoryMetaData.getName())); + assertLoaderRepositoryConfig(2, loaderRepositoryMetaData, mode); + } + + private void assertLoaderRepositoryConfig(int size, LoaderRepositoryMetaData loaderRepositoryMetaData, Mode mode) + { + Set configs = loaderRepositoryMetaData.getLoaderRepositoryConfig(); + assertNotNull(configs); + assertEquals(size, configs.size()); + for (int count = 1; count < configs.size(); ++count) + { + LoaderRepositoryConfigMetaData config = new LoaderRepositoryConfigMetaData(); + if(mode != Mode.JBOSS_DTD) + config.setId("loaderRepositoryConfig" + count + "-id"); + config.setConfig("loaderRepositoryConfig" + count); + config.setConfigParserClass("loaderRepositoryConfigParserClass" + count); + assertTrue(configs + " contains " + config, configs.contains(config)); +// assertId("loaderRepositoryConfig" + count, config); +// assertEquals("loaderRepositoryConfigParserClass" + count, config.getConfigParserClass()); +// assertEquals("loaderRepositoryConfig" + count, trim(config.getConfig())); + } + } + + public void assertWebservices(WebservicesMetaData webservices, Mode mode) + { + assertNotNull(webservices); + if(mode != Mode.JBOSS_DTD) + assertId("webservices", webservices); + assertEquals("webservicesContextRoot", webservices.getContextRoot()); + WebserviceDescriptionsMetaData webserviceDescriptionsMetaData = webservices.getWebserviceDescriptions(); + assertNotNull(webserviceDescriptionsMetaData); + assertEquals(2, webserviceDescriptionsMetaData.size()); + int count = 1; + for (WebserviceDescriptionMetaData description : webserviceDescriptionsMetaData) + { + if(mode != Mode.JBOSS_DTD) + assertId("webserviceDescription" + count, description); + assertEquals("webserviceDescription" + count + "ConfigName", description.getConfigName()); + assertEquals("webserviceDescription" + count + "ConfigFile", description.getConfigFile()); + assertEquals("webserviceDescription" + count + "WsdlPublishLocation", description.getWsdlPublishLocation()); + ++count; + } + } + +/* private void assertWebservices(ApplicationMetaData application) + { + assertEquals("webservicesContextRoot", application.getWebServiceContextRoot()); + assertEquals("webserviceDescription2ConfigName", application.getConfigName()); + assertEquals("webserviceDescription2ConfigFile", application.getConfigFile()); + Map result = application.getWsdlPublishLocations(); + Map expected = new HashMap(); + expected.put("webserviceDescription1Name", "webserviceDescription1WsdlPublishLocation"); + expected.put("webserviceDescription2Name", "webserviceDescription2WsdlPublishLocation"); + assertEquals(expected, result); + assertEquals("webserviceDescription1WsdlPublishLocation", application.getWsdlPublishLocationByName("webserviceDescription1Name")); + assertEquals("webserviceDescription2WsdlPublishLocation", application.getWsdlPublishLocationByName("webserviceDescription2Name")); + } +*/ + private String trim(String string) + { + assertNotNull(string); + return string.trim(); + } + + private void assertJBossEnterpriseBeans(JBossMetaData jbossMetaData, Mode mode) + { + JBossEnterpriseBeansMetaData enterpriseBeansMetaData = jbossMetaData.getEnterpriseBeans(); + assertNotNull(enterpriseBeansMetaData); + // no entities in jboss_6_0.xsd + int beansTotal = mode == Mode.JBOSS ? 6 : 9; + assertEquals(beansTotal, enterpriseBeansMetaData.size()); + + assertNullSessionBean("session0", jbossMetaData); + assertFullSessionBean("session1", jbossMetaData, true, mode, 1); + assertFullSessionBean("session2", jbossMetaData, false, mode, 2); + + if(mode != Mode.JBOSS) + { + assertNullEntityBean("entity0", jbossMetaData); + assertFullEntityBean("entity1", jbossMetaData, true, mode); + assertFullEntityBean("entity2", jbossMetaData, false, mode); + } + + assertNullMessageDrivenBean("mdb0", jbossMetaData); + assertFullMessageDrivenBean("mdb1", jbossMetaData, true, mode); + assertFullMessageDrivenBean("mdb2", jbossMetaData, false, mode); + } + + private T assertJBossEnterpriseBean(String prefix, JBossMetaData jBossMetaData, Class expected) + { + JBossEnterpriseBeanMetaData ejb = jBossMetaData.getEnterpriseBean(prefix + "EjbName"); + assertNotNull(ejb); + assertEquals(prefix + "EjbName", ejb.getEjbName()); + assertTrue(expected.isInstance(ejb)); + return expected.cast(ejb); + } + +/* private T assertBeanMetaData(String prefix, ApplicationMetaData application, Class expected) + { + BeanMetaData ejb = application.getBeanByEjbName(prefix + "EjbName"); + assertNotNull(ejb); + assertEquals(prefix + "EjbName", ejb.getEjbName()); + assertTrue(expected.isInstance(ejb)); + return expected.cast(ejb); + } +*/ + private JBossSessionBeanMetaData assertJBossSessionBean(String prefix, JBossMetaData jbossMetaData) + { + JBossSessionBeanMetaData ejb = assertJBossEnterpriseBean(prefix, jbossMetaData, JBossSessionBeanMetaData.class); + assertTrue(ejb.isSession()); + assertFalse(ejb.isEntity()); + assertFalse(ejb.isMessageDriven()); + return ejb; + } + +/* private SessionMetaData assertJBossSessionBean(String prefix, ApplicationMetaData application) + { + SessionMetaData ejb = assertBeanMetaData(prefix, application, SessionMetaData.class); + assertTrue(ejb.isSession()); + assertFalse(ejb.isEntity()); + assertFalse(ejb.isMessageDriven()); + return ejb; + } +*/ + private void assertFullSessionBean(String prefix, JBossMetaData jbossMetaData, boolean first, Mode mode, int num) + { + JBossSessionBeanMetaData session = assertJBossSessionBean(prefix, jbossMetaData); + assertId(prefix, session); + if(mode != Mode.JBOSS_DTD) + { + assertDescriptionGroup(prefix, session.getDescriptionGroup()); + assertRemoteBindings(prefix, session.getRemoteBindings()); + assertEquals(prefix + "LocalHomeJndiName", session.getLocalHomeJndiName()); + assertEquals(prefix + "SecurityDomain", session.getSecurityDomain()); // TODO!!! this should be in the DTD as well + + assertAnnotations(prefix, 2, session.getAnnotations()); + assertIgnoreDependency(prefix, session.getIgnoreDependency()); + assertEquals(prefix + "AOPDomain", session.getAopDomainName()); + assertCacheConfig(prefix, num, session.getCacheConfig()); + assertPoolConfig(prefix, session.getPoolConfig()); + assertJndiRefs(prefix, 2, session.getJndiRefs(), mode); + + if (first) + assertTrue(session.isConcurrent()); + else + assertFalse(session.isConcurrent()); + } + + assertEquals(prefix + "JndiName", session.getJndiName()); + assertEquals(prefix + "HomeJndiName", session.getHomeJndiName()); + assertEquals(prefix + "LocalJndiName", session.getLocalJndiName()); + assertEquals(prefix + "ConfigurationName", session.getConfigurationName()); + assertEquals(prefix + "SecurityProxy", session.getSecurityProxy()); + + if (first) + { + assertTrue(session.isCallByValue()); + assertTrue(session.isExceptionOnRollback()); + assertTrue(session.isTimerPersistence()); + assertTrue(session.isClustered()); + } + else + { + assertFalse(session.isCallByValue()); + assertFalse(session.isExceptionOnRollback()); + assertFalse(session.isTimerPersistence()); + assertFalse(session.isClustered()); + } + + assertInvokerBindings(prefix, session.getInvokerBindings(), mode); + + assertEnvironment(prefix, session.getJndiEnvironmentRefsGroup(), false, mode); + + assertSecurityIdentity(prefix, "SecurityIdentity", session.getSecurityIdentity(), false, mode); + + ClusterConfigMetaData clusterConfig = null; + if(mode == Mode.JBOSS) + clusterConfig = session.getClusterConfig(); + else + clusterConfig = session.determineClusterConfig(); + assertClusterConfig(prefix, clusterConfig, true, mode); + + assertMethodAttributes(prefix, session.getMethodAttributes(), mode); + + assertDepends(prefix, 2, session.getDepends()); + + assertIORSecurityConfig(prefix, session.getIorSecurityConfig(), mode); + + assertPortComponent(prefix, session.getPortComponent(), mode); + + assertSecurityIdentity(prefix, "EjbTimeoutIdentity", session.getEjbTimeoutIdentity(), false, mode); + + if (this.hasStandardJBoss) + { + ContainerConfigurationMetaData ccmd = session.determineContainerConfiguration(); + this.assertContainerPoolConf(prefix, ccmd.getContainerPoolConf(), mode); + } + + //Ensure that we can see the principal versus role map + Map> principalVsRolesMap = session.getSecurityRolesPrincipalVersusRolesMap(); + assertTrue("Keys size > 0", principalVsRolesMap.keySet().size() > 0); + } + + private void assertNullSessionBean(String prefix, JBossMetaData jbossMetaData) + { + JBossSessionBeanMetaData session = assertJBossSessionBean(prefix, jbossMetaData); + assertNull(session.getId()); + assertNull(session.getDescriptionGroup()); + + assertNull(session.getRemoteBindings()); + + assertNull(session.getJndiName()); + assertNull(session.getHomeJndiName()); + assertNull(session.getLocalJndiName()); + assertNull(session.getLocalHomeJndiName()); + assertNull(session.getConfigurationName()); + assertNull(session.getSecurityProxy()); + assertNull(session.getSecurityDomain()); + + assertFalse(session.isCallByValue()); + assertFalse(session.isExceptionOnRollback()); + assertTrue(session.isTimerPersistence()); + assertFalse(session.isClustered()); + + assertNull(session.getInvokerBindings()); + + assertNullEnvironment(session.getJndiEnvironmentRefsGroup()); + + assertNull(session.getMethodAttributes()); + + assertNull(session.getSecurityIdentity()); + assertNull(session.getEjbTimeoutIdentity()); + + assertNull(session.getClusterConfig()); + + assertNull(session.getDepends()); + + assertNull(session.getIorSecurityConfig()); + + assertNull(session.getAnnotations()); + assertNull(session.getIgnoreDependency()); + assertNull(session.getAopDomainName()); + assertNull(session.isConcurrent()); + assertNull(session.getJndiRefs()); + } + + private JBossEntityBeanMetaData assertJBossEntityBean(String prefix, JBossMetaData jbossMetaData) + { + JBossEntityBeanMetaData ejb = assertJBossEnterpriseBean(prefix, jbossMetaData, JBossEntityBeanMetaData.class); + assertFalse(ejb.isSession()); + assertTrue(ejb.isEntity()); + assertFalse(ejb.isMessageDriven()); + return ejb; + } + +/* private EntityMetaData assertJBossEntityBean(String prefix, ApplicationMetaData application) + { + EntityMetaData ejb = assertBeanMetaData(prefix, application, EntityMetaData.class); + assertFalse(ejb.isSession()); + assertTrue(ejb.isEntity()); + assertFalse(ejb.isMessageDriven()); + return ejb; + } +*/ + private void assertFullEntityBean(String prefix, JBossMetaData jbossMetaData, boolean first, Mode mode) + { + JBossEntityBeanMetaData entity = assertJBossEntityBean(prefix, jbossMetaData); + assertId(prefix, entity); + + assertEquals(prefix + "JndiName", entity.getJndiName()); + assertEquals(prefix + "LocalJndiName", entity.getLocalJndiName()); + assertEquals(prefix + "ConfigurationName", entity.getConfigurationName()); + assertEquals(prefix + "SecurityProxy", entity.getSecurityProxy()); + // TODO assertEquals(prefix + "SecurityDomain", entity.getSecurityDomain()); + + if (first) + { + assertTrue(entity.isCallByValue()); + assertTrue(entity.isReadOnly()); + assertTrue(entity.isExceptionOnRollback()); + assertTrue(entity.isTimerPersistence()); + assertTrue(entity.isClustered()); + assertTrue(entity.isCacheInvalidation()); + } + else + { + assertFalse(entity.isCallByValue()); + assertFalse(entity.isReadOnly()); + assertFalse(entity.isExceptionOnRollback()); + assertFalse(entity.isTimerPersistence()); + assertFalse(entity.isClustered()); + assertFalse(entity.isCacheInvalidation()); + } + + assertInvokerBindings(prefix, entity.getInvokerBindings(), mode); + + assertEnvironment(prefix, entity.getJndiEnvironmentRefsGroup(), false, mode); + + assertSecurityIdentity(prefix, "SecurityIdentity", entity.getSecurityIdentity(), false, mode); + + assertClusterConfig(prefix, entity.getClusterConfig(), false, mode); + + assertMethodAttributes(prefix, entity.getMethodAttributes(), mode); + + assertDepends(prefix, 2, entity.getDepends()); + + assertIORSecurityConfig(prefix, entity.getIorSecurityConfig(), mode); + + assertCacheInvalidationConfig(prefix, entity.getCacheInvalidationConfig(), mode); + + // TODO DOM cache-config + + // TODO DOM pool-config + } + + private void assertNullEntityBean(String prefix, JBossMetaData jbossMetaData) + { + JBossEntityBeanMetaData entity = assertJBossEntityBean(prefix, jbossMetaData); + assertNull(entity.getId()); + assertNull(entity.getDescriptionGroup()); + + assertNull(entity.getJndiName()); + assertNull(entity.getLocalJndiName()); + assertNull(entity.getConfigurationName()); + assertNull(entity.getSecurityProxy()); + assertNull(entity.getSecurityDomain()); + + assertFalse(entity.isCallByValue()); + assertFalse(entity.isReadOnly()); + assertFalse(entity.isExceptionOnRollback()); + assertTrue(entity.isTimerPersistence()); + assertFalse(entity.isClustered()); + assertFalse(entity.isCacheInvalidation()); + + assertNull(entity.getInvokerBindings()); + + assertNullEnvironment(entity.getJndiEnvironmentRefsGroup()); + + assertNull(entity.getMethodAttributes()); + + assertNull(entity.getSecurityIdentity()); + + assertNull(entity.getClusterConfig()); + + assertNull(entity.getCacheInvalidationConfig()); + + assertNull(entity.getDepends()); + + assertNull(entity.getIorSecurityConfig()); + + assertNull(entity.getAnnotations()); + assertNull(entity.getIgnoreDependency()); + assertNull(entity.getAopDomainName()); + assertNull(entity.getJndiRefs()); + } + +/* private void assertFullEntityBean(String prefix, ApplicationMetaData application, boolean first) + { + EntityMetaData entity = assertJBossEntityBean(prefix, application); + + assertEquals(prefix + "JndiName", entity.getJndiName()); + assertEquals(prefix + "LocalJndiName", entity.getLocalJndiName()); + assertEquals(prefix + "ConfigurationName", entity.getConfigurationName()); + assertEquals(prefix + "SecurityProxy", entity.getSecurityProxy()); + + if (first) + { + assertTrue(entity.isCallByValue()); + assertTrue(entity.isReadOnly()); + assertTrue(entity.getExceptionRollback()); + assertTrue(entity.getTimerPersistence()); + assertTrue(entity.isClustered()); + } + else + { + assertFalse(entity.isCallByValue()); + assertFalse(entity.isReadOnly()); + assertFalse(entity.getExceptionRollback()); + assertFalse(entity.getTimerPersistence()); + assertFalse(entity.isClustered()); + } + + assertInvokerBindings(prefix, entity, entity.getInvokerBindings()); + + assertEnvironment(prefix, entity, false); + + assertSecurityIdentity(prefix, "SecurityIdentity", entity.getSecurityIdentityMetaData(), false); + + assertClusterConfig(prefix, entity.getClusterConfigMetaData(), false); + + assertMethodAttributes(prefix, entity); + + assertCacheInvalidationConfig(prefix, entity.getDistributedCacheInvalidationConfig()); + + assertDepends(prefix, 2, entity.getDepends()); + + assertIORSecurityConfig(prefix, entity.getIorSecurityConfigMetaData()); + } +*/ +/* private void assertNullEntityBean(String prefix, ApplicationMetaData application) + { + EntityMetaData entity = assertJBossEntityBean(prefix, application); + + String ejbName = entity.getEjbName(); + assertEquals(entity.getEjbName(), entity.getJndiName()); + String localName = "local/" + ejbName + '@' + System.identityHashCode(ejbName); + assertEquals(localName, entity.getLocalJndiName()); + assertEquals(ContainerConfigurationMetaData.CMP_2x, entity.getConfigurationName()); + assertNull(entity.getSecurityProxy()); + + assertFalse(entity.isCallByValue()); + assertFalse(entity.isReadOnly()); + assertFalse(entity.getExceptionRollback()); + assertTrue(entity.getTimerPersistence()); + assertFalse(entity.isClustered()); + assertFalse(entity.doDistributedCacheInvalidations()); + + assertDefaultInvoker(InvokerBindingMetaData.CMP_2x, entity); + + assertNullEnvironment(entity); + + assertNull(entity.getSecurityIdentityMetaData()); + + assertNull(entity.getDistributedCacheInvalidationConfig()); + + assertEmpty(entity.getDepends()); + + assertNull(entity.getIorSecurityConfigMetaData()); + } +*/ + private JBossMessageDrivenBeanMetaData assertJBossMessageDrivenBean(String prefix, JBossMetaData jbossMetaData) + { + JBossMessageDrivenBeanMetaData ejb = assertJBossEnterpriseBean(prefix, jbossMetaData, JBossMessageDrivenBeanMetaData.class); + assertFalse(ejb.isSession()); + assertFalse(ejb.isEntity()); + assertTrue(ejb.isMessageDriven()); + return ejb; + } + +/* private MessageDrivenMetaData assertJBossMessageDrivenBean(String prefix, ApplicationMetaData application) + { + MessageDrivenMetaData ejb = assertBeanMetaData(prefix, application, MessageDrivenMetaData.class); + assertFalse(ejb.isSession()); + assertFalse(ejb.isEntity()); + assertTrue(ejb.isMessageDriven()); + return ejb; + } +*/ + private void assertFullMessageDrivenBean(String prefix, JBossMetaData jbossMetaData, boolean first, Mode mode) + { + JBossMessageDrivenBeanMetaData mdb = assertJBossMessageDrivenBean(prefix, jbossMetaData); + assertId(prefix, mdb); + + if(mode != Mode.JBOSS_DTD) + { + assertDescriptionGroup(prefix, mdb.getDescriptionGroup()); + assertAnnotations(prefix, 2, mdb.getAnnotations()); + assertIgnoreDependency(prefix, mdb.getIgnoreDependency()); + assertEquals(prefix + "AOPDomain", mdb.getAopDomainName()); + assertJndiRefs(prefix, 2, mdb.getJndiRefs(), mode); + assertMethodAttributes(prefix, mdb.getMethodAttributes(), mode); + } + + assertEquals(prefix + "DestinationJndiName", mdb.getDestinationJndiName()); + assertEquals(prefix + "LocalJndiName", mdb.getLocalJndiName()); + assertEquals(prefix + "User", mdb.getMdbUser()); + assertEquals(prefix + "Password", mdb.getMdbPassword()); + assertEquals(prefix + "ClientId", mdb.getMdbClientId()); + assertEquals(prefix + "SubscriptionId", mdb.getMdbSubscriptionId()); + assertEquals(prefix + "RAR", mdb.getResourceAdapterName()); + assertEquals(prefix + "ConfigurationName", mdb.getConfigurationName()); + assertEquals(prefix + "SecurityProxy", mdb.getSecurityProxy()); + + if (first) + { + assertTrue(mdb.isExceptionOnRollback()); + assertTrue(mdb.isTimerPersistence()); + } + else + { + assertFalse(mdb.isExceptionOnRollback()); + assertFalse(mdb.isTimerPersistence()); + } + + assertInvokerBindings(prefix, mdb.getInvokerBindings(), mode); + + assertEnvironment(prefix, mdb.getJndiEnvironmentRefsGroup(), false, mode); + + assertSecurityIdentity(prefix, "SecurityIdentity", mdb.getSecurityIdentity(), false, mode); + + assertDepends(prefix, 2, mdb.getDepends()); + + assertIORSecurityConfig(prefix, mdb.getIorSecurityConfig(), mode); + + assertSecurityIdentity(prefix, "EjbTimeoutIdentity", mdb.getEjbTimeoutIdentity(), false, mode); + + // TODO DOM pool-config + + assertActivationConfig(prefix, mdb.getActivationConfig(), mode); + } + + private void assertNullMessageDrivenBean(String prefix, JBossMetaData jbossMetaData) + { + JBossMessageDrivenBeanMetaData mdb = assertJBossMessageDrivenBean(prefix, jbossMetaData); + assertNull(mdb.getId()); + assertNull(mdb.getDescriptionGroup()); + + assertNull(mdb.getDestinationJndiName()); + assertNull(mdb.getLocalJndiName()); + assertNull(mdb.getMdbUser()); + assertNull(mdb.getMdbPassword()); + assertNull(mdb.getMdbClientId()); + assertNull(mdb.getMdbSubscriptionId()); + assertNull(mdb.getResourceAdapterName()); + assertNull(mdb.getConfigurationName()); + assertNull(mdb.getSecurityProxy()); + + assertFalse(mdb.isExceptionOnRollback()); + assertTrue(mdb.isTimerPersistence()); + + assertNull(mdb.getInvokerBindings()); + + assertNullEnvironment(mdb.getJndiEnvironmentRefsGroup()); + + assertNull(mdb.getMethodAttributes()); + + assertNull(mdb.getSecurityIdentity()); + assertNull(mdb.getEjbTimeoutIdentity()); + + assertNull(mdb.getDepends()); + + assertNull(mdb.getIorSecurityConfig()); + + assertNull(mdb.getAnnotations()); + assertNull(mdb.getIgnoreDependency()); + assertNull(mdb.getAopDomainName()); + assertNull(mdb.getJndiRefs()); + } + + private void assertContainerConfigurations(JBossMetaData jbossMetaData, Mode mode) + { + ContainerConfigurationsMetaData configurations = jbossMetaData.getContainerConfigurations(); + assertNotNull(configurations); + int expectedSize = hasStandardJBoss ? 34 : 13; + assertEquals(expectedSize, configurations.size()); + assertNullContainerConfiguration("containerConfiguration0", jbossMetaData); + assertFullContainerConfiguration("containerConfiguration1", jbossMetaData, true, mode); + assertFullContainerConfiguration("containerConfiguration2", jbossMetaData, false, mode); + ContainerConfigurationMetaData configuration = assertContainerConfiguration("containerConfiguration3", jbossMetaData); + assertEquals(CommitOption.B, configuration.getCommitOption()); + configuration = assertContainerConfiguration("containerConfiguration4", jbossMetaData); + assertEquals(CommitOption.C, configuration.getCommitOption()); + } + + private ContainerConfigurationMetaData assertContainerConfiguration(String prefix, JBossMetaData jBossMetaData) + { + ContainerConfigurationMetaData configuration = jBossMetaData.getContainerConfiguration(prefix + "Name"); + assertNotNull(configuration); + assertEquals(prefix + "Name", configuration.getContainerName()); + String policy = configuration.getLockingPolicy(); + if(hasStandardJBoss && policy.startsWith("org.jboss")) + assertEquals("org.jboss.ejb.plugins.lock.QueuedPessimisticEJBLock", policy); + else if(policy != null) + assertEquals(prefix+"LockingPolicy", policy); + return configuration; + } + + private void assertFullContainerConfiguration(String prefix, JBossMetaData jBossMetaData, boolean first, Mode mode) + { + ContainerConfigurationMetaData configuration = assertContainerConfiguration(prefix, jBossMetaData); + if(mode != Mode.JBOSS_DTD) + { + assertId(prefix, configuration); + assertDescriptions(prefix, configuration.getDescriptions()); + } + assertEquals(prefix + "Extends", configuration.getExtendsName()); + assertEquals(prefix + "InstancePool", configuration.getInstancePool()); + assertEquals(prefix + "InstanceCache", configuration.getInstanceCache()); + assertEquals(prefix + "PersistenceManager", configuration.getPersistenceManager()); + assertEquals(prefix + "WebClassLoader", configuration.getWebClassLoader()); + assertEquals(prefix + "LockingPolicy", configuration.getLockingPolicy()); + assertEquals(prefix + "SecurityDomain", configuration.getSecurityDomain()); + if (first) + { + assertTrue(configuration.isCallLogging()); + assertTrue(configuration.isSyncOnCommitOnly()); + assertTrue(configuration.isInsertAfterEjbPostCreate()); + assertTrue(configuration.isEjbStoreOnClean()); + assertTrue(configuration.isStoreNotFlushed()); + } + else + { + assertFalse(configuration.isCallLogging()); + assertFalse(configuration.isSyncOnCommitOnly()); + assertFalse(configuration.isInsertAfterEjbPostCreate()); + assertFalse(configuration.isEjbStoreOnClean()); + assertFalse(configuration.isStoreNotFlushed()); + } + + assertInvokerProxyBindingNames(prefix, 2, configuration.getInvokerProxyBindingNames()); + Element interceptors = configuration.getContainerInterceptors(); + assertContainerInterceptors(prefix, interceptors); + Element cacheConf = configuration.getContainerCacheConf(); + assertContainerCacheConf(prefix, cacheConf); + Element poolConf = configuration.getContainerPoolConf(); + assertContainerPoolConf(prefix, poolConf, mode); + assertEquals(CommitOption.D, configuration.getCommitOption()); + assertEquals(10000, configuration.getOptiondRefreshRateMillis()); + assertClusterConfig(prefix, configuration.getClusterConfig(), true, mode); + assertDepends(prefix, 2, configuration.getDepends()); + } + + private void assertNullContainerConfiguration(String prefix, JBossMetaData jBossMetaData) + { + ContainerConfigurationMetaData configuration = assertContainerConfiguration(prefix, jBossMetaData); + assertNull(configuration.getId()); + assertNull(configuration.getDescriptions()); + assertNull(configuration.getExtendsName()); + assertNull(configuration.getInstancePool()); + assertNull(configuration.getInstanceCache()); + assertNull(configuration.getPersistenceManager()); + if(this.hasStandardJBoss) + assertEquals("org.jboss.web.WebClassLoader", configuration.getWebClassLoader()); + else + assertEquals(null, configuration.getWebClassLoader()); + if(this.hasStandardJBoss) + assertEquals("org.jboss.ejb.plugins.lock.QueuedPessimisticEJBLock", configuration.getLockingPolicy()); + else + assertEquals(null, configuration.getLockingPolicy()); + assertNull(configuration.getSecurityDomain()); + assertFalse(configuration.isCallLogging()); + assertFalse(configuration.isSyncOnCommitOnly()); + assertFalse(configuration.isInsertAfterEjbPostCreate()); + assertFalse(configuration.isEjbStoreOnClean()); + assertTrue(configuration.isStoreNotFlushed()); + assertNull(configuration.getInvokerProxyBindingNames()); + assertNull(configuration.getContainerInterceptors()); + assertNull(configuration.getContainerPoolConf()); + assertNull(configuration.getContainerCacheConf()); + assertEquals(CommitOption.A, configuration.getCommitOption()); + if(this.hasStandardJBoss) + assertEquals(30000, configuration.getOptiondRefreshRateMillis()); + else + assertEquals(0, configuration.getOptiondRefreshRateMillis()); + assertNull(configuration.getClusterConfig()); + if(this.hasStandardJBoss) + assertTrue(configuration.getDepends().isEmpty()); + else + assertNull(configuration.getDepends()); + } + + /** + * Validate the container-configuration/container-interceptors config + * @param prefix + * @param config + */ + private void assertContainerInterceptors(String prefix, Element config) + { + assertNotNull(config); + NodeList interceptors = config.getElementsByTagName("interceptor"); + assertEquals("interceptors count is 5", 5, interceptors.getLength()); + for(int n = 0; n < interceptors.getLength(); n ++) + { + Element interceptor = (Element) interceptors.item(n); + String tx = interceptor.getAttribute("transaction"); + String text = interceptor.getTextContent(); + String expected; + if (tx.length() == 0 || tx.equals("Both")) + expected = prefix+".Interceptor"+(n+1); + else if (tx.equals("Container")) + expected = prefix+".Interceptor"+(n+1)+"c"; + else + expected = prefix+".Interceptor"+(n+1)+"b"; + assertEquals(tx, expected, text); + } + } + /** + * Validate the container-configuration/container-cache-conf + * @param prefix + * @param config + */ + private void assertContainerCacheConf(String prefix, Element config) + { + assertNotNull(config); + assertEquals(prefix+".Policy", getElementText("cache-policy", config)); + Element policyConf = getElement("cache-policy-conf", config); + assertNotNull(policyConf); + assertEquals("50", getElementText("min-capacity", policyConf)); + assertEquals("1000000", getElementText("max-capacity", policyConf)); + assertEquals("1800", getElementText("remover-period", policyConf)); + assertEquals("1800", getElementText("max-bean-life", policyConf)); + assertEquals("300", getElementText("overager-period", policyConf)); + assertEquals("600", getElementText("max-bean-age", policyConf)); + assertEquals("400", getElementText("resizer-period", policyConf)); + assertEquals("60", getElementText("max-cache-miss-period", policyConf)); + assertEquals("1", getElementText("min-cache-miss-period", policyConf)); + assertEquals("0.75", getElementText("cache-load-factor", policyConf)); + } + + /** + * Validate the container-configuration/container-pool-conf + * @param prefix + * @param config + */ + private void assertContainerPoolConf(String prefix, Element config, Mode mode) + { + assertNotNull(prefix+" container-pool-conf", config); + String id = config.getAttribute("id"); + // standardjboss.xml does not specify ids + if ((mode != Mode.JBOSS_DTD && hasStandardJBoss == false) || id.length() > 0) + assertEquals(prefix+"-pool-conf", id); + assertEquals("100", getElementText("MaximumSize", config)); + } + + private void assertInvokerProxyBindingNames(String prefix, int size, Collection names) + { + assertNotNull(names); + assertEquals(size, names.size()); + for(int count = 1; count <= names.size(); ++count) + { + assertTrue(names.contains(prefix + "InvokerProxyBindingName" + count)); + } + } + + private void assertDepends(String prefix, int size, Collection depends) + { + assertNotNull(depends); + assertEquals(size, depends.size()); + for(int count = 1; count <= depends.size(); ++count) + { + assertTrue(depends.contains(prefix + "Depends" + count)); + } + } + + private void assertInvokerProxyBindings(InvokerProxyBindingsMetaData bindings, Mode mode) + { + assertNotNull(bindings); + if(mode != Mode.JBOSS_DTD) + { + assertId("invoker-proxy-bindings", bindings); + assertDescriptions("invoker-proxy-bindings", bindings.getDescriptions()); + } + assertEquals(2, bindings.size()); + int count = 1; + for (InvokerProxyBindingMetaData binding : bindings) + { + assertInvokerProxyBinding("invokerProxyBinding" + count, count, binding, mode); + ++count; + } + } + + private void assertInvokerProxyBinding(String prefix, int count, InvokerProxyBindingMetaData binding, Mode mode) + { + assertNotNull(binding); + if(mode != Mode.JBOSS_DTD) + { + assertId(prefix, binding); + assertDescriptions(prefix, binding.getDescriptions()); + } + assertEquals(prefix + "Name", binding.getInvokerProxyBindingName()); + assertEquals(prefix + "InvokerMBean", binding.getInvokerMBean()); + assertEquals(prefix + "ProxyFactory", binding.getProxyFactory()); + // The DOM invoker-proxy-config + Element config = binding.getProxyFactoryConfig(); + if (config == null) + return; + if (config.getElementsByTagName("client-interceptors").getLength() > 0) + assertInvokerProxyBindingPFCClientInterceptor(prefix, count, config); + } + private void assertInvokerProxyBindingPFCClientInterceptor(String prefix, int count, Element config) + { + NodeList ci = config.getElementsByTagName("client-interceptors"); + assertEquals("client-interceptors count is 1", 1, ci.getLength()); + Element cis = (Element) ci.item(0); + NodeList home = cis.getElementsByTagName("home"); + Element homeE = (Element) home.item(0); + NodeList homeInterceptors = homeE.getElementsByTagName("interceptor"); + assertEquals("home count is 4", 4, homeInterceptors.getLength()); + for(int n = 0; n < homeInterceptors.getLength(); n ++) + { + Element interceptor = (Element) homeInterceptors.item(n); + String callByValue = interceptor.getAttribute("call-by-value"); + String text = interceptor.getTextContent(); + String expected; + if (callByValue.length() == 0) + expected = "org.jboss.proxy.ejb.HomeInterceptor"+(n+1)+"."+count; + else + expected = "org.jboss.proxy.ejb.HomeInterceptor"+(Boolean.valueOf(callByValue)?"cbvt" : "cbvf")+(n+1)+"."+count; + assertEquals(expected, text); + } + NodeList bean = cis.getElementsByTagName("bean"); + Element beanE = (Element) bean.item(0); + NodeList beanInterceptors = beanE.getElementsByTagName("interceptor"); + assertEquals("bean count is 4", 4, beanInterceptors.getLength()); + for(int n = 0; n < beanInterceptors.getLength(); n ++) + { + Element interceptor = (Element) beanInterceptors.item(n); + String callByValue = interceptor.getAttribute("call-by-value"); + String text = interceptor.getTextContent(); + String expected; + if (callByValue.length() == 0) + expected = "org.jboss.proxy.ejb.BeanInterceptor"+(n+1)+"."+count; + else + expected = "org.jboss.proxy.ejb.BeanInterceptor"+(Boolean.valueOf(callByValue)?"cbvt" : "cbvf")+(n+1)+"."+count; + assertEquals(expected, text); + } + } + + private void assertInvokerBindings(String prefix, InvokerBindingsMetaData bindings, Mode mode) + { + if(mode != Mode.JBOSS_DTD) + { + assertId(prefix + "InvokerBindings", bindings); + assertDescriptions(prefix + "InvokerBindings", bindings.getDescriptions()); + } + assertNotNull(bindings); + assertEquals(2, bindings.size()); + int count = 1; + for (InvokerBindingMetaData binding : bindings) + { + assertInvokerBinding(prefix, count, binding, mode); + ++count; + } + } + + private void assertInvokerBinding(String ejbPrefix, int count, InvokerBindingMetaData binding, Mode mode) + { + String invokerPrefix = ejbPrefix + "Invoker" + count; + assertNotNull(binding); + if(mode != Mode.JBOSS_DTD) + { + assertId(invokerPrefix, binding); + assertDescriptions(invokerPrefix, binding.getDescriptions()); + } + assertEquals("invokerProxyBinding"+count+"Name", binding.getInvokerProxyBindingName()); + assertEquals(invokerPrefix + "JndiName", binding.getJndiName()); + // TODO LAST ejb-ref - needs a seperate test + List ejbRefs = binding.getEjbRefs(); + assertNotNull(ejbRefs); + assertEquals(count, ejbRefs.size()); + int i = 1; + for(EjbRef ejbRef : ejbRefs) + { + assertNotNull(ejbRef); + assertEquals(ejbPrefix + "EjbRef" + i + "Name", ejbRef.getEjbRefName()); + assertEquals(invokerPrefix + "EjbName" + i, ejbRef.getJndiName()); + ++i; + } + } + + private void assertResourceManagers(ResourceManagersMetaData resources, Mode mode) + { + assertNotNull(resources); + if(mode != Mode.JBOSS_DTD) + { + assertId("resource-managers", resources); + assertDescriptions("resource-managers", resources.getDescriptions()); + } + assertEquals(2, resources.size()); + int count = 1; + for (ResourceManagerMetaData resource : resources) + { + assertResourceManager("resourceManager" + count, count == 1, resource, mode); + ++count; + } + } + + private void assertResourceManager(String prefix, boolean jndi, ResourceManagerMetaData resource, Mode mode) + { + assertNotNull(resource); + if(mode != Mode.JBOSS_DTD) + { + assertId(prefix, resource); + assertDescriptions(prefix, resource.getDescriptions()); + } + assertEquals(prefix + "Name", resource.getResName()); + if (jndi) + { + assertEquals(prefix + "JndiName", resource.getResJndiName()); + assertNull(resource.getResUrl()); + assertEquals(prefix + "JndiName", resource.getResource()); + } + else + { + assertNull(resource.getResJndiName()); + assertEquals(prefix + "URL", resource.getResUrl()); + assertEquals(prefix + "URL", resource.getResource()); + } + } + + protected void assertAssemblyDescriptor(JBossMetaData jbossMetaData, Mode mode) + { + JBossAssemblyDescriptorMetaData assemblyDescriptorMetaData = (JBossAssemblyDescriptorMetaData) jbossMetaData.getAssemblyDescriptor(); + assertNotNull(assemblyDescriptorMetaData); + if(mode != Mode.JBOSS_DTD) + assertId("assembly-descriptor", assemblyDescriptorMetaData); + assertSecurityRoles(2, assemblyDescriptorMetaData.getSecurityRoles(), mode); + assertMessageDestinations(2, assemblyDescriptorMetaData.getMessageDestinations(), mode); + Map> prmap = assemblyDescriptorMetaData.getPrincipalVersusRolesMap(); + assertNotNull(prmap); + //Check the keys + assertTrue(prmap.containsKey("securityRole1Principal1")); + assertTrue(prmap.containsKey("securityRole1Principal2")); + assertTrue(prmap.containsKey("securityRole2Principal1")); + assertTrue(prmap.containsKey("securityRole2Principal2")); + //Check the values + assertTrue(prmap.get("securityRole1Principal1").size() == 1); + assertTrue(prmap.get("securityRole1Principal1").contains("securityRoleRef1RoleLink")); + + assertTrue(prmap.get("securityRole1Principal2").size() == 1); + assertTrue(prmap.get("securityRole1Principal2").contains("securityRoleRef1RoleLink")); + + assertTrue(prmap.get("securityRole2Principal1").size() == 1); + assertTrue(prmap.get("securityRole2Principal1").contains("securityRoleRef2RoleLink")); + + assertTrue(prmap.get("securityRole2Principal2").size() == 1); + assertTrue(prmap.get("securityRole2Principal2").contains("securityRoleRef2RoleLink")); + } + + @Override + protected void assertSecurityRole(String prefix, int count, SecurityRoleMetaData securityRoleMetaData, Mode mode) + { + super.assertSecurityRole(prefix, count, securityRoleMetaData, mode); + assertPrincipals(prefix, count, 2, securityRoleMetaData.getPrincipals()); + } + +/* @Override + protected void assertSecurityRole(String prefix, org.jboss.security.SecurityRoleMetaData securityRoleMetaData) + { + super.assertSecurityRole(prefix, securityRoleMetaData); + assertPrincipals(prefix, 2, securityRoleMetaData.getPrincipals()); + } +*/ + protected void assertMessageDestination(String prefix, MessageDestinationMetaData messageDestinationMetaData, Mode mode) + { + assertMessageDestination14(prefix, messageDestinationMetaData, mode); + assertEquals(prefix + "JndiName", messageDestinationMetaData.getMappedName()); + } + + private void assertPoolConfig(String prefix, PoolConfigMetaData poolConfig) + { + assertNotNull(prefix + " has no poolConfig", poolConfig); + assertEquals(prefix + "PoolClass", poolConfig.getValue()); + assertEquals(10, (int) poolConfig.getMaxSize()); + assertEquals(11, (int) poolConfig.getTimeout()); + } + + private void assertPartitionName(ClusterConfigMetaData config, String expectedSource) + { + String value= config.getPartitionName(); + assertExpectedSource(value, expectedSource, "PartitionName"); + } + + private void assertHomeLoadBalancePolicy(ClusterConfigMetaData config, String expectedSource) + { + String value = config.getHomeLoadBalancePolicy(); + assertExpectedSource(value, expectedSource, "HomeLoadBalancePolicy"); + } + + private void assertBeanLoadBalancePolicy(ClusterConfigMetaData config, String expectedSource) + { + String value = config.getBeanLoadBalancePolicy(); + assertExpectedSource(value, expectedSource, "BeanLoadBalancePolicy"); + } + + private void assertSessionStateManagerJndiName(ClusterConfigMetaData config, String expectedSource) + { + String value = config.getSessionStateManagerJndiName(); + assertExpectedSource(value, expectedSource, "SessionStateManagerJndiName"); + } + + private void assertExpectedSource(String value, String expectedPrefix, String suffix) + { + if (expectedPrefix == null) + assertNull(value); + else + assertEquals(expectedPrefix + "Configuration" + suffix, value); + } + + @Override + protected void assertResourceGroup(String prefix, ResourceInjectionMetaData resourceInjectionMetaData, boolean full, boolean first, Mode mode) + { + if(mode == Mode.JBOSS) + { + super.assertResourceGroupNoJndiName(prefix, resourceInjectionMetaData, true, first); + if (first) + assertTrue(resourceInjectionMetaData.isDependencyIgnored()); + else + assertFalse(resourceInjectionMetaData.isDependencyIgnored()); + } + assertEquals(prefix + "JndiName", resourceInjectionMetaData.getMappedName()); + } + + @Override + protected void assertSecurityIdentity(String ejbName, String type, SecurityIdentityMetaData securityIdentity, boolean full, Mode mode) + { + super.assertSecurityIdentity(ejbName, type, securityIdentity, full, mode); + assertEquals(ejbName + type + "RunAsPrincipal", securityIdentity.getRunAsPrincipal()); + } + +/* @Override + protected void assertSecurityIdentity(String ejbName, String type, org.jboss.metadata.SecurityIdentityMetaData securityIdentity, boolean full) + { + super.assertSecurityIdentity(ejbName, type, securityIdentity, full); + assertEquals(ejbName + type + "RunAsPrincipal", securityIdentity.getRunAsPrincipalName()); + } +*/ +/* @Override + protected void assertMethodAttributes(String ejbName, BeanMetaData bean) + { + assertTrue(bean.isMethodReadOnly("getSomething")); + assertEquals(5000, bean.getTransactionTimeout("getSomething")); + assertFalse(bean.isMethodReadOnly("setSomething")); + assertEquals(0, bean.getTransactionTimeout("setSomething")); + } +*/} Property changes on: src/test/java/org/jboss/test/metadata/ejb/JBoss60EverythingUnitTestCase.java ___________________________________________________________________ Added: svn:keywords + Id Revision Added: svn:eol-style + LF Index: src/test/java/org/jboss/test/metadata/ejb/EjbJarJBossMergeEverythingUnitTestCase.java =================================================================== --- src/test/java/org/jboss/test/metadata/ejb/EjbJarJBossMergeEverythingUnitTestCase.java (revision 108615) +++ src/test/java/org/jboss/test/metadata/ejb/EjbJarJBossMergeEverythingUnitTestCase.java (working copy) @@ -38,6 +38,7 @@ import org.jboss.metadata.ejb.jboss.InvokerProxyBindingsMetaData; import org.jboss.metadata.ejb.jboss.JBoss50DTDMetaData; import org.jboss.metadata.ejb.jboss.JBoss50MetaData; +import org.jboss.metadata.ejb.jboss.JBoss60MetaData; import org.jboss.metadata.ejb.jboss.JBossEnterpriseBeanMetaData; import org.jboss.metadata.ejb.jboss.JBossEnterpriseBeansMetaData; import org.jboss.metadata.ejb.jboss.JBossMessageDrivenBeanMetaData; @@ -155,8 +156,88 @@ } /** + * Very basic merge test + */ + public void testEJB3xAS6Everything() throws Exception + { + EjbJar3xMetaData ejbJarMetaData = unmarshal("EjbJar3xEverything_testEverything.xml", EjbJar30MetaData.class, null); + EjbJar3xEverythingUnitTestCase ejbJar = new EjbJar3xEverythingUnitTestCase("ejb-jar"); + ejbJar.assertEverything(ejbJarMetaData, Mode.SPEC); + + JBoss60MetaData jbossMetaData = unmarshal("JBoss60Everything_testEverything.xml", JBoss60MetaData.class, null); + JBoss60EverythingUnitTestCase jboss = new JBoss60EverythingUnitTestCase("jboss"); + jboss.assertEverything(jbossMetaData, Mode.JBOSS); + + // Create the merged view + jbossMetaData.merge(null, ejbJarMetaData); + + assertTrue(jbossMetaData.isEJB3x()); + + ejbJar.assertInterceptors(jbossMetaData, Mode.JBOSS); + + JBossEnterpriseBeanMetaData ejb = jbossMetaData.getEnterpriseBean("session1EjbName"); + assertNotNull(ejb); + JBossSessionBeanMetaData jejb = (JBossSessionBeanMetaData) ejb; + ejbJar.assertFullSessionBean("session1", jejb, Mode.JBOSS); + jboss.assertWebservices(jbossMetaData.getWebservices(), Mode.JBOSS); + + { + JBossMessageDrivenBeanMetaData mdb = (JBossMessageDrivenBeanMetaData) jbossMetaData.getEnterpriseBean("mdb1EjbName"); + ejbJar.assertActivationConfig("mdb1", mdb.getActivationConfig(), Mode.JBOSS); + } + + ejbJar.assertInterceptorBindings(3, jbossMetaData.getAssemblyDescriptor().getInterceptorBindings()); + + // Basic check if EjbReferences.invokerBindings are merged + assertEjbReferenceInvokerBindings(ejb); + //this is ejb2 only? assertInvokerBindings(jbossMetaData.getInvokerProxyBindings()); + } + + /** * merge jbossMetaData more times */ + public void testEJB3xAS6EverythingDualMerge() throws Exception + { + EjbJar3xMetaData ejbJarMetaData = unmarshal("EjbJar3xEverything_testEverything.xml", EjbJar30MetaData.class, null); + EjbJar3xEverythingUnitTestCase ejbJar = new EjbJar3xEverythingUnitTestCase("ejb-jar"); + ejbJar.assertEverything(ejbJarMetaData, Mode.SPEC); + + JBossMetaData specMetaData = new JBossMetaData(); + specMetaData.merge(null, ejbJarMetaData); + + JBoss60MetaData jbossMetaData = unmarshal("JBoss60Everything_testEverything.xml", JBoss60MetaData.class, null); + JBoss60EverythingUnitTestCase jboss = new JBoss60EverythingUnitTestCase("jboss"); + jboss.assertEverything(jbossMetaData, Mode.JBOSS); + jboss.assertWebservices(jbossMetaData.getWebservices(), Mode.JBOSS); + + // Create the merged view + JBossMetaData mergedMetaData = new JBossMetaData(); + mergedMetaData.merge(jbossMetaData, specMetaData); + + assertTrue(mergedMetaData.isEJB3x()); + ejbJar.assertInterceptors(mergedMetaData, Mode.JBOSS); + + JBossEnterpriseBeanMetaData ejb = mergedMetaData.getEnterpriseBean("session1EjbName"); + assertNotNull(ejb); + JBossSessionBeanMetaData jejb = (JBossSessionBeanMetaData) ejb; + ejbJar.assertFullSessionBean("session1", jejb, Mode.JBOSS); + jboss.assertWebservices(mergedMetaData.getWebservices(), Mode.JBOSS); + + { + JBossMessageDrivenBeanMetaData mdb = (JBossMessageDrivenBeanMetaData) mergedMetaData.getEnterpriseBean("mdb1EjbName"); + ejbJar.assertActivationConfig("mdb1", mdb.getActivationConfig(), Mode.JBOSS); + } + + ejbJar.assertInterceptorBindings(3, mergedMetaData.getAssemblyDescriptor().getInterceptorBindings()); + + // Basic check if EjbReferences.invokerBindings are merged + assertEjbReferenceInvokerBindings(ejb); + // this is ejb2 only? assertInvokerBindings(mergedMetaData.getInvokerProxyBindings()); + } + + /** + * merge jbossMetaData more times + */ public void testEJB21EverythingDualMerge() throws Exception { EjbJar21MetaData ejbJarMetaData = unmarshal("EjbJar21Everything_testEverything.xml", EjbJar21MetaData.class, null); Index: src/test/resources/schema2class.properties =================================================================== --- src/test/resources/schema2class.properties (revision 108615) +++ src/test/resources/schema2class.properties (working copy) @@ -14,6 +14,7 @@ jboss_6_0.dtd org.jboss.metadata.ejb.jboss.JBoss60DTDMetaData jboss_5_0.xsd org.jboss.metadata.ejb.jboss.JBoss50MetaData jboss_5_1.xsd org.jboss.metadata.ejb.jboss.JBoss51MetaData +jboss_6_0.xsd org.jboss.metadata.ejb.jboss.JBoss60MetaData # JPA persistence_1_0.xsd org.jboss.metadata.jpa.spec.PersistenceMetaData Index: src/test/resources/org/jboss/test/metadata/ejb/JBoss60Everything_testEverything.xml =================================================================== --- src/test/resources/org/jboss/test/metadata/ejb/JBoss60Everything_testEverything.xml (revision 0) +++ src/test/resources/org/jboss/test/metadata/ejb/JBoss60Everything_testEverything.xml (revision 0) @@ -0,0 +1,1638 @@ + + + + + en-jboss-desc + fr-jboss-desc + de-jboss-desc + en-jboss-disp + fr-jboss-disp + de-jboss-disp + + en-jboss-small-icon + en-jboss-large-icon + + + fr-jboss-small-icon + fr-jboss-large-icon + + + de-jboss-small-icon + de-jboss-large-icon + + + + loaderRepositoryName + + loaderRepositoryConfig1 + + + loaderRepositoryConfig2 + + + + jboss-jmx-name + jboss-security-domain + false + jboss-unauthenticated-principal + + + webservicesContextRoot + + webserviceDescription1Name + webserviceDescription1ConfigName + webserviceDescription1ConfigFile + webserviceDescription1WsdlPublishLocation + + + webserviceDescription2Name + webserviceDescription2ConfigName + webserviceDescription2ConfigFile + webserviceDescription2WsdlPublishLocation + + + + + + + session0EjbName + + + + en-session1-desc + fr-session1-desc + de-session1-desc + en-session1-disp + fr-session1-disp + de-session1-disp + + en-session1-small-icon + en-session1-large-icon + + + fr-session1-small-icon + fr-session1-large-icon + + + de-session1-small-icon + de-session1-large-icon + + + session1EjbName + + + en-session1EjbRef1-desc + fr-session1EjbRef1-desc + de-session1EjbRef1-desc + + session1EjbRef1Name + session1EjbRef1JndiName + + session1EjbRef1Injection1Class + session1EjbRef1Injection1Name + + + session1EjbRef1Injection2Class + session1EjbRef1Injection2Name + + + + + en-session1EjbRef2-desc + fr-session1EjbRef2-desc + de-session1EjbRef2-desc + + session1EjbRef2Name + session1EjbRef2JndiName + + session1EjbRef2Injection1Class + session1EjbRef2Injection1Name + + + session1EjbRef2Injection2Class + session1EjbRef2Injection2Name + + + + + en-session1EjbLocalRef1-desc + fr-session1EjbLocalRef1-desc + de-session1EjbLocalRef1-desc + + session1EjbLocalRef1Name + session1EjbLocalRef1JndiName + + session1EjbLocalRef1Injection1Class + session1EjbLocalRef1Injection1Name + + + session1EjbLocalRef1Injection2Class + session1EjbLocalRef1Injection2Name + + + + + en-session1EjbLocalRef2-desc + fr-session1EjbLocalRef2-desc + de-session1EjbLocalRef2-desc + + session1EjbLocalRef2Name + session1EjbLocalRef2JndiName + + session1EjbLocalRef2Injection1Class + session1EjbLocalRef2Injection1Name + + + session1EjbLocalRef2Injection2Class + session1EjbLocalRef2Injection2Name + + + + + + + en-session1ResourceRef1-desc + fr-session1ResourceRef1-desc + de-session1ResourceRef1-desc + session1ResourceRef1Name + session1ResourceRef1JndiName + + session1ResourceRef1Injection1Class + session1ResourceRef1Injection1Name + + + session1ResourceRef1Injection2Class + session1ResourceRef1Injection2Name + + + + + en-session1ResourceRef2-desc + fr-session1ResourceRef2-desc + de-session1ResourceRef2-desc + session1ResourceRef2Name + session1ResourceRef2JndiName + + session1ResourceRef2Injection1Class + session1ResourceRef2Injection1Name + + + session1ResourceRef2Injection2Class + session1ResourceRef2Injection2Name + + + + en-session1ResourceEnvRef1-desc + fr-session1ResourceEnvRef1-desc + de-session1ResourceEnvRef1-desc + session1ResourceEnvRef1Name + session1ResourceEnvRef1JndiName + + session1ResourceEnvRef1Injection1Class + session1ResourceEnvRef1Injection1Name + + + session1ResourceEnvRef1Injection2Class + session1ResourceEnvRef1Injection2Name + + + + + en-session1ResourceEnvRef2-desc + fr-session1ResourceEnvRef2-desc + de-session1ResourceEnvRef2-desc + session1ResourceEnvRef2Name + session1ResourceEnvRef2JndiName + + session1ResourceEnvRef2Injection1Class + session1ResourceEnvRef2Injection1Name + + + session1ResourceEnvRef2Injection2Class + session1ResourceEnvRef2Injection2Name + + + + en-session1MessageDestinationRef1-desc + fr-session1MessageDestinationRef1-desc + de-session1MessageDestinationRef1-desc + session1MessageDestinationRef1Name + session1MessageDestinationRef1JndiName + + session1MessageDestinationRef1Injection1Class + session1MessageDestinationRef1Injection1Name + + + session1MessageDestinationRef1Injection2Class + session1MessageDestinationRef1Injection2Name + + + + + en-session1MessageDestinationRef2-desc + fr-session1MessageDestinationRef2-desc + de-session1MessageDestinationRef2-desc + session1MessageDestinationRef2Name + session1MessageDestinationRef2JndiName + + session1MessageDestinationRef2Injection1Class + session1MessageDestinationRef2Injection1Name + + + session1MessageDestinationRef2Injection2Class + session1MessageDestinationRef2Injection2Name + + + + en-session1MessageDestinationRef3-desc + fr-session1MessageDestinationRef3-desc + de-session1MessageDestinationRef3-desc + session1MessageDestinationRef3Name + session1MessageDestinationRef3JndiName + + session1MessageDestinationRef3Injection1Class + session1MessageDestinationRef3Injection1Name + + + session1MessageDestinationRef3Injection2Class + session1MessageDestinationRef3Injection2Name + + + + + en-session1SecurityIdentity-desc + fr-session1SecurityIdentity-desc + de-session1SecurityIdentity-desc + session1SecurityIdentityRunAsPrincipal + + + + en-session1RemoteBinding-desc + fr-session1RemoteBinding-desc + de-session1RemoteBinding-desc + session1RemoteBindingJndiName + session1RemoteBindingClientBindUrl + session1RemoteBindingInterceptorStack + session1RemoteBindingInvokerName + + + session1JndiName + session1HomeJndiName + + session1LocalJndiName + session1LocalHomeJndiName + + true + + + en-session1ClusterConfig-desc + fr-session1ClusterConfig-desc + de-session1ClusterConfig-desc + session1ClusterConfigPartitionName + session1ClusterConfigHomeLoadBalancePolicy + session1ClusterConfigBeanLoadBalancePolicy + session1ClusterConfigSessionStateManagerJndiName + + + session1SecurityDomain + + + + get* + true + true + 5000 + + + * + + + + session1Depends1 + session1Depends2 + + + en-session1Annotation1-desc + fr-session1Annotation1-desc + de-session1Annotation1-desc + + session1Annotation1Class + session1Annotation1Impl + + session1Annotation1InjectionTargetClass + session1Annotation1InjectionTargetName + + + en-session1Annotation1Property1-desc + fr-session1Annotation1Property1-desc + de-session1Annotation1Property1-desc + session1Annotation1Property1Name + session1Annotation1Property1Value + + + en-session1Annotation1Property2-desc + fr-session1Annotation1Property2-desc + de-session1Annotation1Property2-desc + session1Annotation1Property2Name + session1Annotation1Property2Value + + + + en-session1Annotation2-desc + fr-session1Annotation2-desc + de-session1Annotation2-desc + + session1Annotation2Class + session1Annotation2Impl + + session1Annotation2InjectionTargetClass + session1Annotation2InjectionTargetName + + + en-session1Annotation2Property1-desc + fr-session1Annotation2Property1-desc + de-session1Annotation2Property1-desc + session1Annotation2Property1Name + session1Annotation2Property1Value + + + en-session1Annotation2Property2-desc + fr-session1Annotation2Property2-desc + de-session1Annotation2Property2-desc + session1Annotation2Property2Name + session1Annotation2Property2Value + + + + + en-session1IgnoreDependency-desc + fr-session1IgnoreDependency-desc + de-session1IgnoreDependency-desc + + session1IgnoreDependencyInjection1Class + session1IgnoreDependencyInjection1Name + + + session1IgnoreDependencyInjection2Class + session1IgnoreDependencyInjection2Name + + + + session1AOPDomain + + + session1CacheClass + 10 + 11 + 12 + session1CacheName + session1PersistenceManager + SYNCHRONOUS + -1 + + + + session1PoolClass + 10 + 11 + + + true + + + + en-session1JndiRef1-desc + fr-session1JndiRef1-desc + de-session1JndiRef1-desc + session1JndiRef1Name + session1JndiRef1MappedName + + session1JndiRef1Injection1Class + session1JndiRef1Injection1Name + + + session1JndiRef1Injection2Class + session1JndiRef1Injection2Name + + + + en-session1JndiRef2-desc + fr-session1JndiRef2-desc + de-session1JndiRef2-desc + session1JndiRef2Name + session1JndiRef2MappedName + + session1JndiRef2Injection1Class + session1JndiRef2Injection1Name + + + session1JndiRef2Injection2Class + session1JndiRef2Injection2Name + + + + + session1-PortComponent + /session1/PortComponentURI + BASIC + NONE + true + + + + en-session1EjbTimeoutIdentity-desc + fr-session1EjbTimeoutIdentity-desc + de-session1EjbTimeoutIdentity-desc + session1EjbTimeoutIdentityRunAsPrincipal + + + + + + en-session2-desc + fr-session2-desc + de-session2-desc + en-session2-disp + fr-session2-disp + de-session2-disp + + en-session2-small-icon + en-session2-large-icon + + + fr-session2-small-icon + fr-session2-large-icon + + + de-session2-small-icon + de-session2-large-icon + + + session2EjbName + + + en-session2EjbRef1-desc + fr-session2EjbRef1-desc + de-session2EjbRef1-desc + + session2EjbRef1Name + session2EjbRef1JndiName + + session2EjbRef1Injection1Class + session2EjbRef1Injection1Name + + + session2EjbRef1Injection2Class + session2EjbRef1Injection2Name + + + + + en-session2EjbRef2-desc + fr-session2EjbRef2-desc + de-session2EjbRef2-desc + + session2EjbRef2Name + session2EjbRef2JndiName + + session2EjbRef2Injection1Class + session2EjbRef2Injection1Name + + + session2EjbRef2Injection2Class + session2EjbRef2Injection2Name + + + + + en-session2EjbLocalRef1-desc + fr-session2EjbLocalRef1-desc + de-session2EjbLocalRef1-desc + + session2EjbLocalRef1Name + session2EjbLocalRef1JndiName + + session2EjbLocalRef1Injection1Class + session2EjbLocalRef1Injection1Name + + + session2EjbLocalRef1Injection2Class + session2EjbLocalRef1Injection2Name + + + + + en-session2EjbLocalRef2-desc + fr-session2EjbLocalRef2-desc + de-session2EjbLocalRef2-desc + + session2EjbLocalRef2Name + session2EjbLocalRef2JndiName + + session2EjbLocalRef2Injection1Class + session2EjbLocalRef2Injection1Name + + + session2EjbLocalRef2Injection2Class + session2EjbLocalRef2Injection2Name + + + + + + + en-session2ResourceRef1-desc + fr-session2ResourceRef1-desc + de-session2ResourceRef1-desc + session2ResourceRef1Name + session2ResourceRef1JndiName + + session2ResourceRef1Injection1Class + session2ResourceRef1Injection1Name + + + session2ResourceRef1Injection2Class + session2ResourceRef1Injection2Name + + + + + en-session2ResourceRef2-desc + fr-session2ResourceRef2-desc + de-session2ResourceRef2-desc + session2ResourceRef2Name + session2ResourceRef2JndiName + + session2ResourceRef2Injection1Class + session2ResourceRef2Injection1Name + + + session2ResourceRef2Injection2Class + session2ResourceRef2Injection2Name + + + + en-session2ResourceEnvRef1-desc + fr-session2ResourceEnvRef1-desc + de-session2ResourceEnvRef1-desc + session2ResourceEnvRef1Name + session2ResourceEnvRef1JndiName + + session2ResourceEnvRef1Injection1Class + session2ResourceEnvRef1Injection1Name + + + session2ResourceEnvRef1Injection2Class + session2ResourceEnvRef1Injection2Name + + + + + en-session2ResourceEnvRef2-desc + fr-session2ResourceEnvRef2-desc + de-session2ResourceEnvRef2-desc + session2ResourceEnvRef2Name + session2ResourceEnvRef2JndiName + + session2ResourceEnvRef2Injection1Class + session2ResourceEnvRef2Injection1Name + + + session2ResourceEnvRef2Injection2Class + session2ResourceEnvRef2Injection2Name + + + + en-session2MessageDestinationRef1-desc + fr-session2MessageDestinationRef1-desc + de-session2MessageDestinationRef1-desc + session2MessageDestinationRef1Name + session2MessageDestinationRef1JndiName + + session2MessageDestinationRef1Injection1Class + session2MessageDestinationRef1Injection1Name + + + session2MessageDestinationRef1Injection2Class + session2MessageDestinationRef1Injection2Name + + + + + en-session2MessageDestinationRef2-desc + fr-session2MessageDestinationRef2-desc + de-session2MessageDestinationRef2-desc + session2MessageDestinationRef2Name + session2MessageDestinationRef2JndiName + + session2MessageDestinationRef2Injection1Class + session2MessageDestinationRef2Injection1Name + + + session2MessageDestinationRef2Injection2Class + session2MessageDestinationRef2Injection2Name + + + + en-session2MessageDestinationRef3-desc + fr-session2MessageDestinationRef3-desc + de-session2MessageDestinationRef3-desc + session2MessageDestinationRef3Name + session2MessageDestinationRef3JndiName + + session2MessageDestinationRef3Injection1Class + session2MessageDestinationRef3Injection1Name + + + session2MessageDestinationRef3Injection2Class + session2MessageDestinationRef3Injection2Name + + + + + en-session2SecurityIdentity-desc + fr-session2SecurityIdentity-desc + de-session2SecurityIdentity-desc + session2SecurityIdentityRunAsPrincipal + + + + en-session2RemoteBinding-desc + fr-session2RemoteBinding-desc + de-session2RemoteBinding-desc + session2RemoteBindingJndiName + session2RemoteBindingClientBindUrl + session2RemoteBindingInterceptorStack + session2RemoteBindingInvokerName + + + session2JndiName + session2HomeJndiName + + session2LocalJndiName + session2LocalHomeJndiName + + false + + + en-session2ClusterConfig-desc + fr-session2ClusterConfig-desc + de-session2ClusterConfig-desc + session2ClusterConfigPartitionName + session2ClusterConfigHomeLoadBalancePolicy + session2ClusterConfigBeanLoadBalancePolicy + session2ClusterConfigSessionStateManagerJndiName + + + session2SecurityDomain + + + + get* + true + true + 5000 + + + * + + + + session2Depends1 + session2Depends2 + + + en-session2Annotation1-desc + fr-session2Annotation1-desc + de-session2Annotation1-desc + + session2Annotation1Class + session2Annotation1Impl + + session2Annotation1InjectionTargetClass + session2Annotation1InjectionTargetName + + + en-session2Annotation1Property1-desc + fr-session2Annotation1Property1-desc + de-session2Annotation1Property1-desc + session2Annotation1Property1Name + session2Annotation1Property1Value + + + en-session2Annotation1Property2-desc + fr-session2Annotation1Property2-desc + de-session2Annotation1Property2-desc + session2Annotation1Property2Name + session2Annotation1Property2Value + + + + en-session2Annotation2-desc + fr-session2Annotation2-desc + de-session2Annotation2-desc + + session2Annotation2Class + session2Annotation2Impl + + session2Annotation2InjectionTargetClass + session2Annotation2InjectionTargetName + + + en-session2Annotation2Property1-desc + fr-session2Annotation2Property1-desc + de-session2Annotation2Property1-desc + session2Annotation2Property1Name + session2Annotation2Property1Value + + + en-session2Annotation2Property2-desc + fr-session2Annotation2Property2-desc + de-session2Annotation2Property2-desc + session2Annotation2Property2Name + session2Annotation2Property2Value + + + + + en-session2IgnoreDependency-desc + fr-session2IgnoreDependency-desc + de-session2IgnoreDependency-desc + + session2IgnoreDependencyInjection1Class + session2IgnoreDependencyInjection1Name + + + session2IgnoreDependencyInjection2Class + session2IgnoreDependencyInjection2Name + + + + session2AOPDomain + + + session2CacheClass + 20 + 22 + 24 + session2CacheName + session2PersistenceManager + SYNCHRONOUS + -1 + + + + session2PoolClass + 10 + 11 + + + false + + + en-session2JndiRef1-desc + fr-session2JndiRef1-desc + de-session2JndiRef1-desc + session2JndiRef1Name + session2JndiRef1MappedName + + session2JndiRef1Injection1Class + session2JndiRef1Injection1Name + + + session2JndiRef1Injection2Class + session2JndiRef1Injection2Name + + + + en-session2JndiRef2-desc + fr-session2JndiRef2-desc + de-session2JndiRef2-desc + session2JndiRef2Name + session2JndiRef2MappedName + + session2JndiRef2Injection1Class + session2JndiRef2Injection1Name + + + session2JndiRef2Injection2Class + session2JndiRef2Injection2Name + + + + + session2-PortComponent + /session2/PortComponentURI + BASIC + NONE + true + + + + en-session2EjbTimeoutIdentity-desc + fr-session2EjbTimeoutIdentity-desc + de-session2EjbTimeoutIdentity-desc + session2EjbTimeoutIdentityRunAsPrincipal + + + + + mdb0EjbName + + + + en-mdb1-desc + fr-mdb1-desc + de-mdb1-desc + en-mdb1-disp + fr-mdb1-disp + de-mdb1-disp + + en-mdb1-small-icon + en-mdb1-large-icon + + + fr-mdb1-small-icon + fr-mdb1-large-icon + + + de-mdb1-small-icon + de-mdb1-large-icon + + + mdb1EjbName + + + + mdb1ActivationConfigProperty1Name + mdb1ActivationConfigProperty1Value + + + mdb1ActivationConfigProperty2Name + mdb1ActivationConfigProperty2Value + + + + mdb1DestinationJndiName + mdb1User + mdb1Password + mdb1ClientId + mdb1SubscriptionId + mdb1RAR + + + en-mdb1EjbRef1-desc + fr-mdb1EjbRef1-desc + de-mdb1EjbRef1-desc + + mdb1EjbRef1Name + mdb1EjbRef1JndiName + + mdb1EjbRef1Injection1Class + mdb1EjbRef1Injection1Name + + + mdb1EjbRef1Injection2Class + mdb1EjbRef1Injection2Name + + + + + en-mdb1EjbRef2-desc + fr-mdb1EjbRef2-desc + de-mdb1EjbRef2-desc + + mdb1EjbRef2Name + mdb1EjbRef2JndiName + + mdb1EjbRef2Injection1Class + mdb1EjbRef2Injection1Name + + + mdb1EjbRef2Injection2Class + mdb1EjbRef2Injection2Name + + + + + en-mdb1EjbLocalRef1-desc + fr-mdb1EjbLocalRef1-desc + de-mdb1EjbLocalRef1-desc + + mdb1EjbLocalRef1Name + mdb1EjbLocalRef1JndiName + + mdb1EjbLocalRef1Injection1Class + mdb1EjbLocalRef1Injection1Name + + + mdb1EjbLocalRef1Injection2Class + mdb1EjbLocalRef1Injection2Name + + + + + en-mdb1EjbLocalRef2-desc + fr-mdb1EjbLocalRef2-desc + de-mdb1EjbLocalRef2-desc + + mdb1EjbLocalRef2Name + mdb1EjbLocalRef2JndiName + + mdb1EjbLocalRef2Injection1Class + mdb1EjbLocalRef2Injection1Name + + + mdb1EjbLocalRef2Injection2Class + mdb1EjbLocalRef2Injection2Name + + + + + + + en-mdb1ResourceRef1-desc + fr-mdb1ResourceRef1-desc + de-mdb1ResourceRef1-desc + mdb1ResourceRef1Name + mdb1ResourceRef1JndiName + + mdb1ResourceRef1Injection1Class + mdb1ResourceRef1Injection1Name + + + mdb1ResourceRef1Injection2Class + mdb1ResourceRef1Injection2Name + + + + + en-mdb1ResourceRef2-desc + fr-mdb1ResourceRef2-desc + de-mdb1ResourceRef2-desc + mdb1ResourceRef2Name + mdb1ResourceRef2JndiName + + mdb1ResourceRef2Injection1Class + mdb1ResourceRef2Injection1Name + + + mdb1ResourceRef2Injection2Class + mdb1ResourceRef2Injection2Name + + + + en-mdb1ResourceEnvRef1-desc + fr-mdb1ResourceEnvRef1-desc + de-mdb1ResourceEnvRef1-desc + mdb1ResourceEnvRef1Name + mdb1ResourceEnvRef1JndiName + + mdb1ResourceEnvRef1Injection1Class + mdb1ResourceEnvRef1Injection1Name + + + mdb1ResourceEnvRef1Injection2Class + mdb1ResourceEnvRef1Injection2Name + + + + + en-mdb1ResourceEnvRef2-desc + fr-mdb1ResourceEnvRef2-desc + de-mdb1ResourceEnvRef2-desc + mdb1ResourceEnvRef2Name + mdb1ResourceEnvRef2JndiName + + mdb1ResourceEnvRef2Injection1Class + mdb1ResourceEnvRef2Injection1Name + + + mdb1ResourceEnvRef2Injection2Class + mdb1ResourceEnvRef2Injection2Name + + + + en-mdb1MessageDestinationRef1-desc + fr-mdb1MessageDestinationRef1-desc + de-mdb1MessageDestinationRef1-desc + mdb1MessageDestinationRef1Name + mdb1MessageDestinationRef1JndiName + + mdb1MessageDestinationRef1Injection1Class + mdb1MessageDestinationRef1Injection1Name + + + mdb1MessageDestinationRef1Injection2Class + mdb1MessageDestinationRef1Injection2Name + + + + + en-mdb1MessageDestinationRef2-desc + fr-mdb1MessageDestinationRef2-desc + de-mdb1MessageDestinationRef2-desc + mdb1MessageDestinationRef2Name + mdb1MessageDestinationRef2JndiName + + mdb1MessageDestinationRef2Injection1Class + mdb1MessageDestinationRef2Injection1Name + + + mdb1MessageDestinationRef2Injection2Class + mdb1MessageDestinationRef2Injection2Name + + + + en-mdb1MessageDestinationRef3-desc + fr-mdb1MessageDestinationRef3-desc + de-mdb1MessageDestinationRef3-desc + mdb1MessageDestinationRef3Name + mdb1MessageDestinationRef3JndiName + + mdb1MessageDestinationRef3Injection1Class + mdb1MessageDestinationRef3Injection1Name + + + mdb1MessageDestinationRef3Injection2Class + mdb1MessageDestinationRef3Injection2Name + + + + + en-mdb1SecurityIdentity-desc + fr-mdb1SecurityIdentity-desc + de-mdb1SecurityIdentity-desc + mdb1SecurityIdentityRunAsPrincipal + + + + + get* + true + true + 5000 + + + * + + + + mdb1Depends1 + mdb1Depends2 + + + en-mdb1EjbTimeoutIdentity-desc + fr-mdb1EjbTimeoutIdentity-desc + de-mdb1EjbTimeoutIdentity-desc + mdb1EjbTimeoutIdentityRunAsPrincipal + + + + en-mdb1Annotation1-desc + fr-mdb1Annotation1-desc + de-mdb1Annotation1-desc + + mdb1Annotation1Class + mdb1Annotation1Impl + + mdb1Annotation1InjectionTargetClass + mdb1Annotation1InjectionTargetName + + + en-mdb1Annotation1Property1-desc + fr-mdb1Annotation1Property1-desc + de-mdb1Annotation1Property1-desc + mdb1Annotation1Property1Name + mdb1Annotation1Property1Value + + + en-mdb1Annotation1Property2-desc + fr-mdb1Annotation1Property2-desc + de-mdb1Annotation1Property2-desc + mdb1Annotation1Property2Name + mdb1Annotation1Property2Value + + + + en-mdb1Annotation2-desc + fr-mdb1Annotation2-desc + de-mdb1Annotation2-desc + + mdb1Annotation2Class + mdb1Annotation2Impl + + mdb1Annotation2InjectionTargetClass + mdb1Annotation2InjectionTargetName + + + en-mdb1Annotation2Property1-desc + fr-mdb1Annotation2Property1-desc + de-mdb1Annotation2Property1-desc + mdb1Annotation2Property1Name + mdb1Annotation2Property1Value + + + en-mdb1Annotation2Property2-desc + fr-mdb1Annotation2Property2-desc + de-mdb1Annotation2Property2-desc + mdb1Annotation2Property2Name + mdb1Annotation2Property2Value + + + + + en-mdb1IgnoreDependency-desc + fr-mdb1IgnoreDependency-desc + de-mdb1IgnoreDependency-desc + + mdb1IgnoreDependencyInjection1Class + mdb1IgnoreDependencyInjection1Name + + + mdb1IgnoreDependencyInjection2Class + mdb1IgnoreDependencyInjection2Name + + + + mdb1AOPDomain + + + + + en-mdb1JndiRef1-desc + fr-mdb1JndiRef1-desc + de-mdb1JndiRef1-desc + mdb1JndiRef1Name + mdb1JndiRef1MappedName + + mdb1JndiRef1Injection1Class + mdb1JndiRef1Injection1Name + + + mdb1JndiRef1Injection2Class + mdb1JndiRef1Injection2Name + + + + en-mdb1JndiRef2-desc + fr-mdb1JndiRef2-desc + de-mdb1JndiRef2-desc + mdb1JndiRef2Name + mdb1JndiRef2MappedName + + mdb1JndiRef2Injection1Class + mdb1JndiRef2Injection1Name + + + mdb1JndiRef2Injection2Class + mdb1JndiRef2Injection2Name + + + + + + en-mdb2-desc + fr-mdb2-desc + de-mdb2-desc + en-mdb2-disp + fr-mdb2-disp + de-mdb2-disp + + en-mdb2-small-icon + en-mdb2-large-icon + + + fr-mdb2-small-icon + fr-mdb2-large-icon + + + de-mdb2-small-icon + de-mdb2-large-icon + + + mdb2EjbName + + + + mdb2ActivationConfigProperty1Name + mdb2ActivationConfigProperty1Value + + + mdb2ActivationConfigProperty2Name + mdb2ActivationConfigProperty2Value + + + + mdb2DestinationJndiName + mdb2User + mdb2Password + mdb2ClientId + mdb2SubscriptionId + mdb2RAR + + + en-mdb2EjbRef1-desc + fr-mdb2EjbRef1-desc + de-mdb2EjbRef1-desc + + mdb2EjbRef1Name + mdb2EjbRef1JndiName + + mdb2EjbRef1Injection1Class + mdb2EjbRef1Injection1Name + + + mdb2EjbRef1Injection2Class + mdb2EjbRef1Injection2Name + + + + + en-mdb2EjbRef2-desc + fr-mdb2EjbRef2-desc + de-mdb2EjbRef2-desc + + mdb2EjbRef2Name + mdb2EjbRef2JndiName + + mdb2EjbRef2Injection1Class + mdb2EjbRef2Injection1Name + + + mdb2EjbRef2Injection2Class + mdb2EjbRef2Injection2Name + + + + + en-mdb2EjbLocalRef1-desc + fr-mdb2EjbLocalRef1-desc + de-mdb2EjbLocalRef1-desc + + mdb2EjbLocalRef1Name + mdb2EjbLocalRef1JndiName + + mdb2EjbLocalRef1Injection1Class + mdb2EjbLocalRef1Injection1Name + + + mdb2EjbLocalRef1Injection2Class + mdb2EjbLocalRef1Injection2Name + + + + + en-mdb2EjbLocalRef2-desc + fr-mdb2EjbLocalRef2-desc + de-mdb2EjbLocalRef2-desc + + mdb2EjbLocalRef2Name + mdb2EjbLocalRef2JndiName + + mdb2EjbLocalRef2Injection1Class + mdb2EjbLocalRef2Injection1Name + + + mdb2EjbLocalRef2Injection2Class + mdb2EjbLocalRef2Injection2Name + + + + + + + en-mdb2ResourceRef1-desc + fr-mdb2ResourceRef1-desc + de-mdb2ResourceRef1-desc + mdb2ResourceRef1Name + mdb2ResourceRef1JndiName + + mdb2ResourceRef1Injection1Class + mdb2ResourceRef1Injection1Name + + + mdb2ResourceRef1Injection2Class + mdb2ResourceRef1Injection2Name + + + + + en-mdb2ResourceRef2-desc + fr-mdb2ResourceRef2-desc + de-mdb2ResourceRef2-desc + mdb2ResourceRef2Name + mdb2ResourceRef2JndiName + + mdb2ResourceRef2Injection1Class + mdb2ResourceRef2Injection1Name + + + mdb2ResourceRef2Injection2Class + mdb2ResourceRef2Injection2Name + + + + en-mdb2ResourceEnvRef1-desc + fr-mdb2ResourceEnvRef1-desc + de-mdb2ResourceEnvRef1-desc + mdb2ResourceEnvRef1Name + mdb2ResourceEnvRef1JndiName + + mdb2ResourceEnvRef1Injection1Class + mdb2ResourceEnvRef1Injection1Name + + + mdb2ResourceEnvRef1Injection2Class + mdb2ResourceEnvRef1Injection2Name + + + + + en-mdb2ResourceEnvRef2-desc + fr-mdb2ResourceEnvRef2-desc + de-mdb2ResourceEnvRef2-desc + mdb2ResourceEnvRef2Name + mdb2ResourceEnvRef2JndiName + + mdb2ResourceEnvRef2Injection1Class + mdb2ResourceEnvRef2Injection1Name + + + mdb2ResourceEnvRef2Injection2Class + mdb2ResourceEnvRef2Injection2Name + + + + en-mdb2MessageDestinationRef1-desc + fr-mdb2MessageDestinationRef1-desc + de-mdb2MessageDestinationRef1-desc + mdb2MessageDestinationRef1Name + mdb2MessageDestinationRef1JndiName + + mdb2MessageDestinationRef1Injection1Class + mdb2MessageDestinationRef1Injection1Name + + + mdb2MessageDestinationRef1Injection2Class + mdb2MessageDestinationRef1Injection2Name + + + + + en-mdb2MessageDestinationRef2-desc + fr-mdb2MessageDestinationRef2-desc + de-mdb2MessageDestinationRef2-desc + mdb2MessageDestinationRef2Name + mdb2MessageDestinationRef2JndiName + + mdb2MessageDestinationRef2Injection1Class + mdb2MessageDestinationRef2Injection1Name + + + mdb2MessageDestinationRef2Injection2Class + mdb2MessageDestinationRef2Injection2Name + + + + en-mdb2MessageDestinationRef3-desc + fr-mdb2MessageDestinationRef3-desc + de-mdb2MessageDestinationRef3-desc + mdb2MessageDestinationRef3Name + mdb2MessageDestinationRef3JndiName + + mdb2MessageDestinationRef3Injection1Class + mdb2MessageDestinationRef3Injection1Name + + + mdb2MessageDestinationRef3Injection2Class + mdb2MessageDestinationRef3Injection2Name + + + + + en-mdb2SecurityIdentity-desc + fr-mdb2SecurityIdentity-desc + de-mdb2SecurityIdentity-desc + mdb2SecurityIdentityRunAsPrincipal + + + + + get* + true + true + 5000 + + + * + + + + mdb2Depends1 + mdb2Depends2 + + + en-mdb2EjbTimeoutIdentity-desc + fr-mdb2EjbTimeoutIdentity-desc + de-mdb2EjbTimeoutIdentity-desc + mdb2EjbTimeoutIdentityRunAsPrincipal + + + + en-mdb2Annotation1-desc + fr-mdb2Annotation1-desc + de-mdb2Annotation1-desc + + mdb2Annotation1Class + mdb2Annotation1Impl + + mdb2Annotation1InjectionTargetClass + mdb2Annotation1InjectionTargetName + + + en-mdb2Annotation1Property1-desc + fr-mdb2Annotation1Property1-desc + de-mdb2Annotation1Property1-desc + mdb2Annotation1Property1Name + mdb2Annotation1Property1Value + + + en-mdb2Annotation1Property2-desc + fr-mdb2Annotation1Property2-desc + de-mdb2Annotation1Property2-desc + mdb2Annotation1Property2Name + mdb2Annotation1Property2Value + + + + en-mdb2Annotation2-desc + fr-mdb2Annotation2-desc + de-mdb2Annotation2-desc + + mdb2Annotation2Class + mdb2Annotation2Impl + + mdb2Annotation2InjectionTargetClass + mdb2Annotation2InjectionTargetName + + + en-mdb2Annotation2Property1-desc + fr-mdb2Annotation2Property1-desc + de-mdb2Annotation2Property1-desc + mdb2Annotation2Property1Name + mdb2Annotation2Property1Value + + + en-mdb2Annotation2Property2-desc + fr-mdb2Annotation2Property2-desc + de-mdb2Annotation2Property2-desc + mdb2Annotation2Property2Name + mdb2Annotation2Property2Value + + + + + en-mdb2IgnoreDependency-desc + fr-mdb2IgnoreDependency-desc + de-mdb2IgnoreDependency-desc + + mdb2IgnoreDependencyInjection1Class + mdb2IgnoreDependencyInjection1Name + + + mdb2IgnoreDependencyInjection2Class + mdb2IgnoreDependencyInjection2Name + + + + mdb2AOPDomain + + + + + en-mdb2JndiRef1-desc + fr-mdb2JndiRef1-desc + de-mdb2JndiRef1-desc + mdb2JndiRef1Name + mdb2JndiRef1MappedName + + mdb2JndiRef1Injection1Class + mdb2JndiRef1Injection1Name + + + mdb2JndiRef1Injection2Class + mdb2JndiRef1Injection2Name + + + + en-mdb2JndiRef2-desc + fr-mdb2JndiRef2-desc + de-mdb2JndiRef2-desc + mdb2JndiRef2Name + mdb2JndiRef2MappedName + + mdb2JndiRef2Injection1Class + mdb2JndiRef2Injection1Name + + + mdb2JndiRef2Injection2Class + mdb2JndiRef2Injection2Name + + + + + + + + + + en-securityRole1-desc + fr-securityRole1-desc + de-securityRole1-desc + securityRoleRef1RoleLink + securityRole1Principal1 + securityRole1Principal2 + + + en-securityRole2-desc + fr-securityRole2-desc + de-securityRole2-desc + securityRoleRef2RoleLink + securityRole2Principal1 + securityRole2Principal2 + + + + en-messageDestination1-desc + fr-messageDestination1-desc + de-messageDestination1-desc + en-messageDestination1-disp + fr-messageDestination1-disp + de-messageDestination1-disp + + en-messageDestination1-small-icon + en-messageDestination1-large-icon + + + fr-messageDestination1-small-icon + fr-messageDestination1-large-icon + + + de-messageDestination1-small-icon + de-messageDestination1-large-icon + + messageDestination1Name + messageDestination1JndiName + + + en-messageDestination2-desc + fr-messageDestination2-desc + de-messageDestination2-desc + en-messageDestination2-disp + fr-messageDestination2-disp + de-messageDestination2-disp + + en-messageDestination2-small-icon + en-messageDestination2-large-icon + + + fr-messageDestination2-small-icon + fr-messageDestination2-large-icon + + + de-messageDestination2-small-icon + de-messageDestination2-large-icon + + messageDestination2Name + messageDestination2JndiName + + + + + + en-resource-managers-desc + fr-resource-managers-desc + de-resource-managers-desc + + en-resourceManager1-desc + fr-resourceManager1-desc + de-resourceManager1-desc + resourceManager1Name + resourceManager1JndiName + + + en-resourceManager2-desc + fr-resourceManager2-desc + de-resourceManager2-desc + resourceManager2Name + resourceManager2URL + + + + \ No newline at end of file Property changes on: src/test/resources/org/jboss/test/metadata/ejb/JBoss60Everything_testEverything.xml ___________________________________________________________________ Added: svn:keywords + Id Revision Added: svn:eol-style + LF Index: src/main/java/org/jboss/metadata/ejb/jboss/JBoss60MetaData.java =================================================================== --- src/main/java/org/jboss/metadata/ejb/jboss/JBoss60MetaData.java (revision 0) +++ src/main/java/org/jboss/metadata/ejb/jboss/JBoss60MetaData.java (revision 0) @@ -0,0 +1,89 @@ +/* +* JBoss, Home of Professional Open Source +* Copyright 2010, JBoss Inc., and individual contributors as indicated +* by the @authors tag. See the copyright.txt in the distribution for a +* full listing of individual contributors. +* +* This is free software; you can redistribute it and/or modify it +* under the terms of the GNU Lesser General Public License as +* published by the Free Software Foundation; either version 2.1 of +* the License, or (at your option) any later version. +* +* This software is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* Lesser General Public License for more details. +* +* You should have received a copy of the GNU Lesser General Public +* License along with this software; if not, write to the Free +* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA +* 02110-1301 USA, or see the FSF site: http://www.fsf.org. +*/ +package org.jboss.metadata.ejb.jboss; + +import org.jboss.metadata.javaee.spec.JavaEEMetaDataConstants; +import org.jboss.xb.annotations.JBossXmlSchema; + +import javax.xml.bind.annotation.XmlAttribute; +import javax.xml.bind.annotation.XmlElement; +import javax.xml.bind.annotation.XmlElementWrapper; +import javax.xml.bind.annotation.XmlElements; +import javax.xml.bind.annotation.XmlNs; +import javax.xml.bind.annotation.XmlNsForm; +import javax.xml.bind.annotation.XmlRootElement; +import javax.xml.bind.annotation.XmlType; + +/** + * 5.0 jboss.xml metadata + * + */ +@XmlRootElement(name="jboss", namespace=JavaEEMetaDataConstants.JBOSS_NS) +@JBossXmlSchema( + xmlns={@XmlNs(namespaceURI = JavaEEMetaDataConstants.JAVAEE_NS, prefix = "jee")}, + ignoreUnresolvedFieldOrClass=false, + namespace=JavaEEMetaDataConstants.JBOSS_NS, + elementFormDefault=XmlNsForm.QUALIFIED, + normalizeSpace=true) +@XmlType(name="jbossType", namespace=JavaEEMetaDataConstants.JBOSS_NS, propOrder={"descriptionGroup", "loaderRepository", + "jmxName", "securityDomain", "excludeMissingMethods", "unauthenticatedPrincipal", + "jndiBindingPolicy", "jaccContextID", "webservices", "enterpriseBeans", "assemblyDescriptor", + "resourceManagers"}) +public class JBoss60MetaData extends JBossMetaData +{ + /** The serialVersionUID */ + private static final long serialVersionUID = 1; + + /** + * Create a new JBoss60MetaData. + */ + public JBoss60MetaData() + { + // For serialization + } + + @XmlAttribute + public void setVersion(String v) + { + super.setVersion(v); + } + + @Override + @XmlElementWrapper(name="enterprise-beans") + @XmlElements({ + @XmlElement(name="session", type=JBoss51SessionBeanMetaData.class), + @XmlElement(name="message-driven", type=JBoss51MessageDrivenBeanMetaData.class), + @XmlElement(name="consumer", type=JBoss51ConsumerBeanMetaData.class), + @XmlElement(name="ejb", type=JBoss51GenericBeanMetaData.class), + @XmlElement(name="service", type=JBoss51ServiceBeanMetaData.class) + }) + public JBossEnterpriseBeansMetaData getEnterpriseBeans() + { + return super.getEnterpriseBeans(); + } + + @Override + public void setEnterpriseBeans(JBossEnterpriseBeansMetaData beans) + { + super.setEnterpriseBeans(beans); + } +} Property changes on: src/main/java/org/jboss/metadata/ejb/jboss/JBoss60MetaData.java ___________________________________________________________________ Added: svn:keywords + Id Revision Added: svn:eol-style + LF