Hibernate/hibernate-orm
1
0
Fork 0
mirror of https://github.com/hibernate/hibernate-orm synced 2025-02-08 20:24:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Attempt to match Hibernate code conventions

Browse Source
This commit is contained in:
davidmc24 2010-12-22 00:45:34 -05:00
parent 6de52c2db3
commit e0b06e8a57
36 changed files with 765 additions and 768 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

134
hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/JPAOverridenAnnotationReader.java
View File

@ -484,7 +484,6 @@ private Annotation getTableGenerator(List<Element> elementsForProperty, XMLConte
} }
} }
private Annotation getSequenceGenerator(List<Element> elementsForProperty, XMLContext.Default defaults) { private Annotation getSequenceGenerator(List<Element> elementsForProperty, XMLContext.Default defaults) {
for (Element element : elementsForProperty) { for (Element element : elementsForProperty) {
Element subelement = element != null ? element.element( annotationToXml.get( SequenceGenerator.class ) ) : null; Element subelement = element != null ? element.element( annotationToXml.get( SequenceGenerator.class ) ) : null;
@ -673,7 +672,7 @@ private void getAssociation(
getFetchType( ad, element ); getFetchType( ad, element );
getCascades( ad, element, defaults ); getCascades( ad, element, defaults );
getJoinTable( annotationList, element, defaults ); getJoinTable( annotationList, element, defaults );
buildJoinColumns( annotationList, element); buildJoinColumns( annotationList, element );
Annotation annotation = getPrimaryKeyJoinColumns( element, defaults ); Annotation annotation = getPrimaryKeyJoinColumns( element, defaults );
addIfNotNull( annotationList, annotation ); addIfNotNull( annotationList, annotation );
copyBooleanAttribute( ad, element, "optional" ); copyBooleanAttribute( ad, element, "optional" );
@ -682,15 +681,15 @@ private void getAssociation(
getOrderBy( annotationList, element ); getOrderBy( annotationList, element );
getMapKey( annotationList, element ); getMapKey( annotationList, element );
getMapKeyClass( annotationList, element, defaults ); getMapKeyClass( annotationList, element, defaults );
getMapKeyColumn(annotationList, element); getMapKeyColumn( annotationList, element );
getOrderColumn(annotationList, element); getOrderColumn( annotationList, element );
getMapKeyTemporal(annotationList, element); getMapKeyTemporal( annotationList, element );
getMapKeyEnumerated(annotationList, element); getMapKeyEnumerated( annotationList, element );
annotation = getMapKeyAttributeOverrides( element, defaults ); annotation = getMapKeyAttributeOverrides( element, defaults );
addIfNotNull( annotationList, annotation ); addIfNotNull( annotationList, annotation );
buildMapKeyJoinColumns( annotationList, element); buildMapKeyJoinColumns( annotationList, element );
getAssociationId(annotationList, element); getAssociationId( annotationList, element );
getMapsId(annotationList, element); getMapsId( annotationList, element );
annotationList.add( AnnotationFactory.create( ad ) ); annotationList.add( AnnotationFactory.create( ad ) );
getAccessType( annotationList, element ); getAccessType( annotationList, element );
} }
@ -825,8 +824,7 @@ else if ( isJavaAnnotationPresent( CollectionOfElements.class ) ) { //legacy Hib
} }
} }
private void buildMapKeyJoinColumns(List<Annotation> annotationList, private void buildMapKeyJoinColumns(List<Annotation> annotationList, Element element) {
Element element) {
MapKeyJoinColumn[] joinColumns = getMapKeyJoinColumns( element ); MapKeyJoinColumn[] joinColumns = getMapKeyJoinColumns( element );
if ( joinColumns.length > 0 ) { if ( joinColumns.length > 0 ) {
AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyJoinColumns.class ); AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyJoinColumns.class );
@ -834,11 +832,9 @@ private void buildMapKeyJoinColumns(List<Annotation> annotationList,
annotationList.add( AnnotationFactory.create( ad ) ); annotationList.add( AnnotationFactory.create( ad ) );
} }
} }
private MapKeyJoinColumn[] getMapKeyJoinColumns(Element element) { private MapKeyJoinColumn[] getMapKeyJoinColumns(Element element) {
List<Element> subelements = element != null ? List<Element> subelements = element != null ? element.elements( "map-key-join-column" ) : null;
element.elements( "map-key-join-column" ) :
null;
List<MapKeyJoinColumn> joinColumns = new ArrayList<MapKeyJoinColumn>(); List<MapKeyJoinColumn> joinColumns = new ArrayList<MapKeyJoinColumn>();
if ( subelements != null ) { if ( subelements != null ) {
for (Element subelement : subelements) { for (Element subelement : subelements) {
@ -857,17 +853,16 @@ private MapKeyJoinColumn[] getMapKeyJoinColumns(Element element) {
return joinColumns.toArray( new MapKeyJoinColumn[joinColumns.size()] ); return joinColumns.toArray( new MapKeyJoinColumn[joinColumns.size()] );
} }
private Annotation getMapKeyAttributeOverrides(Element tree, private Annotation getMapKeyAttributeOverrides(Element tree, Default defaults) {
Default defaults) {
List<AttributeOverride> attributes = buildMapKeyAttributeOverrides( tree ); List<AttributeOverride> attributes = buildMapKeyAttributeOverrides( tree );
return mergeAttributeOverrides( defaults, attributes ); return mergeAttributeOverrides( defaults, attributes );
} }
private List<AttributeOverride> buildMapKeyAttributeOverrides(Element element) { private List<AttributeOverride> buildMapKeyAttributeOverrides(Element element) {
List<Element> subelements = element == null ? null : element.elements( "map-key-attribute-override" ); List<Element> subelements = element == null ? null : element.elements( "map-key-attribute-override" );
return buildMapKeyAttributeOverrides( subelements ); return buildMapKeyAttributeOverrides( subelements );
} }
private List<AttributeOverride> buildMapKeyAttributeOverrides(List<Element> subelements) { private List<AttributeOverride> buildMapKeyAttributeOverrides(List<Element> subelements) {
List<AttributeOverride> overrides = new ArrayList<AttributeOverride>(); List<AttributeOverride> overrides = new ArrayList<AttributeOverride>();
if ( subelements != null && subelements.size() > 0 ) { if ( subelements != null && subelements.size() > 0 ) {
@ -884,48 +879,42 @@ private List<AttributeOverride> buildMapKeyAttributeOverrides(List<Element> sube
} }
/** /**
* Adds a @MapKeyEnumerated annotation to the specified annotationList if * Adds a @MapKeyEnumerated annotation to the specified annotationList if the specified element
* the specified element contains a map-key-enumerated sub-element. This * contains a map-key-enumerated sub-element. This should only be the case for
* should only be the case for element-collection, many-to-many, or * element-collection, many-to-many, or one-to-many associations.
* one-to-many associations.
*/ */
private void getMapKeyEnumerated(List<Annotation> annotationList, private void getMapKeyEnumerated(List<Annotation> annotationList, Element element) {
Element element) {
Element subelement = element != null ? element.element( "map-key-enumerated" ) : null; Element subelement = element != null ? element.element( "map-key-enumerated" ) : null;
if ( subelement != null ) { if ( subelement != null ) {
AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyEnumerated.class ); AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyEnumerated.class );
EnumType value = EnumType.valueOf(subelement.getTextTrim()); EnumType value = EnumType.valueOf( subelement.getTextTrim() );
ad.setValue("value", value); ad.setValue( "value", value );
annotationList.add( AnnotationFactory.create( ad ) ); annotationList.add( AnnotationFactory.create( ad ) );
} }
} }
/** /**
* Adds a @MapKeyTemporal annotation to the specified annotationList if the * Adds a @MapKeyTemporal annotation to the specified annotationList if the specified element
* specified element contains a map-key-temporal sub-element. This should * contains a map-key-temporal sub-element. This should only be the case for element-collection,
* only be the case for element-collection, many-to-many, or one-to-many * many-to-many, or one-to-many associations.
* associations.
*/ */
private void getMapKeyTemporal(List<Annotation> annotationList, private void getMapKeyTemporal(List<Annotation> annotationList, Element element) {
Element element) {
Element subelement = element != null ? element.element( "map-key-temporal" ) : null; Element subelement = element != null ? element.element( "map-key-temporal" ) : null;
if ( subelement != null ) { if ( subelement != null ) {
AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyTemporal.class ); AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyTemporal.class );
TemporalType value = TemporalType.valueOf(subelement.getTextTrim()); TemporalType value = TemporalType.valueOf( subelement.getTextTrim() );
ad.setValue("value", value); ad.setValue( "value", value );
annotationList.add( AnnotationFactory.create( ad ) ); annotationList.add( AnnotationFactory.create( ad ) );
} }
} }
/** /**
* Adds an @OrderColumn annotation to the specified annotationList if the * Adds an @OrderColumn annotation to the specified annotationList if the specified element
* specified element contains an order-column sub-element. This should only * contains an order-column sub-element. This should only be the case for element-collection,
* be the case for element-collection, many-to-many, or one-to-many * many-to-many, or one-to-many associations.
* associations.
*/ */
private void getOrderColumn(List<Annotation> annotationList, private void getOrderColumn(List<Annotation> annotationList, Element element) {
Element element) {
Element subelement = element != null ? element.element( "order-column" ) : null; Element subelement = element != null ? element.element( "order-column" ) : null;
if ( subelement != null ) { if ( subelement != null ) {
AnnotationDescriptor ad = new AnnotationDescriptor( OrderColumn.class ); AnnotationDescriptor ad = new AnnotationDescriptor( OrderColumn.class );
@ -939,28 +928,27 @@ private void getOrderColumn(List<Annotation> annotationList,
} }
/** /**
* Adds a @MapsId annotation to the specified annotationList if the * Adds a @MapsId annotation to the specified annotationList if the specified element has the
* specified element has the maps-id attribute set. This should only be the * maps-id attribute set. This should only be the case for many-to-one or one-to-one
* case for many-to-one or one-to-one associations. * associations.
*/ */
private void getMapsId(List<Annotation> annotationList, Element element) { private void getMapsId(List<Annotation> annotationList, Element element) {
String attrVal = element.attributeValue("maps-id"); String attrVal = element.attributeValue( "maps-id" );
if(attrVal != null) { if ( attrVal != null ) {
AnnotationDescriptor ad = new AnnotationDescriptor( MapsId.class ); AnnotationDescriptor ad = new AnnotationDescriptor( MapsId.class );
ad.setValue("value", attrVal); ad.setValue( "value", attrVal );
annotationList.add( AnnotationFactory.create( ad ) ); annotationList.add( AnnotationFactory.create( ad ) );
} }
} }
/** /**
* Adds an @Id annotation to the specified annotationList if the specified * Adds an @Id annotation to the specified annotationList if the specified element has the id
* element has the id attribute set to true. This should only be the case * attribute set to true. This should only be the case for many-to-one or one-to-one
* for many-to-one or one-to-one associations. * associations.
*/ */
private void getAssociationId(List<Annotation> annotationList, private void getAssociationId(List<Annotation> annotationList, Element element) {
Element element) { String attrVal = element.attributeValue( "id" );
String attrVal = element.attributeValue("id"); if ( "true".equals( attrVal ) ) {
if("true".equals(attrVal)) {
AnnotationDescriptor ad = new AnnotationDescriptor( Id.class ); AnnotationDescriptor ad = new AnnotationDescriptor( Id.class );
annotationList.add( AnnotationFactory.create( ad ) ); annotationList.add( AnnotationFactory.create( ad ) );
} }
@ -972,8 +960,7 @@ private void addTargetClass(Element element, AnnotationDescriptor ad, String nod
Class clazz; Class clazz;
try { try {
clazz = ReflectHelper.classForName( clazz = ReflectHelper.classForName(
XMLContext.buildSafeClassName( className, defaults ), XMLContext.buildSafeClassName( className, defaults ), this.getClass()
this.getClass()
); );
} }
catch (ClassNotFoundException e) { catch (ClassNotFoundException e) {
@ -981,11 +968,11 @@ private void addTargetClass(Element element, AnnotationDescriptor ad, String nod
"Unable to find " + element.getPath() + " " + nodeName + ": " + className, e "Unable to find " + element.getPath() + " " + nodeName + ": " + className, e
); );
} }
ad.setValue( getJavaAttributeNameFromXMLOne(nodeName), clazz ); ad.setValue( getJavaAttributeNameFromXMLOne( nodeName ), clazz );
} }
} }
// TODO: Complete parsing of all element-collection related xml //TODO: Complete parsing of all element-collection related xml
private void getElementCollection(List<Annotation> annotationList, XMLContext.Default defaults) { private void getElementCollection(List<Annotation> annotationList, XMLContext.Default defaults) {
for ( Element element : elementsForProperty ) { for ( Element element : elementsForProperty ) {
if ( "element-collection".equals( element.getName() ) ) { if ( "element-collection".equals( element.getName() ) ) {
@ -999,24 +986,24 @@ private void getElementCollection(List<Annotation> annotationList, XMLContext.De
//TODO: support map-key-temporal //TODO: support map-key-temporal
//TODO: support map-key-enumerated //TODO: support map-key-enumerated
//TODO: support map-key-attribute-override //TODO: support map-key-attribute-override
getMapKeyColumn(annotationList, element); getMapKeyColumn( annotationList, element );
//TODO: support map-key-join-column //TODO: support map-key-join-column
Annotation annotation = getColumn(element.element( "column" ), false, element); Annotation annotation = getColumn( element.element( "column" ), false, element );
addIfNotNull(annotationList, annotation); addIfNotNull( annotationList, annotation );
getTemporal(annotationList, element); getTemporal( annotationList, element );
getEnumerated(annotationList, element); getEnumerated( annotationList, element );
getLob(annotationList, element); getLob( annotationList, element );
annotation = getAttributeOverrides( element, defaults ); annotation = getAttributeOverrides( element, defaults );
addIfNotNull( annotationList, annotation ); addIfNotNull( annotationList, annotation );
annotation = getAssociationOverrides( element, defaults ); annotation = getAssociationOverrides( element, defaults );
addIfNotNull( annotationList, annotation ); addIfNotNull( annotationList, annotation );
getCollectionTable(annotationList, element, defaults); getCollectionTable( annotationList, element, defaults );
annotationList.add( AnnotationFactory.create( ad ) ); annotationList.add( AnnotationFactory.create( ad ) );
getAccessType( annotationList, element ); getAccessType( annotationList, element );
} }
} }
} }
private void getOrderBy(List<Annotation> annotationList, Element element) { private void getOrderBy(List<Annotation> annotationList, Element element) {
Element subelement = element != null ? element.element( "order-by" ) : null; Element subelement = element != null ? element.element( "order-by" ) : null;
if ( subelement != null ) { if ( subelement != null ) {
@ -1036,7 +1023,7 @@ private void getMapKey(List<Annotation> annotationList, Element element) {
annotationList.add( AnnotationFactory.create( ad ) ); annotationList.add( AnnotationFactory.create( ad ) );
} }
} }
private void getMapKeyColumn(List<Annotation> annotationList, Element element) { private void getMapKeyColumn(List<Annotation> annotationList, Element element) {
Element subelement = element != null ? element.element( "map-key-column" ) : null; Element subelement = element != null ? element.element( "map-key-column" ) : null;
if ( subelement != null ) { if ( subelement != null ) {
@ -1054,7 +1041,7 @@ private void getMapKeyColumn(List<Annotation> annotationList, Element element) {
annotationList.add( AnnotationFactory.create( ad ) ); annotationList.add( AnnotationFactory.create( ad ) );
} }
} }
private void getMapKeyClass(List<Annotation> annotationList, Element element, XMLContext.Default defaults) { private void getMapKeyClass(List<Annotation> annotationList, Element element, XMLContext.Default defaults) {
String nodeName = "map-key-class"; String nodeName = "map-key-class";
Element subelement = element != null ? element.element( nodeName ) : null; Element subelement = element != null ? element.element( nodeName ) : null;
@ -1065,7 +1052,7 @@ private void getMapKeyClass(List<Annotation> annotationList, Element element, XM
Class clazz; Class clazz;
try { try {
clazz = ReflectHelper.classForName( clazz = ReflectHelper.classForName(
XMLContext.buildSafeClassName( mapKeyClassName, defaults ), XMLContext.buildSafeClassName(mapKeyClassName, defaults ),
this.getClass() this.getClass()
); );
} }
@ -1079,7 +1066,7 @@ private void getMapKeyClass(List<Annotation> annotationList, Element element, XM
annotationList.add( AnnotationFactory.create( ad ) ); annotationList.add( AnnotationFactory.create( ad ) );
} }
} }
private void getCollectionTable(List<Annotation> annotationList, Element element, XMLContext.Default defaults) { private void getCollectionTable(List<Annotation> annotationList, Element element, XMLContext.Default defaults) {
Element subelement = element != null ? element.element( "collection-table" ) : null; Element subelement = element != null ? element.element( "collection-table" ) : null;
if ( subelement != null ) { if ( subelement != null ) {
@ -1579,8 +1566,7 @@ private AttributeOverrides getAttributeOverrides(List<Element> elements, XMLCont
return mergeAttributeOverrides( defaults, attributes ); return mergeAttributeOverrides( defaults, attributes );
} }
private AttributeOverrides mergeAttributeOverrides(XMLContext.Default defaults, private AttributeOverrides mergeAttributeOverrides(XMLContext.Default defaults, List<AttributeOverride> attributes) {
List<AttributeOverride> attributes) {
if ( defaults.canUseJavaAnnotations() ) { if ( defaults.canUseJavaAnnotations() ) {
AttributeOverride annotation = getJavaAnnotation( AttributeOverride.class ); AttributeOverride annotation = getJavaAnnotation( AttributeOverride.class );
addAttributeOverrideIfNeeded( annotation, attributes ); addAttributeOverrideIfNeeded( annotation, attributes );
@ -1789,8 +1775,8 @@ public static List<SqlResultSetMapping> buildSqlResultsetMappings(Element elemen
Class clazz; Class clazz;
try { try {
clazz = ReflectHelper.classForName( clazz = ReflectHelper.classForName(
XMLContext.buildSafeClassName( clazzName, defaults ), XMLContext.buildSafeClassName( clazzName, defaults ),
JPAOverridenAnnotationReader.class JPAOverridenAnnotationReader.class
); );
} }
catch (ClassNotFoundException e) { catch (ClassNotFoundException e) {

322
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/Ejb3XmlManyToOneTest.java
View File

@ -37,198 +37,200 @@
import javax.persistence.UniqueConstraint; import javax.persistence.UniqueConstraint;
public class Ejb3XmlManyToOneTest extends Ejb3XmlTestCase { public class Ejb3XmlManyToOneTest extends Ejb3XmlTestCase {
public void testNoJoins() throws Exception { public void testNoJoins() throws Exception {
reader = getReader(Entity1.class, "field1", "many-to-one.orm1.xml"); reader = getReader( Entity1.class, "field1", "many-to-one.orm1.xml" );
assertAnnotationPresent(ManyToOne.class); assertAnnotationPresent( ManyToOne.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
assertAnnotationNotPresent(JoinColumns.class); assertAnnotationNotPresent( JoinColumns.class );
assertAnnotationNotPresent(JoinTable.class); assertAnnotationNotPresent( JoinTable.class );
assertAnnotationNotPresent(Id.class); assertAnnotationNotPresent( Id.class );
assertAnnotationNotPresent(MapsId.class); assertAnnotationNotPresent( MapsId.class );
assertAnnotationNotPresent(Access.class); assertAnnotationNotPresent( Access.class );
ManyToOne relAnno = reader.getAnnotation(ManyToOne.class); ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
assertEquals(0, relAnno.cascade().length); assertEquals( 0, relAnno.cascade().length );
assertEquals(FetchType.EAGER, relAnno.fetch()); assertEquals( FetchType.EAGER, relAnno.fetch() );
assertTrue(relAnno.optional()); assertTrue( relAnno.optional() );
assertEquals(void.class, relAnno.targetEntity()); assertEquals( void.class, relAnno.targetEntity() );
} }
/** /**
* When there's a single join column, we still wrap it with a JoinColumns * When there's a single join column, we still wrap it with a JoinColumns
* annotation. * annotation.
*/ */
public void testSingleJoinColumn() throws Exception { public void testSingleJoinColumn() throws Exception {
reader = getReader(Entity1.class, "field1", "many-to-one.orm2.xml"); reader = getReader( Entity1.class, "field1", "many-to-one.orm2.xml" );
assertAnnotationPresent(ManyToOne.class); assertAnnotationPresent( ManyToOne.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
assertAnnotationPresent(JoinColumns.class); assertAnnotationPresent( JoinColumns.class );
assertAnnotationNotPresent(JoinTable.class); assertAnnotationNotPresent( JoinTable.class );
JoinColumns joinColumnsAnno = reader.getAnnotation(JoinColumns.class); JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
JoinColumn[] joinColumns = joinColumnsAnno.value(); JoinColumn[] joinColumns = joinColumnsAnno.value();
assertEquals(1, joinColumns.length); assertEquals( 1, joinColumns.length );
assertEquals("col1", joinColumns[0].name()); assertEquals( "col1", joinColumns[0].name() );
assertEquals("col2", joinColumns[0].referencedColumnName()); assertEquals( "col2", joinColumns[0].referencedColumnName() );
assertEquals("table1", joinColumns[0].table()); assertEquals( "table1", joinColumns[0].table() );
} }
public void testMultipleJoinColumns() throws Exception { public void testMultipleJoinColumns() throws Exception {
reader = getReader(Entity1.class, "field1", "many-to-one.orm3.xml"); reader = getReader( Entity1.class, "field1", "many-to-one.orm3.xml" );
assertAnnotationPresent(ManyToOne.class); assertAnnotationPresent( ManyToOne.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
assertAnnotationPresent(JoinColumns.class); assertAnnotationPresent( JoinColumns.class );
assertAnnotationNotPresent(JoinTable.class); assertAnnotationNotPresent( JoinTable.class );
JoinColumns joinColumnsAnno = reader.getAnnotation(JoinColumns.class); JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
JoinColumn[] joinColumns = joinColumnsAnno.value(); JoinColumn[] joinColumns = joinColumnsAnno.value();
assertEquals(2, joinColumns.length); assertEquals( 2, joinColumns.length );
assertEquals("", joinColumns[0].name()); assertEquals( "", joinColumns[0].name() );
assertEquals("", joinColumns[0].referencedColumnName()); assertEquals( "", joinColumns[0].referencedColumnName() );
assertEquals("", joinColumns[0].table()); assertEquals( "", joinColumns[0].table() );
assertEquals("", joinColumns[0].columnDefinition()); assertEquals( "", joinColumns[0].columnDefinition() );
assertTrue(joinColumns[0].insertable()); assertTrue( joinColumns[0].insertable() );
assertTrue(joinColumns[0].updatable()); assertTrue( joinColumns[0].updatable() );
assertTrue(joinColumns[0].nullable()); assertTrue( joinColumns[0].nullable() );
assertFalse(joinColumns[0].unique()); assertFalse( joinColumns[0].unique() );
assertEquals("col1", joinColumns[1].name()); assertEquals( "col1", joinColumns[1].name() );
assertEquals("col2", joinColumns[1].referencedColumnName()); assertEquals( "col2", joinColumns[1].referencedColumnName() );
assertEquals("table1", joinColumns[1].table()); assertEquals( "table1", joinColumns[1].table() );
assertEquals("int", joinColumns[1].columnDefinition()); assertEquals( "int", joinColumns[1].columnDefinition() );
assertFalse(joinColumns[1].insertable()); assertFalse( joinColumns[1].insertable() );
assertFalse(joinColumns[1].updatable()); assertFalse( joinColumns[1].updatable() );
assertFalse(joinColumns[1].nullable()); assertFalse( joinColumns[1].nullable() );
assertTrue(joinColumns[1].unique()); assertTrue( joinColumns[1].unique() );
} }
public void testJoinTableNoChildren() throws Exception { public void testJoinTableNoChildren() throws Exception {
reader = getReader(Entity1.class, "field1", "many-to-one.orm4.xml"); reader = getReader( Entity1.class, "field1", "many-to-one.orm4.xml" );
assertAnnotationPresent(ManyToOne.class); assertAnnotationPresent( ManyToOne.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
assertAnnotationNotPresent(JoinColumns.class); assertAnnotationNotPresent( JoinColumns.class );
assertAnnotationPresent(JoinTable.class); assertAnnotationPresent( JoinTable.class );
JoinTable joinTableAnno = reader.getAnnotation(JoinTable.class); JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
assertEquals("", joinTableAnno.catalog()); assertEquals( "", joinTableAnno.catalog() );
assertEquals("", joinTableAnno.name()); assertEquals( "", joinTableAnno.name() );
assertEquals("", joinTableAnno.schema()); assertEquals( "", joinTableAnno.schema() );
assertEquals(0, joinTableAnno.joinColumns().length); assertEquals( 0, joinTableAnno.joinColumns().length );
assertEquals(0, joinTableAnno.inverseJoinColumns().length); assertEquals( 0, joinTableAnno.inverseJoinColumns().length );
assertEquals(0, joinTableAnno.uniqueConstraints().length); assertEquals( 0, joinTableAnno.uniqueConstraints().length );
} }
public void testJoinTableAllChildren() throws Exception { public void testJoinTableAllChildren() throws Exception {
reader = getReader(Entity1.class, "field1", "many-to-one.orm5.xml"); reader = getReader( Entity1.class, "field1", "many-to-one.orm5.xml" );
assertAnnotationPresent(ManyToOne.class); assertAnnotationPresent( ManyToOne.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
assertAnnotationNotPresent(JoinColumns.class); assertAnnotationNotPresent( JoinColumns.class );
assertAnnotationPresent(JoinTable.class); assertAnnotationPresent( JoinTable.class );
JoinTable joinTableAnno = reader.getAnnotation(JoinTable.class); JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
assertEquals("cat1", joinTableAnno.catalog()); assertEquals( "cat1", joinTableAnno.catalog() );
assertEquals("table1", joinTableAnno.name()); assertEquals( "table1", joinTableAnno.name() );
assertEquals("schema1", joinTableAnno.schema()); assertEquals( "schema1", joinTableAnno.schema() );
// JoinColumns // JoinColumns
JoinColumn[] joinColumns = joinTableAnno.joinColumns(); JoinColumn[] joinColumns = joinTableAnno.joinColumns();
assertEquals(2, joinColumns.length); assertEquals( 2, joinColumns.length );
assertEquals("", joinColumns[0].name()); assertEquals( "", joinColumns[0].name() );
assertEquals("", joinColumns[0].referencedColumnName()); assertEquals( "", joinColumns[0].referencedColumnName() );
assertEquals("", joinColumns[0].table()); assertEquals( "", joinColumns[0].table() );
assertEquals("", joinColumns[0].columnDefinition()); assertEquals( "", joinColumns[0].columnDefinition() );
assertTrue(joinColumns[0].insertable()); assertTrue( joinColumns[0].insertable() );
assertTrue(joinColumns[0].updatable()); assertTrue( joinColumns[0].updatable() );
assertTrue(joinColumns[0].nullable()); assertTrue( joinColumns[0].nullable() );
assertFalse(joinColumns[0].unique()); assertFalse( joinColumns[0].unique() );
assertEquals("col1", joinColumns[1].name()); assertEquals( "col1", joinColumns[1].name() );
assertEquals("col2", joinColumns[1].referencedColumnName()); assertEquals( "col2", joinColumns[1].referencedColumnName() );
assertEquals("table2", joinColumns[1].table()); assertEquals( "table2", joinColumns[1].table() );
assertEquals("int", joinColumns[1].columnDefinition()); assertEquals( "int", joinColumns[1].columnDefinition() );
assertFalse(joinColumns[1].insertable()); assertFalse( joinColumns[1].insertable() );
assertFalse(joinColumns[1].updatable()); assertFalse( joinColumns[1].updatable() );
assertFalse(joinColumns[1].nullable()); assertFalse( joinColumns[1].nullable() );
assertTrue(joinColumns[1].unique()); assertTrue( joinColumns[1].unique() );
//InverseJoinColumns // InverseJoinColumns
JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns(); JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
assertEquals(2, inverseJoinColumns.length); assertEquals( 2, inverseJoinColumns.length );
assertEquals("", inverseJoinColumns[0].name()); assertEquals( "", inverseJoinColumns[0].name() );
assertEquals("", inverseJoinColumns[0].referencedColumnName()); assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
assertEquals("", inverseJoinColumns[0].table()); assertEquals( "", inverseJoinColumns[0].table() );
assertEquals("", inverseJoinColumns[0].columnDefinition()); assertEquals( "", inverseJoinColumns[0].columnDefinition() );
assertTrue(inverseJoinColumns[0].insertable()); assertTrue( inverseJoinColumns[0].insertable() );
assertTrue(inverseJoinColumns[0].updatable()); assertTrue( inverseJoinColumns[0].updatable() );
assertTrue(inverseJoinColumns[0].nullable()); assertTrue( inverseJoinColumns[0].nullable() );
assertFalse(inverseJoinColumns[0].unique()); assertFalse( inverseJoinColumns[0].unique() );
assertEquals("col3", inverseJoinColumns[1].name()); assertEquals( "col3", inverseJoinColumns[1].name() );
assertEquals("col4", inverseJoinColumns[1].referencedColumnName()); assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
assertEquals("table3", inverseJoinColumns[1].table()); assertEquals( "table3", inverseJoinColumns[1].table() );
assertEquals("int", inverseJoinColumns[1].columnDefinition()); assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
assertFalse(inverseJoinColumns[1].insertable()); assertFalse( inverseJoinColumns[1].insertable() );
assertFalse(inverseJoinColumns[1].updatable()); assertFalse( inverseJoinColumns[1].updatable() );
assertFalse(inverseJoinColumns[1].nullable()); assertFalse( inverseJoinColumns[1].nullable() );
assertTrue(inverseJoinColumns[1].unique()); assertTrue( inverseJoinColumns[1].unique() );
//UniqueConstraints // UniqueConstraints
UniqueConstraint[] uniqueConstraints = joinTableAnno.uniqueConstraints(); UniqueConstraint[] uniqueConstraints = joinTableAnno
assertEquals(2, uniqueConstraints.length); .uniqueConstraints();
assertEquals(1, uniqueConstraints[0].columnNames().length); assertEquals( 2, uniqueConstraints.length );
assertEquals("col5", uniqueConstraints[0].columnNames()[0]); assertEquals( 1, uniqueConstraints[0].columnNames().length );
assertEquals(2, uniqueConstraints[1].columnNames().length); assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
assertEquals("col6", uniqueConstraints[1].columnNames()[0]); assertEquals( 2, uniqueConstraints[1].columnNames().length );
assertEquals("col7", uniqueConstraints[1].columnNames()[1]); assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
} }
public void testAllAttributes() throws Exception { public void testAllAttributes() throws Exception {
reader = getReader(Entity1.class, "field1", "many-to-one.orm6.xml"); reader = getReader( Entity1.class, "field1", "many-to-one.orm6.xml" );
assertAnnotationPresent(ManyToOne.class); assertAnnotationPresent( ManyToOne.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
assertAnnotationNotPresent(JoinColumns.class); assertAnnotationNotPresent( JoinColumns.class );
assertAnnotationNotPresent(JoinTable.class); assertAnnotationNotPresent( JoinTable.class );
assertAnnotationPresent(Id.class); assertAnnotationPresent( Id.class );
assertAnnotationPresent(MapsId.class); assertAnnotationPresent( MapsId.class );
assertAnnotationPresent(Access.class); assertAnnotationPresent( Access.class );
ManyToOne relAnno = reader.getAnnotation(ManyToOne.class); ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
assertEquals(0, relAnno.cascade().length); assertEquals( 0, relAnno.cascade().length );
assertEquals(FetchType.LAZY, relAnno.fetch()); assertEquals( FetchType.LAZY, relAnno.fetch() );
assertFalse(relAnno.optional()); assertFalse( relAnno.optional() );
assertEquals(Entity3.class, relAnno.targetEntity()); assertEquals( Entity3.class, relAnno.targetEntity() );
assertEquals("col1", reader.getAnnotation(MapsId.class).value()); assertEquals( "col1", reader.getAnnotation( MapsId.class ).value() );
assertEquals(AccessType.PROPERTY, assertEquals( AccessType.PROPERTY, reader.getAnnotation( Access.class )
reader.getAnnotation(Access.class).value()); .value() );
} }
public void testCascadeAll() throws Exception { public void testCascadeAll() throws Exception {
reader = getReader(Entity1.class, "field1", "many-to-one.orm7.xml"); reader = getReader( Entity1.class, "field1", "many-to-one.orm7.xml" );
assertAnnotationPresent(ManyToOne.class); assertAnnotationPresent( ManyToOne.class );
ManyToOne relAnno = reader.getAnnotation(ManyToOne.class); ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
assertEquals(1, relAnno.cascade().length); assertEquals( 1, relAnno.cascade().length );
assertEquals(CascadeType.ALL, relAnno.cascade()[0]); assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
} }
public void testCascadeSomeWithDefaultPersist() throws Exception { public void testCascadeSomeWithDefaultPersist() throws Exception {
reader = getReader(Entity1.class, "field1", "many-to-one.orm8.xml"); reader = getReader( Entity1.class, "field1", "many-to-one.orm8.xml" );
assertAnnotationPresent(ManyToOne.class); assertAnnotationPresent( ManyToOne.class );
ManyToOne relAnno = reader.getAnnotation(ManyToOne.class); ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
assertEquals(4, relAnno.cascade().length); assertEquals( 4, relAnno.cascade().length );
assertEquals(CascadeType.REMOVE, relAnno.cascade()[0]); assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] );
assertEquals(CascadeType.REFRESH, relAnno.cascade()[1]); assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] );
assertEquals(CascadeType.DETACH, relAnno.cascade()[2]); assertEquals( CascadeType.DETACH, relAnno.cascade()[2] );
assertEquals(CascadeType.PERSIST, relAnno.cascade()[3]); assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] );
} }
/** /**
* Make sure that it doesn't break the handler when {@link CascadeType#ALL} * Make sure that it doesn't break the handler when {@link CascadeType#ALL}
* is specified in addition to a default cascade-persist or individual * is specified in addition to a default cascade-persist or individual
* cascade settings. * cascade settings.
*/ */
public void testCascadeAllPlusMore() throws Exception { public void testCascadeAllPlusMore() throws Exception {
reader = getReader(Entity1.class, "field1", "many-to-one.orm9.xml"); reader = getReader( Entity1.class, "field1", "many-to-one.orm9.xml" );
assertAnnotationPresent(ManyToOne.class); assertAnnotationPresent( ManyToOne.class );
ManyToOne relAnno = reader.getAnnotation(ManyToOne.class); ManyToOne relAnno = reader.getAnnotation( ManyToOne.class );
assertEquals(6, relAnno.cascade().length); assertEquals( 6, relAnno.cascade().length );
assertEquals(CascadeType.ALL, relAnno.cascade()[0]); assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
assertEquals(CascadeType.PERSIST, relAnno.cascade()[1]); assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] );
assertEquals(CascadeType.MERGE, relAnno.cascade()[2]); assertEquals( CascadeType.MERGE, relAnno.cascade()[2] );
assertEquals(CascadeType.REMOVE, relAnno.cascade()[3]); assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] );
assertEquals(CascadeType.REFRESH, relAnno.cascade()[4]); assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] );
assertEquals(CascadeType.DETACH, relAnno.cascade()[5]); assertEquals( CascadeType.DETACH, relAnno.cascade()[5] );
} }
//TODO: tests for merging/overriding //TODO: tests for merging/overriding
} }

800
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/Ejb3XmlOneToManyTest.java
View File

@ -48,474 +48,482 @@
import javax.persistence.UniqueConstraint; import javax.persistence.UniqueConstraint;
public class Ejb3XmlOneToManyTest extends Ejb3XmlTestCase { public class Ejb3XmlOneToManyTest extends Ejb3XmlTestCase {
public void testNoChildren() throws Exception { public void testNoChildren() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm1.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm1.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(OrderBy.class); assertAnnotationNotPresent( OrderBy.class );
assertAnnotationNotPresent(OrderColumn.class); assertAnnotationNotPresent( OrderColumn.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
assertAnnotationNotPresent(JoinTable.class); assertAnnotationNotPresent( JoinTable.class );
assertAnnotationNotPresent(JoinColumns.class); assertAnnotationNotPresent( JoinColumns.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
assertAnnotationNotPresent(Access.class); assertAnnotationNotPresent( Access.class );
OneToMany relAnno = reader.getAnnotation(OneToMany.class);; OneToMany relAnno = reader.getAnnotation( OneToMany.class );
assertEquals(0, relAnno.cascade().length); assertEquals( 0, relAnno.cascade().length );
assertEquals(FetchType.LAZY, relAnno.fetch()); assertEquals( FetchType.LAZY, relAnno.fetch() );
assertEquals("", relAnno.mappedBy()); assertEquals( "", relAnno.mappedBy() );
assertFalse(relAnno.orphanRemoval()); assertFalse( relAnno.orphanRemoval() );
assertEquals(void.class, relAnno.targetEntity()); assertEquals( void.class, relAnno.targetEntity() );
} }
public void testOrderBy() throws Exception { public void testOrderBy() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm2.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm2.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationPresent(OrderBy.class); assertAnnotationPresent( OrderBy.class );
assertAnnotationNotPresent(OrderColumn.class); assertAnnotationNotPresent( OrderColumn.class );
assertEquals("col1 ASC, col2 DESC", reader.getAnnotation(OrderBy.class).value()); assertEquals( "col1 ASC, col2 DESC", reader.getAnnotation( OrderBy.class )
.value() );
} }
public void testOrderColumnNoAttributes() throws Exception { public void testOrderColumnNoAttributes() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm3.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm3.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(OrderBy.class); assertAnnotationNotPresent( OrderBy.class );
assertAnnotationPresent(OrderColumn.class); assertAnnotationPresent( OrderColumn.class );
OrderColumn orderColumnAnno = reader.getAnnotation(OrderColumn.class); OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
assertEquals("", orderColumnAnno.columnDefinition()); assertEquals( "", orderColumnAnno.columnDefinition() );
assertEquals("", orderColumnAnno.name()); assertEquals( "", orderColumnAnno.name() );
assertTrue(orderColumnAnno.insertable()); assertTrue( orderColumnAnno.insertable() );
assertTrue(orderColumnAnno.nullable()); assertTrue( orderColumnAnno.nullable() );
assertTrue(orderColumnAnno.updatable()); assertTrue( orderColumnAnno.updatable() );
} }
public void testOrderColumnAllAttributes() throws Exception { public void testOrderColumnAllAttributes() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm4.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm4.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(OrderBy.class); assertAnnotationNotPresent( OrderBy.class );
assertAnnotationPresent(OrderColumn.class); assertAnnotationPresent( OrderColumn.class );
OrderColumn orderColumnAnno = reader.getAnnotation(OrderColumn.class); OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class );
assertEquals("int", orderColumnAnno.columnDefinition()); assertEquals( "int", orderColumnAnno.columnDefinition() );
assertEquals("col1", orderColumnAnno.name()); assertEquals( "col1", orderColumnAnno.name() );
assertFalse(orderColumnAnno.insertable()); assertFalse( orderColumnAnno.insertable() );
assertFalse(orderColumnAnno.nullable()); assertFalse( orderColumnAnno.nullable() );
assertFalse(orderColumnAnno.updatable()); assertFalse( orderColumnAnno.updatable() );
} }
public void testMapKeyNoAttributes() throws Exception { public void testMapKeyNoAttributes() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm5.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm5.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationPresent(MapKey.class); assertAnnotationPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
assertEquals("", reader.getAnnotation(MapKey.class).name()); assertEquals( "", reader.getAnnotation( MapKey.class ).name() );
} }
public void testMapKeyAllAttributes() throws Exception { public void testMapKeyAllAttributes() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm6.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm6.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationPresent(MapKey.class); assertAnnotationPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
assertEquals("field2", reader.getAnnotation(MapKey.class).name()); assertEquals( "field2", reader.getAnnotation( MapKey.class ).name() );
} }
public void testMapKeyClass() throws Exception { public void testMapKeyClass() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm7.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm7.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationPresent(MapKeyClass.class); assertAnnotationPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
assertEquals(Entity2.class, reader.getAnnotation(MapKeyClass.class).value()); assertEquals( Entity2.class, reader.getAnnotation( MapKeyClass.class )
.value() );
} }
public void testMapKeyTemporal() throws Exception { public void testMapKeyTemporal() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm8.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm8.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationPresent(MapKeyTemporal.class); assertAnnotationPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
assertEquals(TemporalType.DATE, reader.getAnnotation(MapKeyTemporal.class).value()); assertEquals( TemporalType.DATE, reader.getAnnotation(
MapKeyTemporal.class ).value() );
} }
public void testMapKeyEnumerated() throws Exception { public void testMapKeyEnumerated() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm9.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm9.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationPresent(MapKeyEnumerated.class); assertAnnotationPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
assertEquals(EnumType.STRING, reader.getAnnotation(MapKeyEnumerated.class).value()); assertEquals( EnumType.STRING, reader.getAnnotation(
MapKeyEnumerated.class ).value() );
} }
/** /**
* When there's a single map key attribute override, we still wrap it with * When there's a single map key attribute override, we still wrap it with
* an AttributeOverrides annotation. * an AttributeOverrides annotation.
*/ */
public void testSingleMapKeyAttributeOverride() throws Exception { public void testSingleMapKeyAttributeOverride() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm10.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm10.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
assertAnnotationNotPresent(AttributeOverride.class); assertAnnotationNotPresent( AttributeOverride.class );
assertAnnotationPresent(AttributeOverrides.class); assertAnnotationPresent( AttributeOverrides.class );
AttributeOverrides overridesAnno = reader.getAnnotation(AttributeOverrides.class); AttributeOverrides overridesAnno = reader
.getAnnotation( AttributeOverrides.class );
AttributeOverride[] overrides = overridesAnno.value(); AttributeOverride[] overrides = overridesAnno.value();
assertEquals(1, overrides.length); assertEquals( 1, overrides.length );
assertEquals("field1", overrides[0].name()); assertEquals( "field1", overrides[0].name() );
assertEquals("col1", overrides[0].column().name()); assertEquals( "col1", overrides[0].column().name() );
} }
public void testMultipleMapKeyAttributeOverrides() throws Exception { public void testMultipleMapKeyAttributeOverrides() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm11.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm11.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
assertAnnotationNotPresent(AttributeOverride.class); assertAnnotationNotPresent( AttributeOverride.class );
assertAnnotationPresent(AttributeOverrides.class); assertAnnotationPresent( AttributeOverrides.class );
AttributeOverrides overridesAnno = reader.getAnnotation(AttributeOverrides.class); AttributeOverrides overridesAnno = reader
.getAnnotation( AttributeOverrides.class );
AttributeOverride[] overrides = overridesAnno.value(); AttributeOverride[] overrides = overridesAnno.value();
assertEquals(2, overrides.length); assertEquals( 2, overrides.length );
assertEquals("field1", overrides[0].name()); assertEquals( "field1", overrides[0].name() );
assertEquals("", overrides[0].column().name()); assertEquals( "", overrides[0].column().name() );
assertFalse(overrides[0].column().unique()); assertFalse( overrides[0].column().unique() );
assertTrue(overrides[0].column().nullable()); assertTrue( overrides[0].column().nullable() );
assertTrue(overrides[0].column().insertable()); assertTrue( overrides[0].column().insertable() );
assertTrue(overrides[0].column().updatable()); assertTrue( overrides[0].column().updatable() );
assertEquals("", overrides[0].column().columnDefinition()); assertEquals( "", overrides[0].column().columnDefinition() );
assertEquals("", overrides[0].column().table()); assertEquals( "", overrides[0].column().table() );
assertEquals(255, overrides[0].column().length()); assertEquals( 255, overrides[0].column().length() );
assertEquals(0, overrides[0].column().precision()); assertEquals( 0, overrides[0].column().precision() );
assertEquals(0, overrides[0].column().scale()); assertEquals( 0, overrides[0].column().scale() );
assertEquals("field2", overrides[1].name()); assertEquals( "field2", overrides[1].name() );
assertEquals("col1", overrides[1].column().name()); assertEquals( "col1", overrides[1].column().name() );
assertTrue(overrides[1].column().unique()); assertTrue( overrides[1].column().unique() );
assertFalse(overrides[1].column().nullable()); assertFalse( overrides[1].column().nullable() );
assertFalse(overrides[1].column().insertable()); assertFalse( overrides[1].column().insertable() );
assertFalse(overrides[1].column().updatable()); assertFalse( overrides[1].column().updatable() );
assertEquals("int", overrides[1].column().columnDefinition()); assertEquals( "int", overrides[1].column().columnDefinition() );
assertEquals("table1", overrides[1].column().table()); assertEquals( "table1", overrides[1].column().table() );
assertEquals(50, overrides[1].column().length()); assertEquals( 50, overrides[1].column().length() );
assertEquals(2, overrides[1].column().precision()); assertEquals( 2, overrides[1].column().precision() );
assertEquals(1, overrides[1].column().scale()); assertEquals( 1, overrides[1].column().scale() );
} }
public void testMapKeyColumnNoAttributes() throws Exception { public void testMapKeyColumnNoAttributes() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm12.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm12.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationPresent(MapKeyColumn.class); assertAnnotationPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
MapKeyColumn keyColAnno = reader.getAnnotation(MapKeyColumn.class); MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
assertEquals("", keyColAnno.columnDefinition()); assertEquals( "", keyColAnno.columnDefinition() );
assertEquals("", keyColAnno.name()); assertEquals( "", keyColAnno.name() );
assertEquals("", keyColAnno.table()); assertEquals( "", keyColAnno.table() );
assertFalse(keyColAnno.nullable()); assertFalse( keyColAnno.nullable() );
assertTrue(keyColAnno.insertable()); assertTrue( keyColAnno.insertable() );
assertFalse(keyColAnno.unique()); assertFalse( keyColAnno.unique() );
assertTrue(keyColAnno.updatable()); assertTrue( keyColAnno.updatable() );
assertEquals(255, keyColAnno.length()); assertEquals( 255, keyColAnno.length() );
assertEquals(0, keyColAnno.precision()); assertEquals( 0, keyColAnno.precision() );
assertEquals(0, keyColAnno.scale()); assertEquals( 0, keyColAnno.scale() );
} }
public void testMapKeyColumnAllAttributes() throws Exception { public void testMapKeyColumnAllAttributes() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm13.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm13.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationPresent(MapKeyColumn.class); assertAnnotationPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
MapKeyColumn keyColAnno = reader.getAnnotation(MapKeyColumn.class); MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class );
assertEquals("int", keyColAnno.columnDefinition()); assertEquals( "int", keyColAnno.columnDefinition() );
assertEquals("col1", keyColAnno.name()); assertEquals( "col1", keyColAnno.name() );
assertEquals("table1", keyColAnno.table()); assertEquals( "table1", keyColAnno.table() );
assertTrue(keyColAnno.nullable()); assertTrue( keyColAnno.nullable() );
assertFalse(keyColAnno.insertable()); assertFalse( keyColAnno.insertable() );
assertTrue(keyColAnno.unique()); assertTrue( keyColAnno.unique() );
assertFalse(keyColAnno.updatable()); assertFalse( keyColAnno.updatable() );
assertEquals(50, keyColAnno.length()); assertEquals( 50, keyColAnno.length() );
assertEquals(2, keyColAnno.precision()); assertEquals( 2, keyColAnno.precision() );
assertEquals(1, keyColAnno.scale()); assertEquals( 1, keyColAnno.scale() );
} }
/** /**
* When there's a single map key join column, we still wrap it with a * When there's a single map key join column, we still wrap it with a
* MapKeyJoinColumns annotation. * MapKeyJoinColumns annotation.
*/ */
public void testSingleMapKeyJoinColumn() throws Exception { public void testSingleMapKeyJoinColumn() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm14.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm14.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationPresent(MapKeyJoinColumns.class); assertAnnotationPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
MapKeyJoinColumns joinColumnsAnno = reader.getAnnotation(MapKeyJoinColumns.class); MapKeyJoinColumns joinColumnsAnno = reader
.getAnnotation( MapKeyJoinColumns.class );
MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value(); MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
assertEquals(1, joinColumns.length); assertEquals( 1, joinColumns.length );
assertEquals("col1", joinColumns[0].name()); assertEquals( "col1", joinColumns[0].name() );
} }
public void testMultipleMapKeyJoinColumns() throws Exception { public void testMultipleMapKeyJoinColumns() throws Exception {
reader = getReader(Entity3.class, "field1", "one-to-many.orm15.xml"); reader = getReader( Entity3.class, "field1", "one-to-many.orm15.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationPresent(MapKeyJoinColumns.class); assertAnnotationPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
MapKeyJoinColumns joinColumnsAnno = reader.getAnnotation(MapKeyJoinColumns.class); MapKeyJoinColumns joinColumnsAnno = reader
.getAnnotation( MapKeyJoinColumns.class );
MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value(); MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value();
assertEquals(2, joinColumns.length); assertEquals( 2, joinColumns.length );
assertEquals("", joinColumns[0].name()); assertEquals( "", joinColumns[0].name() );
assertEquals("", joinColumns[0].referencedColumnName()); assertEquals( "", joinColumns[0].referencedColumnName() );
assertFalse(joinColumns[0].unique()); assertFalse( joinColumns[0].unique() );
assertFalse(joinColumns[0].nullable()); assertFalse( joinColumns[0].nullable() );
assertTrue(joinColumns[0].insertable()); assertTrue( joinColumns[0].insertable() );
assertTrue(joinColumns[0].updatable()); assertTrue( joinColumns[0].updatable() );
assertEquals("", joinColumns[0].columnDefinition()); assertEquals( "", joinColumns[0].columnDefinition() );
assertEquals("", joinColumns[0].table()); assertEquals( "", joinColumns[0].table() );
assertEquals("col1", joinColumns[1].name()); assertEquals( "col1", joinColumns[1].name() );
assertEquals("col2", joinColumns[1].referencedColumnName()); assertEquals( "col2", joinColumns[1].referencedColumnName() );
assertTrue(joinColumns[1].unique()); assertTrue( joinColumns[1].unique() );
assertTrue(joinColumns[1].nullable()); assertTrue( joinColumns[1].nullable() );
assertFalse(joinColumns[1].insertable()); assertFalse( joinColumns[1].insertable() );
assertFalse(joinColumns[1].updatable()); assertFalse( joinColumns[1].updatable() );
assertEquals("int", joinColumns[1].columnDefinition()); assertEquals( "int", joinColumns[1].columnDefinition() );
assertEquals("table1", joinColumns[1].table()); assertEquals( "table1", joinColumns[1].table() );
} }
public void testJoinTableNoChildren() throws Exception { public void testJoinTableNoChildren() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm16.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm16.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationPresent(JoinTable.class); assertAnnotationPresent( JoinTable.class );
assertAnnotationNotPresent(JoinColumns.class); assertAnnotationNotPresent( JoinColumns.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
JoinTable joinTableAnno = reader.getAnnotation(JoinTable.class); JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
assertEquals("", joinTableAnno.catalog()); assertEquals( "", joinTableAnno.catalog() );
assertEquals("", joinTableAnno.name()); assertEquals( "", joinTableAnno.name() );
assertEquals("", joinTableAnno.schema()); assertEquals( "", joinTableAnno.schema() );
assertEquals(0, joinTableAnno.joinColumns().length); assertEquals( 0, joinTableAnno.joinColumns().length );
assertEquals(0, joinTableAnno.inverseJoinColumns().length); assertEquals( 0, joinTableAnno.inverseJoinColumns().length );
assertEquals(0, joinTableAnno.uniqueConstraints().length); assertEquals( 0, joinTableAnno.uniqueConstraints().length );
} }
public void testJoinTableAllChildren() throws Exception { public void testJoinTableAllChildren() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm17.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm17.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationPresent(JoinTable.class); assertAnnotationPresent( JoinTable.class );
assertAnnotationNotPresent(JoinColumns.class); assertAnnotationNotPresent( JoinColumns.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
JoinTable joinTableAnno = reader.getAnnotation(JoinTable.class); JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class );
assertEquals("cat1", joinTableAnno.catalog()); assertEquals( "cat1", joinTableAnno.catalog() );
assertEquals("table1", joinTableAnno.name()); assertEquals( "table1", joinTableAnno.name() );
assertEquals("schema1", joinTableAnno.schema()); assertEquals( "schema1", joinTableAnno.schema() );
// JoinColumns // JoinColumns
JoinColumn[] joinColumns = joinTableAnno.joinColumns(); JoinColumn[] joinColumns = joinTableAnno.joinColumns();
assertEquals(2, joinColumns.length); assertEquals( 2, joinColumns.length );
assertEquals("", joinColumns[0].name()); assertEquals( "", joinColumns[0].name() );
assertEquals("", joinColumns[0].referencedColumnName()); assertEquals( "", joinColumns[0].referencedColumnName() );
assertEquals("", joinColumns[0].table()); assertEquals( "", joinColumns[0].table() );
assertEquals("", joinColumns[0].columnDefinition()); assertEquals( "", joinColumns[0].columnDefinition() );
assertTrue(joinColumns[0].insertable()); assertTrue( joinColumns[0].insertable() );
assertTrue(joinColumns[0].updatable()); assertTrue( joinColumns[0].updatable() );
assertTrue(joinColumns[0].nullable()); assertTrue( joinColumns[0].nullable() );
assertFalse(joinColumns[0].unique()); assertFalse( joinColumns[0].unique() );
assertEquals("col1", joinColumns[1].name()); assertEquals( "col1", joinColumns[1].name() );
assertEquals("col2", joinColumns[1].referencedColumnName()); assertEquals( "col2", joinColumns[1].referencedColumnName() );
assertEquals("table2", joinColumns[1].table()); assertEquals( "table2", joinColumns[1].table() );
assertEquals("int", joinColumns[1].columnDefinition()); assertEquals( "int", joinColumns[1].columnDefinition() );
assertFalse(joinColumns[1].insertable()); assertFalse( joinColumns[1].insertable() );
assertFalse(joinColumns[1].updatable()); assertFalse( joinColumns[1].updatable() );
assertFalse(joinColumns[1].nullable()); assertFalse( joinColumns[1].nullable() );
assertTrue(joinColumns[1].unique()); assertTrue( joinColumns[1].unique() );
//InverseJoinColumns // InverseJoinColumns
JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns(); JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns();
assertEquals(2, inverseJoinColumns.length); assertEquals( 2, inverseJoinColumns.length );
assertEquals("", inverseJoinColumns[0].name()); assertEquals( "", inverseJoinColumns[0].name() );
assertEquals("", inverseJoinColumns[0].referencedColumnName()); assertEquals( "", inverseJoinColumns[0].referencedColumnName() );
assertEquals("", inverseJoinColumns[0].table()); assertEquals( "", inverseJoinColumns[0].table() );
assertEquals("", inverseJoinColumns[0].columnDefinition()); assertEquals( "", inverseJoinColumns[0].columnDefinition() );
assertTrue(inverseJoinColumns[0].insertable()); assertTrue( inverseJoinColumns[0].insertable() );
assertTrue(inverseJoinColumns[0].updatable()); assertTrue( inverseJoinColumns[0].updatable() );
assertTrue(inverseJoinColumns[0].nullable()); assertTrue( inverseJoinColumns[0].nullable() );
assertFalse(inverseJoinColumns[0].unique()); assertFalse( inverseJoinColumns[0].unique() );
assertEquals("col3", inverseJoinColumns[1].name()); assertEquals( "col3", inverseJoinColumns[1].name() );
assertEquals("col4", inverseJoinColumns[1].referencedColumnName()); assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() );
assertEquals("table3", inverseJoinColumns[1].table()); assertEquals( "table3", inverseJoinColumns[1].table() );
assertEquals("int", inverseJoinColumns[1].columnDefinition()); assertEquals( "int", inverseJoinColumns[1].columnDefinition() );
assertFalse(inverseJoinColumns[1].insertable()); assertFalse( inverseJoinColumns[1].insertable() );
assertFalse(inverseJoinColumns[1].updatable()); assertFalse( inverseJoinColumns[1].updatable() );
assertFalse(inverseJoinColumns[1].nullable()); assertFalse( inverseJoinColumns[1].nullable() );
assertTrue(inverseJoinColumns[1].unique()); assertTrue( inverseJoinColumns[1].unique() );
//UniqueConstraints // UniqueConstraints
UniqueConstraint[] uniqueConstraints = joinTableAnno.uniqueConstraints(); UniqueConstraint[] uniqueConstraints = joinTableAnno
assertEquals(2, uniqueConstraints.length); .uniqueConstraints();
assertEquals(1, uniqueConstraints[0].columnNames().length); assertEquals( 2, uniqueConstraints.length );
assertEquals("col5", uniqueConstraints[0].columnNames()[0]); assertEquals( 1, uniqueConstraints[0].columnNames().length );
assertEquals(2, uniqueConstraints[1].columnNames().length); assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
assertEquals("col6", uniqueConstraints[1].columnNames()[0]); assertEquals( 2, uniqueConstraints[1].columnNames().length );
assertEquals("col7", uniqueConstraints[1].columnNames()[1]); 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 * When there's a single join column, we still wrap it with a JoinColumns
* annotation. * annotation.
*/ */
public void testSingleJoinColumn() throws Exception { public void testSingleJoinColumn() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm18.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm18.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
assertAnnotationPresent(JoinColumns.class); assertAnnotationPresent( JoinColumns.class );
assertAnnotationNotPresent(JoinTable.class); assertAnnotationNotPresent( JoinTable.class );
JoinColumns joinColumnsAnno = reader.getAnnotation(JoinColumns.class); JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
JoinColumn[] joinColumns = joinColumnsAnno.value(); JoinColumn[] joinColumns = joinColumnsAnno.value();
assertEquals(1, joinColumns.length); assertEquals( 1, joinColumns.length );
assertEquals("col1", joinColumns[0].name()); assertEquals( "col1", joinColumns[0].name() );
assertEquals("col2", joinColumns[0].referencedColumnName()); assertEquals( "col2", joinColumns[0].referencedColumnName() );
assertEquals("table1", joinColumns[0].table()); assertEquals( "table1", joinColumns[0].table() );
} }
public void testMultipleJoinColumns() throws Exception { public void testMultipleJoinColumns() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm19.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm19.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
assertAnnotationPresent(JoinColumns.class); assertAnnotationPresent( JoinColumns.class );
assertAnnotationNotPresent(JoinTable.class); assertAnnotationNotPresent( JoinTable.class );
JoinColumns joinColumnsAnno = reader.getAnnotation(JoinColumns.class); JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class );
JoinColumn[] joinColumns = joinColumnsAnno.value(); JoinColumn[] joinColumns = joinColumnsAnno.value();
assertEquals(2, joinColumns.length); assertEquals( 2, joinColumns.length );
assertEquals("", joinColumns[0].name()); assertEquals( "", joinColumns[0].name() );
assertEquals("", joinColumns[0].referencedColumnName()); assertEquals( "", joinColumns[0].referencedColumnName() );
assertEquals("", joinColumns[0].table()); assertEquals( "", joinColumns[0].table() );
assertEquals("", joinColumns[0].columnDefinition()); assertEquals( "", joinColumns[0].columnDefinition() );
assertTrue(joinColumns[0].insertable()); assertTrue( joinColumns[0].insertable() );
assertTrue(joinColumns[0].updatable()); assertTrue( joinColumns[0].updatable() );
assertTrue(joinColumns[0].nullable()); assertTrue( joinColumns[0].nullable() );
assertFalse(joinColumns[0].unique()); assertFalse( joinColumns[0].unique() );
assertEquals("col1", joinColumns[1].name()); assertEquals( "col1", joinColumns[1].name() );
assertEquals("col2", joinColumns[1].referencedColumnName()); assertEquals( "col2", joinColumns[1].referencedColumnName() );
assertEquals("table1", joinColumns[1].table()); assertEquals( "table1", joinColumns[1].table() );
assertEquals("int", joinColumns[1].columnDefinition()); assertEquals( "int", joinColumns[1].columnDefinition() );
assertFalse(joinColumns[1].insertable()); assertFalse( joinColumns[1].insertable() );
assertFalse(joinColumns[1].updatable()); assertFalse( joinColumns[1].updatable() );
assertFalse(joinColumns[1].nullable()); assertFalse( joinColumns[1].nullable() );
assertTrue(joinColumns[1].unique()); assertTrue( joinColumns[1].unique() );
} }
public void testCascadeAll() throws Exception { public void testCascadeAll() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm20.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm20.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
OneToMany relAnno = reader.getAnnotation(OneToMany.class); OneToMany relAnno = reader.getAnnotation( OneToMany.class );
assertEquals(1, relAnno.cascade().length); assertEquals( 1, relAnno.cascade().length );
assertEquals(CascadeType.ALL, relAnno.cascade()[0]); assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
} }
public void testCascadeSomeWithDefaultPersist() throws Exception { public void testCascadeSomeWithDefaultPersist() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm21.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm21.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
OneToMany relAnno = reader.getAnnotation(OneToMany.class); OneToMany relAnno = reader.getAnnotation( OneToMany.class );
assertEquals(4, relAnno.cascade().length); assertEquals( 4, relAnno.cascade().length );
assertEquals(CascadeType.REMOVE, relAnno.cascade()[0]); assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] );
assertEquals(CascadeType.REFRESH, relAnno.cascade()[1]); assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] );
assertEquals(CascadeType.DETACH, relAnno.cascade()[2]); assertEquals( CascadeType.DETACH, relAnno.cascade()[2] );
assertEquals(CascadeType.PERSIST, relAnno.cascade()[3]); assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] );
} }
/** /**
* Make sure that it doesn't break the handler when {@link CascadeType#ALL} * Make sure that it doesn't break the handler when {@link CascadeType#ALL}
* is specified in addition to a default cascade-persist or individual * is specified in addition to a default cascade-persist or individual
* cascade settings. * cascade settings.
*/ */
public void testCascadeAllPlusMore() throws Exception { public void testCascadeAllPlusMore() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm22.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm22.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
OneToMany relAnno = reader.getAnnotation(OneToMany.class); OneToMany relAnno = reader.getAnnotation( OneToMany.class );
assertEquals(6, relAnno.cascade().length); assertEquals( 6, relAnno.cascade().length );
assertEquals(CascadeType.ALL, relAnno.cascade()[0]); assertEquals( CascadeType.ALL, relAnno.cascade()[0] );
assertEquals(CascadeType.PERSIST, relAnno.cascade()[1]); assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] );
assertEquals(CascadeType.MERGE, relAnno.cascade()[2]); assertEquals( CascadeType.MERGE, relAnno.cascade()[2] );
assertEquals(CascadeType.REMOVE, relAnno.cascade()[3]); assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] );
assertEquals(CascadeType.REFRESH, relAnno.cascade()[4]); assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] );
assertEquals(CascadeType.DETACH, relAnno.cascade()[5]); assertEquals( CascadeType.DETACH, relAnno.cascade()[5] );
} }
public void testAllAttributes() throws Exception { public void testAllAttributes() throws Exception {
reader = getReader(Entity2.class, "field1", "one-to-many.orm23.xml"); reader = getReader( Entity2.class, "field1", "one-to-many.orm23.xml" );
assertAnnotationPresent(OneToMany.class); assertAnnotationPresent( OneToMany.class );
assertAnnotationNotPresent(OrderBy.class); assertAnnotationNotPresent( OrderBy.class );
assertAnnotationNotPresent(OrderColumn.class); assertAnnotationNotPresent( OrderColumn.class );
assertAnnotationNotPresent(MapKey.class); assertAnnotationNotPresent( MapKey.class );
assertAnnotationNotPresent(MapKeyClass.class); assertAnnotationNotPresent( MapKeyClass.class );
assertAnnotationNotPresent(MapKeyTemporal.class); assertAnnotationNotPresent( MapKeyTemporal.class );
assertAnnotationNotPresent(MapKeyEnumerated.class); assertAnnotationNotPresent( MapKeyEnumerated.class );
assertAnnotationNotPresent(MapKeyColumn.class); assertAnnotationNotPresent( MapKeyColumn.class );
assertAnnotationNotPresent(MapKeyJoinColumns.class); assertAnnotationNotPresent( MapKeyJoinColumns.class );
assertAnnotationNotPresent(MapKeyJoinColumn.class); assertAnnotationNotPresent( MapKeyJoinColumn.class );
assertAnnotationNotPresent(JoinTable.class); assertAnnotationNotPresent( JoinTable.class );
assertAnnotationNotPresent(JoinColumns.class); assertAnnotationNotPresent( JoinColumns.class );
assertAnnotationNotPresent(JoinColumn.class); assertAnnotationNotPresent( JoinColumn.class );
assertAnnotationPresent(Access.class); assertAnnotationPresent( Access.class );
OneToMany relAnno = reader.getAnnotation(OneToMany.class);; OneToMany relAnno = reader.getAnnotation( OneToMany.class );
assertEquals(0, relAnno.cascade().length); assertEquals( 0, relAnno.cascade().length );
assertEquals(FetchType.EAGER, relAnno.fetch()); assertEquals( FetchType.EAGER, relAnno.fetch() );
assertEquals("field2", relAnno.mappedBy()); assertEquals( "field2", relAnno.mappedBy() );
assertTrue(relAnno.orphanRemoval()); assertTrue( relAnno.orphanRemoval() );
assertEquals(Entity3.class, relAnno.targetEntity()); assertEquals( Entity3.class, relAnno.targetEntity() );
assertEquals(AccessType.PROPERTY, assertEquals( AccessType.PROPERTY, reader.getAnnotation( Access.class )
reader.getAnnotation(Access.class).value()); .value() );
} }
//TODO: tests for merging/overriding //TODO: tests for merging/overriding
} }

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

@ -36,39 +36,40 @@
abstract class Ejb3XmlTestCase extends TestCase { abstract class Ejb3XmlTestCase extends TestCase {
protected JPAOverridenAnnotationReader reader; protected JPAOverridenAnnotationReader reader;
protected void assertAnnotationPresent(Class<? extends Annotation> annotationType) { protected void assertAnnotationPresent(Class<? extends Annotation> annotationType) {
assertTrue(reader.isAnnotationPresent(annotationType)); assertTrue( reader.isAnnotationPresent( annotationType ) );
} }
protected void assertAnnotationNotPresent(Class<? extends Annotation> annotationType) { protected void assertAnnotationNotPresent(Class<? extends Annotation> annotationType) {
assertFalse(reader.isAnnotationPresent(annotationType)); assertFalse( reader.isAnnotationPresent( annotationType ) );
} }
protected JPAOverridenAnnotationReader getReader(Class<?> entityClass, String fieldName, String ormResourceName) throws Exception { protected JPAOverridenAnnotationReader getReader(Class<?> entityClass, String fieldName, String ormResourceName)
AnnotatedElement el = getAnnotatedElement(entityClass, fieldName); throws Exception {
XMLContext xmlContext = getContext(ormResourceName); AnnotatedElement el = getAnnotatedElement( entityClass, fieldName );
JPAOverridenAnnotationReader reader = new JPAOverridenAnnotationReader(el, xmlContext); XMLContext xmlContext = getContext( ormResourceName );
JPAOverridenAnnotationReader reader = new JPAOverridenAnnotationReader( el, xmlContext );
return reader; return reader;
} }
protected AnnotatedElement getAnnotatedElement(Class<?> entityClass, String fieldName) throws Exception { protected AnnotatedElement getAnnotatedElement(Class<?> entityClass, String fieldName) throws Exception {
return entityClass.getDeclaredField(fieldName); return entityClass.getDeclaredField( fieldName );
} }
protected XMLContext getContext(String resourceName) throws Exception { protected XMLContext getContext(String resourceName) throws Exception {
InputStream is = getClass().getResourceAsStream(resourceName); InputStream is = getClass().getResourceAsStream( resourceName );
assertNotNull("Could not load resource " + resourceName, is); assertNotNull( "Could not load resource " + resourceName, is );
return getContext(is); return getContext( is );
} }
protected XMLContext getContext(InputStream is) throws Exception { protected XMLContext getContext(InputStream is) throws Exception {
XMLContext xmlContext = new XMLContext(); XMLContext xmlContext = new XMLContext();
Document doc = new SAXReader().read(is); Document doc = new SAXReader().read( is );
xmlContext.addDocument(doc); xmlContext.addDocument( doc );
return xmlContext; return xmlContext;
} }
@Override @Override
protected Class<?>[] getAnnotatedClasses() { protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[0]; return new Class<?>[0];

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm1.xml
View File

@ -28,12 +28,12 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1"> <entity class="Entity1">
<attributes> <attributes>
<many-to-one name="field1" /> <many-to-one name="field1"/>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm2.xml
View File

@ -28,15 +28,15 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1"> <entity class="Entity1">
<attributes> <attributes>
<many-to-one name="field1"> <many-to-one name="field1">
<join-column name="col1" referenced-column-name="col2" <join-column name="col1" referenced-column-name="col2"
table="table1" /> table="table1"/>
</many-to-one> </many-to-one>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

8
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm3.xml
View File

@ -28,17 +28,17 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1"> <entity class="Entity1">
<attributes> <attributes>
<many-to-one name="field1"> <many-to-one name="field1">
<join-column /> <join-column/>
<join-column name="col1" referenced-column-name="col2" <join-column name="col1" referenced-column-name="col2"
table="table1" insertable="false" updatable="false" table="table1" insertable="false" updatable="false"
column-definition="int" nullable="false" unique="true" /> column-definition="int" nullable="false" unique="true"/>
</many-to-one> </many-to-one>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm4.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1"> <entity class="Entity1">
<attributes> <attributes>
<many-to-one name="field1"> <many-to-one name="field1">
<join-table /> <join-table/>
</many-to-one> </many-to-one>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

12
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm5.xml
View File

@ -28,21 +28,21 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1"> <entity class="Entity1">
<attributes> <attributes>
<many-to-one name="field1"> <many-to-one name="field1">
<join-table name="table1" catalog="cat1" schema="schema1"> <join-table name="table1" catalog="cat1" schema="schema1">
<join-column /> <join-column/>
<join-column name="col1" referenced-column-name="col2" <join-column name="col1" referenced-column-name="col2"
table="table2" column-definition="int" insertable="false" table="table2" column-definition="int" insertable="false"
updatable="false" nullable="false" unique="true" /> updatable="false" nullable="false" unique="true"/>
<inverse-join-column /> <inverse-join-column/>
<inverse-join-column name="col3" <inverse-join-column name="col3"
referenced-column-name="col4" table="table3" column-definition="int" referenced-column-name="col4" table="table3" column-definition="int"
insertable="false" updatable="false" nullable="false" unique="true" /> insertable="false" updatable="false" nullable="false" unique="true"/>
<unique-constraint> <unique-constraint>
<column-name>col5</column-name> <column-name>col5</column-name>
</unique-constraint> </unique-constraint>
@ -54,4 +54,4 @@
</many-to-one> </many-to-one>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm6.xml
View File

@ -28,13 +28,13 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1"> <entity class="Entity1">
<attributes> <attributes>
<many-to-one name="field1" target-entity="Entity3" fetch="LAZY" <many-to-one name="field1" target-entity="Entity3" fetch="LAZY"
optional="false" access="PROPERTY" maps-id="col1" id="true" /> optional="false" access="PROPERTY" maps-id="col1" id="true"/>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm7.xml
View File

@ -28,16 +28,16 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1"> <entity class="Entity1">
<attributes> <attributes>
<many-to-one name="field1"> <many-to-one name="field1">
<cascade> <cascade>
<cascade-all /> <cascade-all/>
</cascade> </cascade>
</many-to-one> </many-to-one>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

12
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm8.xml
View File

@ -28,9 +28,9 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
<persistence-unit-defaults> <persistence-unit-defaults>
<cascade-persist /> <cascade-persist/>
</persistence-unit-defaults> </persistence-unit-defaults>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
@ -38,11 +38,11 @@
<attributes> <attributes>
<many-to-one name="field1"> <many-to-one name="field1">
<cascade> <cascade>
<cascade-remove /> <cascade-remove/>
<cascade-refresh /> <cascade-refresh/>
<cascade-detach /> <cascade-detach/>
</cascade> </cascade>
</many-to-one> </many-to-one>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

18
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm9.xml
View File

@ -28,9 +28,9 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
<persistence-unit-defaults> <persistence-unit-defaults>
<cascade-persist /> <cascade-persist/>
</persistence-unit-defaults> </persistence-unit-defaults>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
@ -38,14 +38,14 @@
<attributes> <attributes>
<many-to-one name="field1"> <many-to-one name="field1">
<cascade> <cascade>
<cascade-all /> <cascade-all/>
<cascade-persist /> <cascade-persist/>
<cascade-merge /> <cascade-merge/>
<cascade-remove /> <cascade-remove/>
<cascade-refresh /> <cascade-refresh/>
<cascade-detach /> <cascade-detach/>
</cascade> </cascade>
</many-to-one> </many-to-one>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm1.xml
View File

@ -28,12 +28,12 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2"> <entity class="Entity2">
<attributes> <attributes>
<one-to-many name="field1" /> <one-to-many name="field1"/>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm10.xml
View File

@ -28,16 +28,16 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<map-key-attribute-override name="field1"> <map-key-attribute-override name="field1">
<column name="col1" /> <column name="col1"/>
</map-key-attribute-override> </map-key-attribute-override>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

8
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm11.xml
View File

@ -28,21 +28,21 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<map-key-attribute-override name="field1"> <map-key-attribute-override name="field1">
<column /> <column/>
</map-key-attribute-override> </map-key-attribute-override>
<map-key-attribute-override name="field2"> <map-key-attribute-override name="field2">
<column name="col1" column-definition="int" insertable="false" <column name="col1" column-definition="int" insertable="false"
nullable="false" length="50" precision="2" scale="1" table="table1" nullable="false" length="50" precision="2" scale="1" table="table1"
unique="true" updatable="false" /> unique="true" updatable="false"/>
</map-key-attribute-override> </map-key-attribute-override>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm12.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<map-key-column /> <map-key-column/>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm13.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
@ -36,8 +36,8 @@
<one-to-many name="field1"> <one-to-many name="field1">
<map-key-column column-definition="int" insertable="false" <map-key-column column-definition="int" insertable="false"
length="50" name="col1" nullable="true" precision="2" scale="1" length="50" name="col1" nullable="true" precision="2" scale="1"
table="table1" unique="true" updatable="false" /> table="table1" unique="true" updatable="false"/>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

4
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm14.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
@ -38,4 +38,4 @@
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

8
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm15.xml
View File

@ -28,18 +28,18 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<map-key-join-column /> <map-key-join-column/>
<map-key-join-column name="col1" <map-key-join-column name="col1"
column-definition="int" insertable="false" nullable="true" column-definition="int" insertable="false" nullable="true"
referenced-column-name="col2" table="table1" unique="true" referenced-column-name="col2" table="table1" unique="true"
updatable="false" /> updatable="false"/>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

4
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm16.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2"> <entity class="Entity2">
@ -38,4 +38,4 @@
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

12
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm17.xml
View File

@ -28,21 +28,21 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2"> <entity class="Entity2">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<join-table name="table1" catalog="cat1" schema="schema1"> <join-table name="table1" catalog="cat1" schema="schema1">
<join-column /> <join-column/>
<join-column name="col1" referenced-column-name="col2" <join-column name="col1" referenced-column-name="col2"
table="table2" column-definition="int" insertable="false" table="table2" column-definition="int" insertable="false"
updatable="false" nullable="false" unique="true" /> updatable="false" nullable="false" unique="true"/>
<inverse-join-column /> <inverse-join-column/>
<inverse-join-column name="col3" <inverse-join-column name="col3"
referenced-column-name="col4" table="table3" column-definition="int" referenced-column-name="col4" table="table3" column-definition="int"
insertable="false" updatable="false" nullable="false" unique="true" /> insertable="false" updatable="false" nullable="false" unique="true"/>
<unique-constraint> <unique-constraint>
<column-name>col5</column-name> <column-name>col5</column-name>
</unique-constraint> </unique-constraint>
@ -54,4 +54,4 @@
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm18.xml
View File

@ -28,15 +28,15 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2"> <entity class="Entity2">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<join-column name="col1" referenced-column-name="col2" <join-column name="col1" referenced-column-name="col2"
table="table1" /> table="table1"/>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

8
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm19.xml
View File

@ -28,17 +28,17 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2"> <entity class="Entity2">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<join-column /> <join-column/>
<join-column name="col1" referenced-column-name="col2" <join-column name="col1" referenced-column-name="col2"
table="table1" insertable="false" updatable="false" table="table1" insertable="false" updatable="false"
column-definition="int" nullable="false" unique="true" /> column-definition="int" nullable="false" unique="true"/>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

4
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm2.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2"> <entity class="Entity2">
@ -38,4 +38,4 @@
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm20.xml
View File

@ -23,16 +23,16 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2"> <entity class="Entity2">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<cascade> <cascade>
<cascade-all /> <cascade-all/>
</cascade> </cascade>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

12
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm21.xml
View File

@ -23,9 +23,9 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
<persistence-unit-defaults> <persistence-unit-defaults>
<cascade-persist /> <cascade-persist/>
</persistence-unit-defaults> </persistence-unit-defaults>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
@ -33,11 +33,11 @@
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<cascade> <cascade>
<cascade-remove /> <cascade-remove/>
<cascade-refresh /> <cascade-refresh/>
<cascade-detach /> <cascade-detach/>
</cascade> </cascade>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

18
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm22.xml
View File

@ -23,9 +23,9 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
<persistence-unit-defaults> <persistence-unit-defaults>
<cascade-persist /> <cascade-persist/>
</persistence-unit-defaults> </persistence-unit-defaults>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
@ -33,14 +33,14 @@
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<cascade> <cascade>
<cascade-all /> <cascade-all/>
<cascade-persist /> <cascade-persist/>
<cascade-merge /> <cascade-merge/>
<cascade-remove /> <cascade-remove/>
<cascade-refresh /> <cascade-refresh/>
<cascade-detach /> <cascade-detach/>
</cascade> </cascade>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm23.xml
View File

@ -23,13 +23,13 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2"> <entity class="Entity2">
<attributes> <attributes>
<one-to-many name="field1" access="PROPERTY" fetch="EAGER" <one-to-many name="field1" access="PROPERTY" fetch="EAGER"
mapped-by="field2" orphan-removal="true" target-entity="Entity3" /> mapped-by="field2" orphan-removal="true" target-entity="Entity3"/>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm3.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2"> <entity class="Entity2">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<order-column /> <order-column/>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm4.xml
View File

@ -28,15 +28,15 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2"> <entity class="Entity2">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<order-column column-definition="int" name="col1" <order-column column-definition="int" name="col1"
insertable="false" nullable="false" updatable="false" /> insertable="false" nullable="false" updatable="false"/>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm5.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<map-key /> <map-key/>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm6.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<map-key name="field2" /> <map-key name="field2"/>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm7.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
<attributes> <attributes>
<one-to-many name="field1"> <one-to-many name="field1">
<map-key-class class="Entity2" /> <map-key-class class="Entity2"/>
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

4
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm8.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
@ -38,4 +38,4 @@
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>

4
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm9.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0"> version="2.0">
<persistence-unit-metadata> <persistence-unit-metadata>
<xml-mapping-metadata-complete /> <xml-mapping-metadata-complete/>
</persistence-unit-metadata> </persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package> <package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3"> <entity class="Entity3">
@ -38,4 +38,4 @@
</one-to-many> </one-to-many>
</attributes> </attributes>
</entity> </entity>
</entity-mappings> </entity-mappings>