Attachment #151264 for bug #266912

This Bugzilla instance is deprecated, and most Eclipse projects now use GitHub or Eclipse GitLab. Please see the deprecation plan for details.

View | Details | Raw Unified | Return to bug 266912 | Differences between

and this patch

Collapse All | Expand All

Lines 28-34 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/ManyToManyMapping.java (-1 / +29 lines)
28	/**	28	/**
29	* <p><b>Purpose</b>: Many to many mappings are used to represent the relationships	29	* <p><b>Purpose</b>: Many to many mappings are used to represent the relationships
30	* between a collection of source objects and a collection of target objects.	30	* between a collection of source objects and a collection of target objects.
31	* The mapping require the creation of an intermediate table for managing the	31	* The mapping requires the creation of an intermediate table for managing the
32	* associations between the source and target records.	32	* associations between the source and target records.
33	*	33	*
34	* @author Sati	34	* @author Sati
Lines 46-51 Link Here
46	protected HistoryPolicy historyPolicy;	46	protected HistoryPolicy historyPolicy;
47		47
48	/**	48	/**
		49	* 266912: Since: EclipseLink 2.0 for the Metamodel API
		50	* For 1:1 and m:m mappings - track the original externally defined mapping if different
		51	* Note: This field will provide differentiation for the following
		52	* external to internal representations for mapping types<br>
		53	* - A OneToManyMapping will be represented by a ManyToManyMapping if unidirectional<br>
		54	* - A ManyToOneMapping will be represented by a OneToOneMapping (without a FK constraint)<br>
		55	*/
		56	protected boolean isDefinedAsOneToManyMapping = false;
		57
		58	/**
49	* PUBLIC:	59	* PUBLIC:
50	* Default constructor.	60	* Default constructor.
51	*/	61	*/
Lines 696-701 Link Here
696		706
697	/**	707	/**
698	* INTERNAL:	708	* INTERNAL:
		709	* Return whether this mapping was originally defined as a OneToMany
		710	* @return
		711	*/
		712	public boolean isDefinedAsOneToManyMapping() {
		713	return isDefinedAsOneToManyMapping;
		714	}
		715
		716	/**
		717	* INTERNAL:
699	* Return if this mapping support joining.	718	* Return if this mapping support joining.
700	*/	719	*/
701	public boolean isJoiningSupported() {	720	public boolean isJoiningSupported() {
Lines 942-947 Link Here
942	public void setDeleteSQLString(String sqlString) {	961	public void setDeleteSQLString(String sqlString) {
943	this.mechanism.setDeleteSQLString(sqlString);	962	this.mechanism.setDeleteSQLString(sqlString);
944	}	963	}
		964
		965	/**
		966	* INTERNAL:
		967	* Set whether this mapping was originally defined as a OneToMany
		968	* @param isDefinedAsOneToManyMapping
		969	*/
		970	public void setDefinedAsOneToManyMapping(boolean isDefinedAsOneToManyMapping) {
		971	this.isDefinedAsOneToManyMapping = isDefinedAsOneToManyMapping;
		972	}
945		973
946	/**	974	/**
947	* PUBLIC:	975	* PUBLIC:

Lines 63-68 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/OneToOneMapping.java (+27 lines)
63	/** Mechanism holds relationTable and all fields and queries associated with it. */	63	/** Mechanism holds relationTable and all fields and queries associated with it. */
64	protected transient RelationTableMechanism mechanism;	64	protected transient RelationTableMechanism mechanism;
65		65
		66	/**
		67	* 266912: Since: EclipseLink 2.0 for the Metamodel API
		68	* For 1:1 and m:m mappings - track the original externally defined mapping if different
		69	* Note: This field will provide differentiation for the following
		70	* external to internal representations for mapping types<br>
		71	* - A OneToManyMapping will be represented by a ManyToManyMapping if unidirectional<br>
		72	* - A ManyToOneMapping will be represented by a OneToOneMapping (without a FK constraint)<br>
		73	*/
		74	protected boolean isDefinedAsManyToOneMapping = false;
66		75
67	/**	76	/**
68	* PUBLIC:	77	* PUBLIC:
Lines 1245-1250 Link Here
1245	}	1254	}
1246		1255
1247	/**	1256	/**
		1257	* INTERNAL:
		1258	* Set whether this mapping was originally defined as a ManyToOne
		1259	* @param isDefinedAsManyToOneMapping
		1260	*/
		1261	public void setDefinedAsManyToOneMapping(boolean isDefinedAsManyToOneMapping) {
		1262	this.isDefinedAsManyToOneMapping = isDefinedAsManyToOneMapping;
		1263	}
		1264
		1265	/**
1248	* PUBLIC:	1266	* PUBLIC:
1249	* Define the foreign key relationship in the 1-1 mapping.	1267	* Define the foreign key relationship in the 1-1 mapping.
1250	* This method is used for singleton foreign key relationships only,	1268	* This method is used for singleton foreign key relationships only,
Lines 1369-1374 Link Here
1369		1387
1370	/**	1388	/**
1371	* INTERNAL:	1389	* INTERNAL:
		1390	* Return whether this mapping was originally defined as a ManyToOne
		1391	* @return
		1392	*/
		1393	public boolean isDefinedAsManyToOneMapping() {
		1394	return isDefinedAsManyToOneMapping;
		1395	}
		1396
		1397	/**
		1398	* INTERNAL:
1372	* Return if this mapping support joining.	1399	* Return if this mapping support joining.
1373	*/	1400	*/
1374	public boolean isJoiningSupported() {	1401	public boolean isJoiningSupported() {

Lines 27-32 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/models/jpa/metamodel/Board.java (-2 / +4 lines)
27	import javax.persistence.Entity;	27	import javax.persistence.Entity;
28	import javax.persistence.GeneratedValue;	28	import javax.persistence.GeneratedValue;
29	import javax.persistence.Id;	29	import javax.persistence.Id;
		30	import javax.persistence.JoinColumn;
		31	import javax.persistence.JoinTable;
30	import javax.persistence.ManyToOne;	32	import javax.persistence.ManyToOne;
31	import javax.persistence.OneToMany;	33	import javax.persistence.OneToMany;
32	import javax.persistence.Table;	34	import javax.persistence.Table;
Lines 65-73 Link Here
65		67
66	// The M:1 side is the owning side for "circuitBoards"	68	// The M:1 side is the owning side for "circuitBoards"
67	@ManyToOne(fetch=EAGER)	69	@ManyToOne(fetch=EAGER)
68	/* @JoinTable(name="CMP3_MM_COMPUTER_MM_BOARD",	70	@JoinTable(name="CMP3_MM_COMPUTER_MM_BOARD",
69	joinColumns = @JoinColumn(name="BOARD_ID"),	71	joinColumns = @JoinColumn(name="BOARD_ID"),
70	inverseJoinColumns = @JoinColumn(name="COMPUTER_ID"))*/	72	inverseJoinColumns = @JoinColumn(name="COMPUTER_ID"))
71	private Computer computer;	73	private Computer computer;
72		74
73	public Board() {}	75	public Board() {}

Lines 37-42 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/models/jpa/metamodel/Manufacturer.java (-1 / +5 lines)
37	@Entity(name="ManufacturerMetamodel")	37	@Entity(name="ManufacturerMetamodel")
38	@Table(name="CMP3_MM_MANUF")	38	@Table(name="CMP3_MM_MANUF")
39	public class Manufacturer extends Corporation implements java.io.Serializable{	39	public class Manufacturer extends Corporation implements java.io.Serializable{
		40	private static final long serialVersionUID = 5796354087505114955L;
		41
40	@Version	42	@Version
41	@Column(name="MANUF_VERSION")	43	@Column(name="MANUF_VERSION")
42	private int version;	44	private int version;
Lines 114-120 Link Here
114		116
115	// Define static types	117	// Define static types
116		118
117	public Manufacturer() {}	119	public Manufacturer() {
		120	//this.hardwareDesignersMap = new HashMap<String, HardwareDesigner>();
		121	}
118		122
119	public int getVersion() {	123	public int getVersion() {
120	return version;	124	return version;




import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.Root;
import javax.persistence.metamodel.Attribute;
import javax.persistence.metamodel.Bindable;
import javax.persistence.metamodel.CollectionAttribute;

import javax.persistence.metamodel.MapAttribute;
import javax.persistence.metamodel.Metamodel;
import javax.persistence.metamodel.PluralAttribute;
import javax.persistence.metamodel.SetAttribute;
import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.Type;
import javax.persistence.metamodel.Attribute.PersistentAttributeType;
import javax.persistence.metamodel.PluralAttribute.CollectionType;
import javax.persistence.metamodel.Type.PersistenceType;

import junit.framework.Test;

import org.eclipse.persistence.testing.models.jpa.metamodel.Memory;
import org.eclipse.persistence.testing.models.jpa.metamodel.Person;
import org.eclipse.persistence.testing.models.jpa.metamodel.Processor;
import org.eclipse.persistence.testing.models.jpa.metamodel.SoftwareDesigner;
import org.eclipse.persistence.testing.models.jpa.metamodel.User;
import org.eclipse.persistence.testing.models.jpa.metamodel.VectorProcessor;

/**
 * Disclaimer:


    public static Test suite() {
        TestSuite suite = new TestSuite("MetamodelMetamodelTest");
        // Test has been expanded by interface function below
        //suite.addTest(new MetamodelMetamodelTest("test_MetamodelFullImplementation"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_getPersistentAttributeType_BASIC_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_getPersistentAttributeType_EMBEDDED_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_getPersistentAttributeType_ONE_TO_ONE_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_getPersistentAttributeType_ONE_TO_MANY_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_getPersistentAttributeType_MANY_TO_MANY_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_getPersistentAttributeType_MANY_TO_ONE_Method"));
        //suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_getPersistentAttributeType_MANY_TO_ONE_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_getPersistentAttributeType_ELEMENT_COLLECTION_Method"));        
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_getName_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_getDeclaringType_Method"));

        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_isAssociation_on_Singular_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_isCollection_false_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_Interface_isCollection_true_Method"));
        
        suite.addTest(new MetamodelMetamodelTest("testBasicType_Interface"));
        suite.addTest(new MetamodelMetamodelTest("testBindable_Interface_getBindableType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testBindable_Interface_getBindableJavaType_Method"));

        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getDeclaredId_variant_execution_attribute_is_not_declared_at_all"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getDeclaredId_normal_execution_attribute_is_declared"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getIdType_handles_possible_null_cmppolicy"));
        
        suite.addTest(new MetamodelMetamodelTest("testListAttribute_Interface"));
        
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getAttributes_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getDeclaredAttributes_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getSingularAttribute_Type_param_Method"));

        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getPluralAttributes_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getDeclaredPluralAttributes_internal_entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getDeclaredPluralAttributes_root_entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getDeclaredPluralAttributes_root_mappedSuperclass_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getAttribute_on_Entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getAttribute_on_MappedSuperclass_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getAttribute_doesNotExist_on_Entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getAttribute_doesNotExist_on_MappedSuperclass_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getDeclaredAttribute_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getDeclaredAttribute_above_throws_iae_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getDeclaredAttribute_doesNotExist_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getSingularAttribute_BASIC_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getSingularAttribute_EMBEDDED_Method"));        
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getDeclaredSingularAttribute_on_Entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getDeclaredSingularAttribute_on_MappedSuperclass_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getCollection_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getDeclaredCollection_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_Interface_getSet_Method"));

    
    public void setUp() {
        super.setUp();
        // Drop all tables : Thank you Chris
        /*java.util.Vector v = JUnitTestCase.getServerSession("metamodel1").executeSQL("select tablename from sys.systables where tabletype='T'");
        for (int i=0; i<v.size(); i++){
            try{
                DatabaseRecord dr = (DatabaseRecord)v.get(i);
                JUnitTestCase.getServerSession().executeNonSelectingSQL("Drop table "+dr.getValues().get(0));
            } catch (Exception e){
                System.out.println(e);
            }
        }*/        
        /*JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_HIST_EMPLOY");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MANUF_MM_HWDES_MAP");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MANUF_MM_CORPCOMPUTER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MANUF_MM_COMPUTER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MANUF_MM_HWDESIGNER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_BOARD_MM_MEMORY");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_BOARD_MM_PRO");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_COMPUTER_MM_USER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_BOARD_SEQ");

        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_COMPUTER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_USER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_HWDESIGNER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MEMORY");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_PROC");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_LOCATION");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_BOARD");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_SWDESIGNER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MANUF");
        */        
    }
    
    /**

        try {
            emf = initialize(overrideEMFCachingForTesting);
            em = emf.createEntityManager();
            // Unset the metamodel - for repeated runs through this test
            // 20091016 - turn this off for production - as it is a performance hit - reenable if you wish to debug metamodel pre-processing
//            if(!isOnServer()) { 
//                ((EntityManagerFactoryImpl)emf).setMetamodel(null);
//            }
            metamodel = em.getMetamodel();
            assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
        } catch (Exception e) {
            e.printStackTrace();
            cleanup(em);
                cleanup(em);
            }
        }
        return em;
    }

                e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur on getIdType() here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertTrue("non-declared attribute should throw an IAE", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                Attribute anAttribute = entityBoard_.getAttribute("computer");                
                assertNotNull(anAttribute);
                assertEquals(Computer.class, anAttribute.getJavaType());
                // Note: internally our MANY_TO_ONE is treated as a ONE_TO_ONE - although with a DB constraint 
                assertEquals(PersistentAttributeType.MANY_TO_ONE, anAttribute.getPersistentAttributeType());
            } catch (Exception e) {
                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);
                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);
                
                /**
                 *  Return the managed type representing the type in which 
                 *  the attribute was declared.
                 *  @return declaring type
                 */
                //ManagedType<X> getDeclaringType();
                
                // Test case
                Attribute anAttribute = entityManufacturer_.getDeclaredAttribute("hardwareDesignersMapUC4");
                ManagedType aManagedType = anAttribute.getDeclaringType();
                assertEquals(entityManufacturer_, aManagedType);
                
                assertNotNull(anAttribute);
                assertEquals(PersistentAttributeType.ONE_TO_MANY, anAttribute.getPersistentAttributeType());
            } catch (Exception e) {
                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }    

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                assertNotNull(entityHardwareDesigner_);
                
                // Actual Test Case
                // exercise EntityTypeImpl
                //System.out.println("_entityManufacturer.getBindableType(): " + entityManufacturer.getBindableType());
                //System.out.println("_entityManufacturer.getCollections(): " + entityManufacturer.getCollections());
                //System.out.println("_entityManufacturer.getDeclaredCollection(type): " + entityManufacturer.getDeclaredCollection("computers", Computer.class));
                //System.out.println("_entityManufacturer.getDeclaredAttribute(type): " + entityManufacturer.getDeclaredSingularAttribute("name", String.class));            
                //System.out.println("_entityManufacturer.getDeclaredAttribute(): " + entityManufacturer.getDeclaredAttribute("name"));
                //System.out.println("_entityManufacturer.getDeclaredAttributes(): " + entityManufacturer.getDeclaredAttributes());
                //System.out.println("_entityManufacturer.getDeclaredId(type): " + entityManufacturer.getDeclaredId(manufacturer.getId().getClass()));
                //System.out.println("_entityManufacturer.getIdType(): " + entityManufacturer.getIdType());
                //System.out.println("_entityManufacturer.getJavaType(): " + entityManufacturer.getJavaType());
                //System.out.println("_entityManufacturer.getName(): " + entityManufacturer.getName());
                //System.out.println("_entityManufacturer.getSupertype(): " + entityManufacturer.getSupertype());
                //entityManufacturer.getVersion(manufacturer.getVersion());

                /**
                 *  Return the entity name.
                 *  @return entity name

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }


                // Actual Test Case
                /**
                 *  Return the attribute that corresponds to the id attribute 
                 *  declared by the entity or mapped superclass.
                 *  @param type  the type of the represented declared id attribute
                 *  @return declared id attribute
                 *  @throws IllegalArgumentException if id attribute of the given
                 *          type is not declared in the identifiable type or if
                 *          the identifiable type has an id class
                 */
                //<Y> SingularAttribute<X, Y> getDeclaredId(Class<Y> type);
                // Not declared  - invalid
//                assertNotNull(aManufacturerType.getDeclaredId(Integer.class));
                // declared and valid
                
                //*********************************************/
                // Require a version on a MappedSuperclass
                
//                assertNotNull(msPerson1_.getDeclaredId(Integer.class));

                /**
                 *  Return the attribute that corresponds to the version 
                 *  attribute declared by the entity or mapped superclass.
                 *  @param type  the type of the represented declared version 

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                MappedSuperclassTypeImpl<Corporation> msCorporation_ = (MappedSuperclassTypeImpl)metamodel.managedType(Corporation.class);
                assertNotNull(msCorporation_);
                
                // replaced by testIdentifiableType_getIdType_handles_possible_null_cmppolicy()
                /*try {
                    personIdType = msPerson_.getIdType();
                } catch (IllegalArgumentException iae) {
                    // expecting no exception
                    iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);
                assertNotNull(personIdType);
                assertEquals(PersistenceType.BASIC, personIdType.getPersistenceType());
                assertEquals(Integer.class, personIdType.getJavaType());
                */
                
                // Verify all types (entities, embeddables, mappedsuperclasses and basic)
                try {
                    // get all 21 types (a non spec function - for testing introspection)

                } catch (Exception e) {
                    e.printStackTrace();
                }
                
                
                
            } catch (Exception e) {
                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                assertNotNull(entityManufacturer_.getAttribute("aChar"));
                assertTrue(entityManufacturer_.getAttribute("aChar").getPersistentAttributeType().equals(PersistentAttributeType.BASIC));
                assertEquals(char.class, entityManufacturer_.getAttribute("aChar").getJavaType());

                

                
                /**
                 *  Return the attributes declared by the managed type.
                 *  Testing for Design Issue 52:

                    // name is declared 1 level above but is not visible in a ms-->ms hierarchy
                    //assertFalse(declaredAttributesSetForCorporation.contains(msCorporation.getAttribute("name"))); //
                    // corporateComputers is declared at this level
                    // Note: internally EclipseLink treats a ONE_TO_MANY as a MANY_TO_MANY for the case of a unidirectional mapping on a MappedSuperclass                    
                    assertTrue(declaredAttributesSetForCorporation.contains(msCorporation_.getAttribute("corporateComputers"))); //
                    // historicalEmployers is declared 1 level above but is not visible in a ms-->ms hierarchy
                    //assertFalse(declaredAttributesSetForCorporation.contains(msCorporation.getAttribute("historicalEmployers"))); //                

                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);            
               
                
                // Test Entity-->Entity hierarchy
                

                /**
                 *  Return the single-valued attribute of the managed 
                 *  type that corresponds to the specified name and Java type 

                expectedIAExceptionThrown = false;            
                try {
                    //<E> ListAttribute<X, E> getDeclaredList(String name, Class<E> elementType);
                    // Note: internally EclipseLink treats a ONE_TO_MANY as a MANY_TO_MANY for the case of a unidirectional mapping on a MappedSuperclass                    
                    // UC4 - the attribute is on the immediate superclass and is the correct COLLECTION - we still get an IAE
                    CollectionAttribute<Manufacturer, Computer> anAttribute = 
                        entityManufacturer_.getDeclaredCollection("corporateComputers", entityComputer_.getJavaType());

                try {
                    //<E> ListAttribute<X, E> getDeclaredList(String name, Class<E> elementType);
                    // UC4 - the attribute is on the immediate superclass
                    // Note: internally EclipseLink treats a ONE_TO_MANY as a MANY_TO_MANY for the case of a unidirectional mapping on a MappedSuperclass                    
                    CollectionAttribute<Manufacturer, Computer> anAttribute = 
                        entityManufacturer_.getDeclaredCollection("corporateComputers", entityComputer_.getJavaType());
                } catch (IllegalArgumentException iae) {

                try {
                    //<E> ListAttribute<X, E> getDeclaredList(String name, Class<E> elementType);
                    // UC4 - the attribute is on the immediate superclass
                    // Note: internally EclipseLink treats a ONE_TO_MANY as a MANY_TO_MANY for the case of a unidirectional mapping on a MappedSuperclass                    
                    Attribute<Manufacturer, ?> anAttribute = 
                        entityManufacturer_.getDeclaredAttribute("corporateComputers");//, entityComputer.getJavaType());
                } catch (IllegalArgumentException iae) {

                try {
                    //<E> ListAttribute<X, E> getDeclaredList(String name, Class<E> elementType);
                    // the attribute is on the class
                    IdentifiableType corporation = entityManufacturer_.getSupertype();
                    // Note: internally EclipseLink treats a ONE_TO_MANY as a MANY_TO_MANY for the case of a unidirectional mapping on a MappedSuperclass                    
                    aCollectionAttribute2 = corporation.getDeclaredAttribute("corporateComputers");//, entityComputer.getJavaType());
                } catch (IllegalArgumentException iae) {
                    // expecting

                expectedIAExceptionThrown = false;            
                try {
                    // UC4 - the attribute is on the immediate superclass
                    // Note: internally EclipseLink treats a ONE_TO_MANY as a MANY_TO_MANY for the case of a unidirectional mapping on a MappedSuperclass                    
                    CollectionAttribute<Manufacturer, ?> anAttribute = 
                        entityManufacturer_.getDeclaredCollection("corporateComputers");
                } catch (IllegalArgumentException iae) {


                expectedIAExceptionThrown = false;
                try {
                    // Note: internally EclipseLink treats a ONE_TO_MANY as a MANY_TO_MANY for the case of a unidirectional mapping on a MappedSuperclass                    
                    CollectionAttribute<Corporation, ?> anAttribute = 
                        msCorporation_.getDeclaredCollection("corporateComputers");
                } catch (IllegalArgumentException iae) {

                try {
                    //<E> ListAttribute<X, E> getDeclaredList(String name, Class<E> elementType);
                    // UC4 - the attribute is on the immediate superclass
                    // Note: internally EclipseLink treats a ONE_TO_MANY as a MANY_TO_MANY for the case of a unidirectional mapping on a MappedSuperclass                    
                    CollectionAttribute<Manufacturer, Computer> anAttribute = 
                        entityManufacturer_.getDeclaredCollection("corporateComputers", entityComputer_.getJavaType());
                } catch (IllegalArgumentException iae) {

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                // This also tests getCollections()
                expectedIAExceptionThrown = false;            
                try {
                    Set<PluralAttribute<Computer, ?, ?>> collections =
                        entityComputer_.getDeclaredPluralAttributes();
                    assertNotNull(collections);
                    

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

    // Requires test model expansion before enabling test
    public void testManagedType_Interface_getDeclaredPluralAttributes_root_mappedSuperclass_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;


                // This also tests getCollections()
                expectedIAExceptionThrown = false;
                // historicalComputers is defined as a plural declared attribute on a root mappedSuperclass
                Set<PluralAttribute<Person, ?, ?>> collections = 
                    msPerson_.getDeclaredPluralAttributes();
                        entityManufacturer_.getDeclaredPluralAttributes();
                } catch (IllegalArgumentException iae) {
                    iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);            
*/
            } catch (Exception e) {
                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }
    
    public void testManagedType_Interface_getAttribute_on_Entity_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);
                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);
                
                // Test case
                Attribute anAttribute = entityManufacturer_.getAttribute("hardwareDesignersMapUC4");
                assertNotNull(anAttribute);
                assertEquals(PersistentAttributeType.ONE_TO_MANY, anAttribute.getPersistentAttributeType());
                assertTrue(((AttributeImpl)anAttribute).isPlural());
                assertTrue(anAttribute instanceof MapAttribute);
                assertEquals(entityHardwareDesigner_, ((MapAttribute)anAttribute).getElementType());
                assertEquals(CollectionType.MAP, ((MapAttribute)anAttribute).getCollectionType());                
                assertEquals(String.class, ((MapAttribute)anAttribute).getKeyJavaType());
                assertEquals(HardwareDesigner.class, anAttribute.getJavaType());
            } catch (Exception e) {
                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
            }
        }
    }

    public void testManagedType_Interface_getAttribute_on_MappedSuperclass_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;
            try {
                em = privateTestSetup();
                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                ManagedType<Corporation> msCorporation_  = metamodel.managedType(Corporation.class);
                assertNotNull(msCorporation_);
                EntityTypeImpl<GalacticPosition> entityLocation_ =(EntityTypeImpl) metamodel.entity(GalacticPosition.class);
                assertNotNull(entityLocation_);
                EntityTypeImpl<Computer> entityComputer_ = (EntityTypeImpl)metamodel.entity(Computer.class);
                assertNotNull(entityComputer_);
                
                
                // Test case
                // Note: internally EclipseLink treats a ONE_TO_MANY as a MANY_TO_MANY for the case of a unidirectional mapping on a MappedSuperclass
                Attribute anAttribute = msCorporation_.getAttribute("corporateComputers");
                assertNotNull(anAttribute);
                assertEquals(PersistentAttributeType.ONE_TO_MANY, anAttribute.getPersistentAttributeType());
                assertTrue(((AttributeImpl)anAttribute).isPlural());
                assertTrue(anAttribute instanceof CollectionAttribute);
                assertEquals(entityComputer_, ((CollectionAttribute)anAttribute).getElementType());
                assertEquals(CollectionType.COLLECTION, ((CollectionAttribute)anAttribute).getCollectionType());                
                assertEquals(Computer.class, anAttribute.getJavaType());
            } catch (Exception e) {
                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
            }
        }
    }
    
    public void testManagedType_Interface_getAttribute_doesNotExist_on_Entity_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;
            Attribute anAttribute = null;            
            try {
                em = privateTestSetup();
                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);
                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);
                
                // Test case
                anAttribute = entityManufacturer_.getAttribute("does_not_exist");
            } catch (Exception e) {
                // We expect and exception
                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertNull(anAttribute);                
                assertTrue("An IAE exception should have occured on a non-existent attribute.", expectedIAExceptionThrown);
            }
        }
    }

    public void testManagedType_Interface_getAttribute_doesNotExist_on_MappedSuperclass_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;
            Attribute anAttribute = null;            
            try {
                em = privateTestSetup();
                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                ManagedType<Corporation> msCorporation_  = metamodel.managedType(Corporation.class);
                assertNotNull(msCorporation_);
                
                // Test case
                anAttribute = msCorporation_.getAttribute("does_not_exist");
            } catch (Exception e) {
                // We expect and exception
                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertNull(anAttribute);                
                assertTrue("An IAE exception should have occured on a non-existent attribute.", expectedIAExceptionThrown);
                }
            }
        }
    }

                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);
                MappedSuperclassTypeImpl<Person> msPerson_ = (MappedSuperclassTypeImpl)metamodel.managedType(Person.class);
                assertNotNull(msPerson_);
                MappedSuperclassTypeImpl<Corporation> msCorporation_ = (MappedSuperclassTypeImpl)metamodel.managedType(Corporation.class);
                assertNotNull(msCorporation_);
                EntityTypeImpl<GalacticPosition> entityLocation_ =(EntityTypeImpl) metamodel.entity(GalacticPosition.class);
                assertNotNull(entityLocation_);
                EntityTypeImpl<Computer> entityComputer_ = (EntityTypeImpl)metamodel.entity(Computer.class);
                assertNotNull(entityComputer_);
                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);
                
                // Test case
                Attribute anAttribute = entityManufacturer_.getDeclaredAttribute("hardwareDesignersMapUC4");
                assertNotNull(anAttribute);
                assertEquals(PersistentAttributeType.ONE_TO_MANY, anAttribute.getPersistentAttributeType());
                assertTrue(((AttributeImpl)anAttribute).isPlural());
                assertTrue(anAttribute instanceof MapAttribute);
                assertEquals(entityHardwareDesigner_, ((MapAttribute)anAttribute).getElementType());
                assertEquals(CollectionType.MAP, ((MapAttribute)anAttribute).getCollectionType());                
                assertEquals(String.class, ((MapAttribute)anAttribute).getKeyJavaType());
                assertEquals(HardwareDesigner.class, anAttribute.getJavaType());
            } catch (Exception e) {
                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

    public void testManagedType_Interface_getDeclaredAttribute_above_throws_iae_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;
            Attribute anAttribute = null;
            try {
                em = privateTestSetup();
                assertNotNull(em);

                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Test case
                // attribute is declared on a mappedsuperclass 
                // Note: internally EclipseLink treats a ONE_TO_MANY as a MANY_TO_MANY for the case of a unidirectional mapping on a MappedSuperclass                
                anAttribute = entityManufacturer_.getDeclaredAttribute("corporateComputers ");
            } catch (Exception e) {
                // We expect and exception
                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertNull(anAttribute);                
                assertTrue("An IAE exception should have occured on an attribute declared above this entity.", expectedIAExceptionThrown);
            }
        }
    }

    public void testManagedType_Interface_getDeclaredAttribute_doesNotExist_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;
            Attribute anAttribute = null;
            try {
                em = privateTestSetup();
                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Test case
                anAttribute = entityManufacturer_.getDeclaredAttribute("does_not_exist");
            } catch (Exception e) {
                // We expect and exception
                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertNull(anAttribute);                
                assertTrue("An IAE exception should have occured on a non-existent attribute.", expectedIAExceptionThrown);
            }
        }
    }
    
    
    public void testManagedType_Interface_getSingularAttribute_BASIC_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;
            try {
                em = privateTestSetup();
                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                EntityTypeImpl<GalacticPosition> entityLocation_ =(EntityTypeImpl) metamodel.entity(GalacticPosition.class);
                assertNotNull(entityLocation_);
                EntityTypeImpl<Computer> entityComputer_ = (EntityTypeImpl)metamodel.entity(Computer.class);
                assertNotNull(entityComputer_);
                
                // Test case
                Attribute anAttribute = entityComputer_.getSingularAttribute("version");
                assertNotNull(anAttribute);
                assertEquals(PersistentAttributeType.BASIC, anAttribute.getPersistentAttributeType());
                assertFalse(((AttributeImpl)anAttribute).isPlural());
                assertTrue(anAttribute instanceof SingularAttribute);
                assertEquals(int.class, anAttribute.getJavaType());
            } catch (Exception e) {
                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }
    
    public void testManagedType_Interface_getSingularAttribute_EMBEDDED_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);
                MappedSuperclassTypeImpl<Person> msPerson_ = (MappedSuperclassTypeImpl)metamodel.managedType(Person.class);
                assertNotNull(msPerson_);
                MappedSuperclassTypeImpl<Corporation> msCorporation_ = (MappedSuperclassTypeImpl)metamodel.managedType(Corporation.class);
                assertNotNull(msCorporation_);
                EntityTypeImpl<GalacticPosition> entityLocation_ =(EntityTypeImpl) metamodel.entity(GalacticPosition.class);
                assertNotNull(entityLocation_);
                EntityTypeImpl<Computer> entityComputer_ = (EntityTypeImpl)metamodel.entity(Computer.class);
                assertNotNull(entityComputer_);
                
                // not implemented
            } catch (Exception e) {
                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
            }
        }
    }
    
    public void testManagedType_Interface_getDeclaredSingularAttribute_on_Entity_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;
            try {
                em = privateTestSetup();
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                EntityTypeImpl<GalacticPosition> entityLocation_ =(EntityTypeImpl) metamodel.entity(GalacticPosition.class);
                assertNotNull(entityLocation_);
                EntityTypeImpl<Computer> entityComputer_ = (EntityTypeImpl)metamodel.entity(Computer.class);
                assertNotNull(entityComputer_);
                
                // Test case
                Attribute anAttribute = entityComputer_.getSingularAttribute("location");
                assertNotNull(anAttribute);
                assertEquals(PersistentAttributeType.ONE_TO_ONE, anAttribute.getPersistentAttributeType());
                assertFalse(((AttributeImpl)anAttribute).isPlural());
                assertTrue(anAttribute instanceof SingularAttribute);
            } catch (Exception e) {
                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
            }
        }
    }

    public void testManagedType_Interface_getDeclaredSingularAttribute_on_MappedSuperclass_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;
            try {
                em = privateTestSetup();
                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                MappedSuperclassTypeImpl<Person> msPerson_ = (MappedSuperclassTypeImpl)metamodel.managedType(Person.class);
                assertNotNull(msPerson_);
                
                // Test case
                Attribute anAttribute = msPerson_.getSingularAttribute("name");
                assertNotNull(anAttribute);
                assertEquals(PersistentAttributeType.BASIC, anAttribute.getPersistentAttributeType());
                assertFalse(((AttributeImpl)anAttribute).isPlural());
                assertTrue(anAttribute instanceof SingularAttribute);
                assertEquals(String.class, anAttribute.getJavaType());
            } catch (Exception e) {
                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                assertNotNull(entityComputer_);
                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);
                SetAttribute<? super Manufacturer, Computer> computersAttribute = 
                    entityManufacturer_.getSet("computers", Computer.class);
                assertNotNull("computers SetAttribute should not be null in Manufacturer_", computersAttribute);

            } catch (Exception e) {
                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                 */
                //Class<K> getKeyJavaType();

                /**
                 * Return the type representing the key type of the map.
                 * @return type representing key type
                 */
                //Type<K> getKeyType();
                
                
            } catch (Exception e) {
                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }


                // Actual Test Case
                /**
                 * Return the Java type of the map key.
                 * @return Java key type
                 */
                //Class<K> getKeyJavaType();

                /**
                 * Return the type representing the key type of the map.
                 * @return type representing key type
                 */

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                  */ 
                 //PersistenceType getPersistenceType();

                 /**
                  *  Return the represented Java type.
                  *  @return Java type
                  */
                 //Class<X> getJavaType();
            } catch (Exception e) {
                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }


                // Actual Test Case
                //public static enum PersistenceType { ENTITY,  EMBEDDABLE, MAPPED_SUPERCLASS, BASIC }

                 /**
                  *  Return the persistence type.
                  *  @return persistence type
                  */ 
                 //PersistenceType getPersistenceType();

                 /**
                  *  Return the represented Java type.
                  *  @return Java type
                  */

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                if(null != em) {
                    cleanup(em);
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                try {
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if(null != em) {
                        cleanup(em);
                    }
                }
            }
        }
    }

                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
                try {
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if(null != em) {
                        cleanup(em);
                    }
                }
            }
        }
    }
    
    
    /**
     * The following large single test case contains signatures of all the spec functions.
     * Those that have a test are implemented, the missing ones may still be in development.
     */
    public void test_MetamodelFullImplementation() {
        if(!this.isJPA10()) {
        EntityManager em = null;
        Collection<Board> boardCollection = new HashSet<Board>();        
        Set<Computer> computersList = new HashSet<Computer>();
        Collection<Memory> vectorMemories = new LinkedHashSet<Memory>();
        Collection<Memory> arrayMemories = new LinkedHashSet<Memory>();
        Collection<Processor> vectorProcessors = new HashSet<Processor>();
        Collection<Processor> arrayProcessors = new HashSet<Processor>();
        List<HardwareDesigner> hardwareDesigners = new ArrayList<HardwareDesigner>();
        Map<String, HardwareDesigner> mappedDesigners = new HashMap<String, HardwareDesigner>();
        Computer arrayComputer1 = null;
        Computer vectorComputer2 = null;
        Manufacturer manufacturer = null;
        User user = null;
        HardwareDesigner hardwareDesigner1 = null;
        SoftwareDesigner softwareDesigner1 = null;        
        Processor vectorProcessor1 = null;
        Processor arrayProcessor1 = null;
        Board arrayBoard1 = null;
        Board vectorBoard2 = null;
        Memory arrayMemory1 = null;
        Memory vectorMemory2 = null;
        GalacticPosition location1 = null;
        GalacticPosition location2 = null;   
        
        // Embedded objects
        EmbeddedPK embeddedPKforLocation1 = new EmbeddedPK();        
        EmbeddedPK embeddedPKforLocation2 = new EmbeddedPK();
        
        boolean exceptionThrown = false;
        try {
            em = privateTestSetup();
            assertNotNull(em);
            Metamodel metamodel = em.getMetamodel();
            assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);

            // SE only            
            em.getTransaction().begin();

            // setup entity relationships
            arrayComputer1 = new Computer();
            vectorComputer2 = new Computer();
            arrayMemory1 = new Memory();
            vectorMemory2 = new Memory();
            manufacturer = new Manufacturer();
            user = new User();
            hardwareDesigner1 = new HardwareDesigner();
            softwareDesigner1 = new SoftwareDesigner();
            vectorProcessor1 = new VectorProcessor();
            arrayProcessor1 = new ArrayProcessor();
            arrayBoard1 = new Board();
            vectorBoard2 = new Board();
            location1 = new GalacticPosition();
            location2 = new GalacticPosition();        

            // setup collections
            computersList.add(arrayComputer1);
            computersList.add(vectorComputer2);
            vectorProcessors.add(vectorProcessor1);
            arrayProcessors.add(arrayProcessor1);
            arrayMemories.add(arrayMemory1);
            vectorMemories.add(vectorMemory2);
            hardwareDesigners.add(hardwareDesigner1);
            
            mappedDesigners.put(hardwareDesigner1.getName(), hardwareDesigner1);
            //manufacturer.setHardwareDesignersMap(mappedDesigners);
            //manufacturer.setHardwareDesignersMapUC1a(mappedDesigners);
            //manufacturer.setHardwareDesignersMapUC2(mappedDesigners);
            //manufacturer.setHardwareDesignersMapUC4(mappedDesigners);
            //manufacturer.setHardwareDesignersMapUC7(mappedDesigners);
            //manufacturer.setHardwareDesignersMapUC8(mappedDesigners);            

            // set owning and inverse sides of 1:m and m:1 relationships
            manufacturer.setComputers(computersList);
            manufacturer.setHardwareDesigners(hardwareDesigners);
            
            hardwareDesigner1.setEmployer(manufacturer);
            hardwareDesigner1.setPrimaryEmployer(manufacturer);
            hardwareDesigner1.setSecondaryEmployer(manufacturer);
            // both sides of the relationship are set
            hardwareDesigner1.setMappedEmployer(manufacturer);
            hardwareDesigner1.setMappedEmployerUC1a(manufacturer);
            hardwareDesigner1.setMappedEmployerUC2(manufacturer);
            hardwareDesigner1.setMappedEmployerUC4(manufacturer);
            hardwareDesigner1.setMappedEmployerUC7(manufacturer);
            hardwareDesigner1.setMappedEmployerUC8(manufacturer);            
            
            arrayComputer1.setManufacturer(manufacturer);
            vectorComputer2.setManufacturer(manufacturer);
            arrayBoard1.setMemories(arrayMemories);
            vectorBoard2.setMemories(vectorMemories);
            arrayMemory1.setBoard(arrayBoard1);
            vectorMemory2.setBoard(vectorBoard2);
            arrayBoard1.setProcessors(arrayProcessors);
            vectorBoard2.setProcessors(vectorProcessors);
            arrayProcessor1.setBoard(arrayBoard1);
            vectorProcessor1.setBoard(vectorBoard2);            
            
            softwareDesigner1.setPrimaryEmployer(manufacturer);
            softwareDesigner1.setSecondaryEmployer(manufacturer);
            
            arrayComputer1.setCircuitBoards(boardCollection);
            arrayBoard1.setComputer(arrayComputer1);
            vectorBoard2.setComputer(vectorComputer2);
            
            // set 1:1 relationships
            arrayComputer1.setLocation(location1);
            vectorComputer2.setLocation(location2);
            // No get/set accessors on purpose for testing
            //location1.futurePosition = location2;
            //location2.futurePosition = location1;
            
            // set attributes
            arrayComputer1.setName("CM-5");
            vectorComputer2.setName("CDC-6600");
            
            // setup embedded objects
            location1.setPrimaryKey(embeddedPKforLocation1);
            location2.setPrimaryKey(embeddedPKforLocation2);
                
            // persist all entities to the database in a single transaction
            em.persist(arrayComputer1);
            em.persist(vectorComputer2);
            em.persist(manufacturer);
            em.persist(user);
            em.persist(hardwareDesigner1);
            em.persist(softwareDesigner1);
            em.persist(vectorProcessor1);
            em.persist(arrayProcessor1);
            em.persist(arrayBoard1);
            em.persist(vectorBoard2);
            em.persist(arrayMemory1);
            em.persist(vectorMemory2);
            em.persist(location1);
            em.persist(location2);        
            
            em.getTransaction().commit();            
            
            // Verify EntityType access to entities in the metamodel
            // These entities are metamodel entities (1 per type) not JPA entity instances (IdentifiableType)
            // TODO: temporarily used the impl classes - so F3 resolves in the IDE - revert to the interface for production
            EntityTypeImpl<Computer> entityComputer_ = (EntityTypeImpl)metamodel.entity(Computer.class);
            assertNotNull(entityComputer_);
            EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
            assertNotNull(entityManufacturer_);
            EntityTypeImpl<User> entityUser_ = (EntityTypeImpl)metamodel.entity(User.class);
            assertNotNull(entityUser_);
            EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
            assertNotNull(entityHardwareDesigner_);
            EntityTypeImpl<SoftwareDesigner> entitySoftwareDesigner_ = (EntityTypeImpl)metamodel.entity(SoftwareDesigner.class);
            assertNotNull(entitySoftwareDesigner_);
            EntityTypeImpl<Board> entityBoard_ = (EntityTypeImpl)metamodel.entity(Board.class);
            assertNotNull(entityBoard_);
            EntityTypeImpl<Memory> entityMemory_ = (EntityTypeImpl)metamodel.entity(Memory.class);
            assertNotNull(entityMemory_);
            EntityTypeImpl<GalacticPosition> entityLocation_ =(EntityTypeImpl) metamodel.entity(GalacticPosition.class);
            assertNotNull(entityLocation_);
            EntityTypeImpl<Processor> entityProcessor_ =(EntityTypeImpl) metamodel.entity(Processor.class);
            assertNotNull(entityProcessor_);
            EntityTypeImpl<VectorProcessor> entityVectorProcessor_ =(EntityTypeImpl) metamodel.entity(VectorProcessor.class);
            assertNotNull(entityVectorProcessor_);
            EntityTypeImpl<ArrayProcessor> entityArrayProcessor_ =(EntityTypeImpl) metamodel.entity(ArrayProcessor.class);
            assertNotNull(entityArrayProcessor_);
            
            // Criteria queries (use the Metamodel)
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*            CriteriaBuilder qb = null;
            List results = null;
            try {
                qb = em.getCriteriaBuilder();
                //CriteriaQuery<String> cq = qb.createQuery(String.class);
                CriteriaQuery<Computer> criteriaQuery = qb.createQuery(Computer.class);
                Expression expression = new ClassTypeExpression(); // probably not the right expression impl
                // somehow add "name" to the expression TBD                
                //criteriaQuery.select((new SelectionImpl(String.class, expression)));
                EntityTypeImpl<Computer> entityComputer2 = (EntityTypeImpl)metamodel.entity(Computer.class);                
                Root from = criteriaQuery.from(entityComputer2);
                Path path = from.get("name");
                criteriaQuery.where(qb.equal(path, "CM-5"));  
                Query query = em.createQuery(criteriaQuery);
                results = query.getResultList();
                if(!results.isEmpty()) {
                    Computer computer = (Computer)results.get(0);
                    assertNotNull(computer);
                } else {
                    fail("Results from criteria query (ReadAllQuery(referenceClass=Computer sql=SELECT COMPUTER_ID, NAME, COMPUTER_VERSION, MANUFACTURER_PERSON_ID, LOCATION_LOCATION_ID FROM CMP3_MM_COMPUTER WHERE NAME='CM-5') were expected");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
*/
            /* uncomment when the CriteriaBuilderImpl function below is implemented
             * public <T> ParameterExpression<T> parameter(Class<T> paramClass, String name){
            try {
                qb = em.getCriteriaBuilder();
                CriteriaQuery<Computer> cq = qb.createQuery(Computer.class);
                Root from = cq.from(Computer.class);
                Path c = from.get("name");
                cq.where(qb.equal(c, qb.parameter(String.class, "emp_name")));
                Query query = em.createQuery(cq);
                results = query.getResultList();
                Computer computer = (Computer)results.get(0);
                assertNotNull(computer);
            } catch (Exception e) {
                e.printStackTrace();
            }*/
            
            // SingularAttributeType
            // Test getBindableType - this is for SVN rev# 4644
            //http://fisheye2.atlassian.com/changelog/eclipselink/?cs=4644
            // Basic
            Class nameJavaType = ((SingularAttribute<Computer, String>)entityComputer_.getAttribute("name")).getBindableJavaType();
            assertNotNull(nameJavaType);
            assertEquals(String.class, nameJavaType);
            
            // OneToOne Entity
            Class locationJavaType = ((SingularAttribute<Computer, GalacticPosition>)entityComputer_.getAttribute("location")).getBindableJavaType();
            assertNotNull(locationJavaType);
            assertEquals(GalacticPosition.class, locationJavaType);
            
            
            /*
             * Metamodel model toString
             * ************************************************************************************
    class org.eclipse.persistence.testing.models.jpa.metamodel.Person=MappedSuperclassTypeImpl@9206757 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Person 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Person --> [DatabaseTable(__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME.PERSON_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME.NAME]]],
    class org.eclipse.persistence.testing.models.jpa.metamodel.Corporation=MappedSuperclassTypeImpl@27921979 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Corporation 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Corporation --> [DatabaseTable(__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME)]), 
        mappings: [
            org.eclipse.persistence.mappings.ManyToManyMapping[corporateComputers]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer=EntityTypeImpl@12565475 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer --> [DatabaseTable(CMP3_MM_MANUF)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_MANUF.PERSON_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->CMP3_MM_MANUF.NAME], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_MANUF.MANUF_VERSION], 
            org.eclipse.persistence.mappings.OneToManyMapping[
                computers], 
            org.eclipse.persistence.mappings.OneToManyMapping[
                hardwareDesignersMap], 
            org.eclipse.persistence.mappings.ManyToManyMapping[
                corporateComputers], 
            org.eclipse.persistence.mappings.OneToManyMapping[
                hardwareDesigners]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Memory=EntityTypeImpl@29905988 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Memory 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Memory --> [DatabaseTable(CMP3_MM_MEMORY)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_MEMORY.MEMORY_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_MEMORY.MEMORY_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                board]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Designer=MappedSuperclassTypeImpl@25971327 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Designer 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Designer --> [DatabaseTable(__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME)]), 
        mappings: [
            org.eclipse.persistence.mappings.OneToOneMapping[
                secondaryEmployer], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                primaryEmployer], 
            org.eclipse.persistence.mappings.ManyToManyMapping[
                historicalEmployers]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.HardwareDesigner=EntityTypeImpl@18107298 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.HardwareDesigner 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.HardwareDesigner --> [DatabaseTable(CMP3_MM_HWDESIGNER)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_HWDESIGNER.PERSON_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->CMP3_MM_HWDESIGNER.NAME], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_HWDESIGNER.HWDESIGNER_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                employer], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                mappedEmployer], 
            org.eclipse.persistence.mappings.ManyToManyMapping[
                historicalEmployers], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                secondaryEmployer], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                primaryEmployer]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.SoftwareDesigner=EntityTypeImpl@26130360 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.SoftwareDesigner 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.SoftwareDesigner --> [DatabaseTable(CMP3_MM_SWDESIGNER)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_SWDESIGNER.PERSON_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->CMP3_MM_SWDESIGNER.NAME], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_SWDESIGNER.SWDESIGNER_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                secondaryEmployer], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                primaryEmployer], 
            org.eclipse.persistence.mappings.ManyToManyMapping[
                historicalEmployers]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Board=EntityTypeImpl@24223536 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Board 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Board --> [DatabaseTable(CMP3_MM_BOARD)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_BOARD.BOARD_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_BOARD.BOARD_VERSION], 
            org.eclipse.persistence.mappings.OneToManyMapping[
                memories], 
            org.eclipse.persistence.mappings.OneToManyMapping[
                processors]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.EmbeddedPK=EmbeddableTypeImpl@29441291 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.EmbeddedPK descriptor: 
        RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.EmbeddedPK --> []), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                pk_part1-->LOCATION_ID]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Location=EntityTypeImpl@9050487 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Location 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Location --> [DatabaseTable(CMP3_MM_LOCATION)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_LOCATION.LOCATION_VERSION], 
            org.eclipse.persistence.mappings.AggregateObjectMapping[
                primaryKey]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.VectorProcessor=EntityTypeImpl@9300338 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.VectorProcessor 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.VectorProcessor --> [DatabaseTable(CMP3_MM_PROC)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_PROC.VECTPROC_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_PROC.VECTPROC_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                board]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.ArrayProcessor=EntityTypeImpl@14247087 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.ArrayProcessor 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.ArrayProcessor --> [DatabaseTable(CMP3_MM_ARRAYPROC)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_ARRAYPROC.ARRAYPROC_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_ARRAYPROC.ARRAYPROC_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                board]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Computer=EntityTypeImpl@8355938 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Computer 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Computer --> [DatabaseTable(CMP3_MM_COMPUTER)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_COMPUTER.COMPUTER_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->CMP3_MM_COMPUTER.NAME], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_COMPUTER.COMPUTER_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                manufacturer], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                location]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.User=EntityTypeImpl@12968655 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.User 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.User --> [DatabaseTable(CMP3_MM_USER)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_USER.PERSON_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->CMP3_MM_USER.NAME], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_USER.USER_VERSION]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Processor=MappedSuperclassTypeImpl@24044524 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Processor 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Processor --> [DatabaseTable(__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME)]), 
        mappings: []], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.CompositePK=EmbeddableTypeImpl@6367194 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.CompositePK 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.CompositePK --> []), 
        mappings: []], 
    class java.lang.Integer=BasicTypeImpl@33083511 [ 
        javaType: class java.lang.Integer], 
    class java.lang.String=BasicTypeImpl@4086417 [ 
        javaType: class java.lang.String], 
    int=BasicTypeImpl@28057122 [ 
        javaType: int]}
                */
            
            
            // get some static (non-runtime) attributes parameterized by <Owning type, return Type>
            // Note: the String based attribute names are non type-safe
            /*
            aMember CollectionAttributeImpl<X,E>  (id=183)  
             elementType BasicImpl<X>  (id=188)  
                javaClass   Class<T> (org.eclipse.persistence.testing.models.jpa.metamodel.Computer) (id=126)   
             managedType EntityTypeImpl<X>  (id=151) 
                descriptor  RelationalDescriptor  (id=156)  
                javaClass   Class<T> (org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer) (id=129)   
                members HashMap<K,V>  (id=157)  
                metamodel   MetamodelImpl  (id=52)  
                supertype   null    
            mapping OneToManyMapping  (id=191)  
            */
            // The attributes are in the field ManagedTypeImpl.members
            // The managedType is the owner of the attribute
            //hardwareDesigners=CollectionAttribute[org.eclipse.persistence.mappings.OneToManyMapping[hardwareDesigners]], 
            //computers=CollectionAttribute[org.eclipse.persistence.mappings.OneToManyMapping[computers]],
            
            // 20090707: We are getting a CCE because "all" Collections are defaulting to List 
            // when they are lazy instantiated as IndirectList if persisted as a List independent of what the OneToOne mapping is defined as
//            javax.persistence.metamodel.CollectionAttribute<? super Manufacturer, Computer> computersAttribute = 
//                entityManufacturer.getCollection("computers", Computer.class);
//            javax.persistence.metamodel.CollectionAttribute<? super Manufacturer, Computer> computersAttribute2 = 
//                entityManufacturer.getCollection("computers", Computer.class);
            javax.persistence.metamodel.SetAttribute<? super Manufacturer, Computer> computersAttribute = 
                entityManufacturer_.getSet("computers", Computer.class);
            
            //version=Attribute[org.eclipse.persistence.mappings.DirectToFieldMapping[version-->CMP3_MM_MANUF.MANUF_VERSION]], 
            //name=Attribute[org.eclipse.persistence.mappings.DirectToFieldMapping[name-->CMP3_MM_MANUF.NAME]], 
            //id=Attribute[org.eclipse.persistence.mappings.DirectToFieldMapping[id-->CMP3_MM_MANUF.PERSON_ID]]
            
            
            // Variant use cases
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            boolean iae1thrown = false;
            
            // A Criteria API query that is expected to fail with an IAE
            CriteriaBuilder qbForExceptions = null;
            
            iae1thrown = false;
            try {
                qbForExceptions = em.getCriteriaBuilder();
                CriteriaQuery<Computer> cq = qbForExceptions.createQuery(Computer.class);
                Root from = cq.from(Computer.class);
                Path invalidPath = from.get("____unknown_attribute_name_should_fail_with_IAE_____");
            } catch (Exception e) {
                iae1thrown = true;
                //e.printStackTrace();
            }
            assertTrue("We expect an AE exception here", iae1thrown);
        } catch (Exception e) {
            // we enter here on a failed commit() - for example if the table schema is incorrectly defined
            e.printStackTrace();
            exceptionThrown = true;
        } finally {
            // Runtime behavior should not affect the metamodel
            assertFalse(exceptionThrown);
            if(null != em) {
                cleanup(em);
            }
        }
        }
    }
}

Lines 734-740 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelTableCreator.java (-2 / +2 lines)
734	field4.setIsIdentity(false);	734	field4.setIsIdentity(false);
735	table.addField(field4);	735	table.addField(field4);
736		736
737	// 1:m does not require a JoinTable - only a JoinColumn	737	/* // m:1 requires a JoinTable
738	FieldDefinition field6 = new FieldDefinition();	738	FieldDefinition field6 = new FieldDefinition();
739	field6.setName("COMPUTER_COMPUTER_ID");	739	field6.setName("COMPUTER_COMPUTER_ID");
740	field6.setTypeName("NUMERIC");	740	field6.setTypeName("NUMERIC");
Lines 745-751 Link Here
745	field6.setIsIdentity(false);	745	field6.setIsIdentity(false);
746	field6.setForeignKeyFieldName("CMP3_MM_COMPUTER.COMPUTER_ID");	746	field6.setForeignKeyFieldName("CMP3_MM_COMPUTER.COMPUTER_ID");
747	table.addField(field6);	747	table.addField(field6);
748		748	*/
749	return table;	749	return table;
750	}	750	}
751		751

Lines 26-31 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/accessors/mappings/ManyToOneAccessor.java (+4 lines)
26	import org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataAccessibleObject;	26	import org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataAccessibleObject;
27	import org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataAnnotation;	27	import org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataAnnotation;
28		28
		29	import org.eclipse.persistence.mappings.ManyToManyMapping;
29	import org.eclipse.persistence.mappings.OneToOneMapping;	30	import org.eclipse.persistence.mappings.OneToOneMapping;
30		31
31	/**	32	/**
Lines 89-94 Link Here
89	OneToOneMapping mapping = initOneToOneMapping();	90	OneToOneMapping mapping = initOneToOneMapping();
90	setMapping(mapping);	91	setMapping(mapping);
91		92
		93	// 266912: If this n:1 accessor is different than the 1:1 mapping -track this
		94	mapping.setDefinedAsManyToOneMapping(true);
		95
92	// Process the owning keys for this mapping.	96	// Process the owning keys for this mapping.
93	processOwningMappingKeys(mapping);	97	processOwningMappingKeys(mapping);
94	}	98	}




    private ClassAccessor m_classAccessor;
    private DatabaseMapping m_mapping;
    private Map<String, PropertyMetadata> m_properties = new HashMap<String, PropertyMetadata>();
    
    /**
     * INTERNAL:
     */

    
    /**
     * INTERNAL:
     * This will do three things:
     * 1 - process any common level metadata for all mappings.
     * 2 - add the mapping to the internal descriptor.
     * 3 - store the actual database mapping associated with this accessor.

        getDescriptor().getClassDescriptor().addMapping(mapping);
        
        // Keep a reference back to this mapping for quick look up.
        m_mapping = mapping;  
        
        // REMOVE: The following commented block is for review of an abandoned version
        // and will not be checked in
        /**
         * Since: EclipseLink 2.0 for the Metamodel API
         * For 1:1 and m:m mappings - track the original externally defined mapping if different 
         * Note: This field will provide differentiation for the following 
         *   external to internal representations for mapping types<br>
         *   - A OneToManyMapping will be represented by a ManyToManyMapping if on a MappedSuperclass<br>
         *   - A ManyToOneMapping will be represented by a OneToOneMapping (without a FK constraint)<br>      
         */
/*        // If this n:1 accessor is different than the 1:1 mapping -track this
        if((this.isManyToOne() && mapping.isOneToOneMapping())) {
            ((OneToOneMapping)mapping).setDefinedAsManyToOneMapping(true);
        }
        // If this 1:n accessor is different than the n:n mapping - track this
        if((this.isOneToMany() && mapping.isManyToManyMapping())) {
            ((ManyToManyMapping)mapping).setDefinedAsOneToManyMapping(true);
        }
*/        

    }
    
    /**

Lines 97-103 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/accessors/mappings/OneToManyAccessor.java (-1 / +4 lines)
97		97
98	/**	98	/**
99	* INTERNAL:	99	* INTERNAL:
100	* Process an OneToMany accessor into an EclipseLink OneToManyMapping. If a	100	* Process a OneToMany accessor into an EclipseLink OneToManyMapping. If a
101	* JoinTable is found however, we must create a ManyToManyMapping.	101	* JoinTable is found however, we must create a ManyToManyMapping.
102	*/	102	*/
103	@Override	103	@Override
Lines 149-154 Link Here
149	// first followed by specific metadata.	149	// first followed by specific metadata.
150	ManyToManyMapping mapping = new ManyToManyMapping();	150	ManyToManyMapping mapping = new ManyToManyMapping();
151	process(mapping);	151	process(mapping);
		152
		153	// 266912: If this 1:n accessor is different than the n:n mapping - track this
		154	mapping.setDefinedAsOneToManyMapping(true);
152		155
153	// Process the JoinTable metadata.	156	// Process the JoinTable metadata.
154	processJoinTable(mapping, mapping.getRelationTableMechanism(), getJoinTableMetadata());	157	processJoinTable(mapping, mapping.getRelationTableMechanism(), getJoinTableMetadata());

Lines 12-18 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/AttributeImpl.java (-25 / +40 lines)
12	* 06/30/2009-2.0 mobrien - finish JPA Metadata API modifications in support	12	* 06/30/2009-2.0 mobrien - finish JPA Metadata API modifications in support
13	* of the Metamodel implementation for EclipseLink 2.0 release involving	13	* of the Metamodel implementation for EclipseLink 2.0 release involving
14	* Map, ElementCollection and Embeddable types on MappedSuperclass descriptors	14	* Map, ElementCollection and Embeddable types on MappedSuperclass descriptors
15	* - 266912: JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)	15	* - 266912: JPA 2.0 Metamodel API (part of the JSR-317 EJB 3.1 Criteria API)
		16	* 29/10/2009-2.0 mobrien - m:1 and 1:m relationships require special handling
		17	* in their internal m:m and 1:1 database mapping representations.
		18	* http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_96:_20091019:_Attribute.getPersistentAttributeType.28.29_treats_ManyToOne_the_same_as_OneToOne
16	******************************************************************************/	19	******************************************************************************/
17	package org.eclipse.persistence.internal.jpa.metamodel;	20	package org.eclipse.persistence.internal.jpa.metamodel;
18		21
Lines 27-34 Link Here
27	import org.eclipse.persistence.internal.descriptors.MethodAttributeAccessor;	30	import org.eclipse.persistence.internal.descriptors.MethodAttributeAccessor;
28	import org.eclipse.persistence.mappings.AttributeAccessor;	31	import org.eclipse.persistence.mappings.AttributeAccessor;
29	import org.eclipse.persistence.mappings.DatabaseMapping;	32	import org.eclipse.persistence.mappings.DatabaseMapping;
		33	import org.eclipse.persistence.mappings.ManyToManyMapping;
30	import org.eclipse.persistence.mappings.OneToOneMapping;	34	import org.eclipse.persistence.mappings.OneToOneMapping;
31	import org.eclipse.persistence.mappings.VariableOneToOneMapping;
32		35
33	/**	36	/**
34	* <p>	37	* <p>
Lines 47-59 Link Here
47	*/	50	*/
48	public abstract class AttributeImpl<X, T> implements Attribute<X, T>, Serializable {	51	public abstract class AttributeImpl<X, T> implements Attribute<X, T>, Serializable {
49		52
50	/ the ManagedType associated with this attribute /	53	/ The ManagedType associated with this attribute /
51	private ManagedTypeImpl<X> managedType;	54	private ManagedTypeImpl<X> managedType;
52		55
53	/ The databaseMapping associated with this attribute /	56	/ The databaseMapping associated with this attribute /
54	private DatabaseMapping mapping;	57	private DatabaseMapping mapping;
55		58
56
57	/**	59	/**
58	* INTERNAL:	60	* INTERNAL:
59	*	61	*
Lines 162-201 Link Here
162	* Return the persistent attribute type for the attribute.	164	* Return the persistent attribute type for the attribute.
163	* @return persistent attribute type	165	* @return persistent attribute type
164	*/	166	*/
165	public javax.persistence.metamodel.Attribute.PersistentAttributeType getPersistentAttributeType() {	167	public Attribute.PersistentAttributeType getPersistentAttributeType() {
166	/**	168	/**
167	* process the following mappings	169	* process the following mappings by referencing the Core API Mapping.
168	* MANY_TO_ONE	170	* MANY_TO_ONE (ONE_TO_ONE internally)
169	* ONE_TO_ONE	171	* ONE_TO_ONE (May originally be a MANY_TO_ONE)
170	* BASIC	172	* BASIC
171	* EMBEDDED	173	* EMBEDDED
172	* MANY_TO_MANY	174	* MANY_TO_MANY (May originally be a unidirectional ONE_TO_MANY on a mappedSuperclass)
173	* ONE_TO_MANY	175	* ONE_TO_MANY (MANY_TO_MANY internally for unidirectional mappings on MappedSuperclasses)
174	* ELEMENT_COLLECTION	176	* ELEMENT_COLLECTION
175	*/	177	*/
176	if (getMapping().isDirectToFieldMapping()) {	178	if (mapping.isDirectToFieldMapping()) {
177	return PersistentAttributeType.BASIC;	179	return PersistentAttributeType.BASIC;
178	}	180	}
179	if (getMapping().isAggregateObjectMapping()) {	181	if (mapping.isAggregateObjectMapping()) {
180	return PersistentAttributeType.EMBEDDED;	182	return PersistentAttributeType.EMBEDDED;
181	}	183	}
182	if (getMapping().isOneToManyMapping()) {	184	if (mapping.isOneToManyMapping()) {
183	return PersistentAttributeType.ONE_TO_MANY;	185	return PersistentAttributeType.ONE_TO_MANY;
184	}	186	}
185	if (getMapping().isOneToOneMapping()) {	187
186	return PersistentAttributeType.ONE_TO_ONE;	188	/**
		189	* EclipseLink internally processes a ONE_TO_MANY on a MappedSuperclass as a MANY_TO_MANY
		190	* because the relationship is unidirectional.
		191	*/
		192	if (mapping.isManyToManyMapping()) {
		193	// Check for a OneToMany on a MappedSuperclass being processed internally as a ManyToMany
		194	if(((ManyToManyMapping)mapping).isDefinedAsOneToManyMapping()) {
		195	return PersistentAttributeType.ONE_TO_MANY;
		196	} else {
		197	// Test coverage required
		198	return PersistentAttributeType.MANY_TO_MANY;
		199	}
187	}	200	}
188	// Internally we treat m:1 as 1:1 - place this before the 1:1 check	201
189	// http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_96:_20091019:_Attribute.getPersistentAttributeType.28.29_treats_ManyToOne_the_same_as_OneToOne	202	/**
190	if (getMapping().isRelationalMapping() &&	203	* EclipseLink internally processes a MANY_TO_ONE as a ONE_TO_ONE without a FK constraint.
191	(getMapping() instanceof OneToOneMapping \|\| getMapping() instanceof VariableOneToOneMapping)) {	204	*/
192	return PersistentAttributeType.MANY_TO_ONE;	205	if (mapping.isOneToOneMapping()) {
		206	// Check for a ManyToOne being processed internally as a OneToOne
		207	if(((OneToOneMapping)mapping).isDefinedAsManyToOneMapping()) {
		208	return PersistentAttributeType.MANY_TO_ONE;
		209	} else {
		210	return PersistentAttributeType.ONE_TO_ONE;
		211	}
193	}	212	}
194	// Test coverage required	213	// Test coverage required
195	if (getMapping().isManyToManyMapping()) {
196	return PersistentAttributeType.MANY_TO_MANY;
197	}
198	// Test coverage required
199	return PersistentAttributeType.ELEMENT_COLLECTION;	214	return PersistentAttributeType.ELEMENT_COLLECTION;
200	}	215	}
201		216

Return to bug 266912

Lines 124-130 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/accessors/mappings/MappingAccessor.java (-3 / +24 lines)
124	private ClassAccessor m_classAccessor;	124	private ClassAccessor m_classAccessor;
125	private DatabaseMapping m_mapping;	125	private DatabaseMapping m_mapping;
126	private Map<String, PropertyMetadata> m_properties = new HashMap<String, PropertyMetadata>();	126	private Map<String, PropertyMetadata> m_properties = new HashMap<String, PropertyMetadata>();
127		127
128	/**	128	/**
129	* INTERNAL:	129	* INTERNAL:
130	*/	130	*/
Lines 1674-1680 Link Here
1674		1674
1675	/**	1675	/**
1676	* INTERNAL:	1676	* INTERNAL:
1677	* This will do two things:	1677	* This will do three things:
1678	* 1 - process any common level metadata for all mappings.	1678	* 1 - process any common level metadata for all mappings.
1679	* 2 - add the mapping to the internal descriptor.	1679	* 2 - add the mapping to the internal descriptor.
1680	* 3 - store the actual database mapping associated with this accessor.	1680	* 3 - store the actual database mapping associated with this accessor.
Lines 1694-1700 Link Here
1694	getDescriptor().getClassDescriptor().addMapping(mapping);	1694	getDescriptor().getClassDescriptor().addMapping(mapping);
1695		1695
1696	// Keep a reference back to this mapping for quick look up.	1696	// Keep a reference back to this mapping for quick look up.
1697	m_mapping = mapping;	1697	m_mapping = mapping;
		1698
		1699	// REMOVE: The following commented block is for review of an abandoned version
		1700	// and will not be checked in
		1701	/**
		1702	* Since: EclipseLink 2.0 for the Metamodel API
		1703	* For 1:1 and m:m mappings - track the original externally defined mapping if different
		1704	* Note: This field will provide differentiation for the following
		1705	* external to internal representations for mapping types<br>
		1706	* - A OneToManyMapping will be represented by a ManyToManyMapping if on a MappedSuperclass<br>
		1707	* - A ManyToOneMapping will be represented by a OneToOneMapping (without a FK constraint)<br>
		1708	*/
		1709	/* // If this n:1 accessor is different than the 1:1 mapping -track this
		1710	if((this.isManyToOne() && mapping.isOneToOneMapping())) {
		1711	((OneToOneMapping)mapping).setDefinedAsManyToOneMapping(true);
		1712	}
		1713	// If this 1:n accessor is different than the n:n mapping - track this
		1714	if((this.isOneToMany() && mapping.isManyToManyMapping())) {
		1715	((ManyToManyMapping)mapping).setDefinedAsOneToManyMapping(true);
		1716	}
		1717	*/
		1718
1698	}	1719	}
1699		1720
1700	/**	1721	/**