Merge remote-tracking branch 'upstream/main' into wip/6.0_merge_1

hibernate-core/hibernate-core.gradle

@@ -50,11 +50,6 @@ dependencies {
     compile( libraries.classmate )
     compile( libraries.activation )
 
-    // We need dom4j for a number of things temporarily:
-    //      1) (unsupported) EntityMode.DOM4J support
-    //      2) Envers
-    //      3) hibernate-commons-annotations
-    compile( libraries.dom4j )
     compile( libraries.commons_annotations )
 
     // JAXB

hibernate-core/src/main/java/org/hibernate/boot/internal/BootstrapContextImpl.java

@@ -31,7 +31,6 @@ import org.hibernate.boot.spi.BootstrapContext;
 import org.hibernate.boot.spi.ClassLoaderAccess;
 import org.hibernate.boot.spi.MetadataBuildingOptions;
 import org.hibernate.cfg.AvailableSettings;
-import org.hibernate.cfg.annotations.reflection.JPAMetadataProvider;
 import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenMetadataProvider;
 import org.hibernate.engine.config.spi.ConfigurationService;
 import org.hibernate.jpa.internal.MutableJpaComplianceImpl;
@@ -320,13 +319,7 @@ public class BootstrapContextImpl implements BootstrapContext {
 
 	private JavaReflectionManager generateHcannReflectionManager() {
 		final JavaReflectionManager reflectionManager = new JavaReflectionManager();
-		if ( metadataBuildingOptions.getXmlMappingOptions().isPreferJaxb() ) {
+		reflectionManager.setMetadataProvider( new JPAXMLOverriddenMetadataProvider( this ) );
-			reflectionManager.setMetadataProvider( new JPAXMLOverriddenMetadataProvider( this ) );
-		}
-		else {
-			// Legacy implementation based on DOM4J, for backwards compatibility.
-			reflectionManager.setMetadataProvider( new JPAMetadataProvider( this ) );
-		}
 		return reflectionManager;
 	}
 

hibernate-core/src/main/java/org/hibernate/boot/internal/MetadataBuilderImpl.java

@@ -28,7 +28,6 @@ import org.hibernate.boot.archive.spi.ArchiveDescriptorFactory;
 import org.hibernate.boot.cfgxml.spi.CfgXmlAccessService;
 import org.hibernate.boot.cfgxml.spi.LoadedConfig;
 import org.hibernate.boot.cfgxml.spi.MappingReference;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.boot.model.IdGeneratorStrategyInterpreter;
 import org.hibernate.boot.model.TypeContributions;
 import org.hibernate.boot.model.TypeContributor;
@@ -555,7 +554,7 @@ public class MetadataBuilderImpl implements MetadataBuilderImplementor, TypeCont
 		private IdGeneratorInterpreterImpl idGenerationTypeInterpreter = new IdGeneratorInterpreterImpl();
 
 		private String schemaCharset;
-		private final XmlMappingOptions xmlMappingOptions;
+		private final boolean xmlMappingEnabled;
 
 		public MetadataBuildingOptionsImpl(StandardServiceRegistry serviceRegistry) {
 			this.serviceRegistry = serviceRegistry;
@@ -567,7 +566,11 @@ public class MetadataBuilderImpl implements MetadataBuilderImplementor, TypeCont
 
 			this.multiTenancyStrategy =  MultiTenancyStrategy.determineMultiTenancyStrategy( configService.getSettings() );
 
-			xmlMappingOptions = XmlMappingOptions.get( serviceRegistry );
+			this.xmlMappingEnabled = configService.getSetting(
+					AvailableSettings.XML_MAPPING_ENABLED,
+					StandardConverters.BOOLEAN,
+					true
+			);
 
 			this.implicitDiscriminatorsForJoinedInheritanceSupported = configService.getSetting(
 					AvailableSettings.IMPLICIT_DISCRIMINATOR_COLUMNS_FOR_JOINED_SUBCLASS,
@@ -840,8 +843,8 @@ public class MetadataBuilderImpl implements MetadataBuilderImplementor, TypeCont
 		}
 
 		@Override
-		public XmlMappingOptions getXmlMappingOptions() {
+		public boolean isXmlMappingEnabled() {
-			return xmlMappingOptions;
+			return xmlMappingEnabled;
 		}
 
 		/**

hibernate-core/src/main/java/org/hibernate/boot/jaxb/internal/DefaultXmlMappingOptions.java

@@ -1,12 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later
- * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
- */
-package org.hibernate.boot.jaxb.internal;
-
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
-
-public class DefaultXmlMappingOptions implements XmlMappingOptions {
-}

hibernate-core/src/main/java/org/hibernate/boot/jaxb/internal/MappingBinder.java

@@ -10,11 +10,8 @@ import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import javax.xml.stream.XMLEventFactory;
 import javax.xml.stream.XMLEventReader;
-import javax.xml.stream.XMLStreamException;
 import javax.xml.stream.events.StartElement;
-import javax.xml.stream.events.XMLEvent;
 
-import org.hibernate.boot.MappingException;
 import org.hibernate.boot.UnsupportedOrmXsdVersionException;
 import org.hibernate.boot.jaxb.Origin;
 import org.hibernate.boot.jaxb.hbm.spi.JaxbHbmHibernateMapping;
@@ -22,17 +19,12 @@ import org.hibernate.boot.jaxb.internal.stax.HbmEventReader;
 import org.hibernate.boot.jaxb.internal.stax.JpaOrmXmlEventReader;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
 import org.hibernate.boot.jaxb.spi.Binding;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
 import org.hibernate.boot.xsd.MappingXsdSupport;
 import org.hibernate.internal.util.config.ConfigurationException;
 
 import org.jboss.logging.Logger;
 
-import org.dom4j.Document;
-import org.dom4j.Node;
-import org.dom4j.io.STAXEventReader;
-
 /**
  * @author Steve Ebersole
  */
@@ -41,14 +33,11 @@ public class MappingBinder extends AbstractBinder {
 
 	private final XMLEventFactory xmlEventFactory = XMLEventFactory.newInstance();
 
-	private final XmlMappingOptions options;
-
 	private JAXBContext hbmJaxbContext;
 	private JAXBContext entityMappingsJaxbContext;
 
-	public MappingBinder(ClassLoaderService classLoaderService, boolean validateXml, XmlMappingOptions options) {
+	public MappingBinder(ClassLoaderService classLoaderService, boolean validateXml) {
 		super( classLoaderService, validateXml );
-		this.options = options;
 	}
 
 	@Override
@@ -68,19 +57,11 @@ public class MappingBinder extends AbstractBinder {
 		}
 		else {
 			try {
-				if ( options.isPreferJaxb() ) {
+				log.debugf( "Performing JAXB binding of orm.xml document : %s", origin.toString() );
-					log.debugf( "Performing JAXB binding of orm.xml document : %s", origin.toString() );
 
-					XMLEventReader reader = new JpaOrmXmlEventReader( staxEventReader, xmlEventFactory );
+				XMLEventReader reader = new JpaOrmXmlEventReader( staxEventReader, xmlEventFactory );
-					JaxbEntityMappings bindingRoot = jaxb( reader, MappingXsdSupport.INSTANCE.latestJpaDescriptor().getSchema(), entityMappingsJaxbContext(), origin );
+				JaxbEntityMappings bindingRoot = jaxb( reader, MappingXsdSupport.INSTANCE.latestJpaDescriptor().getSchema(), entityMappingsJaxbContext(), origin );
-					return new Binding<>( bindingRoot, origin );
+				return new Binding<>( bindingRoot, origin );
-				}
-				else {
-					log.debugf( "Performing DOM4J binding of orm.xml document : %s", origin.toString() );
-
-					final XMLEventReader reader = new JpaOrmXmlEventReader( staxEventReader, xmlEventFactory );
-					return new Binding<>( toDom4jDocument( reader, origin ), origin );
-				}
 			}
 			catch (JpaOrmXmlEventReader.BadVersionException e) {
 				throw new UnsupportedOrmXsdVersionException( e.getRequestedVersion(), origin );
@@ -111,32 +92,4 @@ public class MappingBinder extends AbstractBinder {
 		}
 		return entityMappingsJaxbContext;
 	}
-
-	private Document toDom4jDocument(XMLEventReader jpaOrmXmlEventReader, Origin origin) {
-		// todo : do we need to build a DocumentFactory instance for use here?
-		//		historically we did that to set TCCL since, iirc, dom4j uses TCCL
-		org.dom4j.io.STAXEventReader staxToDom4jReader = new STAXEventReader() {
-			@Override
-			public Node readNode(XMLEventReader reader) throws XMLStreamException {
-				// dom4j's reader misses handling of XML comments.  So if the document we
-				// are trying to read has comments this process will blow up.  So we
-				// override that to add that support as best we can
-				XMLEvent event = reader.peek();
-				if ( event instanceof javax.xml.stream.events.Comment ) {
-					return super.readComment( reader );
-				}
-				return super.readNode( reader );
-			}
-		};
-		try {
-			return staxToDom4jReader.readDocument( jpaOrmXmlEventReader );
-		}
-		catch (XMLStreamException e) {
-			throw new MappingException(
-					"An error occurred transforming orm.xml document from StAX to dom4j representation ",
-					e,
-					origin
-			);
-		}
-	}
 }

hibernate-core/src/main/java/org/hibernate/boot/jaxb/spi/XmlMappingOptions.java

@@ -1,86 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later
- * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
- */
-package org.hibernate.boot.jaxb.spi;
-
-import org.hibernate.boot.jaxb.internal.DefaultXmlMappingOptions;
-import org.hibernate.boot.registry.selector.spi.StrategySelector;
-import org.hibernate.cfg.AvailableSettings;
-import org.hibernate.engine.config.spi.ConfigurationService;
-import org.hibernate.engine.config.spi.StandardConverters;
-import org.hibernate.service.ServiceRegistry;
-
-/**
- * The options of XML mapping.
- * <p>
- * We're using an interface instead of simply configuration properties,
- * so that we can override the options easily in integrations (Quarkus)
- * and tests (to run the tests multiple times with different options).
- */
-public interface XmlMappingOptions {
-
-	String DEFAULT_NAME = "default";
-
-	static XmlMappingOptions get(ServiceRegistry serviceRegistry) {
-		final ConfigurationService configService = serviceRegistry.getService( ConfigurationService.class );
-
-		// The config service may be null if we're using a BootstrapServiceRegistry,
-		// since configuration properties are unknown at that point.
-		// That can happen with MetadataSources in particular,
-		// because for some reason we allow MetadataSources to be built before the StandardServiceRegistry
-		// (and Quarkus relies on that).
-		// That's why we prefer to rely on strategies (see below):
-		// they can be customized without relying on configuration properties
-		// through the service loader.
-		boolean xmlMappingEnabled = configService == null || configService.getSetting(
-				AvailableSettings.XML_MAPPING_ENABLED,
-				StandardConverters.BOOLEAN,
-				true
-		);
-
-		XmlMappingOptions result;
-		if ( !xmlMappingEnabled ) {
-			result = new XmlMappingOptions() {
-				@Override
-				public boolean isEnabled() {
-					return false;
-				}
-			};
-		}
-		else {
-			StrategySelector strategySelector = serviceRegistry.getService( StrategySelector.class );
-			result = strategySelector.resolveDefaultableStrategy(
-					XmlMappingOptions.class,
-					XmlMappingOptions.DEFAULT_NAME,
-					new DefaultXmlMappingOptions()
-			);
-		}
-
-		return result;
-	}
-
-	/**
-	 * Allows to skip processing of XML Mapping.
-	 * This is for people using exclusively annotations to define their model, and might
-	 * be able to improve efficiency of booting Hibernate ORM.
-	 * By default, the XML mapping is taken into account.
-	 */
-	default boolean isEnabled() {
-		return true;
-	}
-
-	/**
-	 * Whether to prefer JAXB implementations for XML parsing,
-	 * or to rely on legacy behavior (JAXB for hbm.xml, DOM4J for orm.xml and Envers).
-	 * <p>
-	 * This option will be removed in a future major version (probably ORM 6.0)
-	 * where JAXB will always be used.
-	 */
-	default boolean isPreferJaxb() {
-		return false;
-	}
-
-}

hibernate-core/src/main/java/org/hibernate/boot/model/process/spi/MetadataBuildingProcess.java

@@ -15,7 +15,6 @@ import org.hibernate.boot.MetadataSources;
 import org.hibernate.boot.internal.InFlightMetadataCollectorImpl;
 import org.hibernate.boot.internal.MetadataBuildingContextRootImpl;
 import org.hibernate.boot.jaxb.internal.MappingBinder;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.boot.model.TypeContributions;
 import org.hibernate.boot.model.TypeContributor;
 import org.hibernate.boot.model.process.internal.ManagedResourcesImpl;
@@ -33,8 +32,11 @@ import org.hibernate.boot.spi.BootstrapContext;
 import org.hibernate.boot.spi.MetadataBuildingOptions;
 import org.hibernate.boot.spi.MetadataContributor;
 import org.hibernate.boot.spi.MetadataImplementor;
+import org.hibernate.cfg.AvailableSettings;
 import org.hibernate.cfg.MetadataSourceType;
 import org.hibernate.dialect.Dialect;
+import org.hibernate.engine.config.spi.ConfigurationService;
+import org.hibernate.engine.config.spi.StandardConverters;
 import org.hibernate.engine.jdbc.spi.JdbcServices;
 import org.hibernate.type.BasicType;
 import org.hibernate.type.BasicTypeRegistry;
@@ -95,11 +97,16 @@ public class MetadataBuildingProcess {
 			final MetadataSources sources,
 			final BootstrapContext bootstrapContext) {
 		final ManagedResourcesImpl managedResources = ManagedResourcesImpl.baseline( sources, bootstrapContext );
-		XmlMappingOptions xmlMappingOptions = XmlMappingOptions.get( bootstrapContext.getServiceRegistry() );
+		final ConfigurationService configService = bootstrapContext.getServiceRegistry().getService( ConfigurationService.class );
+		final boolean xmlMappingEnabled = configService.getSetting(
+				AvailableSettings.XML_MAPPING_ENABLED,
+				StandardConverters.BOOLEAN,
+				true
+		);
 		ScanningCoordinator.INSTANCE.coordinateScan(
 				managedResources,
 				bootstrapContext,
-				xmlMappingOptions.isEnabled() ? sources.getXmlMappingBinderAccess() : null
+				xmlMappingEnabled ? sources.getXmlMappingBinderAccess() : null
 		);
 		return managedResources;
 	}
@@ -146,7 +153,7 @@ public class MetadataBuildingProcess {
 
 		final MetadataSourceProcessor processor = new MetadataSourceProcessor() {
 			private final MetadataSourceProcessor hbmProcessor =
-						options.getXmlMappingOptions().isEnabled()
+						options.isXmlMappingEnabled()
 							? new HbmMetadataSourceProcessorImpl( managedResources, rootMetadataBuildingContext )
 							: new NoOpMetadataSourceProcessorImpl();
 
@@ -283,14 +290,13 @@ public class MetadataBuildingProcess {
 
 		metadataCollector.processSecondPasses( rootMetadataBuildingContext );
 
-		final XmlMappingOptions xmlMappingOptions = options.getXmlMappingOptions();
+		if ( options.isXmlMappingEnabled() ) {
-		if ( xmlMappingOptions.isEnabled() ) {
 			final Iterable<AdditionalJaxbMappingProducer> producers = classLoaderService.loadJavaServices( AdditionalJaxbMappingProducer.class );
 			if ( producers != null ) {
 				final EntityHierarchyBuilder hierarchyBuilder = new EntityHierarchyBuilder();
 				// final MappingBinder mappingBinder = new MappingBinder( true );
 				// We need to disable validation here.  It seems Envers is not producing valid (according to schema) XML
-				final MappingBinder mappingBinder = new MappingBinder( classLoaderService, false, xmlMappingOptions );
+				final MappingBinder mappingBinder = new MappingBinder( classLoaderService, false );
 				for ( AdditionalJaxbMappingProducer producer : producers ) {
 					log.tracef( "Calling AdditionalJaxbMappingProducer : %s", producer );
 					Collection<MappingDocument> additionalMappings = producer.produceAdditionalMappings(

hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/annotations/AnnotationMetadataSourceProcessorImpl.java

@@ -24,7 +24,6 @@ import org.hibernate.boot.AttributeConverterInfo;
 import org.hibernate.boot.internal.MetadataBuildingContextRootImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
 import org.hibernate.boot.jaxb.spi.Binding;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.boot.model.convert.spi.ConverterDescriptor;
 import org.hibernate.boot.model.process.spi.ManagedResources;
 import org.hibernate.boot.model.source.spi.MetadataSourceProcessor;
@@ -35,7 +34,6 @@ import org.hibernate.boot.spi.MetadataBuildingOptions;
 import org.hibernate.cfg.AnnotationBinder;
 import org.hibernate.cfg.InheritanceState;
 import org.hibernate.cfg.annotations.reflection.AttributeConverterDefinitionCollector;
-import org.hibernate.cfg.annotations.reflection.JPAMetadataProvider;
 import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenMetadataProvider;
 import org.hibernate.internal.util.StringHelper;
 import org.hibernate.internal.util.collections.CollectionHelper;
@@ -43,8 +41,6 @@ import org.hibernate.internal.util.collections.CollectionHelper;
 import org.jboss.jandex.IndexView;
 import org.jboss.logging.Logger;
 
-import org.dom4j.Document;
-
 /**
  * @author Steve Ebersole
  */
@@ -80,43 +76,24 @@ public class AnnotationMetadataSourceProcessorImpl implements MetadataSourceProc
 		this.classLoaderService = rootMetadataBuildingContext.getBuildingOptions().getServiceRegistry().getService( ClassLoaderService.class );
 
 		MetadataBuildingOptions metadataBuildingOptions = rootMetadataBuildingContext.getBuildingOptions();
-		XmlMappingOptions xmlMappingOptions = metadataBuildingOptions.getXmlMappingOptions();
+		if ( metadataBuildingOptions.isXmlMappingEnabled() ) {
-		if ( xmlMappingOptions.isEnabled() ) {
 			// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 			// Ewww.  This is temporary until we migrate to Jandex + StAX for annotation binding
-			if ( xmlMappingOptions.isPreferJaxb() ) {
+			final JPAXMLOverriddenMetadataProvider jpaMetadataProvider = (JPAXMLOverriddenMetadataProvider) ( (MetadataProviderInjector) reflectionManager )
-				final JPAXMLOverriddenMetadataProvider jpaMetadataProvider = (JPAXMLOverriddenMetadataProvider) ( (MetadataProviderInjector) reflectionManager )
+					.getMetadataProvider();
-						.getMetadataProvider();
+			for ( Binding<?> xmlBinding : managedResources.getXmlMappingBindings() ) {
-				for ( Binding<?> xmlBinding : managedResources.getXmlMappingBindings() ) {
+				Object root = xmlBinding.getRoot();
-					Object root = xmlBinding.getRoot();
+				if ( !(root instanceof JaxbEntityMappings) ) {
-					if ( !(root instanceof JaxbEntityMappings) ) {
+					continue;
-						continue;
-					}
-					JaxbEntityMappings entityMappings = (JaxbEntityMappings) xmlBinding.getRoot();
-
-					final List<String> classNames = jpaMetadataProvider.getXMLContext().addDocument( entityMappings );
-					for ( String className : classNames ) {
-						xClasses.add( toXClass( className, reflectionManager, classLoaderService ) );
-					}
 				}
-				jpaMetadataProvider.getXMLContext().applyDiscoveredAttributeConverters( attributeConverterManager );
+				JaxbEntityMappings entityMappings = (JaxbEntityMappings) xmlBinding.getRoot();
-			}
-			else {
-				final JPAMetadataProvider jpaMetadataProvider = (JPAMetadataProvider) ( (MetadataProviderInjector) reflectionManager )
-						.getMetadataProvider();
-				for ( Binding xmlBinding : managedResources.getXmlMappingBindings() ) {
-					if ( !org.dom4j.Document.class.isInstance( xmlBinding.getRoot() ) ) {
-						continue;
-					}
-					org.dom4j.Document dom4jDocument = (Document) xmlBinding.getRoot();
 
-					final List<String> classNames = jpaMetadataProvider.getXMLContext().addDocument( dom4jDocument );
+				final List<String> classNames = jpaMetadataProvider.getXMLContext().addDocument( entityMappings );
-					for ( String className : classNames ) {
+				for ( String className : classNames ) {
-						xClasses.add( toXClass( className, reflectionManager, classLoaderService ) );
+					xClasses.add( toXClass( className, reflectionManager, classLoaderService ) );
-					}
 				}
-				jpaMetadataProvider.getXMLContext().applyDiscoveredAttributeConverters( attributeConverterManager );
 			}
+			jpaMetadataProvider.getXMLContext().applyDiscoveredAttributeConverters( attributeConverterManager );
 			// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 		}
 

hibernate-core/src/main/java/org/hibernate/boot/model/source/spi/AttributeSource.java

@@ -35,7 +35,8 @@ public interface AttributeSource extends ToolingHintContextContainer {
 	public boolean isSingular();
 
 	/**
-	 * Ugh.  This is the deprecated DOM4J entity-mode feature
+	 * This is only useful to log warnings when these deprecated attributes are populated.
+	 * It was only useful for DOM4J entity-mode, which was removed a long time ago.
 	 *
 	 * @return The xml node name
 	 */

hibernate-core/src/main/java/org/hibernate/boot/registry/selector/internal/StrategySelectorBuilder.java

@@ -9,8 +9,6 @@ package org.hibernate.boot.registry.selector.internal;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.hibernate.boot.jaxb.internal.DefaultXmlMappingOptions;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
 import org.hibernate.boot.model.naming.ImplicitNamingStrategyComponentPathImpl;
 import org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl;
@@ -105,8 +103,6 @@ public class StrategySelectorBuilder {
 		addSqmMultiTableMutationStrategies( strategySelector );
 		addImplicitNamingStrategies( strategySelector );
 		addCacheKeysFactories( strategySelector );
-		strategySelector.registerStrategyImplementor( XmlMappingOptions.class, XmlMappingOptions.DEFAULT_NAME,
-				DefaultXmlMappingOptions.class );
 
 		// apply auto-discovered registrations
 		for ( StrategyRegistrationProvider provider : classLoaderService.loadJavaServices( StrategyRegistrationProvider.class ) ) {

hibernate-core/src/main/java/org/hibernate/boot/spi/AbstractDelegatingMetadataBuildingOptions.java

@@ -16,7 +16,6 @@ import org.hibernate.boot.CacheRegionDefinition;
 import org.hibernate.boot.archive.scan.spi.ScanEnvironment;
 import org.hibernate.boot.archive.scan.spi.ScanOptions;
 import org.hibernate.boot.archive.spi.ArchiveDescriptorFactory;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.boot.model.IdGeneratorStrategyInterpreter;
 import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
 import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
@@ -185,8 +184,8 @@ public abstract class AbstractDelegatingMetadataBuildingOptions implements Metad
 	}
 
 	@Override
-	public XmlMappingOptions getXmlMappingOptions() {
+	public boolean isXmlMappingEnabled() {
-		return delegate.getXmlMappingOptions();
+		return delegate.isXmlMappingEnabled();
 	}
 
 }

hibernate-core/src/main/java/org/hibernate/boot/spi/MetadataBuildingOptions.java

@@ -15,7 +15,6 @@ import org.hibernate.boot.CacheRegionDefinition;
 import org.hibernate.boot.archive.scan.spi.ScanEnvironment;
 import org.hibernate.boot.archive.scan.spi.ScanOptions;
 import org.hibernate.boot.archive.spi.ArchiveDescriptorFactory;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.boot.model.IdGeneratorStrategyInterpreter;
 import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
 import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
@@ -261,7 +260,7 @@ public interface MetadataBuildingOptions {
 		return null;
 	}
 
-	default XmlMappingOptions getXmlMappingOptions() {
+	default boolean isXmlMappingEnabled() {
-		return XmlMappingOptions.get( getServiceRegistry() );
+		return true;
 	}
 }

hibernate-core/src/main/java/org/hibernate/boot/spi/XmlMappingBinderAccess.java

@@ -20,11 +20,7 @@ import org.hibernate.boot.jaxb.internal.InputStreamXmlSource;
 import org.hibernate.boot.jaxb.internal.MappingBinder;
 import org.hibernate.boot.jaxb.internal.UrlXmlSource;
 import org.hibernate.boot.jaxb.spi.Binding;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
-import org.hibernate.cfg.AvailableSettings;
-import org.hibernate.engine.config.spi.ConfigurationService;
-import org.hibernate.engine.config.spi.StandardConverters;
 import org.hibernate.service.ServiceRegistry;
 
 import org.jboss.logging.Logger;
@@ -41,12 +37,10 @@ public class XmlMappingBinderAccess {
 	public XmlMappingBinderAccess(ServiceRegistry serviceRegistry) {
 		this.classLoaderService = serviceRegistry.getService( ClassLoaderService.class );
 
-		XmlMappingOptions xmlMappingOptions = XmlMappingOptions.get( serviceRegistry );
-
 		// NOTE : The boolean here indicates whether or not to perform validation as we load XML documents.
 		// Should we expose this setting?  Disabling would speed up JAXP and JAXB at runtime, but potentially
 		// at the cost of less obvious errors when a document is not valid.
-		this.mappingBinder = new MappingBinder( classLoaderService, true, xmlMappingOptions );
+		this.mappingBinder = new MappingBinder( classLoaderService, true );
 	}
 
 	public MappingBinder getMappingBinder() {

hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/JPAMetadataProvider.java

@@ -1,240 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.cfg.annotations.reflection;
-
-import java.lang.reflect.AnnotatedElement;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import javax.persistence.EntityListeners;
-import javax.persistence.NamedNativeQuery;
-import javax.persistence.NamedQuery;
-import javax.persistence.NamedStoredProcedureQuery;
-import javax.persistence.SequenceGenerator;
-import javax.persistence.SqlResultSetMapping;
-import javax.persistence.TableGenerator;
-
-import org.hibernate.annotations.common.reflection.AnnotationReader;
-import org.hibernate.annotations.common.reflection.MetadataProvider;
-import org.hibernate.annotations.common.reflection.java.JavaMetadataProvider;
-import org.hibernate.boot.internal.ClassLoaderAccessImpl;
-import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
-import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
-import org.hibernate.boot.spi.BootstrapContext;
-import org.hibernate.boot.spi.ClassLoaderAccess;
-import org.hibernate.boot.spi.ClassLoaderAccessDelegateImpl;
-import org.hibernate.boot.spi.MetadataBuildingOptions;
-import org.hibernate.internal.util.collections.CollectionHelper;
-import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenMetadataProvider;
-
-import org.dom4j.Element;
-
-/**
- * MetadataProvider aware of the JPA Deployment descriptor
- *
- * @author Emmanuel Bernard
- *
- * @deprecated This class is not API: do not use it from application code.
- * This class will be removed in Hibernate ORM 6.0.
- * For implementation code, use {@link JPAXMLOverriddenMetadataProvider}
- * instead.
- */
-@Deprecated
-@SuppressWarnings("unchecked")
-public final class JPAMetadataProvider implements MetadataProvider {
-
-	private static final MetadataProvider STATELESS_BASE_DELEGATE = new JavaMetadataProvider();
-
-	private final ClassLoaderAccess classLoaderAccess;
-	private final XMLContext xmlContext;
-
-	/**
-	 * We allow fully disabling XML sources so to improve the efficiency of
-	 * the boot process for those not using it.
-	 */
-	private final boolean xmlMappingEnabled;
-
-	private Map<Object, Object> defaults;
-	private Map<AnnotatedElement, AnnotationReader> cache;
-
-	/**
-	 * @deprecated Use {@link JPAMetadataProvider#JPAMetadataProvider(BootstrapContext)} instead.
-	 */
-	@Deprecated
-	public JPAMetadataProvider(final MetadataBuildingOptions metadataBuildingOptions) {
-		this( new ClassLoaderAccessDelegateImpl() {
-			ClassLoaderAccess delegate;
-
-			@Override
-			protected ClassLoaderAccess getDelegate() {
-				if ( delegate == null ) {
-					delegate = new ClassLoaderAccessImpl(
-							metadataBuildingOptions.getTempClassLoader(),
-							metadataBuildingOptions.getServiceRegistry().getService( ClassLoaderService.class )
-					);
-				}
-				return delegate;
-			}
-		},
-				metadataBuildingOptions.getXmlMappingOptions().isEnabled() );
-	}
-
-	public JPAMetadataProvider(BootstrapContext bootstrapContext) {
-		this( bootstrapContext.getClassLoaderAccess(),
-				bootstrapContext.getMetadataBuildingOptions().getXmlMappingOptions().isEnabled() );
-	}
-
-	JPAMetadataProvider(ClassLoaderAccess classLoaderAccess, boolean xmlMetadataEnabled) {
-		this.classLoaderAccess = classLoaderAccess;
-		this.xmlContext = new XMLContext( classLoaderAccess );
-		this.xmlMappingEnabled = xmlMetadataEnabled;
-	}
-
-	//all of the above can be safely rebuilt from XMLContext: only XMLContext this object is serialized
-	@Override
-	public AnnotationReader getAnnotationReader(AnnotatedElement annotatedElement) {
-		if ( cache == null ) {
-			cache =  new HashMap<>(50 );
-		}
-		AnnotationReader reader = cache.get( annotatedElement );
-		if (reader == null) {
-			if ( xmlContext.hasContext() ) {
-				reader = new JPAOverriddenAnnotationReader( annotatedElement, xmlContext, classLoaderAccess );
-			}
-			else {
-				reader = STATELESS_BASE_DELEGATE.getAnnotationReader( annotatedElement );
-			}
-			cache.put( annotatedElement, reader );
-		}
-		return reader;
-	}
-
-	@Override
-	public void reset() {
-		//It's better to remove the HashMap, as it could grow rather large:
-		//when doing a clear() the internal buckets array is not scaled down.
-		this.cache = null;
-	}
-
-	@Override
-	public Map<Object, Object> getDefaults() {
-		if ( !xmlMappingEnabled ) {
-			return Collections.emptyMap();
-		}
-		else {
-			if ( defaults == null ) {
-				defaults = new HashMap<>();
-				XMLContext.Default xmlDefaults = xmlContext.getDefault( null );
-
-				defaults.put( "schema", xmlDefaults.getSchema() );
-				defaults.put( "catalog", xmlDefaults.getCatalog() );
-				defaults.put( "delimited-identifier", xmlDefaults.getDelimitedIdentifier() );
-				defaults.put( "cascade-persist", xmlDefaults.getCascadePersist() );
-				List<Class> entityListeners = new ArrayList<>();
-				for ( String className : xmlContext.getDefaultEntityListeners() ) {
-					try {
-						entityListeners.add( classLoaderAccess.classForName( className ) );
-					}
-					catch ( ClassLoadingException e ) {
-						throw new IllegalStateException( "Default entity listener class not found: " + className );
-					}
-				}
-				defaults.put( EntityListeners.class, entityListeners );
-				for ( Element element : xmlContext.getAllDocuments() ) {
-					@SuppressWarnings( "unchecked" )
-					List<Element> elements = element.elements( "sequence-generator" );
-					List<SequenceGenerator> sequenceGenerators = ( List<SequenceGenerator> ) defaults.get( SequenceGenerator.class );
-					if ( sequenceGenerators == null ) {
-						sequenceGenerators = new ArrayList<>();
-						defaults.put( SequenceGenerator.class, sequenceGenerators );
-					}
-					for ( Element subelement : elements ) {
-						sequenceGenerators.add( JPAOverriddenAnnotationReader
-								.buildSequenceGeneratorAnnotation( subelement ) );
-					}
-
-					elements = element.elements( "table-generator" );
-					List<TableGenerator> tableGenerators = ( List<TableGenerator> ) defaults.get( TableGenerator.class );
-					if ( tableGenerators == null ) {
-						tableGenerators = new ArrayList<>();
-						defaults.put( TableGenerator.class, tableGenerators );
-					}
-					for ( Element subelement : elements ) {
-						tableGenerators.add(
-								JPAOverriddenAnnotationReader.buildTableGeneratorAnnotation(
-										subelement, xmlDefaults
-								)
-						);
-					}
-
-					List<NamedQuery> namedQueries = ( List<NamedQuery> ) defaults.get( NamedQuery.class );
-					if ( namedQueries == null ) {
-						namedQueries = new ArrayList<>();
-						defaults.put( NamedQuery.class, namedQueries );
-					}
-					List<NamedQuery> currentNamedQueries = JPAOverriddenAnnotationReader
-							.buildNamedQueries(
-							element,
-							false,
-							xmlDefaults,
-							classLoaderAccess
-					);
-					namedQueries.addAll( currentNamedQueries );
-
-					List<NamedNativeQuery> namedNativeQueries = ( List<NamedNativeQuery> ) defaults.get( NamedNativeQuery.class );
-					if ( namedNativeQueries == null ) {
-						namedNativeQueries = new ArrayList<>();
-						defaults.put( NamedNativeQuery.class, namedNativeQueries );
-					}
-					List<NamedNativeQuery> currentNamedNativeQueries = JPAOverriddenAnnotationReader
-							.buildNamedQueries(
-							element,
-							true,
-							xmlDefaults,
-							classLoaderAccess
-					);
-					namedNativeQueries.addAll( currentNamedNativeQueries );
-
-					List<SqlResultSetMapping> sqlResultSetMappings = ( List<SqlResultSetMapping> ) defaults.get(
-							SqlResultSetMapping.class
-					);
-					if ( sqlResultSetMappings == null ) {
-						sqlResultSetMappings = new ArrayList<>();
-						defaults.put( SqlResultSetMapping.class, sqlResultSetMappings );
-					}
-					List<SqlResultSetMapping> currentSqlResultSetMappings = JPAOverriddenAnnotationReader
-							.buildSqlResultsetMappings(
-							element,
-							xmlDefaults,
-							classLoaderAccess
-					);
-					sqlResultSetMappings.addAll( currentSqlResultSetMappings );
-
-					List<NamedStoredProcedureQuery> namedStoredProcedureQueries = (List<NamedStoredProcedureQuery>)defaults.get( NamedStoredProcedureQuery.class );
-					if(namedStoredProcedureQueries==null){
-						namedStoredProcedureQueries = new ArrayList<>(  );
-						defaults.put( NamedStoredProcedureQuery.class, namedStoredProcedureQueries );
-					}
-					List<NamedStoredProcedureQuery> currentNamedStoredProcedureQueries = JPAOverriddenAnnotationReader
-							.buildNamedStoreProcedureQueries(
-							element,
-							xmlDefaults,
-							classLoaderAccess
-					);
-					namedStoredProcedureQueries.addAll( currentNamedStoredProcedureQueries );
-				}
-			}
-			return defaults;
-		}
-	}
-
-	public XMLContext getXMLContext() {
-		return xmlContext;
-	}
-}

hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/XMLContext.java

@@ -1,363 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.cfg.annotations.reflection;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import javax.persistence.AccessType;
-import javax.persistence.AttributeConverter;
-
-import org.hibernate.AnnotationException;
-import org.hibernate.boot.AttributeConverterInfo;
-import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
-import org.hibernate.boot.spi.BootstrapContext;
-import org.hibernate.boot.spi.ClassLoaderAccess;
-import org.hibernate.cfg.AttributeConverterDefinition;
-import org.hibernate.internal.CoreLogging;
-import org.hibernate.internal.CoreMessageLogger;
-import org.hibernate.internal.util.StringHelper;
-
-import org.dom4j.Document;
-import org.dom4j.Element;
-
-/**
- * A helper for consuming orm.xml mappings.
- *
- * @author Emmanuel Bernard
- * @author Brett Meyer
- *
- * @deprecated This class is not API: do not use it from application code.
- * This class will be removed in Hibernate ORM 6.0.
- * For implementation code, use {@link org.hibernate.cfg.annotations.reflection.internal.XMLContext} instead.
- */
-@Deprecated
-public class XMLContext implements Serializable {
-	private static final CoreMessageLogger LOG = CoreLogging.messageLogger( XMLContext.class );
-
-	private final ClassLoaderAccess classLoaderAccess;
-
-	private Default globalDefaults;
-	private Map<String, Element> classOverriding = new HashMap<>();
-	private Map<String, Default> defaultsOverriding = new HashMap<>();
-	private List<Element> defaultElements = new ArrayList<>();
-	private List<String> defaultEntityListeners = new ArrayList<>();
-	private boolean hasContext = false;
-
-	/**
-	 * @deprecated Use {@link XMLContext#XMLContext(BootstrapContext)} instead.
-	 */
-	@Deprecated
-	public XMLContext(ClassLoaderAccess classLoaderAccess) {
-		this.classLoaderAccess = classLoaderAccess;
-	}
-
-	public XMLContext(BootstrapContext bootstrapContext) {
-		this.classLoaderAccess = bootstrapContext.getClassLoaderAccess();
-	}
-
-	/**
-	 * @param doc The xml document to add
-	 * @return Add an xml document to this context and return the list of added class names.
-	 */
-	@SuppressWarnings( "unchecked" )
-	public List<String> addDocument(Document doc) {
-		hasContext = true;
-		List<String> addedClasses = new ArrayList<>();
-		Element root = doc.getRootElement();
-		//global defaults
-		Element metadata = root.element( "persistence-unit-metadata" );
-		if ( metadata != null ) {
-			if ( globalDefaults == null ) {
-				globalDefaults = new Default();
-				globalDefaults.setMetadataComplete(
-						metadata.element( "xml-mapping-metadata-complete" ) != null ?
-								Boolean.TRUE :
-								null
-				);
-				Element defaultElement = metadata.element( "persistence-unit-defaults" );
-				if ( defaultElement != null ) {
-					Element unitElement = defaultElement.element( "schema" );
-					globalDefaults.setSchema( unitElement != null ? unitElement.getTextTrim() : null );
-					unitElement = defaultElement.element( "catalog" );
-					globalDefaults.setCatalog( unitElement != null ? unitElement.getTextTrim() : null );
-					unitElement = defaultElement.element( "access" );
-					setAccess( unitElement, globalDefaults );
-					unitElement = defaultElement.element( "cascade-persist" );
-					globalDefaults.setCascadePersist( unitElement != null ? Boolean.TRUE : null );
-					unitElement = defaultElement.element( "delimited-identifiers" );
-					globalDefaults.setDelimitedIdentifiers( unitElement != null ? Boolean.TRUE : null );
-					defaultEntityListeners.addAll( addEntityListenerClasses( defaultElement, null, addedClasses ) );
-				}
-			}
-			else {
-				LOG.duplicateMetadata();
-			}
-		}
-
-		//entity mapping default
-		Default entityMappingDefault = new Default();
-		Element unitElement = root.element( "package" );
-		String packageName = unitElement != null ? unitElement.getTextTrim() : null;
-		entityMappingDefault.setPackageName( packageName );
-		unitElement = root.element( "schema" );
-		entityMappingDefault.setSchema( unitElement != null ? unitElement.getTextTrim() : null );
-		unitElement = root.element( "catalog" );
-		entityMappingDefault.setCatalog( unitElement != null ? unitElement.getTextTrim() : null );
-		unitElement = root.element( "access" );
-		setAccess( unitElement, entityMappingDefault );
-		defaultElements.add( root );
-
-		setLocalAttributeConverterDefinitions( root.elements( "converter" ) );
-
-		List<Element> entities = root.elements( "entity" );
-		addClass( entities, packageName, entityMappingDefault, addedClasses );
-
-		entities = root.elements( "mapped-superclass" );
-		addClass( entities, packageName, entityMappingDefault, addedClasses );
-
-		entities = root.elements( "embeddable" );
-		addClass( entities, packageName, entityMappingDefault, addedClasses );
-		return addedClasses;
-	}
-
-	private void setAccess(Element unitElement, Default defaultType) {
-		if ( unitElement != null ) {
-			String access = unitElement.getTextTrim();
-			setAccess( access, defaultType );
-		}
-	}
-
-	private void setAccess( String access, Default defaultType) {
-		AccessType type;
-		if ( access != null ) {
-			try {
-				type = AccessType.valueOf( access );
-			}
-			catch ( IllegalArgumentException e ) {
-				throw new AnnotationException( "Invalid access type: " + access + " (check your xml configuration)" );
-			}
-			defaultType.setAccess( type );
-		}
-	}
-
-	private void addClass(List<Element> entities, String packageName, Default defaults, List<String> addedClasses) {
-		for (Element element : entities) {
-			String className = buildSafeClassName( element.attributeValue( "class" ), packageName );
-			if ( classOverriding.containsKey( className ) ) {
-				//maybe switch it to warn?
-				throw new IllegalStateException( "Duplicate XML entry for " + className );
-			}
-			addedClasses.add( className );
-			classOverriding.put( className, element );
-			Default localDefault = new Default();
-			localDefault.override( defaults );
-			String metadataCompleteString = element.attributeValue( "metadata-complete" );
-			if ( metadataCompleteString != null ) {
-				localDefault.setMetadataComplete( Boolean.parseBoolean( metadataCompleteString ) );
-			}
-			String access = element.attributeValue( "access" );
-			setAccess( access, localDefault );
-			defaultsOverriding.put( className, localDefault );
-
-			LOG.debugf( "Adding XML overriding information for %s", className );
-			addEntityListenerClasses( element, packageName, addedClasses );
-		}
-	}
-
-	private List<String> addEntityListenerClasses(Element element, String packageName, List<String> addedClasses) {
-		List<String> localAddedClasses = new ArrayList<>();
-		Element listeners = element.element( "entity-listeners" );
-		if ( listeners != null ) {
-			@SuppressWarnings( "unchecked" )
-			List<Element> elements = listeners.elements( "entity-listener" );
-			for (Element listener : elements) {
-				String listenerClassName = buildSafeClassName( listener.attributeValue( "class" ), packageName );
-				if ( classOverriding.containsKey( listenerClassName ) ) {
-					//maybe switch it to warn?
-					if ( "entity-listener".equals( classOverriding.get( listenerClassName ).getName() ) ) {
-						LOG.duplicateListener( listenerClassName );
-						continue;
-					}
-					throw new IllegalStateException("Duplicate XML entry for " + listenerClassName);
-				}
-				localAddedClasses.add( listenerClassName );
-				classOverriding.put( listenerClassName, listener );
-			}
-		}
-		LOG.debugf( "Adding XML overriding information for listeners: %s", localAddedClasses );
-		addedClasses.addAll( localAddedClasses );
-		return localAddedClasses;
-	}
-
-	@SuppressWarnings("unchecked")
-	private void setLocalAttributeConverterDefinitions(List<Element> converterElements) {
-		for ( Element converterElement : converterElements ) {
-			final String className = converterElement.attributeValue( "class" );
-			final String autoApplyAttribute = converterElement.attributeValue( "auto-apply" );
-			final boolean autoApply = Boolean.parseBoolean( autoApplyAttribute );
-
-			try {
-				final Class<? extends AttributeConverter> attributeConverterClass = classLoaderAccess.classForName(
-						className
-				);
-				attributeConverterInfoList.add(
-						new AttributeConverterDefinition( attributeConverterClass.newInstance(), autoApply )
-				);
-			}
-			catch (ClassLoadingException e) {
-				throw new AnnotationException( "Unable to locate specified AttributeConverter implementation class : " + className, e );
-			}
-			catch (Exception e) {
-				throw new AnnotationException( "Unable to instantiate specified AttributeConverter implementation class : " + className, e );
-			}
-		}
-	}
-
-	public static String buildSafeClassName(String className, String defaultPackageName) {
-		if ( className.indexOf( '.' ) < 0 && StringHelper.isNotEmpty( defaultPackageName ) ) {
-			className = StringHelper.qualify( defaultPackageName, className );
-		}
-		return className;
-	}
-
-	public static String buildSafeClassName(String className, Default defaults) {
-		return buildSafeClassName( className, defaults.getPackageName() );
-	}
-
-	public Default getDefault(String className) {
-		Default xmlDefault = new Default();
-		xmlDefault.override( globalDefaults );
-		if ( className != null ) {
-			Default entityMappingOverriding = defaultsOverriding.get( className );
-			xmlDefault.override( entityMappingOverriding );
-		}
-		return xmlDefault;
-	}
-
-	public Element getXMLTree(String className ) {
-		return classOverriding.get( className );
-	}
-
-	public List<Element> getAllDocuments() {
-		return defaultElements;
-	}
-
-	public boolean hasContext() {
-		return hasContext;
-	}
-
-	private List<AttributeConverterInfo> attributeConverterInfoList = new ArrayList<>();
-
-	public void applyDiscoveredAttributeConverters(AttributeConverterDefinitionCollector collector) {
-		for ( AttributeConverterInfo info : attributeConverterInfoList ) {
-			collector.addAttributeConverter( info );
-		}
-		attributeConverterInfoList.clear();
-	}
-
-	public static class Default implements Serializable {
-		private AccessType access;
-		private String packageName;
-		private String schema;
-		private String catalog;
-		private Boolean metadataComplete;
-		private Boolean cascadePersist;
-		private Boolean delimitedIdentifier;
-
-		public AccessType getAccess() {
-			return access;
-		}
-
-		protected void setAccess(AccessType access) {
-			this.access = access;
-		}
-
-		public String getCatalog() {
-			return catalog;
-		}
-
-		protected void setCatalog(String catalog) {
-			this.catalog = catalog;
-		}
-
-		public String getPackageName() {
-			return packageName;
-		}
-
-		protected void setPackageName(String packageName) {
-			this.packageName = packageName;
-		}
-
-		public String getSchema() {
-			return schema;
-		}
-
-		protected void setSchema(String schema) {
-			this.schema = schema;
-		}
-
-		public Boolean getMetadataComplete() {
-			return metadataComplete;
-		}
-
-		public boolean canUseJavaAnnotations() {
-			return metadataComplete == null || !metadataComplete;
-		}
-
-		protected void setMetadataComplete(Boolean metadataComplete) {
-			this.metadataComplete = metadataComplete;
-		}
-
-		public Boolean getCascadePersist() {
-			return cascadePersist;
-		}
-
-		void setCascadePersist(Boolean cascadePersist) {
-			this.cascadePersist = cascadePersist;
-		}
-
-		public void override(Default globalDefault) {
-			if ( globalDefault != null ) {
-				if ( globalDefault.getAccess() != null ) {
-					access = globalDefault.getAccess();
-				}
-				if ( globalDefault.getPackageName() != null ) {
-					packageName = globalDefault.getPackageName();
-				}
-				if ( globalDefault.getSchema() != null ) {
-					schema = globalDefault.getSchema();
-				}
-				if ( globalDefault.getCatalog() != null ) {
-					catalog = globalDefault.getCatalog();
-				}
-				if ( globalDefault.getDelimitedIdentifier() != null ) {
-					delimitedIdentifier = globalDefault.getDelimitedIdentifier();
-				}
-				if ( globalDefault.getMetadataComplete() != null ) {
-					metadataComplete = globalDefault.getMetadataComplete();
-				}
-				//TODO fix that in stone if cascade-persist is set already?
-				if ( globalDefault.getCascadePersist() != null ) cascadePersist = globalDefault.getCascadePersist();
-			}
-		}
-
-		public void setDelimitedIdentifiers(Boolean delimitedIdentifier) {
-			this.delimitedIdentifier = delimitedIdentifier;
-		}
-
-		public Boolean getDelimitedIdentifier() {
-			return delimitedIdentifier;
-		}
-	}
-
-	public List<String> getDefaultEntityListeners() {
-		return defaultEntityListeners;
-	}
-}

hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/internal/JPAXMLOverriddenAnnotationReader.java

@@ -2063,7 +2063,7 @@ public class JPAXMLOverriddenAnnotationReader implements AnnotationReader {
 			bindNamedAttributeNodes( element.getNamedAttributeNode(), ann );
 
 			bindNamedSubgraph( defaults, ann, "subgraphs", element.getSubgraph(), classLoaderAccess );
-			bindNamedSubgraph( defaults, ann, "subclass-subgraph", element.getSubclassSubgraph(), classLoaderAccess );
+			bindNamedSubgraph( defaults, ann, "subclassSubgraphs", element.getSubclassSubgraph(), classLoaderAccess );
 			namedEntityGraphList.add( AnnotationFactory.create( ann ) );
 		}
 		//TODO

hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/internal/JPAXMLOverriddenMetadataProvider.java

@@ -26,7 +26,6 @@ import org.hibernate.annotations.common.reflection.java.JavaMetadataProvider;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbSequenceGenerator;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbTableGenerator;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
 import org.hibernate.boot.spi.BootstrapContext;
 import org.hibernate.boot.spi.ClassLoaderAccess;
@@ -48,7 +47,7 @@ public final class JPAXMLOverriddenMetadataProvider implements MetadataProvider
 	 * We allow fully disabling XML sources so to improve the efficiency of
 	 * the boot process for those not using it.
 	 */
-	private final XmlMappingOptions xmlMappingOptions;
+	private final boolean xmlMappingEnabled;
 
 	private Map<Object, Object> defaults;
 	private Map<AnnotatedElement, AnnotationReader> cache;
@@ -56,7 +55,7 @@ public final class JPAXMLOverriddenMetadataProvider implements MetadataProvider
 	public JPAXMLOverriddenMetadataProvider(BootstrapContext bootstrapContext) {
 		this.classLoaderAccess = bootstrapContext.getClassLoaderAccess();
 		this.xmlContext = new XMLContext( classLoaderAccess );
-		this.xmlMappingOptions = bootstrapContext.getMetadataBuildingOptions().getXmlMappingOptions();
+		this.xmlMappingEnabled = bootstrapContext.getMetadataBuildingOptions().isXmlMappingEnabled();
 	}
 
 	//all of the above can be safely rebuilt from XMLContext: only XMLContext this object is serialized
@@ -89,7 +88,7 @@ public final class JPAXMLOverriddenMetadataProvider implements MetadataProvider
 
 	@Override
 	public Map<Object, Object> getDefaults() {
-		if ( !xmlMappingOptions.isEnabled() ) {
+		if ( !xmlMappingEnabled ) {
 			return Collections.emptyMap();
 		}
 		else {

hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/internal/XMLContext.java

@@ -54,7 +54,7 @@ public class XMLContext implements Serializable {
 	private boolean hasContext = false;
 
 	/**
-	 * @deprecated Use {@link org.hibernate.cfg.annotations.reflection.XMLContext#XMLContext(BootstrapContext)} instead.
+	 * @deprecated Use {@link #XMLContext(BootstrapContext)} instead.
 	 */
 	@Deprecated
 	public XMLContext(ClassLoaderAccess classLoaderAccess) {
@@ -127,11 +127,16 @@ public class XMLContext implements Serializable {
 			}
 			addedClasses.add( className );
 			managedTypeOverride.put( className, element );
-			Default localDefault = new Default();
+			Default mergedDefaults = new Default();
-			localDefault.override( defaults );
+			// Apply entity mapping defaults
-			localDefault.setMetadataComplete( element.isMetadataComplete() );
+			mergedDefaults.override( defaults );
-			localDefault.setAccess( element.getAccess() );
+			// ... then apply entity settings
-			defaultsOverride.put( className, localDefault );
+			Default fileDefaults = new Default();
+			fileDefaults.setMetadataComplete( element.isMetadataComplete() );
+			fileDefaults.setAccess( element.getAccess() );
+			mergedDefaults.override( fileDefaults );
+			// ... and we get the merged defaults for that entity
+			defaultsOverride.put( className, mergedDefaults );
 
 			LOG.debugf( "Adding XML overriding information for %s", className );
 			if ( element instanceof JaxbEntity ) {

hibernate-core/src/main/java/org/hibernate/event/internal/DefaultFlushEntityEventListener.java

@@ -133,7 +133,8 @@ public class DefaultFlushEntityEventListener implements FlushEntityEventListener
 		event.setPropertyValues( values );
 
 		//TODO: avoid this for non-new instances where mightBeDirty==false
-		boolean substitute = wrapCollections( session, persister, types, values );
+
+		boolean substitute = wrapCollections( session, persister, entity, entry.getId(), types, values );
 
 		if ( isUpdateNecessary( event, mightBeDirty ) ) {
 			substitute = scheduleUpdate( event ) || substitute;
@@ -181,6 +182,8 @@ public class DefaultFlushEntityEventListener implements FlushEntityEventListener
 	private boolean wrapCollections(
 			EventSource session,
 			EntityPersister persister,
+			Object entity,
+			Object id,
 			Type[] types,
 			Object[] values
 	) {
@@ -194,7 +197,7 @@ public class DefaultFlushEntityEventListener implements FlushEntityEventListener
 			// don't dirty the container. Also, for versioned data, we
 			// need to wrap before calling searchForDirtyCollections
 
-			WrapVisitor visitor = new WrapVisitor( session );
+			WrapVisitor visitor = new WrapVisitor( entity, id ,session );
 			// substitutes into values by side-effect
 			visitor.processEntityPropertyValues( values, types );
 			return visitor.isSubstitutionRequired();

hibernate-core/src/main/java/org/hibernate/event/internal/FlushVisitor.java

@@ -43,9 +43,12 @@ public class FlushVisitor extends AbstractVisitor {
 			else if ( collection == LazyPropertyInitializer.UNFETCHED_PROPERTY ) {
 				coll = (PersistentCollection) type.resolve( collection, session, owner );
 			}
-			else {
+			else if ( collection instanceof PersistentCollection ) {
 				coll = (PersistentCollection) collection;
 			}
+			else {
+				return null;
+			}
 
 			Collections.processReachableCollection( coll, type, owner, session);
 		}

hibernate-core/src/main/java/org/hibernate/event/internal/WrapVisitor.java

@@ -9,8 +9,11 @@ package org.hibernate.event.internal;
 import org.hibernate.EntityMode;
 import org.hibernate.HibernateException;
 import org.hibernate.bytecode.enhance.spi.LazyPropertyInitializer;
+import org.hibernate.bytecode.enhance.spi.interceptor.EnhancementAsProxyLazinessInterceptor;
 import org.hibernate.collection.spi.PersistentCollection;
 import org.hibernate.engine.spi.PersistenceContext;
+import org.hibernate.engine.spi.PersistentAttributeInterceptable;
+import org.hibernate.engine.spi.PersistentAttributeInterceptor;
 import org.hibernate.engine.spi.SessionImplementor;
 import org.hibernate.event.spi.EventSource;
 import org.hibernate.internal.CoreLogging;
@@ -29,8 +32,8 @@ import org.hibernate.type.Type;
 @SuppressWarnings("WeakerAccess")
 public class WrapVisitor extends ProxyVisitor {
 	private static final CoreMessageLogger LOG = CoreLogging.messageLogger( WrapVisitor.class );
-	private Object entity;
+	protected Object entity;
-	private Object id;
+	protected Object id;
 
 	private boolean substitute;
 
@@ -103,8 +106,17 @@ public class WrapVisitor extends ProxyVisitor {
 				return null;
 			}
 			else {
+				if ( entity instanceof PersistentAttributeInterceptable ) {
+					final PersistentAttributeInterceptor interceptor = ( (PersistentAttributeInterceptable) entity ).$$_hibernate_getInterceptor();
+					if ( interceptor instanceof EnhancementAsProxyLazinessInterceptor ) {
+						if ( !( (EnhancementAsProxyLazinessInterceptor) interceptor ).isInitialized() ) {
+							return null;
+						}
+					}
+				}
+
+				final PersistentCollection persistentCollection = collectionType.wrap( session, collection );
 
-				PersistentCollection persistentCollection = collectionType.wrap( session, collection );
 				persistenceContext.addNewCollection( persister, persistentCollection );
 
 				if ( LOG.isTraceEnabled() ) {
@@ -112,11 +124,8 @@ public class WrapVisitor extends ProxyVisitor {
 				}
 
 				return persistentCollection; //Force a substitution!
-
 			}
-
 		}
-
 	}
 
 	@Override

hibernate-core/src/main/java/org/hibernate/internal/log/DeprecationLogger.java

@@ -53,7 +53,8 @@ public interface DeprecationLogger extends BasicLogger {
 	public void logDeprecationOfMultipleEntityModeSupport();
 
 	/**
-	 * Log message indicating the use of DOM4J EntityMode.
+	 * Log message indicating the use of features that were only useful for DOM4J EntityMode,
+	 * which was removed a long time ago.
 	 */
 	@LogMessage( level = WARN )
 	@Message(

hibernate-core/src/main/java/org/hibernate/tuple/Tuplizer.java

@@ -27,10 +27,6 @@ import org.hibernate.property.access.spi.Getter;
  * <li>extract and inject values through getters/setter, or by direct field access, etc
  * </ul>
  * </p>
- * That same piece of data might also be represented as a DOM structure, using
- * the tuplizer associated with the DOM4J entity-mode, which would generate instances
- * of {@link org.dom4j.Element} as the data structure and know how to access the
- * values as either nested {@link org.dom4j.Element}s or as {@link org.dom4j.Attribute}s.
  *
  * @see org.hibernate.tuple.entity.EntityTuplizer
  * @see org.hibernate.tuple.component.ComponentTuplizer

hibernate-core/src/main/java/org/hibernate/type/CollectionType.java

@@ -571,7 +571,6 @@ public abstract class CollectionType extends AbstractType implements Association
 			Object owner,
 			Map copyCache,
 			SharedSessionContractImplementor session) {
-		// TODO: does not work for EntityMode.DOM4J yet!
 		java.util.Collection result = ( java.util.Collection ) target;
 		result.clear();
 

hibernate-core/src/test/java/org/hibernate/internal/util/xml/XMLHelper.java

@@ -1,78 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.internal.util.xml;
-
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-
-import org.dom4j.DocumentFactory;
-import org.dom4j.io.SAXReader;
-import org.xml.sax.EntityResolver;
-
-/**
- * Small helper class that lazily loads DOM and SAX reader and keep them for fast use afterwards.
- *
- * This was part of Hibernate ORM core, but moved into the testsuite helpers to not expose
- * access to the dom4j types. It's also used by Hibernate Envers, so we will need two copies
- * until Envers is able to remove its reliance on dom4j.
- * The rest of Hibernate uses StAX now for XML processing.  See {@link org.hibernate.boot.jaxb.internal.stax}
- */
-public final class XMLHelper {
-	private final DocumentFactory documentFactory;
-
-	public XMLHelper() {
-		PrivilegedAction<DocumentFactory> action = new PrivilegedAction<DocumentFactory>() {
-			public DocumentFactory run() {
-				final ClassLoader originalTccl = Thread.currentThread().getContextClassLoader();
-				try {
-					// We need to make sure we get DocumentFactory
-					// loaded from the same ClassLoader that loads
-					// Hibernate classes, to make sure we get the
-					// proper version of DocumentFactory, This class
-					// is "internal", and should only be used for XML
-					// files generated by Envers.
-
-					// Using the (Hibernate) ClassLoader that loads
-					// this Class will avoid collisions in the case
-					// that DocumentFactory can be loaded from,
-					// for example, the application ClassLoader.
-					Thread.currentThread().setContextClassLoader( this.getClass().getClassLoader() );
-					return DocumentFactory.getInstance();
-				}
-				finally {
-					Thread.currentThread().setContextClassLoader( originalTccl );
-				}
-			}
-		};
-
-		this.documentFactory = System.getSecurityManager() != null
-				? AccessController.doPrivileged( action )
-				: action.run();
-	}
-
-	public DocumentFactory getDocumentFactory() {
-		return documentFactory;
-	}
-
-	public SAXReader createSAXReader(ErrorLogger errorLogger, EntityResolver entityResolver) {
-		SAXReader saxReader = new SAXReader();
-		try {
-			saxReader.setFeature( "http://apache.org/xml/features/nonvalidating/load-external-dtd", false );
-			saxReader.setFeature( "http://xml.org/sax/features/external-general-entities", false );
-			saxReader.setFeature( "http://xml.org/sax/features/external-parameter-entities", false );
-		}
-		catch (Exception e) {
-			throw new RuntimeException( e );
-		}
-		saxReader.setMergeAdjacentText( true );
-		saxReader.setValidation( true );
-		saxReader.setErrorHandler( errorLogger );
-		saxReader.setEntityResolver( entityResolver );
-
-		return saxReader;
-	}
-}

hibernate-core/src/test/java/org/hibernate/internal/util/xml/XMLMappingHelper.java

@@ -14,10 +14,6 @@ import org.hibernate.boot.jaxb.SourceType;
 import org.hibernate.boot.jaxb.internal.MappingBinder;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
 import org.hibernate.boot.jaxb.spi.Binding;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
-import org.hibernate.boot.registry.BootstrapServiceRegistry;
-import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
-import org.hibernate.service.spi.ServiceRegistryImplementor;
 
 import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
 import org.junit.Assert;
@@ -28,8 +24,8 @@ import org.junit.Assert;
 public final class XMLMappingHelper {
 	private final MappingBinder binder;
 
-	public XMLMappingHelper(XmlMappingOptions xmlMappingOptions) {
+	public XMLMappingHelper() {
-		binder = new MappingBinder( ClassLoaderServiceTestingImpl.INSTANCE, true, xmlMappingOptions );
+		binder = new MappingBinder( ClassLoaderServiceTestingImpl.INSTANCE, true );
 	}
 
 	public JaxbEntityMappings readOrmXmlMappings(String name) throws IOException {

hibernate-core/src/test/java/org/hibernate/internal/util/xml/XmlMappingOptionsStrategyRegistrationProvider.java

@@ -1,66 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later
- * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
- */
-package org.hibernate.internal.util.xml;
-
-import java.util.Collections;
-
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
-import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
-import org.hibernate.boot.registry.selector.SimpleStrategyRegistrationImpl;
-import org.hibernate.boot.registry.selector.StrategyRegistration;
-import org.hibernate.boot.registry.selector.StrategyRegistrationProvider;
-
-import org.jboss.logging.Logger;
-
-/**
- * A strategy registration provider that allows running the whole test suite with different XML mapping options.
- * <p>
- * By default, this provider does nothing.
- * In some CI jobs, we set the system property {@value STRATEGY_PROPERTY_KEY}
- * to re-run the whole test suite using JAXB for orm.xml parsing instead of dom4j.
- */
-public class XmlMappingOptionsStrategyRegistrationProvider implements StrategyRegistrationProvider {
-
-	protected final Logger log = Logger.getLogger( getClass() );
-
-	private static final String STRATEGY_PROPERTY_KEY = "testing.mapping.xml.strategy";
-
-	public static void applyJaxbStrategy(BootstrapServiceRegistryBuilder builder) {
-		builder.applyStrategySelector( XmlMappingOptions.class, XmlMappingOptions.DEFAULT_NAME,
-				PreferJaxbXmlMappingOptions.class
-		);
-	}
-
-	@Override
-	public Iterable<StrategyRegistration> getStrategyRegistrations() {
-		switch ( getStrategyFromSystemProperties() ) {
-			case "jaxb":
-				log.warn( "Overriding the default configuration because of a test system property:"
-						+ " will favor jaxb when parsing XML mapping." );
-				return Collections.singleton(
-						new SimpleStrategyRegistrationImpl<>( XmlMappingOptions.class,
-								PreferJaxbXmlMappingOptions.class,
-								XmlMappingOptions.DEFAULT_NAME )
-				);
-			case "default":
-			default:
-				return Collections.emptyList();
-		}
-	}
-
-	private static String getStrategyFromSystemProperties() {
-		String strategy = System.getProperty( STRATEGY_PROPERTY_KEY );
-		return strategy == null || strategy.isEmpty() ? "default" : strategy;
-	}
-
-	public static class PreferJaxbXmlMappingOptions implements XmlMappingOptions {
-		@Override
-		public boolean isPreferJaxb() {
-			return true;
-		}
-	}
-}

hibernate-core/src/test/java/org/hibernate/orm/test/entitygraph/named/subgraph/orm.xml

@@ -35,12 +35,12 @@
             <id name="id"/>
             <basic name="isbn"/>
             <basic name="title"/>
-            <many-to-many name="authors">
-                <join-table name="book_author"/>
-            </many-to-many>
             <one-to-many name="prizes">
                 <join-table name="book_prize"/>
             </one-to-many>
+            <many-to-many name="authors">
+                <join-table name="book_author"/>
+            </many-to-many>
         </attributes>
     </entity>
 

hibernate-core/src/test/java/org/hibernate/orm/test/filter/DynamicFilterTest.java

@@ -39,6 +39,7 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -251,6 +252,22 @@ public class DynamicFilterTest extends BaseNonConfigCoreFunctionalTestCase {
 		);
 	}
 
+	@Test
+	@TestForIssue(jiraKey = "HHH-14567")
+	public void testHqlFiltersAppliedAfterQueryCreation() {
+		inTransaction( session -> {
+			Query<Salesperson> query = session.createQuery(
+					"select s from Salesperson s",
+					Salesperson.class
+			);
+			List<Salesperson> list = query.list();
+			assertThat( list ).hasSize( 2 );
+
+			session.enableFilter( "region" ).setParameter( "region", "APAC" );
+			assertThat( query.list() ).hasSize( 1 );
+		} );
+	}
+
 	@Test
 	public void testFiltersWithCustomerReadAndWrite() {
 		//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

hibernate-core/src/test/java/org/hibernate/orm/test/filter/Salesperson.java

@@ -24,6 +24,13 @@ public class Salesperson {
 	private Department department;
 	private Set orders = new HashSet();
 
+	@Override
+	public String toString() {
+		return "Salesperson#" + id + "{"
+				+ ", name='" + name + '\'' +
+				'}';
+	}
+
 	public Long getId() {
 		return id;
 	}

hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/ElementCollectionConverterTest.java

@@ -7,7 +7,6 @@
 package org.hibernate.test.annotations.reflection;
 
 import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
-import org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider;
 
 import org.hibernate.testing.TestForIssue;
 import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
@@ -22,7 +21,6 @@ public class ElementCollectionConverterTest extends BaseCoreFunctionalTestCase {
 	@Override
 	protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
 		super.prepareBootstrapRegistryBuilder( builder );
-		XmlMappingOptionsStrategyRegistrationProvider.applyJaxbStrategy( builder );
 	}
 
 	@Override

hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/JPAXMLOverriddenAnnotationReaderTest.java

@@ -6,45 +6,25 @@
  */
 package org.hibernate.test.annotations.reflection;
 
-import org.dom4j.DocumentException;
-import org.dom4j.io.SAXReader;
 import org.hibernate.annotations.Columns;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
-import org.hibernate.cfg.EJB3DTDEntityResolver;
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
 import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader;
 import org.hibernate.cfg.annotations.reflection.internal.XMLContext;
-import org.hibernate.internal.util.xml.ErrorLogger;
-import org.hibernate.internal.util.xml.XMLHelper;
 import org.hibernate.internal.util.xml.XMLMappingHelper;
 
 import org.hibernate.testing.boot.BootstrapContextImpl;
 import org.hibernate.testing.junit4.BaseUnitTestCase;
 import org.hibernate.testing.TestForIssue;
-import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
 import org.junit.Test;
-import org.xml.sax.InputSource;
-import org.xml.sax.SAXException;
-import org.xml.sax.SAXNotSupportedException;
 
 import javax.persistence.*;
-import java.io.BufferedInputStream;
 import java.io.IOException;
-import java.io.InputStream;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 
 import static org.junit.Assert.*;
 
 /**
- * Tests the new {@link JPAXMLOverriddenAnnotationReader},
- * which will be replacing {@link JPAOverriddenAnnotationReader}.
- * {@link JPAOverriddenAnnotationReader} is still the default implementation,
- * but we want to switch to {@link JPAXMLOverriddenAnnotationReader}
- * as soon as it will be practical.
- *
- * @see LegacyJPAOverriddenAnnotationReaderTest
  * @author Emmanuel Bernard
  */
 @TestForIssue(jiraKey = "HHH-14529")
@@ -405,12 +385,7 @@ public class JPAXMLOverriddenAnnotationReaderTest extends BaseUnitTestCase {
 	}
 
 	private XMLContext buildContext(String ormfile) throws IOException {
-		XMLMappingHelper xmlHelper = new XMLMappingHelper( new XmlMappingOptions() {
+		XMLMappingHelper xmlHelper = new XMLMappingHelper();
-			@Override
-			public boolean isPreferJaxb() {
-				return true;
-			}
-		} );
 		JaxbEntityMappings mappings = xmlHelper.readOrmXmlMappings( ormfile );
 		XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
 		context.addDocument( mappings );

hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/LegacyElementCollectionConverterTest.java

@@ -1,71 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.reflection;
-
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-
-import org.hibernate.testing.TestForIssue;
-import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
-import org.junit.Test;
-
-import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
-import static org.junit.Assert.assertEquals;
-
-/**
- * Tests the legacy {@link JPAOverriddenAnnotationReader},
- * which will be replaced with {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}.
- * {@link JPAOverriddenAnnotationReader} is still the default implementation,
- * but we want to switch to {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}
- * as soon as it will be practical.
- *
- * @see JPAXMLOverriddenAnnotationReaderTest
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@Deprecated
-@TestForIssue( jiraKey = "HHH-11924")
-public class LegacyElementCollectionConverterTest extends BaseCoreFunctionalTestCase {
-
-	@Override
-	protected Class[] getAnnotatedClasses() {
-		return new Class[] {
-			Company.class,
-		};
-	}
-
-	@Override
-	protected String[] getOrmXmlFiles() {
-		return new String[] { "org/hibernate/test/annotations/reflection/element-collection-converter-orm.xml" };
-	}
-
-
-	@Test
-	public void testConverterIsAppliedToElementCollection() {
-		doInHibernate( this::sessionFactory, session -> {
-			Company company = new Company();
-			company.setId( 1L );
-
-			Organization org1 = new Organization();
-			org1.setOrganizationId( "ACME" );
-
-			company.getOrganizations().add( org1 );
-
-			session.persist( company );
-		} );
-
-		doInHibernate( this::sessionFactory, session -> {
-			String organizationId = (String) session
-					.createNativeQuery( "select organizations from Company_organizations" )
-					.getSingleResult();
-			assertEquals( "ORG-ACME", organizationId );
-
-			Company company = session.find( Company.class, 1L );
-
-			assertEquals( 1, company.getOrganizations().size() );
-			assertEquals( "ACME" , company.getOrganizations().get( 0 ).getOrganizationId());
-		} );
-	}
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/LegacyJPAOverriddenAnnotationReaderTest.java

@@ -1,485 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.reflection;
-
-import java.io.BufferedInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import javax.persistence.AssociationOverrides;
-import javax.persistence.AttributeOverrides;
-import javax.persistence.Basic;
-import javax.persistence.Column;
-import javax.persistence.Converts;
-import javax.persistence.DiscriminatorColumn;
-import javax.persistence.DiscriminatorValue;
-import javax.persistence.ElementCollection;
-import javax.persistence.Embedded;
-import javax.persistence.EmbeddedId;
-import javax.persistence.Entity;
-import javax.persistence.EntityListeners;
-import javax.persistence.EnumType;
-import javax.persistence.Enumerated;
-import javax.persistence.ExcludeDefaultListeners;
-import javax.persistence.ExcludeSuperclassListeners;
-import javax.persistence.FetchType;
-import javax.persistence.GeneratedValue;
-import javax.persistence.GenerationType;
-import javax.persistence.Id;
-import javax.persistence.IdClass;
-import javax.persistence.Inheritance;
-import javax.persistence.InheritanceType;
-import javax.persistence.JoinColumns;
-import javax.persistence.JoinTable;
-import javax.persistence.Lob;
-import javax.persistence.ManyToMany;
-import javax.persistence.MapKey;
-import javax.persistence.MappedSuperclass;
-import javax.persistence.NamedNativeQueries;
-import javax.persistence.NamedQueries;
-import javax.persistence.OneToMany;
-import javax.persistence.OneToOne;
-import javax.persistence.OrderBy;
-import javax.persistence.PostLoad;
-import javax.persistence.PostPersist;
-import javax.persistence.PrePersist;
-import javax.persistence.PrimaryKeyJoinColumn;
-import javax.persistence.PrimaryKeyJoinColumns;
-import javax.persistence.SecondaryTable;
-import javax.persistence.SecondaryTables;
-import javax.persistence.SequenceGenerator;
-import javax.persistence.SqlResultSetMappings;
-import javax.persistence.Table;
-import javax.persistence.TableGenerator;
-import javax.persistence.Temporal;
-import javax.persistence.TemporalType;
-import javax.persistence.Transient;
-import javax.persistence.Version;
-
-import org.hibernate.annotations.Columns;
-import org.hibernate.cfg.EJB3DTDEntityResolver;
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-import org.hibernate.cfg.annotations.reflection.XMLContext;
-import org.hibernate.internal.util.xml.ErrorLogger;
-import org.hibernate.internal.util.xml.XMLHelper;
-
-import org.hibernate.testing.TestForIssue;
-import org.hibernate.testing.boot.BootstrapContextImpl;
-import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
-import org.hibernate.testing.junit4.BaseUnitTestCase;
-import org.junit.Test;
-
-import org.dom4j.DocumentException;
-import org.dom4j.io.SAXReader;
-import org.xml.sax.InputSource;
-import org.xml.sax.SAXException;
-import org.xml.sax.SAXNotSupportedException;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Tests the legacy {@link JPAOverriddenAnnotationReader},
- * which will be replaced with {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}.
- * {@link JPAOverriddenAnnotationReader} is still the default implementation,
- * but we want to switch to {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}
- * as soon as it will be practical.
- *
- * @see JPAXMLOverriddenAnnotationReaderTest
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@Deprecated
-public class LegacyJPAOverriddenAnnotationReaderTest extends BaseUnitTestCase {
-	@Test
-	public void testMappedSuperclassAnnotations() throws Exception {
-		XMLContext context = buildContext(
-				"org/hibernate/test/annotations/reflection/metadata-complete.xml"
-		);
-		JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( Organization.class, context, BootstrapContextImpl.INSTANCE );
-		assertTrue( reader.isAnnotationPresent( MappedSuperclass.class ) );
-	}
-
-	@Test
-	public void testEntityRelatedAnnotations() throws Exception {
-		XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
-		JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( Administration.class, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Entity.class ) );
-		assertEquals(
-				"Default value in xml entity should not override @Entity.name", "JavaAdministration",
-				reader.getAnnotation( Entity.class ).name()
-		);
-		assertNotNull( reader.getAnnotation( Table.class ) );
-		assertEquals( "@Table not overridden", "tbl_admin", reader.getAnnotation( Table.class ).name() );
-		assertEquals( "Default schema not overridden", "myschema", reader.getAnnotation( Table.class ).schema() );
-		assertEquals(
-				"Proper @Table.uniqueConstraints", 2,
-				reader.getAnnotation( Table.class ).uniqueConstraints()[0].columnNames().length
-		);
-		String columnName = reader.getAnnotation( Table.class ).uniqueConstraints()[0].columnNames()[0];
-		assertTrue(
-				"Proper @Table.uniqueConstraints", "firstname".equals( columnName ) || "lastname".equals( columnName )
-		);
-		assertNull( "Both Java and XML used", reader.getAnnotation( SecondaryTable.class ) );
-		assertNotNull( "XML does not work", reader.getAnnotation( SecondaryTables.class ) );
-		SecondaryTable[] tables = reader.getAnnotation( SecondaryTables.class ).value();
-		assertEquals( 1, tables.length );
-		assertEquals( "admin2", tables[0].name() );
-		assertEquals( "unique constraints ignored", 1, tables[0].uniqueConstraints().length );
-		assertEquals( "pk join column ignored", 1, tables[0].pkJoinColumns().length );
-		assertEquals( "pk join column ignored", "admin_id", tables[0].pkJoinColumns()[0].name() );
-		assertNotNull( "Sequence Overriding not working", reader.getAnnotation( SequenceGenerator.class ) );
-		assertEquals(
-				"wrong sequence name", "seqhilo", reader.getAnnotation( SequenceGenerator.class ).sequenceName()
-		);
-		assertEquals( "default fails", 50, reader.getAnnotation( SequenceGenerator.class ).allocationSize() );
-		assertNotNull( "TableOverriding not working", reader.getAnnotation( TableGenerator.class ) );
-		assertEquals( "wrong tble name", "tablehilo", reader.getAnnotation( TableGenerator.class ).table() );
-		assertEquals( "no schema overriding", "myschema", reader.getAnnotation( TableGenerator.class ).schema() );
-
-		reader = new JPAOverriddenAnnotationReader( Match.class, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Table.class ) );
-		assertEquals(
-				"Java annotation not taken into account", "matchtable", reader.getAnnotation( Table.class ).name()
-		);
-		assertEquals(
-				"Java annotation not taken into account", "matchschema", reader.getAnnotation( Table.class ).schema()
-		);
-		assertEquals( "Overriding not taken into account", "mycatalog", reader.getAnnotation( Table.class ).catalog() );
-		assertNotNull( "SecondaryTable swallowed", reader.getAnnotation( SecondaryTables.class ) );
-		assertEquals(
-				"Default schema not taken into account", "myschema",
-				reader.getAnnotation( SecondaryTables.class ).value()[0].schema()
-		);
-		assertNotNull( reader.getAnnotation( Inheritance.class ) );
-		assertEquals(
-				"inheritance strategy not overriden", InheritanceType.JOINED,
-				reader.getAnnotation( Inheritance.class ).strategy()
-		);
-		assertNotNull( "NamedQuery not overriden", reader.getAnnotation( NamedQueries.class ) );
-		assertEquals( "No deduplication", 3, reader.getAnnotation( NamedQueries.class ).value().length );
-		assertEquals(
-				"deduplication kept the Java version", 1,
-				reader.getAnnotation( NamedQueries.class ).value()[1].hints().length
-		);
-		assertEquals(
-				"org.hibernate.timeout", reader.getAnnotation( NamedQueries.class ).value()[1].hints()[0].name()
-		);
-		assertNotNull( "NamedNativeQuery not overriden", reader.getAnnotation( NamedNativeQueries.class ) );
-		assertEquals( "No deduplication", 3, reader.getAnnotation( NamedNativeQueries.class ).value().length );
-		assertEquals(
-				"deduplication kept the Java version", 1,
-				reader.getAnnotation( NamedNativeQueries.class ).value()[1].hints().length
-		);
-		assertEquals(
-				"org.hibernate.timeout", reader.getAnnotation( NamedNativeQueries.class ).value()[1].hints()[0].name()
-		);
-		assertNotNull( reader.getAnnotation( SqlResultSetMappings.class ) );
-		assertEquals(
-				"competitor1Point", reader.getAnnotation( SqlResultSetMappings.class ).value()[0].columns()[0].name()
-		);
-		assertEquals(
-				"competitor1Point",
-				reader.getAnnotation( SqlResultSetMappings.class ).value()[0].entities()[0].fields()[0].column()
-		);
-		assertNotNull( reader.getAnnotation( ExcludeSuperclassListeners.class ) );
-		assertNotNull( reader.getAnnotation( ExcludeDefaultListeners.class ) );
-
-		reader = new JPAOverriddenAnnotationReader( Competition.class, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( MappedSuperclass.class ) );
-
-		reader = new JPAOverriddenAnnotationReader( TennisMatch.class, context, BootstrapContextImpl.INSTANCE );
-		assertNull( "Mutualize PKJC into PKJCs", reader.getAnnotation( PrimaryKeyJoinColumn.class ) );
-		assertNotNull( reader.getAnnotation( PrimaryKeyJoinColumns.class ) );
-		assertEquals(
-				"PrimaryKeyJoinColumn overrden", "id",
-				reader.getAnnotation( PrimaryKeyJoinColumns.class ).value()[0].name()
-		);
-		assertNotNull( reader.getAnnotation( AttributeOverrides.class ) );
-		assertEquals( "Wrong deduplication", 3, reader.getAnnotation( AttributeOverrides.class ).value().length );
-		assertEquals(
-				"Wrong priority (XML vs java annotations)", "fld_net",
-				reader.getAnnotation( AttributeOverrides.class ).value()[0].column().name()
-		);
-		assertEquals(
-				"Column mapping", 2, reader.getAnnotation( AttributeOverrides.class ).value()[1].column().scale()
-		);
-		assertEquals(
-				"Column mapping", true, reader.getAnnotation( AttributeOverrides.class ).value()[1].column().unique()
-		);
-		assertNotNull( reader.getAnnotation( AssociationOverrides.class ) );
-		assertEquals( "no XML processing", 1, reader.getAnnotation( AssociationOverrides.class ).value().length );
-		assertEquals(
-				"wrong xml processing", "id",
-				reader.getAnnotation( AssociationOverrides.class ).value()[0].joinColumns()[0].referencedColumnName()
-		);
-
-
-		reader = new JPAOverriddenAnnotationReader( SocialSecurityPhysicalAccount.class, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( IdClass.class ) );
-		assertEquals( "id-class not used", SocialSecurityNumber.class, reader.getAnnotation( IdClass.class ).value() );
-		assertEquals(
-				"discriminator-value not used", "Physical", reader.getAnnotation( DiscriminatorValue.class ).value()
-		);
-		assertNotNull( "discriminator-column not used", reader.getAnnotation( DiscriminatorColumn.class ) );
-		assertEquals(
-				"discriminator-column.name default value broken", "DTYPE",
-				reader.getAnnotation( DiscriminatorColumn.class ).name()
-		);
-		assertEquals(
-				"discriminator-column.length broken", 34, reader.getAnnotation( DiscriminatorColumn.class ).length()
-		);
-	}
-
-	@Test
-	public void testEntityRelatedAnnotationsMetadataComplete() throws Exception {
-		XMLContext context = buildContext(
-				"org/hibernate/test/annotations/reflection/metadata-complete.xml"
-		);
-		JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( Administration.class, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Entity.class ) );
-		assertEquals(
-				"Metadata complete should ignore java annotations", "", reader.getAnnotation( Entity.class ).name()
-		);
-		assertNotNull( reader.getAnnotation( Table.class ) );
-		assertEquals( "@Table should not be used", "", reader.getAnnotation( Table.class ).name() );
-		assertEquals( "Default schema not overriden", "myschema", reader.getAnnotation( Table.class ).schema() );
-
-		reader = new JPAOverriddenAnnotationReader( Match.class, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Table.class ) );
-		assertEquals( "@Table should not be used", "", reader.getAnnotation( Table.class ).name() );
-		assertEquals( "Overriding not taken into account", "myschema", reader.getAnnotation( Table.class ).schema() );
-		assertEquals( "Overriding not taken into account", "mycatalog", reader.getAnnotation( Table.class ).catalog() );
-		assertNull( "Ignore Java annotation", reader.getAnnotation( SecondaryTable.class ) );
-		assertNull( "Ignore Java annotation", reader.getAnnotation( SecondaryTables.class ) );
-		assertNull( "Ignore Java annotation", reader.getAnnotation( Inheritance.class ) );
-		assertNull( reader.getAnnotation( NamedQueries.class ) );
-		assertNull( reader.getAnnotation( NamedNativeQueries.class ) );
-
-		reader = new JPAOverriddenAnnotationReader( TennisMatch.class, context, BootstrapContextImpl.INSTANCE );
-		assertNull( reader.getAnnotation( PrimaryKeyJoinColumn.class ) );
-		assertNull( reader.getAnnotation( PrimaryKeyJoinColumns.class ) );
-
-		reader = new JPAOverriddenAnnotationReader( Competition.class, context, BootstrapContextImpl.INSTANCE );
-		assertNull( reader.getAnnotation( MappedSuperclass.class ) );
-
-		reader = new JPAOverriddenAnnotationReader( SocialSecurityMoralAccount.class, context, BootstrapContextImpl.INSTANCE );
-		assertNull( reader.getAnnotation( IdClass.class ) );
-		assertNull( reader.getAnnotation( DiscriminatorValue.class ) );
-		assertNull( reader.getAnnotation( DiscriminatorColumn.class ) );
-		assertNull( reader.getAnnotation( SequenceGenerator.class ) );
-		assertNull( reader.getAnnotation( TableGenerator.class ) );
-	}
-
-	@Test
-	public void testIdRelatedAnnotations() throws Exception {
-		XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
-		Method method = Administration.class.getDeclaredMethod( "getId" );
-		JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
-		assertNull( reader.getAnnotation( Id.class ) );
-		assertNull( reader.getAnnotation( Column.class ) );
-		Field field = Administration.class.getDeclaredField( "id" );
-		reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Id.class ) );
-		assertNotNull( reader.getAnnotation( GeneratedValue.class ) );
-		assertEquals( GenerationType.SEQUENCE, reader.getAnnotation( GeneratedValue.class ).strategy() );
-		assertEquals( "generator", reader.getAnnotation( GeneratedValue.class ).generator() );
-		assertNotNull( reader.getAnnotation( SequenceGenerator.class ) );
-		assertEquals( "seq", reader.getAnnotation( SequenceGenerator.class ).sequenceName() );
-		assertNotNull( reader.getAnnotation( Columns.class ) );
-		assertEquals( 1, reader.getAnnotation( Columns.class ).columns().length );
-		assertEquals( "fld_id", reader.getAnnotation( Columns.class ).columns()[0].name() );
-		assertNotNull( reader.getAnnotation( Temporal.class ) );
-		assertEquals( TemporalType.DATE, reader.getAnnotation( Temporal.class ).value() );
-
-		context = buildContext(
-				"org/hibernate/test/annotations/reflection/metadata-complete.xml"
-		);
-		method = Administration.class.getDeclaredMethod( "getId" );
-		reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull(
-				"Default access type when not defined in metadata complete should be property",
-				reader.getAnnotation( Id.class )
-		);
-		field = Administration.class.getDeclaredField( "id" );
-		reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNull(
-				"Default access type when not defined in metadata complete should be property",
-				reader.getAnnotation( Id.class )
-		);
-
-		method = BusTrip.class.getDeclaredMethod( "getId" );
-		reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
-		assertNull( reader.getAnnotation( EmbeddedId.class ) );
-		field = BusTrip.class.getDeclaredField( "id" );
-		reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( EmbeddedId.class ) );
-		assertNotNull( reader.getAnnotation( AttributeOverrides.class ) );
-		assertEquals( 1, reader.getAnnotation( AttributeOverrides.class ).value().length );
-	}
-
-	@Test
-	public void testBasicRelatedAnnotations() throws Exception {
-		XMLContext context = buildContext(
-				"org/hibernate/test/annotations/reflection/metadata-complete.xml"
-		);
-		Field field = BusTrip.class.getDeclaredField( "status" );
-		JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Enumerated.class ) );
-		assertEquals( EnumType.STRING, reader.getAnnotation( Enumerated.class ).value() );
-		assertEquals( false, reader.getAnnotation( Basic.class ).optional() );
-		field = BusTrip.class.getDeclaredField( "serial" );
-		reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Lob.class ) );
-		assertEquals( "serialbytes", reader.getAnnotation( Columns.class ).columns()[0].name() );
-		field = BusTrip.class.getDeclaredField( "terminusTime" );
-		reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Temporal.class ) );
-		assertEquals( TemporalType.TIMESTAMP, reader.getAnnotation( Temporal.class ).value() );
-		assertEquals( FetchType.LAZY, reader.getAnnotation( Basic.class ).fetch() );
-
-		field = BusTripPk.class.getDeclaredField( "busDriver" );
-		reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.isAnnotationPresent( Basic.class ) );
-	}
-
-	@Test
-	public void testVersionRelatedAnnotations() throws Exception {
-		XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
-		Method method = Administration.class.getDeclaredMethod( "getVersion" );
-		JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Version.class ) );
-
-		Field field = Match.class.getDeclaredField( "version" );
-		assertNotNull( reader.getAnnotation( Version.class ) );
-	}
-
-	@Test
-	public void testTransientAndEmbeddedRelatedAnnotations() throws Exception {
-		XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
-
-		Field field = Administration.class.getDeclaredField( "transientField" );
-		JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Transient.class ) );
-		assertNull( reader.getAnnotation( Basic.class ) );
-
-		field = Match.class.getDeclaredField( "playerASSN" );
-		reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( Embedded.class ) );
-	}
-
-	@Test
-	public void testAssociationRelatedAnnotations() throws Exception {
-		XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
-
-		Field field = Administration.class.getDeclaredField( "defaultBusTrip" );
-		JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( OneToOne.class ) );
-		assertNull( reader.getAnnotation( JoinColumns.class ) );
-		assertNotNull( reader.getAnnotation( PrimaryKeyJoinColumns.class ) );
-		assertEquals( "pk", reader.getAnnotation( PrimaryKeyJoinColumns.class ).value()[0].name() );
-		assertEquals( 5, reader.getAnnotation( OneToOne.class ).cascade().length );
-		assertEquals( FetchType.LAZY, reader.getAnnotation( OneToOne.class ).fetch() );
-		assertEquals( "test", reader.getAnnotation( OneToOne.class ).mappedBy() );
-
-		context = buildContext(
-				"org/hibernate/test/annotations/reflection/metadata-complete.xml"
-		);
-		field = BusTrip.class.getDeclaredField( "players" );
-		reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( OneToMany.class ) );
-		assertNotNull( reader.getAnnotation( JoinColumns.class ) );
-		assertEquals( 2, reader.getAnnotation( JoinColumns.class ).value().length );
-		assertEquals( "driver", reader.getAnnotation( JoinColumns.class ).value()[0].name() );
-		assertNotNull( reader.getAnnotation( MapKey.class ) );
-		assertEquals( "name", reader.getAnnotation( MapKey.class ).name() );
-
-		field = BusTrip.class.getDeclaredField( "roads" );
-		reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( ManyToMany.class ) );
-		assertNotNull( reader.getAnnotation( JoinTable.class ) );
-		assertEquals( "bus_road", reader.getAnnotation( JoinTable.class ).name() );
-		assertEquals( 2, reader.getAnnotation( JoinTable.class ).joinColumns().length );
-		assertEquals( 1, reader.getAnnotation( JoinTable.class ).inverseJoinColumns().length );
-		assertEquals( 2, reader.getAnnotation( JoinTable.class ).uniqueConstraints()[0].columnNames().length );
-		assertNotNull( reader.getAnnotation( OrderBy.class ) );
-		assertEquals( "maxSpeed", reader.getAnnotation( OrderBy.class ).value() );
-	}
-
-	@Test
-	@TestForIssue(jiraKey = "HHH-11924")
-	public void testElementCollectionConverter() throws Exception {
-		XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
-
-		Field field = Company.class.getDeclaredField( "organizations" );
-		JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
-		assertNotNull( reader.getAnnotation( ElementCollection.class ) );
-		assertNotNull( reader.getAnnotation( Converts.class ) );
-		assertNotNull( reader.getAnnotation( Converts.class ).value() );
-		assertTrue( reader.getAnnotation( Converts.class ).value().length == 1 );
-		assertEquals(OrganizationConverter.class, reader.getAnnotation( Converts.class ).value()[0].converter());
-	}
-
-	@Test
-	public void testEntityListeners() throws Exception {
-		XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
-
-		Method method = Administration.class.getDeclaredMethod( "calculate" );
-		JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
-		assertTrue( reader.isAnnotationPresent( PrePersist.class ) );
-
-		reader = new JPAOverriddenAnnotationReader( Administration.class, context, BootstrapContextImpl.INSTANCE );
-		assertTrue( reader.isAnnotationPresent( EntityListeners.class ) );
-		assertEquals( 1, reader.getAnnotation( EntityListeners.class ).value().length );
-		assertEquals( LogListener.class, reader.getAnnotation( EntityListeners.class ).value()[0] );
-
-		method = LogListener.class.getDeclaredMethod( "noLog", Object.class );
-		reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
-		assertTrue( reader.isAnnotationPresent( PostLoad.class ) );
-
-		method = LogListener.class.getDeclaredMethod( "log", Object.class );
-		reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
-		assertTrue( reader.isAnnotationPresent( PrePersist.class ) );
-		assertFalse( reader.isAnnotationPresent( PostPersist.class ) );
-
-		assertEquals( 1, context.getDefaultEntityListeners().size() );
-		assertEquals( OtherLogListener.class.getName(), context.getDefaultEntityListeners().get( 0 ) );
-	}
-
-	private XMLContext buildContext(String ormfile) throws SAXException, DocumentException, IOException {
-		XMLHelper xmlHelper = new XMLHelper();
-		InputStream is = ClassLoaderServiceTestingImpl.INSTANCE.locateResourceStream( ormfile );
-		assertNotNull( "ORM.xml not found: " + ormfile, is );
-		XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
-		ErrorLogger errorLogger = new ErrorLogger();
-		SAXReader saxReader = xmlHelper.createSAXReader( errorLogger, EJB3DTDEntityResolver.INSTANCE );
-		//saxReader.setValidation( false );
-		try {
-			saxReader.setFeature( "http://apache.org/xml/features/validation/schema", true );
-		}
-		catch ( SAXNotSupportedException e ) {
-			saxReader.setValidation( false );
-		}
-		org.dom4j.Document doc;
-		try {
-			doc = saxReader.read( new InputSource( new BufferedInputStream( is ) ) );
-		}
-		finally {
-			is.close();
-		}
-		if ( errorLogger.hasErrors() ) {
-			System.out.println( errorLogger.getErrors().get( 0 ) );
-		}
-		assertFalse( errorLogger.hasErrors() );
-		context.addDocument( doc );
-		return context;
-	}
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/LegacyXMLContextTest.java

@@ -1,73 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.reflection;
-
-import java.io.BufferedInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-import org.hibernate.cfg.EJB3DTDEntityResolver;
-import org.hibernate.cfg.annotations.reflection.XMLContext;
-import org.hibernate.internal.util.xml.ErrorLogger;
-import org.hibernate.internal.util.xml.XMLHelper;
-
-import org.hibernate.testing.boot.BootstrapContextImpl;
-import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
-import org.junit.Assert;
-import org.junit.Test;
-
-import org.dom4j.io.SAXReader;
-import org.xml.sax.InputSource;
-import org.xml.sax.SAXNotSupportedException;
-
-/**
- * Tests the legacy {@link XMLContext},
- * which will be replaced with {@link org.hibernate.cfg.annotations.reflection.internal.XMLContext}.
- * {@link XMLContext} is still the default implementation,
- * but we want to switch to {@link org.hibernate.cfg.annotations.reflection.internal.XMLContext}
- * as soon as it will be practical.
- *
- * @see XMLContextTest
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link XMLContext}.
- */
-public class LegacyXMLContextTest {
-	@Test
-	public void testAll() throws Exception {
-		final XMLHelper xmlHelper = new XMLHelper();
-		final XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
-
-		InputStream is = ClassLoaderServiceTestingImpl.INSTANCE.locateResourceStream(
-				"org/hibernate/test/annotations/reflection/orm.xml"
-		);
-		Assert.assertNotNull( "ORM.xml not found", is );
-
-		final ErrorLogger errorLogger = new ErrorLogger();
-		final SAXReader saxReader = xmlHelper.createSAXReader( errorLogger, EJB3DTDEntityResolver.INSTANCE );
-
-		try {
-			saxReader.setFeature( "http://apache.org/xml/features/validation/schema", true );
-		}
-		catch ( SAXNotSupportedException e ) {
-			saxReader.setValidation( false );
-		}
-		org.dom4j.Document doc;
-		try {
-			doc = saxReader.read( new InputSource( new BufferedInputStream( is ) ) );
-		}
-		finally {
-			try {
-				is.close();
-			}
-			catch ( IOException ioe ) {
-				//log.warn( "Could not close input stream", ioe );
-			}
-		}
-		Assert.assertFalse( errorLogger.hasErrors() );
-		context.addDocument( doc );
-	}
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/XMLContextTest.java

@@ -7,7 +7,6 @@
 package org.hibernate.test.annotations.reflection;
 
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.cfg.annotations.reflection.internal.XMLContext;
 import org.hibernate.internal.util.xml.XMLMappingHelper;
 
@@ -16,24 +15,13 @@ import org.hibernate.testing.boot.BootstrapContextImpl;
 import org.junit.Test;
 
 /**
- * Tests the new {@link XMLContext},
- * which will be replacing {@link org.hibernate.cfg.annotations.reflection.XMLContext}.
- * {@link org.hibernate.cfg.annotations.reflection.XMLContext} is still the default implementation,
- * but we want to switch to {@link XMLContext}
- * as soon as it will be practical.
- *
  * @author Emmanuel Bernard
  */
 @TestForIssue(jiraKey = "HHH-14529")
 public class XMLContextTest {
 	@Test
 	public void testAll() throws Exception {
-		XMLMappingHelper xmlHelper = new XMLMappingHelper( new XmlMappingOptions() {
+		XMLMappingHelper xmlHelper = new XMLMappingHelper();
-			@Override
-			public boolean isPreferJaxb() {
-				return true;
-			}
-		} );
 		final XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
 
 		JaxbEntityMappings mappings = xmlHelper.readOrmXmlMappings( "org/hibernate/test/annotations/reflection/orm.xml" );

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/Ejb3XmlTest.java

@@ -17,7 +17,6 @@ import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
 import org.hibernate.dialect.PostgreSQL81Dialect;
 import org.hibernate.dialect.PostgreSQLDialect;
 import org.hibernate.dialect.TeradataDialect;
-import org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider;
 import org.hibernate.persister.collection.BasicCollectionPersister;
 
 import org.hibernate.testing.SkipForDialect;
@@ -37,7 +36,6 @@ public class Ejb3XmlTest extends BaseCoreFunctionalTestCase {
 	@Override
 	protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
 		super.prepareBootstrapRegistryBuilder( builder );
-		XmlMappingOptionsStrategyRegistrationProvider.applyJaxbStrategy( builder );
 	}
 
 	@Test

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/Ejb3XmlTestCase.java

@@ -11,7 +11,6 @@ import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
 
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader;
 import org.hibernate.cfg.annotations.reflection.internal.XMLContext;
 import org.hibernate.internal.util.xml.XMLMappingHelper;
@@ -67,12 +66,7 @@ public abstract class Ejb3XmlTestCase extends BaseUnitTestCase {
 	}
 
 	protected XMLContext getContext(InputStream is, String resourceName) throws Exception {
-		XMLMappingHelper xmlHelper = new XMLMappingHelper( new XmlMappingOptions() {
+		XMLMappingHelper xmlHelper = new XMLMappingHelper();
-			@Override
-			public boolean isPreferJaxb() {
-				return true;
-			}
-		} );
 		JaxbEntityMappings mappings = xmlHelper.readOrmXmlMappings( is, resourceName );
 		XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
 		context.addDocument( mappings );

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlElementCollectionTest.java

@@ -1,716 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.xml.ejb3;
-
-import javax.persistence.Access;
-import javax.persistence.AccessType;
-import javax.persistence.AssociationOverride;
-import javax.persistence.AssociationOverrides;
-import javax.persistence.AttributeOverride;
-import javax.persistence.AttributeOverrides;
-import javax.persistence.CollectionTable;
-import javax.persistence.Column;
-import javax.persistence.ElementCollection;
-import javax.persistence.EnumType;
-import javax.persistence.Enumerated;
-import javax.persistence.FetchType;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinTable;
-import javax.persistence.Lob;
-import javax.persistence.MapKey;
-import javax.persistence.MapKeyClass;
-import javax.persistence.MapKeyColumn;
-import javax.persistence.MapKeyEnumerated;
-import javax.persistence.MapKeyJoinColumn;
-import javax.persistence.MapKeyJoinColumns;
-import javax.persistence.MapKeyTemporal;
-import javax.persistence.OrderBy;
-import javax.persistence.OrderColumn;
-import javax.persistence.Temporal;
-import javax.persistence.TemporalType;
-import javax.persistence.UniqueConstraint;
-
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlElementCollectionTest}
- * for the legacy {@link JPAOverriddenAnnotationReader}.
- *
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@Deprecated
-public class LegacyEjb3XmlElementCollectionTest extends LegacyEjb3XmlTestCase {
-	@Test
-	public void testNoChildren() throws Exception {
-		reader = getReader( Entity2.class, "field1", "element-collection.orm1.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationNotPresent( OrderColumn.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( Column.class );
-		assertAnnotationNotPresent( Temporal.class );
-		assertAnnotationNotPresent( Enumerated.class );
-		assertAnnotationNotPresent( Lob.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationNotPresent( AttributeOverrides.class );
-		assertAnnotationNotPresent( AssociationOverride.class );
-		assertAnnotationNotPresent( AssociationOverrides.class );
-		assertAnnotationNotPresent( CollectionTable.class );
-		assertAnnotationNotPresent( Access.class );
-		ElementCollection relAnno = reader.getAnnotation( ElementCollection.class );
-		assertEquals( FetchType.LAZY, relAnno.fetch() );
-		assertEquals( void.class, relAnno.targetClass() );
-	}
-
-	@Test
-	public void testOrderBy() throws Exception {
-		reader = getReader( Entity2.class, "field1", "element-collection.orm2.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationPresent( OrderBy.class );
-		assertAnnotationNotPresent( OrderColumn.class );
-		assertEquals(
-				"col1 ASC, col2 DESC", reader.getAnnotation( OrderBy.class )
-				.value()
-		);
-	}
-
-	@Test
-	public void testOrderColumnNoAttributes() throws Exception {
-		reader = getReader( Entity2.class, "field1", "element-collection.orm3.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationPresent( OrderColumn.class );
-		OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
-		assertEquals( "", orderColumnAnno.columnDefinition() );
-		assertEquals( "", orderColumnAnno.name() );
-		assertTrue( orderColumnAnno.insertable() );
-		assertTrue( orderColumnAnno.nullable() );
-		assertTrue( orderColumnAnno.updatable() );
-	}
-
-	@Test
-	public void testOrderColumnAllAttributes() throws Exception {
-		reader = getReader( Entity2.class, "field1", "element-collection.orm4.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationPresent( OrderColumn.class );
-		OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
-		assertEquals( "int", orderColumnAnno.columnDefinition() );
-		assertEquals( "col1", orderColumnAnno.name() );
-		assertFalse( orderColumnAnno.insertable() );
-		assertFalse( orderColumnAnno.nullable() );
-		assertFalse( orderColumnAnno.updatable() );
-	}
-
-	@Test
-	public void testMapKeyNoAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm5.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals( "", reader.getAnnotation( MapKey.class ).name() );
-	}
-
-	@Test
-	public void testMapKeyAllAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm6.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals( "field2", reader.getAnnotation( MapKey.class ).name() );
-	}
-
-	@Test
-	public void testMapKeyClass() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm7.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals(
-				Entity2.class, reader.getAnnotation( MapKeyClass.class )
-				.value()
-		);
-	}
-
-	@Test
-	public void testMapKeyTemporal() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm8.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals(
-				TemporalType.DATE, reader.getAnnotation(
-				MapKeyTemporal.class
-		).value()
-		);
-	}
-
-	@Test
-	public void testMapKeyEnumerated() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm9.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals(
-				EnumType.STRING, reader.getAnnotation(
-				MapKeyEnumerated.class
-		).value()
-		);
-	}
-
-	/**
-	 * When there's a single map key attribute override, we still wrap it with
-	 * an AttributeOverrides annotation.
-	 */
-	@Test
-	public void testSingleMapKeyAttributeOverride() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm10.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationPresent( AttributeOverrides.class );
-		AttributeOverrides overridesAnno = reader
-				.getAnnotation( AttributeOverrides.class );
-		AttributeOverride[] overrides = overridesAnno.value();
-		assertEquals( 1, overrides.length );
-		assertEquals( "field1", overrides[0].name() );
-		assertEquals( "col1", overrides[0].column().name() );
-	}
-
-	@Test
-	public void testMultipleMapKeyAttributeOverrides() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm11.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationPresent( AttributeOverrides.class );
-		AttributeOverrides overridesAnno = reader
-				.getAnnotation( AttributeOverrides.class );
-		AttributeOverride[] overrides = overridesAnno.value();
-		assertEquals( 2, overrides.length );
-		assertEquals( "field1", overrides[0].name() );
-		assertEquals( "", overrides[0].column().name() );
-		assertFalse( overrides[0].column().unique() );
-		assertTrue( overrides[0].column().nullable() );
-		assertTrue( overrides[0].column().insertable() );
-		assertTrue( overrides[0].column().updatable() );
-		assertEquals( "", overrides[0].column().columnDefinition() );
-		assertEquals( "", overrides[0].column().table() );
-		assertEquals( 255, overrides[0].column().length() );
-		assertEquals( 0, overrides[0].column().precision() );
-		assertEquals( 0, overrides[0].column().scale() );
-		assertEquals( "field2", overrides[1].name() );
-		assertEquals( "col1", overrides[1].column().name() );
-		assertTrue( overrides[1].column().unique() );
-		assertFalse( overrides[1].column().nullable() );
-		assertFalse( overrides[1].column().insertable() );
-		assertFalse( overrides[1].column().updatable() );
-		assertEquals( "int", overrides[1].column().columnDefinition() );
-		assertEquals( "table1", overrides[1].column().table() );
-		assertEquals( 50, overrides[1].column().length() );
-		assertEquals( 2, overrides[1].column().precision() );
-		assertEquals( 1, overrides[1].column().scale() );
-	}
-
-	@Test
-	public void testMapKeyColumnNoAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm12.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
-		assertEquals( "", keyColAnno.columnDefinition() );
-		assertEquals( "", keyColAnno.name() );
-		assertEquals( "", keyColAnno.table() );
-		assertFalse( keyColAnno.nullable() );
-		assertTrue( keyColAnno.insertable() );
-		assertFalse( keyColAnno.unique() );
-		assertTrue( keyColAnno.updatable() );
-		assertEquals( 255, keyColAnno.length() );
-		assertEquals( 0, keyColAnno.precision() );
-		assertEquals( 0, keyColAnno.scale() );
-	}
-
-	@Test
-	public void testMapKeyColumnAllAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm13.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
-		assertEquals( "int", keyColAnno.columnDefinition() );
-		assertEquals( "col1", keyColAnno.name() );
-		assertEquals( "table1", keyColAnno.table() );
-		assertTrue( keyColAnno.nullable() );
-		assertFalse( keyColAnno.insertable() );
-		assertTrue( keyColAnno.unique() );
-		assertFalse( keyColAnno.updatable() );
-		assertEquals( 50, keyColAnno.length() );
-		assertEquals( 2, keyColAnno.precision() );
-		assertEquals( 1, keyColAnno.scale() );
-	}
-
-	/**
-	 * When there's a single map key join column, we still wrap it with a
-	 * MapKeyJoinColumns annotation.
-	 */
-	@Test
-	public void testSingleMapKeyJoinColumn() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm14.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyJoinColumns joinColumnsAnno = reader
-				.getAnnotation( MapKeyJoinColumns.class );
-		MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 1, joinColumns.length );
-		assertEquals( "col1", joinColumns[0].name() );
-	}
-
-	@Test
-	public void testMultipleMapKeyJoinColumns() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm15.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyJoinColumns joinColumnsAnno = reader
-				.getAnnotation( MapKeyJoinColumns.class );
-		MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertFalse( joinColumns[0].unique() );
-		assertFalse( joinColumns[0].nullable() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertTrue( joinColumns[1].unique() );
-		assertTrue( joinColumns[1].nullable() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertEquals( "table1", joinColumns[1].table() );
-	}
-
-	@Test
-	public void testColumnNoAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm16.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationPresent( Column.class );
-		Column column = reader.getAnnotation( Column.class );
-		assertEquals( "", column.name() );
-		assertFalse( column.unique() );
-		assertTrue( column.nullable() );
-		assertTrue( column.insertable() );
-		assertTrue( column.updatable() );
-		assertEquals( "", column.columnDefinition() );
-		assertEquals( "", column.table() );
-		assertEquals( 255, column.length() );
-		assertEquals( 0, column.precision() );
-		assertEquals( 0, column.scale() );
-	}
-
-	@Test
-	public void testColumnAllAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm17.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationPresent( Column.class );
-		Column column = reader.getAnnotation( Column.class );
-		assertEquals( "col1", column.name() );
-		assertTrue( column.unique() );
-		assertFalse( column.nullable() );
-		assertFalse( column.insertable() );
-		assertFalse( column.updatable() );
-		assertEquals( "int", column.columnDefinition() );
-		assertEquals( "table1", column.table() );
-		assertEquals( 50, column.length() );
-		assertEquals( 2, column.precision() );
-		assertEquals( 1, column.scale() );
-	}
-
-	@Test
-	public void testTemporal() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm18.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationPresent( Temporal.class );
-		assertAnnotationNotPresent( Enumerated.class );
-		assertAnnotationNotPresent( Lob.class );
-		assertEquals(
-				TemporalType.DATE, reader.getAnnotation(
-				Temporal.class
-		).value()
-		);
-	}
-
-	@Test
-	public void testEnumerated() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm19.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( Temporal.class );
-		assertAnnotationPresent( Enumerated.class );
-		assertAnnotationNotPresent( Lob.class );
-		assertEquals(
-				EnumType.STRING, reader.getAnnotation(
-				Enumerated.class
-		).value()
-		);
-	}
-
-	@Test
-	public void testLob() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm20.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( Temporal.class );
-		assertAnnotationNotPresent( Enumerated.class );
-		assertAnnotationPresent( Lob.class );
-	}
-
-	/**
-	 * When there's a single attribute override, we still wrap it with an
-	 * AttributeOverrides annotation.
-	 */
-	@Test
-	public void testSingleAttributeOverride() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm21.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationPresent( AttributeOverrides.class );
-		AttributeOverrides overridesAnno = reader
-				.getAnnotation( AttributeOverrides.class );
-		AttributeOverride[] overrides = overridesAnno.value();
-		assertEquals( 1, overrides.length );
-		assertEquals( "field1", overrides[0].name() );
-		assertEquals( "col1", overrides[0].column().name() );
-	}
-
-	@Test
-	public void testMultipleAttributeOverrides() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm22.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationPresent( AttributeOverrides.class );
-		AttributeOverrides overridesAnno = reader
-				.getAnnotation( AttributeOverrides.class );
-		AttributeOverride[] overrides = overridesAnno.value();
-		assertEquals( 2, overrides.length );
-		assertEquals( "field1", overrides[0].name() );
-		assertEquals( "", overrides[0].column().name() );
-		assertFalse( overrides[0].column().unique() );
-		assertTrue( overrides[0].column().nullable() );
-		assertTrue( overrides[0].column().insertable() );
-		assertTrue( overrides[0].column().updatable() );
-		assertEquals( "", overrides[0].column().columnDefinition() );
-		assertEquals( "", overrides[0].column().table() );
-		assertEquals( 255, overrides[0].column().length() );
-		assertEquals( 0, overrides[0].column().precision() );
-		assertEquals( 0, overrides[0].column().scale() );
-		assertEquals( "field2", overrides[1].name() );
-		assertEquals( "col1", overrides[1].column().name() );
-		assertTrue( overrides[1].column().unique() );
-		assertFalse( overrides[1].column().nullable() );
-		assertFalse( overrides[1].column().insertable() );
-		assertFalse( overrides[1].column().updatable() );
-		assertEquals( "int", overrides[1].column().columnDefinition() );
-		assertEquals( "table1", overrides[1].column().table() );
-		assertEquals( 50, overrides[1].column().length() );
-		assertEquals( 2, overrides[1].column().precision() );
-		assertEquals( 1, overrides[1].column().scale() );
-	}
-
-	/**
-	 * Tests that map-key-attribute-override and attribute-override elements
-	 * both end up in the AttributeOverrides annotation.
-	 */
-	@Test
-	public void testMixedAttributeOverrides() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm23.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationPresent( AttributeOverrides.class );
-		AttributeOverrides overridesAnno = reader
-				.getAnnotation( AttributeOverrides.class );
-		AttributeOverride[] overrides = overridesAnno.value();
-		assertEquals( 2, overrides.length );
-		assertEquals( "field1", overrides[0].name() );
-		assertEquals( "col1", overrides[0].column().name() );
-		assertEquals( "field2", overrides[1].name() );
-		assertEquals( "col2", overrides[1].column().name() );
-	}
-
-	/**
-	 * When there's a single association override, we still wrap it with an
-	 * AssociationOverrides annotation.
-	 */
-	@Test
-	public void testSingleAssociationOverride() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm24.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( AssociationOverride.class );
-		assertAnnotationPresent( AssociationOverrides.class );
-		AssociationOverrides overridesAnno = reader.getAnnotation( AssociationOverrides.class );
-		AssociationOverride[] overrides = overridesAnno.value();
-		assertEquals( 1, overrides.length );
-		assertEquals( "association1", overrides[0].name() );
-		assertEquals( 0, overrides[0].joinColumns().length );
-		assertEquals( "", overrides[0].joinTable().name() );
-	}
-
-	@Test
-	public void testMultipleAssociationOverridesJoinColumns() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm25.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( AssociationOverride.class );
-		assertAnnotationPresent( AssociationOverrides.class );
-		AssociationOverrides overridesAnno = reader.getAnnotation( AssociationOverrides.class );
-		AssociationOverride[] overrides = overridesAnno.value();
-		assertEquals( 2, overrides.length );
-		//First, an association using join table
-		assertEquals( "association1", overrides[0].name() );
-		assertEquals( 0, overrides[0].joinColumns().length );
-
-		JoinTable joinTableAnno = overrides[0].joinTable();
-		assertEquals( "catalog1", joinTableAnno.catalog() );
-		assertEquals( "table1", joinTableAnno.name() );
-		assertEquals( "schema1", joinTableAnno.schema() );
-
-		//JoinColumns
-		JoinColumn[] joinColumns = joinTableAnno.joinColumns();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertTrue( joinColumns[0].nullable() );
-		assertFalse( joinColumns[0].unique() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertEquals( "table2", joinColumns[1].table() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertFalse( joinColumns[1].nullable() );
-		assertTrue( joinColumns[1].unique() );
-
-		//InverseJoinColumns
-		JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
-		assertEquals( 2, inverseJoinColumns.length );
-		assertEquals( "", inverseJoinColumns[0].name() );
-		assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
-		assertEquals( "", inverseJoinColumns[0].table() );
-		assertEquals( "", inverseJoinColumns[0].columnDefinition() );
-		assertTrue( inverseJoinColumns[0].insertable() );
-		assertTrue( inverseJoinColumns[0].updatable() );
-		assertTrue( inverseJoinColumns[0].nullable() );
-		assertFalse( inverseJoinColumns[0].unique() );
-		assertEquals( "col3", inverseJoinColumns[1].name() );
-		assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
-		assertEquals( "table3", inverseJoinColumns[1].table() );
-		assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
-		assertFalse( inverseJoinColumns[1].insertable() );
-		assertFalse( inverseJoinColumns[1].updatable() );
-		assertFalse( inverseJoinColumns[1].nullable() );
-		assertTrue( inverseJoinColumns[1].unique() );
-
-		//UniqueConstraints
-		UniqueConstraint[] uniqueConstraints = joinTableAnno
-				.uniqueConstraints();
-		assertEquals( 2, uniqueConstraints.length );
-		assertEquals( "", uniqueConstraints[0].name() );
-		assertEquals( 1, uniqueConstraints[0].columnNames().length );
-		assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
-		assertEquals( "uq1", uniqueConstraints[1].name() );
-		assertEquals( 2, uniqueConstraints[1].columnNames().length );
-		assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
-		assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
-
-		//Second, an association using join columns
-		assertEquals( "association2", overrides[1].name() );
-
-		//JoinColumns
-		joinColumns = overrides[1].joinColumns();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertTrue( joinColumns[0].nullable() );
-		assertFalse( joinColumns[0].unique() );
-		assertEquals( "col8", joinColumns[1].name() );
-		assertEquals( "col9", joinColumns[1].referencedColumnName() );
-		assertEquals( "table4", joinColumns[1].table() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertFalse( joinColumns[1].nullable() );
-		assertTrue( joinColumns[1].unique() );
-	}
-
-	@Test
-	public void testCollectionTableNoChildren() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm26.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationPresent( CollectionTable.class );
-		CollectionTable tableAnno = reader.getAnnotation( CollectionTable.class );
-		assertEquals( "", tableAnno.name() );
-		assertEquals( "", tableAnno.catalog() );
-		assertEquals( "", tableAnno.schema() );
-		assertEquals( 0, tableAnno.joinColumns().length );
-		assertEquals( 0, tableAnno.uniqueConstraints().length );
-	}
-
-	@Test
-	public void testCollectionTableAllChildren() throws Exception {
-		reader = getReader( Entity3.class, "field1", "element-collection.orm27.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationPresent( CollectionTable.class );
-		CollectionTable tableAnno = reader.getAnnotation( CollectionTable.class );
-		assertEquals( "table1", tableAnno.name() );
-		assertEquals( "catalog1", tableAnno.catalog() );
-		assertEquals( "schema1", tableAnno.schema() );
-
-		//JoinColumns
-		JoinColumn[] joinColumns = tableAnno.joinColumns();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertTrue( joinColumns[0].nullable() );
-		assertFalse( joinColumns[0].unique() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertEquals( "table2", joinColumns[1].table() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertFalse( joinColumns[1].nullable() );
-		assertTrue( joinColumns[1].unique() );
-
-		//UniqueConstraints
-		UniqueConstraint[] uniqueConstraints = tableAnno.uniqueConstraints();
-		assertEquals( 2, uniqueConstraints.length );
-		assertEquals( "", uniqueConstraints[0].name() );
-		assertEquals( 1, uniqueConstraints[0].columnNames().length );
-		assertEquals( "col3", uniqueConstraints[0].columnNames()[0] );
-		assertEquals( "uq1", uniqueConstraints[1].name() );
-		assertEquals( 2, uniqueConstraints[1].columnNames().length );
-		assertEquals( "col4", uniqueConstraints[1].columnNames()[0] );
-		assertEquals( "col5", uniqueConstraints[1].columnNames()[1] );
-	}
-
-	@Test
-	public void testAllAttributes() throws Exception {
-		reader = getReader( Entity2.class, "field1", "element-collection.orm28.xml" );
-		assertAnnotationPresent( ElementCollection.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationNotPresent( OrderColumn.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( Column.class );
-		assertAnnotationNotPresent( Temporal.class );
-		assertAnnotationNotPresent( Enumerated.class );
-		assertAnnotationNotPresent( Lob.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationNotPresent( AttributeOverrides.class );
-		assertAnnotationNotPresent( AssociationOverride.class );
-		assertAnnotationNotPresent( AssociationOverrides.class );
-		assertAnnotationNotPresent( CollectionTable.class );
-		assertAnnotationPresent( Access.class );
-		ElementCollection relAnno = reader.getAnnotation( ElementCollection.class );
-		assertEquals( FetchType.EAGER, relAnno.fetch() );
-		assertEquals( Entity3.class, relAnno.targetClass() );
-		assertEquals(
-				AccessType.PROPERTY, reader.getAnnotation( Access.class )
-				.value()
-		);
-	}
-
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlManyToManyTest.java

@@ -1,508 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.xml.ejb3;
-
-import javax.persistence.Access;
-import javax.persistence.AccessType;
-import javax.persistence.AttributeOverride;
-import javax.persistence.AttributeOverrides;
-import javax.persistence.CascadeType;
-import javax.persistence.EnumType;
-import javax.persistence.FetchType;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinColumns;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToMany;
-import javax.persistence.MapKey;
-import javax.persistence.MapKeyClass;
-import javax.persistence.MapKeyColumn;
-import javax.persistence.MapKeyEnumerated;
-import javax.persistence.MapKeyJoinColumn;
-import javax.persistence.MapKeyJoinColumns;
-import javax.persistence.MapKeyTemporal;
-import javax.persistence.OrderBy;
-import javax.persistence.OrderColumn;
-import javax.persistence.TemporalType;
-import javax.persistence.UniqueConstraint;
-
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlManyToManyTest}
- * for the legacy {@link JPAOverriddenAnnotationReader}.
- *
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@Deprecated
-public class LegacyEjb3XmlManyToManyTest extends LegacyEjb3XmlTestCase {
-	@Test
-	public void testNoChildren() throws Exception {
-		reader = getReader( Entity2.class, "field1", "many-to-many.orm1.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationNotPresent( OrderColumn.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		assertAnnotationNotPresent( Access.class );
-		ManyToMany relAnno = reader.getAnnotation( ManyToMany.class );
-		assertEquals( 0, relAnno.cascade().length );
-		assertEquals( FetchType.LAZY, relAnno.fetch() );
-		assertEquals( "", relAnno.mappedBy() );
-		assertEquals( void.class, relAnno.targetEntity() );
-	}
-
-	@Test
-	public void testOrderBy() throws Exception {
-		reader = getReader( Entity2.class, "field1", "many-to-many.orm2.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationPresent( OrderBy.class );
-		assertAnnotationNotPresent( OrderColumn.class );
-		assertEquals(
-				"col1 ASC, col2 DESC", reader.getAnnotation( OrderBy.class )
-				.value()
-		);
-	}
-
-	@Test
-	public void testOrderColumnNoAttributes() throws Exception {
-		reader = getReader( Entity2.class, "field1", "many-to-many.orm3.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationPresent( OrderColumn.class );
-		OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
-		assertEquals( "", orderColumnAnno.columnDefinition() );
-		assertEquals( "", orderColumnAnno.name() );
-		assertTrue( orderColumnAnno.insertable() );
-		assertTrue( orderColumnAnno.nullable() );
-		assertTrue( orderColumnAnno.updatable() );
-	}
-
-	@Test
-	public void testOrderColumnAllAttributes() throws Exception {
-		reader = getReader( Entity2.class, "field1", "many-to-many.orm4.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationPresent( OrderColumn.class );
-		OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
-		assertEquals( "int", orderColumnAnno.columnDefinition() );
-		assertEquals( "col1", orderColumnAnno.name() );
-		assertFalse( orderColumnAnno.insertable() );
-		assertFalse( orderColumnAnno.nullable() );
-		assertFalse( orderColumnAnno.updatable() );
-	}
-
-	@Test
-	public void testMapKeyNoAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm5.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals( "", reader.getAnnotation( MapKey.class ).name() );
-	}
-
-	@Test
-	public void testMapKeyAllAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm6.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals( "field2", reader.getAnnotation( MapKey.class ).name() );
-	}
-
-	@Test
-	public void testMapKeyClass() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm7.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals(
-				Entity2.class, reader.getAnnotation( MapKeyClass.class )
-				.value()
-		);
-	}
-
-	@Test
-	public void testMapKeyTemporal() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm8.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals(
-				TemporalType.DATE, reader.getAnnotation(
-				MapKeyTemporal.class
-		).value()
-		);
-	}
-
-	@Test
-	public void testMapKeyEnumerated() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm9.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals(
-				EnumType.STRING, reader.getAnnotation(
-				MapKeyEnumerated.class
-		).value()
-		);
-	}
-
-	/**
-	 * When there's a single map key attribute override, we still wrap it with
-	 * an AttributeOverrides annotation.
-	 */
-	@Test
-	public void testSingleMapKeyAttributeOverride() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm10.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationPresent( AttributeOverrides.class );
-		AttributeOverrides overridesAnno = reader
-				.getAnnotation( AttributeOverrides.class );
-		AttributeOverride[] overrides = overridesAnno.value();
-		assertEquals( 1, overrides.length );
-		assertEquals( "field1", overrides[0].name() );
-		assertEquals( "col1", overrides[0].column().name() );
-	}
-
-	@Test
-	public void testMultipleMapKeyAttributeOverrides() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm11.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationPresent( AttributeOverrides.class );
-		AttributeOverrides overridesAnno = reader
-				.getAnnotation( AttributeOverrides.class );
-		AttributeOverride[] overrides = overridesAnno.value();
-		assertEquals( 2, overrides.length );
-		assertEquals( "field1", overrides[0].name() );
-		assertEquals( "", overrides[0].column().name() );
-		assertFalse( overrides[0].column().unique() );
-		assertTrue( overrides[0].column().nullable() );
-		assertTrue( overrides[0].column().insertable() );
-		assertTrue( overrides[0].column().updatable() );
-		assertEquals( "", overrides[0].column().columnDefinition() );
-		assertEquals( "", overrides[0].column().table() );
-		assertEquals( 255, overrides[0].column().length() );
-		assertEquals( 0, overrides[0].column().precision() );
-		assertEquals( 0, overrides[0].column().scale() );
-		assertEquals( "field2", overrides[1].name() );
-		assertEquals( "col1", overrides[1].column().name() );
-		assertTrue( overrides[1].column().unique() );
-		assertFalse( overrides[1].column().nullable() );
-		assertFalse( overrides[1].column().insertable() );
-		assertFalse( overrides[1].column().updatable() );
-		assertEquals( "int", overrides[1].column().columnDefinition() );
-		assertEquals( "table1", overrides[1].column().table() );
-		assertEquals( 50, overrides[1].column().length() );
-		assertEquals( 2, overrides[1].column().precision() );
-		assertEquals( 1, overrides[1].column().scale() );
-	}
-
-	@Test
-	public void testMapKeyColumnNoAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm12.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
-		assertEquals( "", keyColAnno.columnDefinition() );
-		assertEquals( "", keyColAnno.name() );
-		assertEquals( "", keyColAnno.table() );
-		assertFalse( keyColAnno.nullable() );
-		assertTrue( keyColAnno.insertable() );
-		assertFalse( keyColAnno.unique() );
-		assertTrue( keyColAnno.updatable() );
-		assertEquals( 255, keyColAnno.length() );
-		assertEquals( 0, keyColAnno.precision() );
-		assertEquals( 0, keyColAnno.scale() );
-	}
-
-	@Test
-	public void testMapKeyColumnAllAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm13.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
-		assertEquals( "int", keyColAnno.columnDefinition() );
-		assertEquals( "col1", keyColAnno.name() );
-		assertEquals( "table1", keyColAnno.table() );
-		assertTrue( keyColAnno.nullable() );
-		assertFalse( keyColAnno.insertable() );
-		assertTrue( keyColAnno.unique() );
-		assertFalse( keyColAnno.updatable() );
-		assertEquals( 50, keyColAnno.length() );
-		assertEquals( 2, keyColAnno.precision() );
-		assertEquals( 1, keyColAnno.scale() );
-	}
-
-	/**
-	 * When there's a single map key join column, we still wrap it with a
-	 * MapKeyJoinColumns annotation.
-	 */
-	@Test
-	public void testSingleMapKeyJoinColumn() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm14.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyJoinColumns joinColumnsAnno = reader
-				.getAnnotation( MapKeyJoinColumns.class );
-		MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 1, joinColumns.length );
-		assertEquals( "col1", joinColumns[0].name() );
-	}
-
-	@Test
-	public void testMultipleMapKeyJoinColumns() throws Exception {
-		reader = getReader( Entity3.class, "field1", "many-to-many.orm15.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyJoinColumns joinColumnsAnno = reader
-				.getAnnotation( MapKeyJoinColumns.class );
-		MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertFalse( joinColumns[0].unique() );
-		assertFalse( joinColumns[0].nullable() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertTrue( joinColumns[1].unique() );
-		assertTrue( joinColumns[1].nullable() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertEquals( "table1", joinColumns[1].table() );
-	}
-
-	@Test
-	public void testJoinTableNoChildren() throws Exception {
-		reader = getReader( Entity2.class, "field1", "many-to-many.orm16.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationPresent( JoinTable.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
-		assertEquals( "", joinTableAnno.catalog() );
-		assertEquals( "", joinTableAnno.name() );
-		assertEquals( "", joinTableAnno.schema() );
-		assertEquals( 0, joinTableAnno.joinColumns().length );
-		assertEquals( 0, joinTableAnno.inverseJoinColumns().length );
-		assertEquals( 0, joinTableAnno.uniqueConstraints().length );
-	}
-
-	@Test
-	public void testJoinTableAllChildren() throws Exception {
-		reader = getReader( Entity2.class, "field1", "many-to-many.orm17.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationPresent( JoinTable.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
-		assertEquals( "cat1", joinTableAnno.catalog() );
-		assertEquals( "table1", joinTableAnno.name() );
-		assertEquals( "schema1", joinTableAnno.schema() );
-
-		// JoinColumns
-		JoinColumn[] joinColumns = joinTableAnno.joinColumns();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertTrue( joinColumns[0].nullable() );
-		assertFalse( joinColumns[0].unique() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertEquals( "table2", joinColumns[1].table() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertFalse( joinColumns[1].nullable() );
-		assertTrue( joinColumns[1].unique() );
-
-		// InverseJoinColumns
-		JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
-		assertEquals( 2, inverseJoinColumns.length );
-		assertEquals( "", inverseJoinColumns[0].name() );
-		assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
-		assertEquals( "", inverseJoinColumns[0].table() );
-		assertEquals( "", inverseJoinColumns[0].columnDefinition() );
-		assertTrue( inverseJoinColumns[0].insertable() );
-		assertTrue( inverseJoinColumns[0].updatable() );
-		assertTrue( inverseJoinColumns[0].nullable() );
-		assertFalse( inverseJoinColumns[0].unique() );
-		assertEquals( "col3", inverseJoinColumns[1].name() );
-		assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
-		assertEquals( "table3", inverseJoinColumns[1].table() );
-		assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
-		assertFalse( inverseJoinColumns[1].insertable() );
-		assertFalse( inverseJoinColumns[1].updatable() );
-		assertFalse( inverseJoinColumns[1].nullable() );
-		assertTrue( inverseJoinColumns[1].unique() );
-
-		// UniqueConstraints
-		UniqueConstraint[] uniqueConstraints = joinTableAnno
-				.uniqueConstraints();
-		assertEquals( 2, uniqueConstraints.length );
-		assertEquals( "", uniqueConstraints[0].name() );
-		assertEquals( 1, uniqueConstraints[0].columnNames().length );
-		assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
-		assertEquals( "uq1", uniqueConstraints[1].name() );
-		assertEquals( 2, uniqueConstraints[1].columnNames().length );
-		assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
-		assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
-	}
-
-	@Test
-	public void testCascadeAll() throws Exception {
-		reader = getReader( Entity2.class, "field1", "many-to-many.orm18.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		ManyToMany relAnno = reader.getAnnotation( ManyToMany.class );
-		assertEquals( 1, relAnno.cascade().length );
-		assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
-	}
-
-	@Test
-	public void testCascadeSomeWithDefaultPersist() throws Exception {
-		reader = getReader( Entity2.class, "field1", "many-to-many.orm19.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		ManyToMany relAnno = reader.getAnnotation( ManyToMany.class );
-		assertEquals( 4, relAnno.cascade().length );
-		assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] );
-		assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] );
-		assertEquals( CascadeType.DETACH, relAnno.cascade()[2] );
-		assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] );
-	}
-
-	/**
-	 * Make sure that it doesn't break the handler when {@link CascadeType#ALL}
-	 * is specified in addition to a default cascade-persist or individual
-	 * cascade settings.
-	 */
-	@Test
-	public void testCascadeAllPlusMore() throws Exception {
-		reader = getReader( Entity2.class, "field1", "many-to-many.orm20.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		ManyToMany relAnno = reader.getAnnotation( ManyToMany.class );
-		assertEquals( 6, relAnno.cascade().length );
-		assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
-		assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] );
-		assertEquals( CascadeType.MERGE, relAnno.cascade()[2] );
-		assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] );
-		assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] );
-		assertEquals( CascadeType.DETACH, relAnno.cascade()[5] );
-	}
-
-	@Test
-	public void testAllAttributes() throws Exception {
-		reader = getReader( Entity2.class, "field1", "many-to-many.orm21.xml" );
-		assertAnnotationPresent( ManyToMany.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationNotPresent( OrderColumn.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		assertAnnotationPresent( Access.class );
-		ManyToMany relAnno = reader.getAnnotation( ManyToMany.class );
-		assertEquals( 0, relAnno.cascade().length );
-		assertEquals( FetchType.EAGER, relAnno.fetch() );
-		assertEquals( "field2", relAnno.mappedBy() );
-		assertEquals( Entity3.class, relAnno.targetEntity() );
-		assertEquals(
-				AccessType.PROPERTY, reader.getAnnotation( Access.class )
-				.value()
-		);
-	}
-
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlManyToOneTest.java

@@ -1,245 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.xml.ejb3;
-
-import javax.persistence.Access;
-import javax.persistence.AccessType;
-import javax.persistence.CascadeType;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinColumns;
-import javax.persistence.JoinTable;
-import javax.persistence.ManyToOne;
-import javax.persistence.MapsId;
-import javax.persistence.UniqueConstraint;
-
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlManyToOneTest}
- * for the legacy {@link JPAOverriddenAnnotationReader}.
- *
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@Deprecated
-public class LegacyEjb3XmlManyToOneTest extends LegacyEjb3XmlTestCase {
-	@Test
-	public void testNoJoins() throws Exception {
-		reader = getReader( Entity1.class, "field1", "many-to-one.orm1.xml" );
-		assertAnnotationPresent( ManyToOne.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		assertAnnotationNotPresent( Id.class );
-		assertAnnotationNotPresent( MapsId.class );
-		assertAnnotationNotPresent( Access.class );
-		ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
-		assertEquals( 0, relAnno.cascade().length );
-		assertEquals( FetchType.EAGER, relAnno.fetch() );
-		assertTrue( relAnno.optional() );
-		assertEquals( void.class, relAnno.targetEntity() );
-	}
-
-	/**
-	 * When there's a single join column, we still wrap it with a JoinColumns
-	 * annotation.
-	 */
-	@Test
-	public void testSingleJoinColumn() throws Exception {
-		reader = getReader( Entity1.class, "field1", "many-to-one.orm2.xml" );
-		assertAnnotationPresent( ManyToOne.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
-		JoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 1, joinColumns.length );
-		assertEquals( "col1", joinColumns[0].name() );
-		assertEquals( "col2", joinColumns[0].referencedColumnName() );
-		assertEquals( "table1", joinColumns[0].table() );
-	}
-
-	@Test
-	public void testMultipleJoinColumns() throws Exception {
-		reader = getReader( Entity1.class, "field1", "many-to-one.orm3.xml" );
-		assertAnnotationPresent( ManyToOne.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
-		JoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertTrue( joinColumns[0].nullable() );
-		assertFalse( joinColumns[0].unique() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertEquals( "table1", joinColumns[1].table() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertFalse( joinColumns[1].nullable() );
-		assertTrue( joinColumns[1].unique() );
-	}
-
-	@Test
-	public void testJoinTableNoChildren() throws Exception {
-		reader = getReader( Entity1.class, "field1", "many-to-one.orm4.xml" );
-		assertAnnotationPresent( ManyToOne.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationPresent( JoinTable.class );
-		JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
-		assertEquals( "", joinTableAnno.catalog() );
-		assertEquals( "", joinTableAnno.name() );
-		assertEquals( "", joinTableAnno.schema() );
-		assertEquals( 0, joinTableAnno.joinColumns().length );
-		assertEquals( 0, joinTableAnno.inverseJoinColumns().length );
-		assertEquals( 0, joinTableAnno.uniqueConstraints().length );
-	}
-
-	@Test
-	public void testJoinTableAllChildren() throws Exception {
-		reader = getReader( Entity1.class, "field1", "many-to-one.orm5.xml" );
-		assertAnnotationPresent( ManyToOne.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationPresent( JoinTable.class );
-		JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
-		assertEquals( "cat1", joinTableAnno.catalog() );
-		assertEquals( "table1", joinTableAnno.name() );
-		assertEquals( "schema1", joinTableAnno.schema() );
-
-		// JoinColumns
-		JoinColumn[] joinColumns = joinTableAnno.joinColumns();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertTrue( joinColumns[0].nullable() );
-		assertFalse( joinColumns[0].unique() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertEquals( "table2", joinColumns[1].table() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertFalse( joinColumns[1].nullable() );
-		assertTrue( joinColumns[1].unique() );
-
-		// InverseJoinColumns
-		JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
-		assertEquals( 2, inverseJoinColumns.length );
-		assertEquals( "", inverseJoinColumns[0].name() );
-		assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
-		assertEquals( "", inverseJoinColumns[0].table() );
-		assertEquals( "", inverseJoinColumns[0].columnDefinition() );
-		assertTrue( inverseJoinColumns[0].insertable() );
-		assertTrue( inverseJoinColumns[0].updatable() );
-		assertTrue( inverseJoinColumns[0].nullable() );
-		assertFalse( inverseJoinColumns[0].unique() );
-		assertEquals( "col3", inverseJoinColumns[1].name() );
-		assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
-		assertEquals( "table3", inverseJoinColumns[1].table() );
-		assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
-		assertFalse( inverseJoinColumns[1].insertable() );
-		assertFalse( inverseJoinColumns[1].updatable() );
-		assertFalse( inverseJoinColumns[1].nullable() );
-		assertTrue( inverseJoinColumns[1].unique() );
-
-		// UniqueConstraints
-		UniqueConstraint[] uniqueConstraints = joinTableAnno
-				.uniqueConstraints();
-		assertEquals( 2, uniqueConstraints.length );
-		assertEquals( "", uniqueConstraints[0].name() );
-		assertEquals( 1, uniqueConstraints[0].columnNames().length );
-		assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
-		assertEquals( "uq1", uniqueConstraints[1].name() );
-		assertEquals( 2, uniqueConstraints[1].columnNames().length );
-		assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
-		assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
-	}
-
-	@Test
-	public void testAllAttributes() throws Exception {
-		reader = getReader( Entity1.class, "field1", "many-to-one.orm6.xml" );
-		assertAnnotationPresent( ManyToOne.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		assertAnnotationPresent( Id.class );
-		assertAnnotationPresent( MapsId.class );
-		assertAnnotationPresent( Access.class );
-		ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
-		assertEquals( 0, relAnno.cascade().length );
-		assertEquals( FetchType.LAZY, relAnno.fetch() );
-		assertFalse( relAnno.optional() );
-		assertEquals( Entity3.class, relAnno.targetEntity() );
-		assertEquals( "col1", reader.getAnnotation( MapsId.class ).value() );
-		assertEquals(
-				AccessType.PROPERTY, reader.getAnnotation( Access.class )
-				.value()
-		);
-	}
-
-	@Test
-	public void testCascadeAll() throws Exception {
-		reader = getReader( Entity1.class, "field1", "many-to-one.orm7.xml" );
-		assertAnnotationPresent( ManyToOne.class );
-		ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
-		assertEquals( 1, relAnno.cascade().length );
-		assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
-	}
-
-	@Test
-	public void testCascadeSomeWithDefaultPersist() throws Exception {
-		reader = getReader( Entity1.class, "field1", "many-to-one.orm8.xml" );
-		assertAnnotationPresent( ManyToOne.class );
-		ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
-		assertEquals( 4, relAnno.cascade().length );
-		assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] );
-		assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] );
-		assertEquals( CascadeType.DETACH, relAnno.cascade()[2] );
-		assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] );
-	}
-
-	/**
-	 * Make sure that it doesn't break the handler when {@link CascadeType#ALL}
-	 * is specified in addition to a default cascade-persist or individual
-	 * cascade settings.
-	 */
-	@Test
-	public void testCascadeAllPlusMore() throws Exception {
-		reader = getReader( Entity1.class, "field1", "many-to-one.orm9.xml" );
-		assertAnnotationPresent( ManyToOne.class );
-		ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
-		assertEquals( 6, relAnno.cascade().length );
-		assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
-		assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] );
-		assertEquals( CascadeType.MERGE, relAnno.cascade()[2] );
-		assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] );
-		assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] );
-		assertEquals( CascadeType.DETACH, relAnno.cascade()[5] );
-	}
-
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlOneToManyTest.java

@@ -1,561 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.xml.ejb3;
-
-import javax.persistence.Access;
-import javax.persistence.AccessType;
-import javax.persistence.AttributeOverride;
-import javax.persistence.AttributeOverrides;
-import javax.persistence.CascadeType;
-import javax.persistence.EnumType;
-import javax.persistence.FetchType;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinColumns;
-import javax.persistence.JoinTable;
-import javax.persistence.MapKey;
-import javax.persistence.MapKeyClass;
-import javax.persistence.MapKeyColumn;
-import javax.persistence.MapKeyEnumerated;
-import javax.persistence.MapKeyJoinColumn;
-import javax.persistence.MapKeyJoinColumns;
-import javax.persistence.MapKeyTemporal;
-import javax.persistence.OneToMany;
-import javax.persistence.OrderBy;
-import javax.persistence.OrderColumn;
-import javax.persistence.TemporalType;
-import javax.persistence.UniqueConstraint;
-
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlOneToManyTest}
- * for the legacy {@link JPAOverriddenAnnotationReader}.
- *
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@Deprecated
-public class LegacyEjb3XmlOneToManyTest extends LegacyEjb3XmlTestCase {
-	@Test
-	public void testNoChildren() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm1.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationNotPresent( OrderColumn.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationNotPresent( Access.class );
-		OneToMany relAnno = reader.getAnnotation( OneToMany.class );
-		assertEquals( 0, relAnno.cascade().length );
-		assertEquals( FetchType.LAZY, relAnno.fetch() );
-		assertEquals( "", relAnno.mappedBy() );
-		assertFalse( relAnno.orphanRemoval() );
-		assertEquals( void.class, relAnno.targetEntity() );
-	}
-
-	@Test
-	public void testOrderBy() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm2.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationPresent( OrderBy.class );
-		assertAnnotationNotPresent( OrderColumn.class );
-		assertEquals(
-				"col1 ASC, col2 DESC", reader.getAnnotation( OrderBy.class )
-				.value()
-		);
-	}
-
-	@Test
-	public void testOrderColumnNoAttributes() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm3.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationPresent( OrderColumn.class );
-		OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
-		assertEquals( "", orderColumnAnno.columnDefinition() );
-		assertEquals( "", orderColumnAnno.name() );
-		assertTrue( orderColumnAnno.insertable() );
-		assertTrue( orderColumnAnno.nullable() );
-		assertTrue( orderColumnAnno.updatable() );
-	}
-
-	@Test
-	public void testOrderColumnAllAttributes() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm4.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationPresent( OrderColumn.class );
-		OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
-		assertEquals( "int", orderColumnAnno.columnDefinition() );
-		assertEquals( "col1", orderColumnAnno.name() );
-		assertFalse( orderColumnAnno.insertable() );
-		assertFalse( orderColumnAnno.nullable() );
-		assertFalse( orderColumnAnno.updatable() );
-	}
-
-	@Test
-	public void testMapKeyNoAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm5.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals( "", reader.getAnnotation( MapKey.class ).name() );
-	}
-
-	@Test
-	public void testMapKeyAllAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm6.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals( "field2", reader.getAnnotation( MapKey.class ).name() );
-	}
-
-	@Test
-	public void testMapKeyClass() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm7.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals(
-				Entity2.class, reader.getAnnotation( MapKeyClass.class )
-				.value()
-		);
-	}
-
-	@Test
-	public void testMapKeyTemporal() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm8.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals(
-				TemporalType.DATE, reader.getAnnotation(
-				MapKeyTemporal.class
-		).value()
-		);
-	}
-
-	@Test
-	public void testMapKeyEnumerated() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm9.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertEquals(
-				EnumType.STRING, reader.getAnnotation(
-				MapKeyEnumerated.class
-		).value()
-		);
-	}
-
-	/**
-	 * When there's a single map key attribute override, we still wrap it with
-	 * an AttributeOverrides annotation.
-	 */
-	@Test
-	public void testSingleMapKeyAttributeOverride() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm10.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationPresent( AttributeOverrides.class );
-		AttributeOverrides overridesAnno = reader
-				.getAnnotation( AttributeOverrides.class );
-		AttributeOverride[] overrides = overridesAnno.value();
-		assertEquals( 1, overrides.length );
-		assertEquals( "field1", overrides[0].name() );
-		assertEquals( "col1", overrides[0].column().name() );
-	}
-
-	@Test
-	public void testMultipleMapKeyAttributeOverrides() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm11.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( AttributeOverride.class );
-		assertAnnotationPresent( AttributeOverrides.class );
-		AttributeOverrides overridesAnno = reader
-				.getAnnotation( AttributeOverrides.class );
-		AttributeOverride[] overrides = overridesAnno.value();
-		assertEquals( 2, overrides.length );
-		assertEquals( "field1", overrides[0].name() );
-		assertEquals( "", overrides[0].column().name() );
-		assertFalse( overrides[0].column().unique() );
-		assertTrue( overrides[0].column().nullable() );
-		assertTrue( overrides[0].column().insertable() );
-		assertTrue( overrides[0].column().updatable() );
-		assertEquals( "", overrides[0].column().columnDefinition() );
-		assertEquals( "", overrides[0].column().table() );
-		assertEquals( 255, overrides[0].column().length() );
-		assertEquals( 0, overrides[0].column().precision() );
-		assertEquals( 0, overrides[0].column().scale() );
-		assertEquals( "field2", overrides[1].name() );
-		assertEquals( "col1", overrides[1].column().name() );
-		assertTrue( overrides[1].column().unique() );
-		assertFalse( overrides[1].column().nullable() );
-		assertFalse( overrides[1].column().insertable() );
-		assertFalse( overrides[1].column().updatable() );
-		assertEquals( "int", overrides[1].column().columnDefinition() );
-		assertEquals( "table1", overrides[1].column().table() );
-		assertEquals( 50, overrides[1].column().length() );
-		assertEquals( 2, overrides[1].column().precision() );
-		assertEquals( 1, overrides[1].column().scale() );
-	}
-
-	@Test
-	public void testMapKeyColumnNoAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm12.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
-		assertEquals( "", keyColAnno.columnDefinition() );
-		assertEquals( "", keyColAnno.name() );
-		assertEquals( "", keyColAnno.table() );
-		assertFalse( keyColAnno.nullable() );
-		assertTrue( keyColAnno.insertable() );
-		assertFalse( keyColAnno.unique() );
-		assertTrue( keyColAnno.updatable() );
-		assertEquals( 255, keyColAnno.length() );
-		assertEquals( 0, keyColAnno.precision() );
-		assertEquals( 0, keyColAnno.scale() );
-	}
-
-	@Test
-	public void testMapKeyColumnAllAttributes() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm13.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
-		assertEquals( "int", keyColAnno.columnDefinition() );
-		assertEquals( "col1", keyColAnno.name() );
-		assertEquals( "table1", keyColAnno.table() );
-		assertTrue( keyColAnno.nullable() );
-		assertFalse( keyColAnno.insertable() );
-		assertTrue( keyColAnno.unique() );
-		assertFalse( keyColAnno.updatable() );
-		assertEquals( 50, keyColAnno.length() );
-		assertEquals( 2, keyColAnno.precision() );
-		assertEquals( 1, keyColAnno.scale() );
-	}
-
-	/**
-	 * When there's a single map key join column, we still wrap it with a
-	 * MapKeyJoinColumns annotation.
-	 */
-	@Test
-	public void testSingleMapKeyJoinColumn() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm14.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyJoinColumns joinColumnsAnno = reader
-				.getAnnotation( MapKeyJoinColumns.class );
-		MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 1, joinColumns.length );
-		assertEquals( "col1", joinColumns[0].name() );
-	}
-
-	@Test
-	public void testMultipleMapKeyJoinColumns() throws Exception {
-		reader = getReader( Entity3.class, "field1", "one-to-many.orm15.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		MapKeyJoinColumns joinColumnsAnno = reader
-				.getAnnotation( MapKeyJoinColumns.class );
-		MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertFalse( joinColumns[0].unique() );
-		assertFalse( joinColumns[0].nullable() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertTrue( joinColumns[1].unique() );
-		assertTrue( joinColumns[1].nullable() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertEquals( "table1", joinColumns[1].table() );
-	}
-
-	@Test
-	public void testJoinTableNoChildren() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm16.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationPresent( JoinTable.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
-		assertEquals( "", joinTableAnno.catalog() );
-		assertEquals( "", joinTableAnno.name() );
-		assertEquals( "", joinTableAnno.schema() );
-		assertEquals( 0, joinTableAnno.joinColumns().length );
-		assertEquals( 0, joinTableAnno.inverseJoinColumns().length );
-		assertEquals( 0, joinTableAnno.uniqueConstraints().length );
-	}
-
-	@Test
-	public void testJoinTableAllChildren() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm17.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationPresent( JoinTable.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
-		assertEquals( "cat1", joinTableAnno.catalog() );
-		assertEquals( "table1", joinTableAnno.name() );
-		assertEquals( "schema1", joinTableAnno.schema() );
-
-		// JoinColumns
-		JoinColumn[] joinColumns = joinTableAnno.joinColumns();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertTrue( joinColumns[0].nullable() );
-		assertFalse( joinColumns[0].unique() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertEquals( "table2", joinColumns[1].table() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertFalse( joinColumns[1].nullable() );
-		assertTrue( joinColumns[1].unique() );
-
-		// InverseJoinColumns
-		JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
-		assertEquals( 2, inverseJoinColumns.length );
-		assertEquals( "", inverseJoinColumns[0].name() );
-		assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
-		assertEquals( "", inverseJoinColumns[0].table() );
-		assertEquals( "", inverseJoinColumns[0].columnDefinition() );
-		assertTrue( inverseJoinColumns[0].insertable() );
-		assertTrue( inverseJoinColumns[0].updatable() );
-		assertTrue( inverseJoinColumns[0].nullable() );
-		assertFalse( inverseJoinColumns[0].unique() );
-		assertEquals( "col3", inverseJoinColumns[1].name() );
-		assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
-		assertEquals( "table3", inverseJoinColumns[1].table() );
-		assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
-		assertFalse( inverseJoinColumns[1].insertable() );
-		assertFalse( inverseJoinColumns[1].updatable() );
-		assertFalse( inverseJoinColumns[1].nullable() );
-		assertTrue( inverseJoinColumns[1].unique() );
-
-		// UniqueConstraints
-		UniqueConstraint[] uniqueConstraints = joinTableAnno
-				.uniqueConstraints();
-		assertEquals( 2, uniqueConstraints.length );
-		assertEquals( "", uniqueConstraints[0].name() );
-		assertEquals( 1, uniqueConstraints[0].columnNames().length );
-		assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
-		assertEquals( "uq1", uniqueConstraints[1].name() );
-		assertEquals( 2, uniqueConstraints[1].columnNames().length );
-		assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
-		assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
-	}
-
-	/**
-	 * When there's a single join column, we still wrap it with a JoinColumns
-	 * annotation.
-	 */
-	@Test
-	public void testSingleJoinColumn() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm18.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
-		JoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 1, joinColumns.length );
-		assertEquals( "col1", joinColumns[0].name() );
-		assertEquals( "col2", joinColumns[0].referencedColumnName() );
-		assertEquals( "table1", joinColumns[0].table() );
-	}
-
-	@Test
-	public void testMultipleJoinColumns() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm19.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
-		JoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertTrue( joinColumns[0].nullable() );
-		assertFalse( joinColumns[0].unique() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertEquals( "table1", joinColumns[1].table() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertFalse( joinColumns[1].nullable() );
-		assertTrue( joinColumns[1].unique() );
-	}
-
-	@Test
-	public void testCascadeAll() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm20.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		OneToMany relAnno = reader.getAnnotation( OneToMany.class );
-		assertEquals( 1, relAnno.cascade().length );
-		assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
-	}
-
-	@Test
-	public void testCascadeSomeWithDefaultPersist() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm21.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		OneToMany relAnno = reader.getAnnotation( OneToMany.class );
-		assertEquals( 4, relAnno.cascade().length );
-		assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] );
-		assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] );
-		assertEquals( CascadeType.DETACH, relAnno.cascade()[2] );
-		assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] );
-	}
-
-	/**
-	 * Make sure that it doesn't break the handler when {@link CascadeType#ALL}
-	 * is specified in addition to a default cascade-persist or individual
-	 * cascade settings.
-	 */
-	@Test
-	public void testCascadeAllPlusMore() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm22.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		OneToMany relAnno = reader.getAnnotation( OneToMany.class );
-		assertEquals( 6, relAnno.cascade().length );
-		assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
-		assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] );
-		assertEquals( CascadeType.MERGE, relAnno.cascade()[2] );
-		assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] );
-		assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] );
-		assertEquals( CascadeType.DETACH, relAnno.cascade()[5] );
-	}
-
-	@Test
-	public void testAllAttributes() throws Exception {
-		reader = getReader( Entity2.class, "field1", "one-to-many.orm23.xml" );
-		assertAnnotationPresent( OneToMany.class );
-		assertAnnotationNotPresent( OrderBy.class );
-		assertAnnotationNotPresent( OrderColumn.class );
-		assertAnnotationNotPresent( MapKey.class );
-		assertAnnotationNotPresent( MapKeyClass.class );
-		assertAnnotationNotPresent( MapKeyTemporal.class );
-		assertAnnotationNotPresent( MapKeyEnumerated.class );
-		assertAnnotationNotPresent( MapKeyColumn.class );
-		assertAnnotationNotPresent( MapKeyJoinColumns.class );
-		assertAnnotationNotPresent( MapKeyJoinColumn.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationPresent( Access.class );
-		OneToMany relAnno = reader.getAnnotation( OneToMany.class );
-		assertEquals( 0, relAnno.cascade().length );
-		assertEquals( FetchType.EAGER, relAnno.fetch() );
-		assertEquals( "field2", relAnno.mappedBy() );
-		assertTrue( relAnno.orphanRemoval() );
-		assertEquals( Entity3.class, relAnno.targetEntity() );
-		assertEquals(
-				AccessType.PROPERTY, reader.getAnnotation( Access.class )
-				.value()
-		);
-	}
-
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlOneToOneTest.java

@@ -1,309 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.xml.ejb3;
-
-import javax.persistence.Access;
-import javax.persistence.AccessType;
-import javax.persistence.CascadeType;
-import javax.persistence.FetchType;
-import javax.persistence.Id;
-import javax.persistence.JoinColumn;
-import javax.persistence.JoinColumns;
-import javax.persistence.JoinTable;
-import javax.persistence.MapsId;
-import javax.persistence.OneToOne;
-import javax.persistence.PrimaryKeyJoinColumn;
-import javax.persistence.PrimaryKeyJoinColumns;
-import javax.persistence.UniqueConstraint;
-
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlOneToOneTest}
- * for the legacy {@link JPAOverriddenAnnotationReader}.
- *
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@Deprecated
-public class LegacyEjb3XmlOneToOneTest extends LegacyEjb3XmlTestCase {
-	@Test
-	public void testNoChildren() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm1.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		assertAnnotationNotPresent( MapsId.class );
-		assertAnnotationNotPresent( Id.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		assertAnnotationNotPresent( Access.class );
-		OneToOne relAnno = reader.getAnnotation( OneToOne.class );
-		assertEquals( 0, relAnno.cascade().length );
-		assertEquals( FetchType.EAGER, relAnno.fetch() );
-		assertEquals( "", relAnno.mappedBy() );
-		assertTrue( relAnno.optional() );
-		assertFalse( relAnno.orphanRemoval() );
-		assertEquals( void.class, relAnno.targetEntity() );
-	}
-
-	/**
-	 * When there's a single primary key join column, we still wrap it with
-	 * a PrimaryKeyJoinColumns annotation.
-	 */
-	@Test
-	public void testSinglePrimaryKeyJoinColumn() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm2.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
-		assertAnnotationPresent( PrimaryKeyJoinColumns.class );
-		PrimaryKeyJoinColumns joinColumnsAnno =
-				reader.getAnnotation( PrimaryKeyJoinColumns.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		PrimaryKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 1, joinColumns.length );
-		assertEquals( "col1", joinColumns[0].name() );
-		assertEquals( "col2", joinColumns[0].referencedColumnName() );
-		assertEquals( "int", joinColumns[0].columnDefinition() );
-	}
-
-	@Test
-	public void testMultiplePrimaryKeyJoinColumn() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm3.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
-		assertAnnotationPresent( PrimaryKeyJoinColumns.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		PrimaryKeyJoinColumns joinColumnsAnno =
-				reader.getAnnotation( PrimaryKeyJoinColumns.class );
-		PrimaryKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-	}
-
-	/**
-	 * When there's a single join column, we still wrap it with a JoinColumns
-	 * annotation.
-	 */
-	@Test
-	public void testSingleJoinColumn() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm4.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
-		assertAnnotationPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
-		JoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 1, joinColumns.length );
-		assertEquals( "col1", joinColumns[0].name() );
-		assertEquals( "col2", joinColumns[0].referencedColumnName() );
-		assertEquals( "table1", joinColumns[0].table() );
-	}
-
-	@Test
-	public void testMultipleJoinColumns() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm5.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
-		JoinColumn[] joinColumns = joinColumnsAnno.value();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertTrue( joinColumns[0].nullable() );
-		assertFalse( joinColumns[0].unique() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertEquals( "table1", joinColumns[1].table() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertFalse( joinColumns[1].nullable() );
-		assertTrue( joinColumns[1].unique() );
-	}
-
-	@Test
-	public void testJoinTableNoChildren() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm6.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
-		assertAnnotationPresent( JoinTable.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
-		assertEquals( "", joinTableAnno.catalog() );
-		assertEquals( "", joinTableAnno.name() );
-		assertEquals( "", joinTableAnno.schema() );
-		assertEquals( 0, joinTableAnno.joinColumns().length );
-		assertEquals( 0, joinTableAnno.inverseJoinColumns().length );
-		assertEquals( 0, joinTableAnno.uniqueConstraints().length );
-	}
-
-	@Test
-	public void testJoinTableAllChildren() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm7.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
-		assertAnnotationPresent( JoinTable.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
-		assertEquals( "cat1", joinTableAnno.catalog() );
-		assertEquals( "table1", joinTableAnno.name() );
-		assertEquals( "schema1", joinTableAnno.schema() );
-
-		// JoinColumns
-		JoinColumn[] joinColumns = joinTableAnno.joinColumns();
-		assertEquals( 2, joinColumns.length );
-		assertEquals( "", joinColumns[0].name() );
-		assertEquals( "", joinColumns[0].referencedColumnName() );
-		assertEquals( "", joinColumns[0].table() );
-		assertEquals( "", joinColumns[0].columnDefinition() );
-		assertTrue( joinColumns[0].insertable() );
-		assertTrue( joinColumns[0].updatable() );
-		assertTrue( joinColumns[0].nullable() );
-		assertFalse( joinColumns[0].unique() );
-		assertEquals( "col1", joinColumns[1].name() );
-		assertEquals( "col2", joinColumns[1].referencedColumnName() );
-		assertEquals( "table2", joinColumns[1].table() );
-		assertEquals( "int", joinColumns[1].columnDefinition() );
-		assertFalse( joinColumns[1].insertable() );
-		assertFalse( joinColumns[1].updatable() );
-		assertFalse( joinColumns[1].nullable() );
-		assertTrue( joinColumns[1].unique() );
-
-		// InverseJoinColumns
-		JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
-		assertEquals( 2, inverseJoinColumns.length );
-		assertEquals( "", inverseJoinColumns[0].name() );
-		assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
-		assertEquals( "", inverseJoinColumns[0].table() );
-		assertEquals( "", inverseJoinColumns[0].columnDefinition() );
-		assertTrue( inverseJoinColumns[0].insertable() );
-		assertTrue( inverseJoinColumns[0].updatable() );
-		assertTrue( inverseJoinColumns[0].nullable() );
-		assertFalse( inverseJoinColumns[0].unique() );
-		assertEquals( "col3", inverseJoinColumns[1].name() );
-		assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
-		assertEquals( "table3", inverseJoinColumns[1].table() );
-		assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
-		assertFalse( inverseJoinColumns[1].insertable() );
-		assertFalse( inverseJoinColumns[1].updatable() );
-		assertFalse( inverseJoinColumns[1].nullable() );
-		assertTrue( inverseJoinColumns[1].unique() );
-
-		// UniqueConstraints
-		UniqueConstraint[] uniqueConstraints = joinTableAnno
-				.uniqueConstraints();
-		assertEquals( 2, uniqueConstraints.length );
-		assertEquals( "", uniqueConstraints[0].name() );
-		assertEquals( 1, uniqueConstraints[0].columnNames().length );
-		assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
-		assertEquals( "uq1", uniqueConstraints[1].name() );
-		assertEquals( 2, uniqueConstraints[1].columnNames().length );
-		assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
-		assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
-	}
-
-	@Test
-	public void testCascadeAll() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm8.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		OneToOne relAnno = reader.getAnnotation( OneToOne.class );
-		assertEquals( 1, relAnno.cascade().length );
-		assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
-	}
-
-	@Test
-	public void testCascadeSomeWithDefaultPersist() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm9.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		OneToOne relAnno = reader.getAnnotation( OneToOne.class );
-		assertEquals( 4, relAnno.cascade().length );
-		assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] );
-		assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] );
-		assertEquals( CascadeType.DETACH, relAnno.cascade()[2] );
-		assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] );
-	}
-
-	/**
-	 * Make sure that it doesn't break the handler when {@link CascadeType#ALL}
-	 * is specified in addition to a default cascade-persist or individual
-	 * cascade settings.
-	 */
-	@Test
-	public void testCascadeAllPlusMore() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm10.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		OneToOne relAnno = reader.getAnnotation( OneToOne.class );
-		assertEquals( 6, relAnno.cascade().length );
-		assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
-		assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] );
-		assertEquals( CascadeType.MERGE, relAnno.cascade()[2] );
-		assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] );
-		assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] );
-		assertEquals( CascadeType.DETACH, relAnno.cascade()[5] );
-	}
-
-	@Test
-	public void testAllAttributes() throws Exception {
-		reader = getReader( Entity1.class, "field1", "one-to-one.orm11.xml" );
-		assertAnnotationPresent( OneToOne.class );
-		assertAnnotationPresent( MapsId.class );
-		assertAnnotationPresent( Id.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumn.class );
-		assertAnnotationNotPresent( PrimaryKeyJoinColumns.class );
-		assertAnnotationNotPresent( JoinColumns.class );
-		assertAnnotationNotPresent( JoinColumn.class );
-		assertAnnotationNotPresent( JoinTable.class );
-		assertAnnotationPresent( Access.class );
-		OneToOne relAnno = reader.getAnnotation( OneToOne.class );
-		assertEquals( 0, relAnno.cascade().length );
-		assertEquals( FetchType.LAZY, relAnno.fetch() );
-		assertEquals( "field2", relAnno.mappedBy() );
-		assertFalse( relAnno.optional() );
-		assertTrue( relAnno.orphanRemoval() );
-		assertEquals( Entity3.class, relAnno.targetEntity() );
-		assertEquals(
-				AccessType.PROPERTY, reader.getAnnotation( Access.class )
-				.value()
-		);
-		assertEquals(
-				"field3", reader.getAnnotation( MapsId.class )
-				.value()
-		);
-	}
-
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlTest.java

@@ -1,148 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.xml.ejb3;
-
-import java.util.Date;
-import java.util.List;
-
-import org.hibernate.Session;
-import org.hibernate.SessionFactory;
-import org.hibernate.Transaction;
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-import org.hibernate.dialect.CockroachDialect;
-import org.hibernate.dialect.PostgreSQL81Dialect;
-import org.hibernate.dialect.PostgreSQLDialect;
-import org.hibernate.dialect.TeradataDialect;
-import org.hibernate.persister.collection.BasicCollectionPersister;
-
-import org.hibernate.testing.SkipForDialect;
-import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-
-/**
- * Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlTest}
- * for the legacy {@link JPAOverriddenAnnotationReader}.
- *
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@Deprecated
-public class LegacyEjb3XmlTest extends BaseCoreFunctionalTestCase {
-	@Test
-	@SkipForDialect(value = {PostgreSQL81Dialect.class, PostgreSQLDialect.class, CockroachDialect.class},
-			comment = "postgresql jdbc driver does not implement the setQueryTimeout method")
-	@SkipForDialect(value = TeradataDialect.class,
-			jiraKey = "HHH-8190",
-			comment = "uses Teradata reserved word - year")
-	public void testEjb3Xml() throws Exception {
-		Session s = openSession();
-		Transaction tx = s.beginTransaction();
-		CarModel model = new CarModel();
-		model.setYear( new Date() );
-		Manufacturer manufacturer = new Manufacturer();
-		//s.persist( manufacturer );
-		model.setManufacturer( manufacturer );
-		manufacturer.getModels().add( model );
-		s.persist( model );
-		s.flush();
-		s.clear();
-
-		model.setYear( new Date() );
-		manufacturer = (Manufacturer) s.get( Manufacturer.class, manufacturer.getId() );
-		@SuppressWarnings("unchecked")
-		List<Model> cars = s.getNamedQuery( "allModelsPerManufacturer" )
-				.setParameter( "manufacturer", manufacturer )
-				.list();
-		assertEquals( 1, cars.size() );
-		for ( Model car : cars ) {
-			assertNotNull( car.getManufacturer() );
-			s.delete( manufacturer );
-			s.delete( car );
-		}
-		tx.rollback();
-		s.close();
-	}
-
-	@Test
-	public void testXMLEntityHandled() throws Exception {
-		Session s = openSession();
-		s.getTransaction().begin();
-		Lighter l = new Lighter();
-		l.name = "Blue";
-		l.power = "400F";
-		s.persist( l );
-		s.flush();
-		s.getTransaction().rollback();
-		s.close();
-	}
-
-	@Test
-	public void testXmlDefaultOverriding() throws Exception {
-		Session s = openSession();
-		Transaction tx = s.beginTransaction();
-		Manufacturer manufacturer = new Manufacturer();
-		s.persist( manufacturer );
-		s.flush();
-		s.clear();
-
-		assertEquals( 1, s.getNamedQuery( "manufacturer.findAll" ).list().size() );
-		tx.rollback();
-		s.close();
-	}
-
-	@Test
-	@SuppressWarnings("unchecked")
-	public void testMapXMLSupport() throws Exception {
-		Session s = openSession();
-		SessionFactory sf = s.getSessionFactory();
-		Transaction tx = s.beginTransaction();
-
-		// Verify that we can persist an object with a couple Map mappings
-		VicePresident vpSales = new VicePresident();
-		vpSales.name = "Dwight";
-		Company company = new Company();
-		company.conferenceRoomExtensions.put( "8932", "x1234" );
-		company.organization.put( "sales", vpSales );
-		s.persist( company );
-		s.flush();
-		s.clear();
-
-		// For the element-collection, check that the orm.xml entries are honored.
-		// This includes: map-key-column/column/collection-table/join-column
-		BasicCollectionPersister confRoomMeta = (BasicCollectionPersister) sf.getCollectionMetadata( Company.class.getName() + ".conferenceRoomExtensions" );
-		assertEquals( "company_id", confRoomMeta.getKeyColumnNames()[0] );
-		assertEquals( "phone_extension", confRoomMeta.getElementColumnNames()[0] );
-		assertEquals( "room_number", confRoomMeta.getIndexColumnNames()[0] );
-		assertEquals( "phone_extension_lookup", confRoomMeta.getTableName() );
-		tx.rollback();
-		s.close();
-	}
-
-	@Override
-	protected Class[] getAnnotatedClasses() {
-		return new Class[] {
-				CarModel.class,
-				Manufacturer.class,
-				Model.class,
-				Light.class
-				//Lighter.class xml only entuty
-		};
-	}
-
-	@Override
-	protected String[] getOrmXmlFiles() {
-		return new String[] {
-				"org/hibernate/test/annotations/xml/ejb3/orm.xml",
-				"org/hibernate/test/annotations/xml/ejb3/orm2.xml",
-				"org/hibernate/test/annotations/xml/ejb3/orm3.xml",
-				"org/hibernate/test/annotations/xml/ejb3/orm4.xml"
-		};
-	}
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlTestCase.java

@@ -1,82 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.xml.ejb3;
-
-import java.io.InputStream;
-import java.lang.annotation.Annotation;
-import java.lang.reflect.AnnotatedElement;
-
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-import org.hibernate.cfg.annotations.reflection.XMLContext;
-
-import org.hibernate.testing.boot.BootstrapContextImpl;
-import org.hibernate.testing.junit4.BaseUnitTestCase;
-
-import org.dom4j.Document;
-import org.dom4j.io.SAXReader;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Test superclass to provide utility methods for testing the mapping of JPA
- * XML to JPA annotations.  The configuration is built within each test, and no
- * database is used.  Thus, no schema generation or cleanup will be performed.
- * <p>
- * Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlTest}
- * for the legacy {@link JPAOverriddenAnnotationReader}.
- *
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@Deprecated
-abstract class LegacyEjb3XmlTestCase extends BaseUnitTestCase {
-	protected JPAOverriddenAnnotationReader reader;
-
-	protected void assertAnnotationPresent(Class<? extends Annotation> annotationType) {
-		assertTrue(
-				"Expected annotation " + annotationType.getSimpleName() + " was not present",
-				reader.isAnnotationPresent( annotationType )
-		);
-	}
-
-	protected void assertAnnotationNotPresent(Class<? extends Annotation> annotationType) {
-		assertFalse(
-				"Unexpected annotation " + annotationType.getSimpleName() + " was present",
-				reader.isAnnotationPresent( annotationType )
-		);
-	}
-
-	protected JPAOverriddenAnnotationReader getReader(Class<?> entityClass, String fieldName, String ormResourceName)
-			throws Exception {
-		AnnotatedElement el = getAnnotatedElement( entityClass, fieldName );
-		XMLContext xmlContext = getContext( ormResourceName );
-		return new JPAOverriddenAnnotationReader( el, xmlContext, BootstrapContextImpl.INSTANCE );
-	}
-
-	protected AnnotatedElement getAnnotatedElement(Class<?> entityClass, String fieldName) throws Exception {
-		return entityClass.getDeclaredField( fieldName );
-	}
-
-	protected XMLContext getContext(String resourceName) throws Exception {
-		InputStream is = getClass().getResourceAsStream( resourceName );
-		assertNotNull( "Could not load resource " + resourceName, is );
-		return getContext( is );
-	}
-
-	protected XMLContext getContext(InputStream is) throws Exception {
-		XMLContext xmlContext = new XMLContext( BootstrapContextImpl.INSTANCE );
-		SAXReader reader = new SAXReader();
-		reader.setFeature( "http://apache.org/xml/features/nonvalidating/load-external-dtd", false );
-		reader.setFeature( "http://xml.org/sax/features/external-general-entities", false );
-		reader.setFeature( "http://xml.org/sax/features/external-parameter-entities", false );
-		Document doc = reader.read( is );
-		xmlContext.addDocument( doc );
-		return xmlContext;
-	}
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyNonExistentOrmVersionTest.java

@@ -1,42 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.xml.ejb3;
-
-import org.hibernate.InvalidMappingException;
-import org.hibernate.boot.MetadataSources;
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-import org.hibernate.internal.util.xml.UnsupportedOrmXsdVersionException;
-
-import org.hibernate.testing.TestForIssue;
-import org.hibernate.testing.junit4.BaseUnitTestCase;
-import org.junit.Test;
-
-import static org.junit.Assert.fail;
-
-/**
- * Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.NonExistentOrmVersionTest}
- * for the legacy {@link JPAOverriddenAnnotationReader}.
- *
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@TestForIssue(jiraKey = "HHH-6271")
-public class LegacyNonExistentOrmVersionTest extends BaseUnitTestCase {
-	@Test
-	public void testNonExistentOrmVersion() {
-		try {
-			new MetadataSources()
-					.addResource( "org/hibernate/test/annotations/xml/ejb3/orm5.xml" )
-					.buildMetadata();
-			fail( "Expecting failure due to unsupported xsd version" );
-		}
-		catch ( InvalidMappingException expected ) {
-		}
-		catch ( UnsupportedOrmXsdVersionException expected ) {
-		}
-	}
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyOrmVersion1SupportedTest.java

@@ -1,68 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.xml.ejb3;
-
-import org.hibernate.Session;
-import org.hibernate.Transaction;
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-import org.hibernate.internal.CoreMessageLogger;
-import org.hibernate.internal.util.xml.ErrorLogger;
-
-import org.hibernate.testing.TestForIssue;
-import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
-import org.hibernate.testing.logger.LoggerInspectionRule;
-import org.hibernate.testing.logger.Triggerable;
-import org.junit.Rule;
-import org.junit.Test;
-
-import org.jboss.logging.Logger;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-
-/**
- * Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.OrmVersion1SupportedTest}
- * for the legacy {@link JPAOverriddenAnnotationReader}.
- *
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@TestForIssue(jiraKey = "HHH-6271")
-public class LegacyOrmVersion1SupportedTest extends BaseCoreFunctionalTestCase {
-
-	@Rule
-	public LoggerInspectionRule logInspection = new LoggerInspectionRule(
-			Logger.getMessageLogger(
-					CoreMessageLogger.class,
-					ErrorLogger.class.getName()
-			)
-		);
-
-	@Test
-	public void testOrm1Support() {
-		Triggerable triggerable = logInspection.watchForLogMessages( "HHH00196" );
-
-		Session s = openSession();
-		Transaction tx = s.beginTransaction();
-		Light light = new Light();
-		light.name = "the light at the end of the tunnel";
-		s.persist( light );
-		s.flush();
-		s.clear();
-
-		assertEquals( 1, s.getNamedQuery( "find.the.light" ).list().size() );
-		tx.rollback();
-		s.close();
-
-		assertFalse( triggerable.wasTriggered() );
-	}
-
-	@Override
-	protected String[] getOrmXmlFiles() {
-		return new String[] { "org/hibernate/test/annotations/xml/ejb3/orm2.xml" };
-	}
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyPreParsedOrmXmlTest.java

@@ -1,58 +0,0 @@
-/*
- * Hibernate, Relational Persistence for Idiomatic Java
- *
- * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
- * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
- */
-package org.hibernate.test.annotations.xml.ejb3;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.UncheckedIOException;
-
-import org.hibernate.boot.jaxb.spi.Binding;
-import org.hibernate.cfg.Configuration;
-import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
-
-import org.hibernate.testing.TestForIssue;
-import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
-import org.hibernate.test.annotations.xml.ejb3.PreParsedOrmXmlTest.NonAnnotatedEntity;
-import org.junit.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-/**
- * Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.PreParsedOrmXmlTest}
- * for the legacy {@link JPAOverriddenAnnotationReader}.
- *
- * @author Emmanuel Bernard
- * @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
- */
-@TestForIssue(jiraKey = "HHH-14530")
-public class LegacyPreParsedOrmXmlTest extends BaseCoreFunctionalTestCase {
-
-	@Override
-	protected void addMappings(Configuration configuration) {
-		super.addMappings( configuration );
-		try (InputStream xmlStream = Thread.currentThread().getContextClassLoader()
-				.getResourceAsStream( "org/hibernate/test/annotations/xml/ejb3/pre-parsed-orm.xml" )) {
-			Binding<?> parsed = configuration.getXmlMappingBinderAccess().bind( xmlStream );
-			configuration.addXmlMapping( parsed );
-		}
-		catch (IOException e) {
-			throw new UncheckedIOException( e );
-		}
-	}
-
-	@Test
-	public void testPreParsedOrmXml() {
-		// Just check that the entity can be persisted, which means the mapping file was taken into account
-		NonAnnotatedEntity persistedEntity = new NonAnnotatedEntity( "someName" );
-		inTransaction( s -> s.persist( persistedEntity ) );
-		inTransaction( s -> {
-			NonAnnotatedEntity retrievedEntity = s.find( NonAnnotatedEntity.class, persistedEntity.getId() );
-			assertThat( retrievedEntity ).extracting( NonAnnotatedEntity::getName )
-					.isEqualTo( persistedEntity.getName() );
-		} );
-	}
-}

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/NonExistentOrmVersionTest.java

@@ -10,7 +10,6 @@ import org.hibernate.InvalidMappingException;
 import org.hibernate.boot.MetadataSources;
 import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
 import org.hibernate.internal.util.xml.UnsupportedOrmXsdVersionException;
-import org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider;
 
 import org.hibernate.testing.TestForIssue;
 import org.hibernate.testing.junit4.BaseUnitTestCase;
@@ -24,7 +23,6 @@ public class NonExistentOrmVersionTest extends BaseUnitTestCase {
 	public void testNonExistentOrmVersion() {
 		try {
 			BootstrapServiceRegistryBuilder builder = new BootstrapServiceRegistryBuilder();
-			XmlMappingOptionsStrategyRegistrationProvider.applyJaxbStrategy( builder );
 			new MetadataSources( builder.build() )
 					.addResource( "org/hibernate/test/annotations/xml/ejb3/orm5.xml" )
 					.buildMetadata();

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/OrmVersion1SupportedTest.java

@@ -11,7 +11,6 @@ import org.hibernate.Transaction;
 import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
 import org.hibernate.internal.CoreMessageLogger;
 import org.hibernate.internal.util.xml.ErrorLogger;
-import org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider;
 
 import org.hibernate.testing.TestForIssue;
 import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
@@ -31,7 +30,6 @@ public class OrmVersion1SupportedTest extends BaseCoreFunctionalTestCase {
 	@Override
 	protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
 		super.prepareBootstrapRegistryBuilder( builder );
-		XmlMappingOptionsStrategyRegistrationProvider.applyJaxbStrategy( builder );
 	}
 
 	@Rule

hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/PreParsedOrmXmlTest.java

@@ -13,7 +13,6 @@ import java.io.UncheckedIOException;
 import org.hibernate.boot.jaxb.spi.Binding;
 import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
 import org.hibernate.cfg.Configuration;
-import org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider;
 
 import org.hibernate.testing.TestForIssue;
 import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
@@ -27,7 +26,6 @@ public class PreParsedOrmXmlTest extends BaseCoreFunctionalTestCase {
 	@Override
 	protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
 		super.prepareBootstrapRegistryBuilder( builder );
-		XmlMappingOptionsStrategyRegistrationProvider.applyJaxbStrategy( builder );
 	}
 
 	@Override

hibernate-core/src/test/java/org/hibernate/test/bytecode/enhancement/lazy/proxy/inlinedirtychecking/LoadUninitializedCollectionTest.java

@@ -0,0 +1,232 @@
+/*
+ * Hibernate, Relational Persistence for Idiomatic Java
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ */
+package org.hibernate.test.bytecode.enhancement.lazy.proxy.inlinedirtychecking;
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.Id;
+import javax.persistence.ManyToOne;
+import javax.persistence.OneToMany;
+import javax.persistence.Query;
+import javax.persistence.Table;
+
+import org.hibernate.cfg.AvailableSettings;
+import org.hibernate.cfg.Environment;
+import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
+
+import org.hibernate.testing.TestForIssue;
+import org.hibernate.testing.bytecode.enhancement.BytecodeEnhancerRunner;
+import org.hibernate.testing.bytecode.enhancement.CustomEnhancementContext;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
+import static org.junit.Assert.assertEquals;
+
+@TestForIssue(jiraKey = "HHH-14549")
+@RunWith(BytecodeEnhancerRunner.class)
+@CustomEnhancementContext({ DirtyCheckEnhancementContext.class, NoDirtyCheckEnhancementContext.class })
+public class LoadUninitializedCollectionTest extends BaseEntityManagerFunctionalTestCase {
+
+	boolean skipTest;
+
+	@Override
+	protected Class<?>[] getAnnotatedClasses() {
+		return new Class[] {
+				Bank.class,
+				BankAccount.class,
+				BankDepartment.class
+		};
+	}
+
+	@Override
+	protected void addMappings(Map settings) {
+		String byteCodeProvider = Environment.getProperties().getProperty( AvailableSettings.BYTECODE_PROVIDER );
+		if ( byteCodeProvider != null && !Environment.BYTECODE_PROVIDER_NAME_BYTEBUDDY.equals( byteCodeProvider ) ) {
+			// skip the test if the bytecode provider is Javassist
+			skipTest = true;
+		}
+	}
+
+
+	@Before
+	public void setUp() {
+		if ( skipTest ) {
+			return;
+		}
+		doInJPA(
+				this::entityManagerFactory, entityManager -> {
+					Bank bank = new Bank( 1L, "International" );
+					BankAccount bankAccount = new BankAccount( 1L, bank, "1234567890" );
+					BankDepartment bankDepartmentA = new BankDepartment( 1L, "A" );
+					BankDepartment bankDepartmentB = new BankDepartment( 2L, "B" );
+					BankDepartment bankDepartmentC = new BankDepartment( 3L, "C" );
+
+					bank.addDepartment( bankDepartmentA );
+					bank.addDepartment( bankDepartmentB );
+					bank.addDepartment( bankDepartmentC );
+
+					entityManager.persist( bank );
+					entityManager.persist( bankAccount );
+					entityManager.persist( bankDepartmentA );
+					entityManager.persist( bankDepartmentB );
+					entityManager.persist( bankDepartmentC );
+				}
+		);
+	}
+
+	@Test
+	public void testLoadAfterNativeQueryExecution() {
+		if ( skipTest ) {
+			return;
+		}
+		doInJPA( this::entityManagerFactory, entityManager -> {
+					 BankAccount account = entityManager.find( BankAccount.class, 1L );
+
+					 Query nativeQuery = entityManager.createNativeQuery( "SELECT ID FROM BANK" );
+					 nativeQuery.getResultList();
+
+					 Bank bank = account.getBank();
+					 List<BankDepartment> deps = bank.getDepartments();
+
+					 assertEquals( deps.size(), 3 );
+				 }
+		);
+	}
+
+	@Test
+	public void testLoadAfterFlush() {
+		if ( skipTest ) {
+			return;
+		}
+		doInJPA( this::entityManagerFactory, entityManager -> {
+					 BankAccount account = entityManager.find( BankAccount.class, 1L );
+
+					 entityManager.flush();
+
+					 Bank bank = account.getBank();
+					 List<BankDepartment> deps = bank.getDepartments();
+
+					 assertEquals( deps.size(), 3 );
+				 }
+		);
+	}
+
+	@After
+	public void tearDown() {
+		if ( skipTest ) {
+			return;
+		}
+		doInJPA( this::entityManagerFactory, entityManager -> {
+					 Bank bank = entityManager.find( Bank.class, 1L );
+					 bank.getDepartments().forEach(
+							 department -> entityManager.remove( department )
+					 );
+					 List<BankAccount> accounts = entityManager.createQuery( "from BankAccount" ).getResultList();
+
+					 accounts.forEach(
+							 account -> entityManager.remove( account )
+					 );
+
+					 entityManager.remove( bank );
+				 }
+		);
+	}
+
+
+	@Entity(name = "Bank")
+	@Table(name = "BANK")
+	public static class Bank {
+
+		@Id
+		@Column(name = "ID")
+		private Long id;
+
+		private String name;
+
+		public Bank() {
+		}
+
+		public Bank(Long id, String name) {
+			this.id = id;
+			this.name = name;
+		}
+
+		@OneToMany
+		private List<BankDepartment> departments = new ArrayList<>();
+
+		public List<BankDepartment> getDepartments() {
+			return departments;
+		}
+
+		public void addDepartment(BankDepartment department) {
+			this.departments.add( department );
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+	}
+
+	@Entity(name = "BankAccount")
+	public static class BankAccount {
+
+		@Id
+		private Long id;
+
+		@ManyToOne(fetch = FetchType.LAZY)
+		private Bank bank;
+
+		private String serialNumber;
+
+		public BankAccount() {
+		}
+
+		public BankAccount(Long id, Bank bank, String serialNumber) {
+			this.id = id;
+			this.bank = bank;
+			this.serialNumber = serialNumber;
+		}
+
+		public Bank getBank() {
+			return bank;
+		}
+
+		public String getSerialNumber() {
+			return serialNumber;
+		}
+	}
+
+	@Entity(name = "BankDepartment")
+	public static class BankDepartment {
+
+		@Id
+		private Long id;
+
+		private String name;
+
+		public BankDepartment() {
+		}
+
+		public BankDepartment(Long id, String name) {
+			this.id = id;
+		}
+	}
+
+
+}

hibernate-core/src/test/java/org/hibernate/test/bytecode/enhancement/lazy/proxy/inlinedirtychecking/LoadingLazyCollectionAfterQueryExecutionWithFlushModeAlwaysTest.java

@@ -0,0 +1,188 @@
+package org.hibernate.test.bytecode.enhancement.lazy.proxy.inlinedirtychecking;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import javax.persistence.Entity;
+import javax.persistence.FetchType;
+import javax.persistence.GeneratedValue;
+import javax.persistence.Id;
+import javax.persistence.MappedSuperclass;
+import javax.persistence.OneToMany;
+import javax.persistence.OneToOne;
+
+import org.hibernate.FlushMode;
+import org.hibernate.cfg.AvailableSettings;
+import org.hibernate.cfg.Environment;
+import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
+
+import org.hibernate.testing.TestForIssue;
+import org.hibernate.testing.bytecode.enhancement.BytecodeEnhancerRunner;
+import org.hibernate.testing.bytecode.enhancement.CustomEnhancementContext;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+@TestForIssue( jiraKey = "HHH-14549")
+@RunWith(BytecodeEnhancerRunner.class)
+@CustomEnhancementContext({ DirtyCheckEnhancementContext.class, NoDirtyCheckEnhancementContext.class })
+public class LoadingLazyCollectionAfterQueryExecutionWithFlushModeAlwaysTest
+		extends BaseEntityManagerFunctionalTestCase {
+
+	boolean skipTest;
+
+	@Override
+	protected Class<?>[] getAnnotatedClasses() {
+		return new Class[] {
+				Customer.class,
+				ProductOrder.class,
+				Product.class,
+				City.class
+		};
+	}
+
+	@Override
+	protected void addMappings(Map settings) {
+		String byteCodeProvider = Environment.getProperties().getProperty( AvailableSettings.BYTECODE_PROVIDER );
+		settings.put( AvailableSettings.FLUSH_MODE, FlushMode.ALWAYS );
+		if ( byteCodeProvider != null && !Environment.BYTECODE_PROVIDER_NAME_BYTEBUDDY.equals( byteCodeProvider ) ) {
+			// skip the test if the bytecode provider is Javassist
+			skipTest = true;
+		}
+	}
+
+	@Before
+	public void setUp() {
+		if ( skipTest ) {
+			return;
+		}
+		doInJPA(
+				this::entityManagerFactory, entityManager -> {
+					ProductOrder order = new ProductOrder();
+					order.setOrderNumber( "12345" );
+
+					Customer customer = new Customer();
+					customer.setProductOrder( order );
+					customer.setName( "Fab" );
+
+					Product product = new Product();
+					product.setName( "gloves" );
+
+					order.addProduct( product );
+
+					entityManager.persist( order );
+					entityManager.persist( product );
+					entityManager.persist( customer );
+				}
+		);
+	}
+
+	@Test
+	public void reproducer_Case1() {
+		if ( skipTest ) {
+			return;
+		}
+		doInJPA(
+				this::entityManagerFactory, entityManager -> {
+					List<Customer> customers = entityManager.createQuery( "select c from Customer c" ).getResultList();
+					assertEquals( 1, customers.size() );
+
+					Customer customer = customers.get( 0 );
+					ProductOrder order = customer.getProductOrder();
+					assertNotNull( order );
+
+					entityManager.createQuery( "select c from City c" ).getResultList();
+
+					assertEquals( 1, order.getProducts().size() );
+				} );
+	}
+
+	@MappedSuperclass
+	public static abstract class Base {
+		@Id
+		@GeneratedValue
+		public Long id;
+
+		public Long getId() {
+			return id;
+		}
+
+		public void setId(long id) {
+			this.id = id;
+		}
+	}
+
+	@Entity(name = "Customer")
+	public static class Customer extends Base {
+
+		private String name;
+
+		@OneToOne(fetch = FetchType.LAZY)
+		ProductOrder order;
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public ProductOrder getProductOrder() {
+			return order;
+		}
+
+		public void setProductOrder(ProductOrder order) {
+			this.order = order;
+		}
+	}
+
+	@Entity(name = "ProductOrder")
+	public static class ProductOrder extends Base {
+
+		private String orderNumber;
+
+		@OneToMany
+		private List<Product> products = new ArrayList<>();
+
+		public String getOrderNumber() {
+			return orderNumber;
+		}
+
+		public void setOrderNumber(String orderNumber) {
+			this.orderNumber = orderNumber;
+		}
+
+		public List<Product> getProducts() {
+			return products;
+		}
+
+		public void addProduct(Product product) {
+			products.add( product );
+		}
+
+	}
+
+	@Entity(name = "Product")
+	public static class Product extends Base {
+
+		private String name;
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+	}
+
+	@Entity(name = "City")
+	public static class City extends Base {
+		private String name;
+	}
+}

hibernate-core/src/test/resources/META-INF/services/org.hibernate.boot.registry.selector.StrategyRegistrationProvider

@@ -1 +0,0 @@
-org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider

hibernate-core/src/test/resources/org/hibernate/orm/test/annotations/embeddables/collection/orm.xml

@@ -23,6 +23,15 @@
             </element-collection>
         </attributes>
     </entity>
+    <entity class="ContactType">
+        <attributes>
+            <id name="id">
+                <generated-value strategy="AUTO"/>
+            </id>
+            <basic name="type"/>
+            <version name="version"/>
+        </attributes>
+    </entity>
     <embeddable class="ContactInformation">
         <attributes>
             <basic name="name"/>
@@ -34,13 +43,4 @@
             </one-to-many>
         </attributes>
     </embeddable>
-    <entity class="ContactType">
-        <attributes>
-            <id name="id">
-                <generated-value strategy="AUTO"/>
-            </id>
-            <version name="version"/>
-            <basic name="type"/>
-        </attributes>
-    </entity>
 </entity-mappings>

hibernate-entitymanager/hibernate-entitymanager.gradle

@@ -4,7 +4,6 @@ apply from: rootProject.file( 'gradle/published-java-module.gradle' )
 
 dependencies {
 	compile( project( ':hibernate-core' ) )
-	compile( libraries.dom4j )
 	compile( libraries.commons_annotations )
 	compile( libraries.jpa )
 	compile( libraries.byteBuddy )

hibernate-envers/hibernate-envers.gradle

@@ -16,6 +16,9 @@ dependencies {
         exclude group: "org.javassist", module: "javassist"
     }
 
+    // TODO HHH-13703: get rid of this dependency
+    compile( libraries.dom4j )
+
     provided( libraries.ant )
     annotationProcessor( project( ':hibernate-jpamodelgen' ) )
 

hibernate-envers/src/main/java/org/hibernate/envers/boot/internal/AdditionalJaxbMappingProducerImpl.java

@@ -24,7 +24,6 @@ import org.hibernate.boot.jaxb.SourceType;
 import org.hibernate.boot.jaxb.hbm.spi.JaxbHbmHibernateMapping;
 import org.hibernate.boot.jaxb.internal.MappingBinder;
 import org.hibernate.boot.jaxb.spi.Binding;
-import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
 import org.hibernate.boot.model.source.internal.hbm.MappingDocument;
 import org.hibernate.boot.spi.AdditionalJaxbMappingProducer;
 import org.hibernate.boot.spi.MetadataBuildingContext;
@@ -32,14 +31,12 @@ import org.hibernate.boot.spi.MetadataBuildingOptions;
 import org.hibernate.boot.spi.MetadataImplementor;
 import org.hibernate.envers.boot.EnversBootLogger;
 import org.hibernate.envers.configuration.internal.MappingCollector;
-import org.hibernate.internal.util.config.ConfigurationHelper;
 import org.hibernate.service.ServiceRegistry;
 
 import org.jboss.jandex.IndexView;
 import org.jboss.logging.Logger;
 
 import org.dom4j.Document;
-import org.dom4j.DocumentException;
 import org.dom4j.io.OutputFormat;
 import org.dom4j.io.XMLWriter;
 
@@ -66,7 +63,7 @@ public class AdditionalJaxbMappingProducerImpl implements AdditionalJaxbMappingP
 			return Collections.emptyList();
 		}
 
-		if ( !metadataBuildingOptions.getXmlMappingOptions().isEnabled() ) {
+		if ( !metadataBuildingOptions.isXmlMappingEnabled() ) {
 			throw new HibernateException( "Hibernate Envers currently requires XML mapping to be enabled."
 					+ " Please don't disable setting `" + XML_MAPPING_ENABLED
 					+ "`; alternatively disable Hibernate Envers." );

hibernate-osgi/hibernate-osgi.gradle

@@ -96,6 +96,7 @@ dependencies {
 	karafDistro "org.apache.karaf:apache-karaf:${project.karafVersion}@tar.gz"
 
 	hibernateEnvers( project( ':hibernate-envers' ) )
+	hibernateEnvers( libraries.dom4j )
 }
 
 jar {
@@ -161,6 +162,9 @@ karaf {
 			name = 'hibernate-envers'
 			description = 'Feature for easily adding Envers support to hibernate-orm'
 			includeProject = false
+			feature ('wrap') {
+				prerequisite = true
+			}
 			configurations 'hibernateEnvers'
 			feature('hibernate-orm') {
 				version = project.version

hibernate-spatial/hibernate-spatial.gradle

@@ -19,10 +19,6 @@ dependencies {
 
     compile( libraries.postgresql )
 
-    compile(libraries.dom4j) {
-        transitive = false
-    }
-
     testCompile(libraries.junit)
     testCompile(project(':hibernate-testing'))
     testCompile( project( path: ':hibernate-core', configuration: 'tests' ) )
@@ -34,6 +30,9 @@ dependencies {
         // for test runtime
         transitive = true
     }
+    testCompile(libraries.dom4j) {
+        transitive = false
+    }
 
     testRuntime( libraries.expression_language )
 

tooling/hibernate-enhance-maven-plugin/hibernate-enhance-maven-plugin.gradle

@@ -55,7 +55,6 @@ task processPluginXml(type: Copy) {
     filter(ReplaceTokens, tokens: ['version' : project.version, 'generated-dependencies' :\
             generateMavenDependency(libraries.jpa)\
             + generateMavenDependency(libraries.antlr)\
-            + generateMavenDependency(libraries.dom4j)\
             + generateMavenDependency(libraries.jta)\
             + generateMavenDependency(libraries.commons_annotations)\
             + generateMavenDependency(libraries.javassist)\