Attachment #151667 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 12-19 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/invalidation/TimeToLiveCacheInvalidationPolicy.java (-2 lines)
12	******************************************************************************/	12	******************************************************************************/
13	package org.eclipse.persistence.descriptors.invalidation;	13	package org.eclipse.persistence.descriptors.invalidation;
14		14
15	import java.util.Random;
16
17	import org.eclipse.persistence.internal.identitymaps.CacheKey;	15	import org.eclipse.persistence.internal.identitymaps.CacheKey;
18	import org.eclipse.persistence.descriptors.invalidation.CacheInvalidationPolicy;	16	import org.eclipse.persistence.descriptors.invalidation.CacheInvalidationPolicy;
19		17




import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity(name="EnclosureMetamodel")
@Table(name="CMP3_MM_ENCLOSURE")
@IdClass(org.eclipse.persistence.testing.models.jpa.metamodel.EnclosureIdClassPK.class)
public class Enclosure implements java.io.Serializable {

    private static final long serialVersionUID = -8761221910595496687L;
    

    @Column(name="WIDTH")
    private String width;
    
    // The M:1 side is the owning side
    @Id
    @ManyToOne
    @JoinColumn(name="PERSON_ID")
/*    @JoinTable(name="CMP3_MM_MANUF_MM_ENCLOSURE_MAPUC9", 
            joinColumns = @JoinColumn(name="ENCLOSURE_MAP_ID"), 
            inverseJoinColumns =@JoinColumn(name="MANUF_ID"))*/   
    private Manufacturer mappedManufacturerUC9;
    
    public EnclosureIdClassPK buildPK(){
        EnclosureIdClassPK pk = new EnclosureIdClassPK();
        pk.setLength(this.getLength());

Lines 17-22 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/models/jpa/metamodel/EnclosureIdClassPK.java (-3 / +14 lines)
17	public String type;	17	public String type;
18	protected String length;	18	protected String length;
19	private String width;	19	private String width;
		20	private Integer mappedManufacturerUC9;
20		21
21	public String getType() {	22	public String getType() {
22	return type;	23	return type;
Lines 42-47 Link Here
42	this.width = width;	43	this.width = width;
43	}	44	}
44		45
		46
		47	public Integer getMappedManufacturerUC9() {
		48	return mappedManufacturerUC9;
		49	}
		50
		51	public void setMappedManufacturerUC9(Integer mappedManufacturerUC9) {
		52	this.mappedManufacturerUC9 = mappedManufacturerUC9;
		53	}
		54
45	public EnclosureIdClassPK() {}	55	public EnclosureIdClassPK() {}
46		56
47	@Override	57	@Override
Lines 52-64 Link Here
52	EnclosureIdClassPK enclosureIdClassPK = (EnclosureIdClassPK) anEnclosureIdClassPK;	62	EnclosureIdClassPK enclosureIdClassPK = (EnclosureIdClassPK) anEnclosureIdClassPK;
53	return (enclosureIdClassPK.getLength().equals(this.getLength()) &&	63	return (enclosureIdClassPK.getLength().equals(this.getLength()) &&
54	enclosureIdClassPK.getWidth().equals(this.getWidth()) &&	64	enclosureIdClassPK.getWidth().equals(this.getWidth()) &&
55	enclosureIdClassPK.getType().equals(this.getType()));	65	enclosureIdClassPK.getType().equals(this.getType()) &&
		66	enclosureIdClassPK.getMappedManufacturerUC9().equals(this.mappedManufacturerUC9));
56	}	67	}
57		68
58	@Override	69	@Override
59	public int hashCode() {	70	public int hashCode() {
60	if (null != type && null != length && null != width) {	71	if (null != type && null != length && null != width && null != mappedManufacturerUC9) {
61	return 9232 * type.hashCode() * length.hashCode() * width.hashCode();	72	return 9232 * type.hashCode() * length.hashCode() * width.hashCode() * mappedManufacturerUC9.hashCode();
62	} else {	73	} else {
63	return super.hashCode();	74	return super.hashCode();
64	}	75	}

Lines 26-31 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/models/jpa/metamodel/Manufacturer.java (+14 lines)
26	import java.util.Map;	26	import java.util.Map;
27	import java.util.Set;	27	import java.util.Set;
28		28
		29	import javax.persistence.CascadeType;
29	import javax.persistence.Column;	30	import javax.persistence.Column;
30	import javax.persistence.Entity;	31	import javax.persistence.Entity;
31	import javax.persistence.MapKey;	32	import javax.persistence.MapKey;
Lines 88-93 Link Here
88	@MapKey // name attribute will default to "id"	89	@MapKey // name attribute will default to "id"
89	private Map<Integer, HardwareDesigner> hardwareDesignersMapUC8;	90	private Map<Integer, HardwareDesigner> hardwareDesignersMapUC8;
90		91
		92	// UC9: no targetEntity, no MapKey, but generics are set (MapKey has an IdClass with an Embeddable)
		93	@OneToMany(cascade=CascadeType.ALL, mappedBy="mappedManufacturerUC9")
		94	private Map<Board, Enclosure> enclosureByBoardMapUC9;
		95
91	// Define Uppercase Object non-java.lang Basic types	96	// Define Uppercase Object non-java.lang Basic types
92	//private Object anObject; // Not supported in JPA	97	//private Object anObject; // Not supported in JPA
93	private Boolean aBooleanObject;	98	private Boolean aBooleanObject;
Lines 391-394 Link Here
391	this.aBigDecimalObject = aBigDecimalObject;	396	this.aBigDecimalObject = aBigDecimalObject;
392	}	397	}
393		398
		399	public Map<Board, Enclosure> getEnclosureByBoardMapUC9() {
		400	return enclosureByBoardMapUC9;
		401	}
		402
		403	public void setEnclosureByBoardMapUC9(Map<Board, Enclosure> enclosureByBoardMapUC9) {
		404	this.enclosureByBoardMapUC9 = enclosureByBoardMapUC9;
		405	}
		406
		407
394	}	408	}




 */
public class MetamodelMetamodelTest extends MetamodelTest {

    public static final int METAMODEL_ALL_ATTRIBUTES_SIZE = 102;//100;//94;
    public static final int METAMODEL_ALL_TYPES = 40;//37;
    public static final int METAMODEL_MANUFACTURER_DECLARED_TYPES = 28;    
    
    public MetamodelMetamodelTest() {
        super();


    public static Test suite() {
        TestSuite suite = new TestSuite("MetamodelMetamodelTest");
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getPersistentAttributeType_BASIC_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getPersistentAttributeType_EMBEDDED_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getPersistentAttributeType_ONE_TO_ONE_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getPersistentAttributeType_ONE_TO_MANY_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getPersistentAttributeType_MANY_TO_MANY_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getPersistentAttributeType_MANY_TO_ONE_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getPersistentAttributeType_ELEMENT_COLLECTION_Method"));        
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getName_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getDeclaringType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getJavaType_BasicType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getJavaType_ManagedType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getJavaMember_BasicType_on_MappedSuperclass_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getJavaMember_BasicType_on_Entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_getJavaMember_ManagedType_Method"));        
        suite.addTest(new MetamodelMetamodelTest("testAttribute_isAssociation_on_Plural_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_isAssociation_on_Singular_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_isCollection_false_Method"));
        suite.addTest(new MetamodelMetamodelTest("testAttribute_isCollection_true_Method"));
        
        suite.addTest(new MetamodelMetamodelTest("testBasicType"));
        suite.addTest(new MetamodelMetamodelTest("testBindable_getBindableType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testBindable_getBindableJavaType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testEmbeddableType"));
        suite.addTest(new MetamodelMetamodelTest("testEntityType"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getIdType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getIdClassAttributes_Method"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_hasVersionAttribute_Method"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_hasSingleIdAttribute_Method"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getSupertype_Method"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getDeclaredVersion_exists_Method"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getDeclaredVersion_exists_above_Method"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getDeclaredVersion_does_not_exist_at_all_Method"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getVersion_Method"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getDeclaredId_Method"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getId_Method"));        
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getDeclaredId_normal_execution_attribute_is_declared"));
        suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getDeclaredId_variant_execution_attribute_is_declared_above"));
        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"));
        
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getAttributes_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredAttributes_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getSingularAttribute_Type_param_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredSingularAttribute_Type_param_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getSingularAttributes_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredSingularAttributes_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getCollection_Type_param_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredCollection_Type_param_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getSet_Type_param_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredSet_Type_param_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getList_Type_param_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredList_Type_param_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getMap_Type_param_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredMap_Type_param_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredMap_Type_param_not_found_iae_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredMap_Type_param_declared_above_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getPluralAttributes_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredPluralAttributes_internal_entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredPluralAttributes_root_entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredPluralAttributes_root_mappedSuperclass_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getAttribute_on_Entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getAttribute_on_MappedSuperclass_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getAttribute_doesNotExist_on_Entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getAttribute_doesNotExist_on_MappedSuperclass_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredAttribute_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredAttribute_above_throws_iae_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredAttribute_doesNotExist_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getSingularAttribute_BASIC_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getSingularAttribute_EMBEDDED_Method"));        
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredSingularAttribute_on_Entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredSingularAttribute_on_MappedSuperclass_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getCollection_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredCollection_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getSet_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredSet_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getList_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredList_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getMap_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_getDeclaredMap_Method"));
        suite.addTest(new MetamodelMetamodelTest("testManagedType_variantCases"));        
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyJavaType_UC0_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyJavaType_UC1a_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyJavaType_UC2_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyJavaType_UC4_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyJavaType_UC7_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyJavaType_UC8_Method"));
        // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_86:_20090921:_Handle_Embeddable_Type_keyType_in_MapAttributeImpl_constructor       suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyJavaType_UC9_DI86_Embeddable_IdClass_keyType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyType_UC0_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyType_UC1a_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyType_UC2_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyType_UC4_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyType_UC7_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyType_UC8_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAttribute_getKeyType_UC9_DI86_Embeddable_IdClass_keyType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMapAtributeElementTypeWhenMapKeySetButNameAttributeIsDefaulted"));
        suite.addTest(new MetamodelMetamodelTest("testMapAtributeElementTypeWhenMapKeySetAndNameAttributeSet"));
        // Pending implementation
        //suite.addTest(new MetamodelMetamodelTest("testMapAtributeElementTypeWhenMapKeyNotSet_MapKeyColumnSet"));
        //suite.addTest(new MetamodelMetamodelTest("testMapAtributeElementTypeWhenMapKeyNotSet_MapKeyColumnSet")); // JPA 2.0 specific
        
        suite.addTest(new MetamodelMetamodelTest("testMappedSuperclassType"));
        suite.addTest(new MetamodelMetamodelTest("testMetamodel_entity_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMetamodel_embeddable_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMetamodel_managedType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMetamodel_getEntities_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMetamodel_getManagedTypes_Method"));
        suite.addTest(new MetamodelMetamodelTest("testMetamodel_getEmbeddables_Method"));
        suite.addTest(new MetamodelMetamodelTest("testPluralAttribute_CollectionType_enum"));
        suite.addTest(new MetamodelMetamodelTest("testPluralAttribute_getCollectionType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testPluralAttribute_getElementType_Method"));        
        suite.addTest(new MetamodelMetamodelTest("testSetAttribute"));
        suite.addTest(new MetamodelMetamodelTest("testSingularAttribute_isOptional_Method"));
        suite.addTest(new MetamodelMetamodelTest("testSingularAttribute_isId_Method"));
        suite.addTest(new MetamodelMetamodelTest("testSingularAttribute_isVersion_Method"));
        suite.addTest(new MetamodelMetamodelTest("testSingularAttribute_getBindableType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testSingularAttribute_getBindableJavaType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testSingularAttribute_getJavaType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testSingularAttribute_getType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testToStringOverrides"));        
        suite.addTest(new MetamodelMetamodelTest("testType_PersistenceType_enum"));
        suite.addTest(new MetamodelMetamodelTest("testType_getPersistenceType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testType_getJavaType_Method"));
        suite.addTest(new MetamodelMetamodelTest("testOutOfSpecificationInternalAPI"));        
        // Not implemented yet
        //suite.addTest(new MetamodelMetamodelTest("testObscureInvalidStateUnitTests"));

                Type<?> personIdType = null;
                MappedSuperclassTypeImpl<Person> msPerson_ = (MappedSuperclassTypeImpl)metamodel.managedType(Person.class);
                assertNotNull(msPerson_);
              
                personIdType = msPerson_.getIdType();
                    personIdType = msPerson_.getIdType();
                } catch (IllegalArgumentException iae) {
                    // expecting no exception
                    iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
                assertNotNull(personIdType);
                assertEquals(PersistenceType.BASIC, personIdType.getPersistenceType());
                assertEquals(Integer.class, personIdType.getJavaType());
            } catch (IllegalArgumentException iae) {
                // expecting no exception
                iae.printStackTrace();
                exceptionThrown = true;            
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur on getIdType() here.", exceptionThrown);

                
                // Test toString() for a Type without a javaType attribute
                //Type invalidType = new BasicTypeImpl(null);
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

            }
        }
    }
    
    /**
     * This test will verify that MapAttribute instance have their elementType set correctly.
     * The elementType corresponds to the 3rd V parameter on the class definition - which is the Map value.
     * MapAttributeImpl<X, K, V> 
     */
    public void testMapAtributeElementTypeWhenMapKeySetButNameAttributeIsDefaulted() {
        if(!this.isJPA10()) {
            boolean exceptionThrown = false;
            EntityManager em = null;            
            try {
                em = privateTestSetup();
                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                
                EntityType<Manufacturer> entityManufacturer = metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer);                
                Attribute hardwareDesignersMap = entityManufacturer.getAttribute("hardwareDesignersMapUC8");
                assertNotNull(hardwareDesignersMap);
                assertTrue(hardwareDesignersMap.isCollection());
                assertTrue(hardwareDesignersMap instanceof MapAttributeImpl);
                MapAttribute<? super Manufacturer, ?, ?> manufactuerHardwareDesignersMap = entityManufacturer.getMap("hardwareDesignersMapUC8");            
                // Verify owning type
                assertNotNull(manufactuerHardwareDesignersMap);
                assertEquals(entityManufacturer, manufactuerHardwareDesignersMap.getDeclaringType());            
                // Verify Map Key - should be PK of owning type
                assertEquals(Integer.class, manufactuerHardwareDesignersMap.getKeyJavaType());            
                // Verify Map Value
                assertEquals(HardwareDesigner.class, manufactuerHardwareDesignersMap.getElementType().getJavaType());
                
            } catch (Exception e) {
                // we enter here on a failed commit() - for example if the table schema is incorrectly defined
                e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }

    public void testMapAtributeElementTypeWhenMapKeySetAndNameAttributeSet() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                
                EntityType<Manufacturer> entityManufacturer = metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer);                
                Attribute hardwareDesignersMap = entityManufacturer.getAttribute("hardwareDesignersMapUC4");
                assertNotNull(hardwareDesignersMap);
                assertTrue(hardwareDesignersMap.isCollection());
                assertTrue(hardwareDesignersMap instanceof MapAttributeImpl);
                MapAttribute<? super Manufacturer, ?, ?> manufactuerHardwareDesignersMap = entityManufacturer.getMap("hardwareDesignersMapUC4");            
                // Verify owning type
                assertNotNull(manufactuerHardwareDesignersMap);
                assertEquals(entityManufacturer, manufactuerHardwareDesignersMap.getDeclaringType());            
                // Verify Map Key - should be PK of owning type
                assertEquals(String.class, manufactuerHardwareDesignersMap.getKeyJavaType());            
                // Verify Map Value
                assertEquals(HardwareDesigner.class, manufactuerHardwareDesignersMap.getElementType().getJavaType());
                
            } catch (Exception e) {
                // we enter here on a failed commit() - for example if the table schema is incorrectly defined
                e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }

    public void testIdentifiableType_getDeclaredId_variant_execution_attribute_is_declared_above() {
        if(!this.isJPA10()) {
            EntityManager em = null;

                //<Y> SingularAttribute<X, Y> getDeclaredId(Class<Y> type);
                // Not declared  - invalid - IAE thrown (actually declared 2 levels above in "Person")
                Attribute idAttribute = ((IdentifiableType)entityManufacturer_).getDeclaredId(Integer.class);                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

                // Require a version on a MappedSuperclass
                
                //assertNotNull(msPerson1_.getDeclaredId(Integer.class));
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

            }
        }
    }
    
    public void testAttribute_getPersistentAttributeType_BASIC_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                assertNotNull(anAttribute);
                assertEquals(int.class, anAttribute.getJavaType());
                assertEquals(PersistentAttributeType.BASIC, anAttribute.getPersistentAttributeType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_getPersistentAttributeType_ONE_TO_ONE_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                assertNotNull(anAttribute);
                assertEquals(GalacticPosition.class, anAttribute.getJavaType());                
                assertEquals(PersistentAttributeType.ONE_TO_ONE, anAttribute.getPersistentAttributeType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_getPersistentAttributeType_ONE_TO_MANY_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                assertNotNull(anAttribute);
                assertEquals(Computer.class, anAttribute.getJavaType());                
                assertEquals(PersistentAttributeType.ONE_TO_MANY, anAttribute.getPersistentAttributeType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_getPersistentAttributeType_MANY_TO_MANY_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                //PersistentAttributeType getPersistentAttributeType();
                // note: not implemented yet - need a manyToMany in the model
                //assertEquals(PersistentAttributeType.MANY_TO_MANY, anAttribute.getPersistentAttributeType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_getPersistentAttributeType_MANY_TO_ONE_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                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 (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_getPersistentAttributeType_ELEMENT_COLLECTION_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                //assertNotNull(anAttribute);
                //assertEquals(Computer.class, anAttribute.getJavaType());                
                //assertEquals(PersistentAttributeType.ELEMENT_COLLECTION, anAttribute.getPersistentAttributeType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_getPersistentAttributeType_EMBEDDED_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                assertNotNull(anAttribute);
                assertEquals(EmbeddedPK.class, anAttribute.getJavaType());                
                assertEquals(PersistentAttributeType.EMBEDDED, anAttribute.getPersistentAttributeType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testAttribute_getName_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                 * @return name
                 */
                //String getName();
                
                ManagedType<Person> msPerson = metamodel.managedType(Person.class);                
                assertNotNull(msPerson);
                assertEquals(Type.PersistenceType.MAPPED_SUPERCLASS, msPerson.getPersistenceType());                
                Attribute idAttribute = ((IdentifiableType)msPerson).getDeclaredId(Integer.class);                
                assertNotNull(idAttribute);
                assertEquals(Integer.class, idAttribute.getJavaType());
                assertEquals("id", idAttribute.getName());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_getDeclaringType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                // Test case
                Attribute anAttribute = entityManufacturer_.getDeclaredAttribute("hardwareDesignersMapUC4");
                ManagedType aManagedType = anAttribute.getDeclaringType();
                assertEquals(entityManufacturer_, aManagedType);                
                
                assertNotNull(anAttribute);
                assertEquals(PersistentAttributeType.ONE_TO_MANY, anAttribute.getPersistentAttributeType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_getJavaType_BasicType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                Attribute idAttribute = ((IdentifiableType)msPerson).getDeclaredId(Integer.class);                
                assertNotNull(idAttribute);
                assertEquals(Integer.class, idAttribute.getJavaType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_getJavaType_ManagedType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                Attribute anAttribute = entityManufacturer_.getAttribute("computers");                
                assertNotNull(anAttribute);
                assertEquals(Computer.class, anAttribute.getJavaType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testAttribute_getJavaMember_BasicType_on_MappedSuperclass_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                assertEquals("id", aMember.getName());
                assertNotNull(((Field)aMember).getType());
                assertEquals(Integer.class.getName(), ((Field)aMember).getType().getName());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_getJavaMember_BasicType_on_Entity_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                assertEquals("anInt", aMember.getName());
                assertNotNull(((Field)aMember).getType());
                assertEquals(int.class.getName(), ((Field)aMember).getType().getName());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testAttribute_getJavaMember_ManagedType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                assertEquals("computers", aMember.getName());
                assertNotNull(((Field)aMember).getType());
                assertEquals(Set.class.getName(), ((Field)aMember).getType().getName());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_isAssociation_on_Plural_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                assertEquals(Computer.class, anAttribute.getJavaType());
                boolean isAssociation = anAttribute.isAssociation();
                assertFalse(isAssociation);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_isAssociation_on_Singular_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                boolean isAssociation = anAttribute.isAssociation();
                // Only a ReferenceMapping that extends ObjectReferenceMapping returns true                
                assertFalse(isAssociation);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testAttribute_isCollection_false_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                Type embeddableType = ((SingularAttributeImpl)locationIdAttribute).getType();
                assertNotNull(embeddableType);
                assertNotSame(embeddableType, locationIdAttributeManagedType);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testAttribute_isCollection_true_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                //boolean isCollection();
                assertTrue(anAttribute.isCollection());
                assertTrue(((AttributeImpl)anAttribute).isPlural()); // non-spec.
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testBasicType() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                BasicTypeImpl aRandomBasicType = (BasicTypeImpl) aRandomType;
                assertFalse(aRandomBasicType.isEntity());
                assertFalse(aRandomBasicType.isMappedSuperclass());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testBindable_getBindableType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                    entityManufacturer_.getDeclaredList("hardwareDesigners", HardwareDesigner.class);
                assertNotNull(manufacturer_hardwareDesignersList);
                assertEquals(Bindable.BindableType.PLURAL_ATTRIBUTE, manufacturer_hardwareDesignersList.getBindableType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testBindable_getBindableJavaType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                assertNotNull(manufacturer_hardwareDesignersType);
                assertNotNull(manufacturer_hardwareDesignersType.getJavaType());
                assertEquals(manufacturer_hardwareDesignersType.getJavaType(), manufacturer_hardwareDesignersList.getBindableJavaType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }    
    
    public void testEmbeddableType() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                assertFalse("Expected EmbeddedPK.isMappedSuperclass = false", embeddableType_.isMappedSuperclass());
                assertEquals(PersistenceType.EMBEDDABLE, embeddableType_.getPersistenceType());
                assertEquals(EmbeddedPK.class, embeddableType_.getJavaType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testEntityType() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                
                // get an Attribute<Container, Type==MappedSuperclass>
                Attribute employerAttribute = entityHardwareDesigner_.getAttribute("employer");
                assertTrue(null != employerAttribute);                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                //e.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testIdentifiableType_getId_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                // declared and valid
                MappedSuperclassTypeImpl<Person> msPerson1_ = (MappedSuperclassTypeImpl)metamodel.managedType(Person.class);
                assertNotNull(msPerson1_.getId(Integer.class));
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testIdentifiableType_getVersion_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;


                // Actual Test Case
                /**
                 *  Return the attribute that corresponds to the version 
                 *    attribute of the entity or mapped superclass.
                 *  @param type  the type of the represented version attribute
                 *  @return version attribute
                 *  @throws IllegalArgumentException if version attribute of the 
                 *          given type is not present in the identifiable type
                 */
                //<Y> SingularAttribute<? super X, Y> getVersion(Class<Y> type);
//              EntityType<Enclosure> anEnclosureType = metamodel.entity(Enclosure.class);
//              assertNotNull(anEnclosureType.getVersion(Integer.class));
                // declared and inherited
                
                // declared 
                assertNotNull(entityManufacturer_.getVersion(int.class));
                // declared and valid
                // TODO : require MS version
//                assertNotNull(msPerson1_.getVersion(Integer.class));
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
            }
        }
    }

    public void testIdentifiableType_getDeclaredId_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;
            try {
                em = privateTestSetup();
                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull(metamodel);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);
                EntityTypeImpl<GalacticPosition> entityLocation_ = (EntityTypeImpl) metamodel.entity(GalacticPosition.class);
                assertNotNull(entityLocation_);                
                EntityTypeImpl<Computer> entityComputer_ = (EntityTypeImpl)metamodel.entity(Computer.class);
                assertNotNull(entityComputer_);

                // 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

            }
        }
    }
    
    public void testIdentifiableType_getDeclaredVersion_exists_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;
            try {
                em = privateTestSetup();
                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull(metamodel);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 *  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 
                 *               attribute
                 *  @return declared version attribute
                 *  @throws IllegalArgumentException if version attribute of the 
                 *          type is not declared in the identifiable type
                 */
                //<Y> SingularAttribute<X, Y> getDeclaredVersion(Class<Y> type);
                // FUTURE: need an undeclared subclass
                // Is declared
                SingularAttribute<Manufacturer,?> anAttribute = entityManufacturer_.getDeclaredVersion(int.class); 
                assertNotNull(anAttribute);
                assertNotNull(anAttribute.getType());
                assertNotNull(anAttribute.getBindableType());
                assertNotNull(anAttribute.getBindableJavaType());
                assertNotNull(anAttribute.getDeclaringType());
                assertEquals(entityManufacturer_, anAttribute.getDeclaringType());
                assertFalse(anAttribute.isId());
                assertTrue(anAttribute.isVersion());
                assertEquals(PersistentAttributeType.BASIC, anAttribute.getPersistentAttributeType());
                assertTrue(anAttribute.isOptional());
                assertNotNull(anAttribute.getJavaType());
                assertFalse(anAttribute.isAssociation());
                assertFalse(anAttribute.isCollection());                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
            }
        }
    }

    public void testIdentifiableType_getDeclaredVersion_exists_above_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertNotNull(metamodel);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);
                EntityTypeImpl<GalacticPosition> entityLocation_ = (EntityTypeImpl) metamodel.entity(GalacticPosition.class);
                assertNotNull(entityLocation_);                
                EntityTypeImpl<Computer> entityComputer_ = (EntityTypeImpl)metamodel.entity(Computer.class);
                assertNotNull(entityComputer_);

                // Actual Test Case
                /**
                 *  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 
                 *               attribute
                 *  @return declared version attribute
                 *  @throws IllegalArgumentException if version attribute of the 
                 *          type is not declared in the identifiable type
                 */
                //<Y> SingularAttribute<X, Y> getDeclaredVersion(Class<Y> type);
                // Does not exist
//                EntityType<Enclosure> anEnclosureType = metamodel.entity(Enclosure.class);
//                assertNotNull(anEnclosureType.getDeclaredVersion(Integer.class));
                // Is declared
                assertNotNull(entityManufacturer_.getDeclaredVersion(int.class));
                
                // TODO: need an undeclared subclass
                // Is declared
//                assertNotNull(msPerson1_.getDeclaredVersion(Integer.class));
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
            } catch (Exception e) {
                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testIdentifiableType_getDeclaredVersion_does_not_exist_at_all_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                // TODO: need an undeclared subclass
                // Is declared
//                assertNotNull(msPerson1_.getDeclaredVersion(Integer.class));
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

            }
        }
    }
    
    public void testIdentifiableType_getSupertype_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                }
                assertFalse(expectedIAExceptionThrown);
                assertNull(superTypeLocation);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testIdentifiableType_hasSingleIdAttribute_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                }
                assertFalse(expectedIAExceptionThrown);            
                assertFalse(hasSingleIdAttribute);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testIdentifiableType_hasVersionAttribute_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityType<Enclosure> anEnclosureType = metamodel.entity(Enclosure.class);
                assertFalse(anEnclosureType.hasVersionAttribute());
                assertTrue(entityManufacturer_.hasVersionAttribute());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testIdentifiableType_getIdClassAttributes_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                expectedIAExceptionThrown = false;
                boolean hasSingleIdAttribute = true;
                Set<SingularAttribute<? super Enclosure, ?>> idClassAttributes = null;
                EntityType<Enclosure> aType = metamodel.entity(Enclosure.class);
                hasSingleIdAttribute = aType.hasSingleIdAttribute();
                // We verify that an @IdClass exists - no single @Id or @EmbeddedId exists
                assertFalse(hasSingleIdAttribute);
                idClassAttributes = aType.getIdClassAttributes();
                    idClassAttributes = aType.getIdClassAttributes();
                     
                } catch (IllegalArgumentException iae) {
                    //iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);            
                assertFalse(hasSingleIdAttribute);
                assertNotNull(idClassAttributes);
                assertEquals(4, idClassAttributes.size());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testIdentifiableType_getIdType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertNotNull(msCorporation_);
                
                // Verify all types (entities, embeddables, mappedsuperclasses and basic)
                // get all 21 types (a non spec function - for testing introspection)
                Map<Class, TypeImpl<?>> typesMap = ((MetamodelImpl)metamodel).getTypes();
                // verify each one
                assertNotNull(typesMap);
                assertEquals(METAMODEL_ALL_TYPES, typesMap.size());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                    e.printStackTrace();
                }
            } catch (Exception e) {
                //e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testListAttribute() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;


                // Actual Test Case
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getAttributes_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                //java.util.Set<SingularAttribute<? super X, ?>> getSingularAttributes();
                Set<SingularAttribute<? super Manufacturer, ?>> singularAttributeSet = entityManufacturer_.getSingularAttributes();
                assertNotNull(singularAttributeSet);
                // We should see 3+18 singular attributes for Manufacturer (id(from the mappedSuperclass), version, name(from the mappedSuperclass))
                assertEquals(METAMODEL_MANUFACTURER_DECLARED_TYPES - 7, singularAttributeSet.size());
                // for each managed entity we will see 2 entries (one for the Id, one for the Version)
                assertTrue(singularAttributeSet.contains(entityManufacturer_.getAttribute("id"))); // 
                assertTrue(singularAttributeSet.contains(entityManufacturer_.getAttribute("version"))); //

                 */
                //<E> ListAttribute<? super X, E> getList(String name, Class<E> elementType);

                /**
                 *  Return the Map-valued attribute of the managed type that
                 *  corresponds to the specified name and Java key and value
                 *  types.
                 *  @param name  the name of the represented attribute
                 *  @param keyType  the key type of the represented attribute
                 *  @param valueType  the value type of the represented attribute
                 *  @return MapAttribute of the given name and key and value
                 *  types
                 *  @throws IllegalArgumentException if attribute of the given
                 *          name and type is not present in the managed type
                 */
                //<K, V> MapAttribute<? super X, K, V> getMap(String name, Class<K> keyType, Class<V> valueType);
                expectedIAExceptionThrown = false;            
                try {
                    MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                        entityManufacturer_.getMap("hardwareDesignersMap");
                    // verify the default key type is the not the Map key - rather that is is the managedType PK
                    Class keyJavaType = anAttribute.getKeyJavaType();
                    //@OneToMany(cascade=ALL, mappedBy="mappedEmployer")
                    //private Map<String, HardwareDesigner> hardwareDesignersMap;// = new HashMap<String, HardwareDesigner>();
                    // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_63:_20090824:_Add_Map_support_for_.40MapKey_to_MapAttribute
                    // Key is the primary key (PK) of the target entity - in this case HardwareDesigner which inherits its @Id from the Person @MappedSuperclass as '''Integer'''.
                    Type keyType = anAttribute.getKeyType(); 
                    //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                    assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                    assertNotNull(keyType);
                    assertTrue(keyType instanceof Type);
                    assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
                    
                } catch (IllegalArgumentException iae) {
                    iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);            

                expectedIAExceptionThrown = false;            
                try {
                    MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                        entityManufacturer_.getMap("hardwareDesignersMapUC1a");
                    // verify the key type is the Map key - not the managedType PK
                    Class keyJavaType = anAttribute.getKeyJavaType();
                    // UC 1a: Generics KV set, no @MapKey present, PK is singular field
                    //@OneToMany(cascade=ALL, mappedBy="mappedEmployerUC1a")
                    //private Map<String, HardwareDesigner> hardwareDesignersMapUC1a;
                    Type keyType = anAttribute.getKeyType(); 
                    //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                    assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                    assertNotNull(keyType);
                    assertTrue(keyType instanceof Type);
                    assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
                } catch (IllegalArgumentException iae) {
                    iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);            

                expectedIAExceptionThrown = false;            
                try {
                    MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                        entityManufacturer_.getMap("hardwareDesignersMapUC2");
                    // verify the key type is the Map key - not the managedType PK
                    Class keyJavaType = anAttribute.getKeyJavaType();
                    // UC 2: Generics KV set, @MapKey is present
                    //@OneToMany(cascade=ALL, mappedBy="mappedEmployerUC2")
                    //@MapKey(name="name")
                    //private Map<String, HardwareDesigner> hardwareDesignersMapUC2;
                    Type keyType = anAttribute.getKeyType(); 
                    assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                    //assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                    assertNotNull(keyType);
                    assertTrue(keyType instanceof Type);
                    assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
                } catch (IllegalArgumentException iae) {
                    iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);            
                
                expectedIAExceptionThrown = false;            
                try {
                    MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                        entityManufacturer_.getMap("hardwareDesignersMapUC4");
                    // verify the key type is the Map key - not the managedType PK
                    Class keyJavaType = anAttribute.getKeyJavaType();
                    // UC 4: No Generics KV set, @MapKey is present
                    //@OneToMany(targetEntity=HardwareDesigner.class, cascade=ALL, mappedBy="mappedEmployerUC4")
                    //@MapKey(name="name")
                    //private Map hardwareDesignersMapUC4;
                    Type keyType = anAttribute.getKeyType(); 
                    assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                    //assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                    assertNotNull(keyType);
                    assertTrue(keyType instanceof Type);
                    assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
                } catch (IllegalArgumentException iae) {
                    iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);            

                expectedIAExceptionThrown = false;            
                try {
                    MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                        entityManufacturer_.getMap("hardwareDesignersMapUC7");
                    // verify the key type is the Map key - not the managedType PK
                    Class keyJavaType = anAttribute.getKeyJavaType();
                    // UC 7: Generics KV set, targetEntity is also set, @MapKey is *(set/unset)
                    //@OneToMany(targetEntity=HardwareDesigner.class, cascade=ALL, mappedBy="mappedEmployerUC7")
                    // Same as UC1a - that is missing the @MapKey
                    //private Map<String, HardwareDesigner> hardwareDesignersMapUC7;
                    Type keyType = anAttribute.getKeyType(); 
                    //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                    assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                    assertNotNull(keyType);
                    assertTrue(keyType instanceof Type);
                    assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
                } catch (IllegalArgumentException iae) {
                    iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);            

                expectedIAExceptionThrown = false;            
                try {
                    MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                        entityManufacturer_.getMap("hardwareDesignersMapUC8");
                    // verify the key type is the Map key - not the managedType PK
                    Class keyJavaType = anAttribute.getKeyJavaType();
                    // UC 8: Generics KV set, targetEntity not set, @MapKey is set but name attribute is defaulted
                    //@OneToMany(targetEntity=HardwareDesigner.class, cascade=ALL, mappedBy="mappedEmployerUC8")
                    // Same as UC1a - that is missing the @MapKey name attribute
                    //private Map<String, HardwareDesigner> hardwareDesignersMapUC8;
                    Type keyType = anAttribute.getKeyType(); 
                    //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                    assertEquals(Integer.class, keyJavaType); // When @MapKey is not present or missing name attribute - we default to the PK
                    assertNotNull(keyType);
                    assertTrue(keyType instanceof Type);
                    assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
                } catch (IllegalArgumentException iae) {
                    iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);            
                
                /**
                 *  Return the Collection-valued attribute declared by the 
                 *  managed type that corresponds to the specified name and Java 

                }
                assertTrue("Expected thrown IllegalArgumentException", expectedIAExceptionThrown);
                
                /**
                 *  Return the Map-valued attribute declared by the managed 
                 *  type that corresponds to the specified name and Java key 
                 *  and value types.
                 *  @param name  the name of the represented attribute
                 *  @param keyType  the key type of the represented attribute
                 *  @param valueType  the value type of the represented attribute
                 *  @return declared MapAttribute of the given name and key 
                 *          and value types
                 *  @throws IllegalArgumentException if attribute of the given
                 *          name and type is not declared in the managed type
                 */
                //<K, V> MapAttribute<X, K, V> getDeclaredMap(String name, Class<K> keyType, Class<V> valueType);
                
                /**
                 *  Return all collection-valued attributes of the managed type.

                //MapAttribute<X, ?, ?> getDeclaredMap(String name);            
                
                
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testManagedType_getDeclaredAttributes_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getSingularAttribute_Type_param_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredSingularAttribute_Type_param_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getSingularAttributes_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredSingularAttributes_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getCollection_Type_param_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredCollection_Type_param_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getSet_Type_param_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredSet_Type_param_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getList_Type_param_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredList_Type_param_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getMap_Type_param_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

                /**
                 *  Return the Map-valued attribute of the managed type that
                 *  corresponds to the specified name and Java key and value
                 *  types.
                 *  @param name  the name of the represented attribute
                 *  @param keyType  the key type of the represented attribute
                 *  @param valueType  the value type of the represented attribute
                 *  @return MapAttribute of the given name and key and value
                 *  types
                 *  @throws IllegalArgumentException if attribute of the given
                 *          name and type is not present in the managed type
                 */
                //<K, V> MapAttribute<? super X, K, V> getMap(String name, Class<K> keyType, Class<V> valueType);
                expectedIAExceptionThrown = false;            
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMap", Integer.class,  HardwareDesigner.class);
                // verify the default key type is the not the Map key - rather that is is the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                //@OneToMany(cascade=ALL, mappedBy="mappedEmployer")
                //private Map<String, HardwareDesigner> hardwareDesignersMap;// = new HashMap<String, HardwareDesigner>();
                // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_63:_20090824:_Add_Map_support_for_.40MapKey_to_MapAttribute
                // Key is the primary key (PK) of the target entity - in this case HardwareDesigner which inherits its @Id from the Person @MappedSuperclass as '''Integer'''.
                Type keyType = anAttribute.getKeyType(); 
                //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredMap_Type_param_declared_above_Method() {
    
    }
    
    public void testManagedType_getDeclaredMap_Type_param_not_found_iae_Method() {
        
    }

    public void testManagedType_getDeclaredMap_Type_param_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

                /**
                 *  Return the Map-valued attribute declared by the managed 
                 *  type that corresponds to the specified name and Java key 
                 *  and value types.
                 *  @param name  the name of the represented attribute
                 *  @param keyType  the key type of the represented attribute
                 *  @param valueType  the value type of the represented attribute
                 *  @return declared MapAttribute of the given name and key 
                 *          and value types
                 *  @throws IllegalArgumentException if attribute of the given
                 *          name and type is not declared in the managed type
                 */
                //<K, V> MapAttribute<X, K, V> getDeclaredMap(String name, Class<K> keyType, Class<V> valueType);
                expectedIAExceptionThrown = false;            
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getDeclaredMap("hardwareDesignersMap", Integer.class,  HardwareDesigner.class);
                // verify the default key type is the not the Map key - rather that is is the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                //@OneToMany(cascade=ALL, mappedBy="mappedEmployer")
                //private Map<String, HardwareDesigner> hardwareDesignersMap;// = new HashMap<String, HardwareDesigner>();
                // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_63:_20090824:_Add_Map_support_for_.40MapKey_to_MapAttribute
                // Key is the primary key (PK) of the target entity - in this case HardwareDesigner which inherits its @Id from the Person @MappedSuperclass as '''Integer'''.
                Type keyType = anAttribute.getKeyType(); 
                //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());                
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getPluralAttributes_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredPluralAttributes_internal_entity_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                }
                assertFalse(expectedIAExceptionThrown);            

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testManagedType_getDeclaredPluralAttributes_root_entity_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertNotNull(entityComputer_);
                // This also tests getCollections()
                expectedIAExceptionThrown = false;            
                Set<PluralAttribute<Computer, ?, ?>> collections =
                    entityComputer_.getDeclaredPluralAttributes();
                assertNotNull(collections);
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                } catch (IllegalArgumentException iae) {
                    iae.printStackTrace();
                    expectedIAExceptionThrown = true;            
                }
                assertFalse(expectedIAExceptionThrown);            

            } catch (Exception e) {
                e.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

    }

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

                // historicalComputers is defined as a plural declared attribute on a root mappedSuperclass
                Set<PluralAttribute<Person, ?, ?>> collections = 
                    msPerson_.getDeclaredPluralAttributes();
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getAttribute_on_Entity_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertEquals(CollectionType.MAP, ((MapAttribute)anAttribute).getCollectionType());                
                assertEquals(String.class, ((MapAttribute)anAttribute).getKeyJavaType());
                assertEquals(HardwareDesigner.class, anAttribute.getJavaType());
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testManagedType_getAttribute_on_MappedSuperclass_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertEquals(entityComputer_, ((CollectionAttribute)anAttribute).getElementType());
                assertEquals(CollectionType.COLLECTION, ((CollectionAttribute)anAttribute).getCollectionType());                
                assertEquals(Computer.class, anAttribute.getJavaType());
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getAttribute_doesNotExist_on_Entity_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                
                // Test case
                anAttribute = entityManufacturer_.getAttribute("does_not_exist");
            } catch (IllegalArgumentException iae) {
                // We expect an exception
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testManagedType_getAttribute_doesNotExist_on_MappedSuperclass_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                
                // Test case
                anAttribute = msCorporation_.getAttribute("does_not_exist");
            } catch (IllegalArgumentException iae) {
                // We expect and exception
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredAttribute_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertEquals(CollectionType.MAP, ((MapAttribute)anAttribute).getCollectionType());                
                assertEquals(String.class, ((MapAttribute)anAttribute).getKeyJavaType());
                assertEquals(HardwareDesigner.class, anAttribute.getJavaType());
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testManagedType_getDeclaredAttribute_above_throws_iae_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                // 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 (IllegalArgumentException iae) {
                // We expect and exception
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testManagedType_getDeclaredAttribute_doesNotExist_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;


                // Test case
                anAttribute = entityManufacturer_.getDeclaredAttribute("does_not_exist");
            } catch (IllegalArgumentException iae) {
                // We expect and exception
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

    }
    
    
    public void testManagedType_getSingularAttribute_BASIC_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertFalse(((AttributeImpl)anAttribute).isPlural());
                assertTrue(anAttribute instanceof SingularAttribute);
                assertEquals(int.class, anAttribute.getJavaType());
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getSingularAttribute_EMBEDDED_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertNotNull(entityComputer_);
                
                // not implemented
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredSingularAttribute_on_Entity_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertEquals(PersistentAttributeType.ONE_TO_ONE, anAttribute.getPersistentAttributeType());
                assertFalse(((AttributeImpl)anAttribute).isPlural());
                assertTrue(anAttribute instanceof SingularAttribute);
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testManagedType_getDeclaredSingularAttribute_on_MappedSuperclass_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertFalse(((AttributeImpl)anAttribute).isPlural());
                assertTrue(anAttribute instanceof SingularAttribute);
                assertEquals(String.class, anAttribute.getJavaType());
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getCollection_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredCollection_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getSet_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                    entityManufacturer_.getSet("computers", Computer.class);
                assertNotNull("computers SetAttribute should not be null in Manufacturer_", computersAttribute);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredSet_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getList_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getDeclaredList_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_getMap_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testManagedType_getDeclaredMap_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                EntityTypeImpl<HardwareDesigner> entityHardwareDesigner_ = (EntityTypeImpl)metamodel.entity(HardwareDesigner.class);
                assertNotNull(entityHardwareDesigner_);

            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testManagedType_variantCases() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                }
                assertTrue(count > 0);
                
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);

        }
    }
    
    /**
     * This test will verify that MapAttribute instance have their elementType set correctly.
     * The elementType corresponds to the 3rd V parameter on the class definition - which is the Map value.
     * MapAttributeImpl<X, K, V> 
     */
    public void testMapAtributeElementTypeWhenMapKeySetButNameAttributeIsDefaulted() {
        if(!this.isJPA10()) {
            boolean exceptionThrown = false;
            EntityManager em = null;            
            try {
                em = privateTestSetup();
                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                
                EntityType<Manufacturer> entityManufacturer = metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer);                
                Attribute hardwareDesignersMap = entityManufacturer.getAttribute("hardwareDesignersMapUC8");
                assertNotNull(hardwareDesignersMap);
                assertTrue(hardwareDesignersMap.isCollection());
                assertTrue(hardwareDesignersMap instanceof MapAttributeImpl);
                MapAttribute<? super Manufacturer, ?, ?> manufactuerHardwareDesignersMap = entityManufacturer.getMap("hardwareDesignersMapUC8");            
                // Verify owning type
                assertNotNull(manufactuerHardwareDesignersMap);
                assertEquals(entityManufacturer, manufactuerHardwareDesignersMap.getDeclaringType());            
                // Verify Map Key - should be PK of owning type
                assertEquals(Integer.class, manufactuerHardwareDesignersMap.getKeyJavaType());            
                // Verify Map Value
                assertEquals(HardwareDesigner.class, manufactuerHardwareDesignersMap.getElementType().getJavaType());                
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }

    public void testMapAtributeElementTypeWhenMapKeySetAndNameAttributeSet() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;
            try {

                assertNotNull(em);
                Metamodel metamodel = em.getMetamodel();
                assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
                
                EntityType<Manufacturer> entityManufacturer = metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer);                
                Attribute hardwareDesignersMap = entityManufacturer.getAttribute("hardwareDesignersMapUC4");
                assertNotNull(hardwareDesignersMap);
                assertTrue(hardwareDesignersMap.isCollection());
                assertTrue(hardwareDesignersMap instanceof MapAttributeImpl);
                MapAttribute<? super Manufacturer, ?, ?> manufactuerHardwareDesignersMap = entityManufacturer.getMap("hardwareDesignersMapUC4");            
                // Verify owning type
                assertNotNull(manufactuerHardwareDesignersMap);
                assertEquals(entityManufacturer, manufactuerHardwareDesignersMap.getDeclaringType());            
                // Verify Map Key - should not be PK of owning type
                assertEquals(String.class, manufactuerHardwareDesignersMap.getKeyJavaType());            
                // Verify Map Value
                assertEquals(HardwareDesigner.class, manufactuerHardwareDesignersMap.getElementType().getJavaType());
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }
    
    public void testMapAttribute_getKeyJavaType_UC0_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**

                 * @return Java key type
                 */
                //Class<K> getKeyJavaType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMap");
                // verify the default key type is the not the Map key - rather that is is the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                //@OneToMany(cascade=ALL, mappedBy="mappedEmployer")
                //private Map<String, HardwareDesigner> hardwareDesignersMap;// = new HashMap<String, HardwareDesigner>();
                // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_63:_20090824:_Add_Map_support_for_.40MapKey_to_MapAttribute
                // Key is the primary key (PK) of the target entity - in this case HardwareDesigner which inherits its @Id from the Person @MappedSuperclass as '''Integer'''.
                Type keyType = anAttribute.getKeyType(); 
                //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());

            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testMapAttribute_getKeyJavaType_UC1a_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = 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_);

                // Actual Test Case
                /**
                 * Return the Java type of the map key.
                 * @return Java key type
                 */
                //Class<K> getKeyJavaType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMapUC1a");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC 1a: Generics KV set, no @MapKey present, PK is singular field
                //@OneToMany(cascade=ALL, mappedBy="mappedEmployerUC1a")
                //private Map<String, HardwareDesigner> hardwareDesignersMapUC1a;
                Type keyType = anAttribute.getKeyType(); 
                //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());

            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }

    public void testMapAttribute_getKeyJavaType_UC2_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the Java type of the map key.
                 * @return Java key type
                 */
                //Class<K> getKeyJavaType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMapUC2");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC 2: Generics KV set, @MapKey is present
                //@OneToMany(cascade=ALL, mappedBy="mappedEmployerUC2")
                //@MapKey(name="name")
                //private Map<String, HardwareDesigner> hardwareDesignersMapUC2;
                Type keyType = anAttribute.getKeyType(); 
                assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                //assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());

            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }

    public void testMapAttribute_getKeyJavaType_UC4_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the Java type of the map key.
                 * @return Java key type
                 */
                //Class<K> getKeyJavaType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMapUC4");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC 4: No Generics KV set, @MapKey is present
                //@OneToMany(targetEntity=HardwareDesigner.class, cascade=ALL, mappedBy="mappedEmployerUC4")
                //@MapKey(name="name")
                //private Map hardwareDesignersMapUC4;
                Type keyType = anAttribute.getKeyType(); 
                assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                //assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());

            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }

    public void testMapAttribute_getKeyJavaType_UC7_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the Java type of the map key.
                 * @return Java key type
                 */
                //Class<K> getKeyJavaType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMapUC7");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC 7: Generics KV set, targetEntity is also set, @MapKey is *(set/unset)
                //@OneToMany(targetEntity=HardwareDesigner.class, cascade=ALL, mappedBy="mappedEmployerUC7")
                // Same as UC1a - that is missing the @MapKey
                //private Map<String, HardwareDesigner> hardwareDesignersMapUC7;
                Type keyType = anAttribute.getKeyType(); 
                //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());

            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }
    
    public void testMapAttribute_getKeyJavaType_UC8_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the Java type of the map key.
                 * @return Java key type
                 */
                //Class<K> getKeyJavaType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMapUC8");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC 8: Generics KV set, targetEntity not set, @MapKey is set but name attribute is defaulted
                //@OneToMany(targetEntity=HardwareDesigner.class, cascade=ALL, mappedBy="mappedEmployerUC8")
                // Same as UC1a - that is missing the @MapKey name attribute
                //private Map<String, HardwareDesigner> hardwareDesignersMapUC8;
                Type keyType = anAttribute.getKeyType(); 
                //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                assertEquals(Integer.class, keyJavaType); // When @MapKey is not present or missing name attribute - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());

            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }

    // See
    // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_86:_20090921:_Handle_Embeddable_Type_keyType_in_MapAttributeImpl_constructor
    public void testMapAttribute_getKeyJavaType_UC9_DI86_Embeddable_IdClass_keyType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the Java type of the map key.
                 * @return Java key type
                 */
                //Class<K> getKeyJavaType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("enclosureByBoardMapUC9");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC9: no targetEntity, no MapKey, but generics are set (MapKey has an IdClass with an Embeddable)
                //@OneToMany(cascade=CascadeType.ALL, mappedBy="mappedManufacturerUC9")
                //private Map<Board, Enclosure> enclosureByBoardMapUC9;
                Type keyType = anAttribute.getKeyType(); 
                assertEquals(Board.class, keyJavaType); // When @MapKey(name="name") is present or we use generics
                //assertEquals(Integer.class, keyJavaType); // When @MapKey is not present or missing name attribute - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.ENTITY, keyType.getPersistenceType());

            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }
    
    public void testMapAttribute_getKeyType_UC0_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the type representing the key type of the map.
                 * @return type representing key type
                 */
                //Type<K> getKeyType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMap");
                // verify the default key type is the not the Map key - rather that is is the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                //@OneToMany(cascade=ALL, mappedBy="mappedEmployer")
                //private Map<String, HardwareDesigner> hardwareDesignersMap;// = new HashMap<String, HardwareDesigner>();
                // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_63:_20090824:_Add_Map_support_for_.40MapKey_to_MapAttribute
                // Key is the primary key (PK) of the target entity - in this case HardwareDesigner which inherits its @Id from the Person @MappedSuperclass as '''Integer'''.
                Type keyType = anAttribute.getKeyType(); 
                //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
                
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

            }
        }
    }

    public void testMapAttribute_getKeyType_UC1a_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the type representing the key type of the map.
                 * @return type representing key type
                 */
                //Type<K> getKeyType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMapUC1a");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC 1a: Generics KV set, no @MapKey present, PK is singular field
                //@OneToMany(cascade=ALL, mappedBy="mappedEmployerUC1a")
                //private Map<String, HardwareDesigner> hardwareDesignersMapUC1a;
                Type keyType = anAttribute.getKeyType(); 
                //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }
    
    public void testMapAttribute_getKeyType_UC2_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = 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_);

                // Actual Test Case
                /**
                 * Return the type representing the key type of the map.
                 * @return type representing key type
                 */
                //Type<K> getKeyType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMapUC2");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC 2: Generics KV set, @MapKey is present
                //@OneToMany(cascade=ALL, mappedBy="mappedEmployerUC2")
                //@MapKey(name="name")
                //private Map<String, HardwareDesigner> hardwareDesignersMapUC2;
                Type keyType = anAttribute.getKeyType(); 
                assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                //assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }
    
    public void testMapAttribute_getKeyType_UC4_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the type representing the key type of the map.
                 * @return type representing key type
                 */
                //Type<K> getKeyType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMapUC4");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC 4: No Generics KV set, @MapKey is present
                //@OneToMany(targetEntity=HardwareDesigner.class, cascade=ALL, mappedBy="mappedEmployerUC4")
                //@MapKey(name="name")
                //private Map hardwareDesignersMapUC4;
                Type keyType = anAttribute.getKeyType(); 
                assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                //assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
                
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }
    
    public void testMapAttribute_getKeyType_UC7_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the type representing the key type of the map.
                 * @return type representing key type
                 */
                //Type<K> getKeyType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMapUC7");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC 7: Generics KV set, targetEntity is also set, @MapKey is *(set/unset)
                //@OneToMany(targetEntity=HardwareDesigner.class, cascade=ALL, mappedBy="mappedEmployerUC7")
                // Same as UC1a - that is missing the @MapKey
                //private Map<String, HardwareDesigner> hardwareDesignersMapUC7;
                Type keyType = anAttribute.getKeyType(); 
                //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                assertEquals(Integer.class, keyJavaType); // When @MapKey is not present - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
                
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }
    
    public void testMapAttribute_getKeyType_UC8_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the type representing the key type of the map.
                 * @return type representing key type
                 */
                //Type<K> getKeyType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("hardwareDesignersMapUC8");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC 8: Generics KV set, targetEntity not set, @MapKey is set but name attribute is defaulted
                //@OneToMany(targetEntity=HardwareDesigner.class, cascade=ALL, mappedBy="mappedEmployerUC8")
                // Same as UC1a - that is missing the @MapKey name attribute
                //private Map<String, HardwareDesigner> hardwareDesignersMapUC8;
                Type keyType = anAttribute.getKeyType(); 
                //assertEquals(String.class, keyJavaType); // When @MapKey(name="name") is present
                assertEquals(Integer.class, keyJavaType); // When @MapKey is not present or missing name attribute - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.BASIC, keyType.getPersistenceType());
                
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }

    // see
    // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_86:_20090921:_Handle_Embeddable_Type_keyType_in_MapAttributeImpl_constructor
    public void testMapAttribute_getKeyType_UC9_DI86_Embeddable_IdClass_keyType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the type representing the key type of the map.
                 * @return type representing key type
                 */
                //Type<K> getKeyType();
                MapAttribute<? super Manufacturer, ?, ?> anAttribute = 
                    entityManufacturer_.getMap("enclosureByBoardMapUC9");
                // verify the key type is the Map key - not the managedType PK
                Class keyJavaType = anAttribute.getKeyJavaType();
                // UC9: no targetEntity, no MapKey, but generics are set (MapKey has an IdClass with an Embeddable)
                //@OneToMany(cascade=CascadeType.ALL, mappedBy="mappedManufacturerUC9")
                //private Map<Board, Enclosure> enclosureByBoardMapUC9;
                Type keyType = anAttribute.getKeyType(); 
                assertEquals(Board.class, keyJavaType); // When @MapKey(name="name") is present or we use generics
                //assertEquals(Integer.class, keyJavaType); // When @MapKey is not present or missing name attribute - we default to the PK
                assertNotNull(keyType);
                assertTrue(keyType instanceof Type);
                assertEquals(Type.PersistenceType.ENTITY, keyType.getPersistenceType());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }
    
    public void testMapAttribute_getKeyType_UC9_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);
                EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl)metamodel.entity(Manufacturer.class);
                assertNotNull(entityManufacturer_);

                // Actual Test Case
                /**
                 * Return the type representing the key type of the map.
                 * @return type representing key type
                 */
                //Type<K> getKeyType();
                
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);
                assertFalse("An IAE exception should not occur here.", exceptionThrown);
            }
        }
    }
    
    public void testMappedSuperclassType() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            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);

                // Actual Test Case
                // Interface is empty - however we will test native functionality
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testMetamodel_managedType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                //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]]
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testMetamodel_getEmbeddables_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                 * @return the metamodel embeddable types
                 */
                //java.util.Set<EmbeddableType<?>> getEmbeddables();            
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testMetamodel_getEntities_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                //java.util.Set<EntityType<?>> getEntities();

                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testMetamodel_getManagedTypes_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                 */
                //java.util.Set<ManagedType<?>> getManagedTypes();

            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testMetamodel_embeddable_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertTrue("Expected thrown IllegalArgumentException", expectedIAExceptionThrown);
                // reset state
                expectedIAExceptionThrown = false;
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

    }
    
    
    public void testMetamodel_entity_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                assertTrue("Expected thrown IllegalArgumentException", expectedIAExceptionThrown);
                // reset exception flag
                expectedIAExceptionThrown = false;
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testPluralAttribute_CollectionType_enum() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;


                // Actual Test Case
                //public static enum CollectionType {COLLECTION, SET, LIST, MAP}
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testPluralAttribute_getCollectionType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                 * @return collection type
                 */
                //CollectionType getCollectionType();
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testPluralAttribute_getElementType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                 */
                //Type<E> getElementType();
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testSetAttribute() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                // Actual Test Case
                // The interface is empty - we will test native functionality
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testSingularAttribute_isOptional_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                //boolean isOptional();                
                assertFalse(((AttributeImpl)nameAttribute).isPlural());
                assertFalse(((SingularAttributeImpl)nameAttribute).isVersion());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testSingularAttribute_isId_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                //boolean isId();
                assertFalse(((AttributeImpl)nameAttribute).isPlural());
                assertFalse(((SingularAttributeImpl)nameAttribute).isVersion());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testSingularAttribute_isVersion_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                //public boolean isVersion() {
                assertFalse(((AttributeImpl)nameAttribute).isPlural());
                assertFalse(((SingularAttributeImpl)nameAttribute).isVersion());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testSingularAttribute_getBindableType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                 *  @return bindable type
                 */ 
                //BindableType getBindableType();
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testSingularAttribute_getBindableJavaType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                 */
                //Class<T> getBindableJavaType();
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testSingularAttribute_getJavaType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                 *  @return Java type
                 */
                //public Class<T> getJavaType() {
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testSingularAttribute_getType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean expectedIAExceptionThrown = false;

                 */
                //public String toString() {
                
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }
    
    public void testType_PersistenceType_enum() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                  */ 
                 //PersistenceType getPersistenceType();

            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testType_getPersistenceType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                  *  @return Java type
                  */
                 //Class<X> getJavaType();
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

        }
    }

    public void testType_getJavaType_Method() {
        if(!this.isJPA10()) {
            EntityManager em = null;
            boolean exceptionThrown = false;

                  *  @return Java type
                  */
                 //Class<X> getJavaType();
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);


                Set<Attribute<Processor, ?>> entityProcessorDeclaredAttributes = entityProcessor_.getDeclaredAttributes();
                assertEquals(3, entityProcessorDeclaredAttributes.size());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);

                assertNotNull(entityManufacturer_.getList("hardwareDesigners").toString());
                assertNotNull(entityManufacturer_.getMap("hardwareDesignersMap").toString());
                assertNotNull(entityManufacturer_.getSet("computers").toString());
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                exceptionThrown = true;
            } finally {
                cleanup(em);




        addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAPUC4_JOINTable());
        addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAPUC7_JOINTable());
        addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAPUC8_JOINTable());        
        addTableDefinition(buildMANUFACTURER_ENCLOSURE_MAPUC9_JOINTable());        
        addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_HISTORICAL_JOINTable());        
        addTableDefinition(buildBOARD_MEMORY_JOINTable());
        addTableDefinition(buildBOARD_PROCESSOR_JOINTable());


        return table;
    }

    public static TableDefinition buildMANUFACTURER_ENCLOSURE_MAPUC9_JOINTable() {
        TableDefinition table = new TableDefinition();
        table.setName("CMP3_MM_MANUF_MM_ENCL_MAPUC9");

        FieldDefinition field1 = new FieldDefinition();
        field1.setName("MANUF_ID");
        field1.setTypeName("NUMERIC");
        field1.setSize(15);
        field1.setShouldAllowNull(false);
        field1.setIsPrimaryKey(false);
        field1.setUnique(false);
        field1.setIsIdentity(false);
        field1.setForeignKeyFieldName("CMP3_MM_MANUF.PERSON_ID");
        table.addField(field1);        

        FieldDefinition field2 = new FieldDefinition();
        field2.setName("ENCLOSURE_MAP_ID");
        field2.setTypeName("NUMERIC");
        field2.setSize(15);
        field2.setShouldAllowNull(false);
        field2.setIsPrimaryKey(false);
        field2.setUnique(false);
        field2.setIsIdentity(false);
        field2.setForeignKeyFieldName("CMP3_MM_ENCLOSURE.PERSON_ID");
        table.addField(field2);        

        return table;
    }
    
    public static TableDefinition buildMANUFACTURER_HARDWAREDESIGNER_MAP_JOINTable() {
        TableDefinition table = new TableDefinition();




                // Search the mappings for Id mappings
                for(DatabaseMapping aMapping : getDescriptor().getMappings()) {                    
                    if(aMapping.isJPAId()) {
                        String attributeName = aMapping.getAttributeName();
                        // get the attribute Id (declared or not)
                        Attribute anAttribute = this.getAttribute(aMapping.getAttributeName());
                        if(anAttribute != null) {
                            return this.getMetamodel().getType(anAttribute.getJavaType());
                        }                        

            if (pkMappings.size() == 1) {
                Class aClass = pkMappings.get(0).getAttributeClassification(); // null for OneToOneMapping
                // lookup class in our types map
                return this.metamodel.getType(aClass);
                return aType;
            }
        }
        

                    return false;
                }
            } else {
                // MappedSuperclass descriptors do not have a CMP policy yet because the are not initialized
                return pkFields.size() < 2;
            }
            List<String> idClasses = getMetamodel().getProject().getMetamodelIdClassMap().get(getJavaType().getCanonicalName());

Lines 12-18 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/MapAttributeImpl.java (-12 / +10 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	* 11/05/2009-2.0 mobrien - DI 86: MapKey support when only generics
		17	* are used to determine the keyType for an IdClass that used an embeddable
16	******************************************************************************/	18	******************************************************************************/
17	package org.eclipse.persistence.internal.jpa.metamodel;	19	package org.eclipse.persistence.internal.jpa.metamodel;
18		20
Lines 74-79 Link Here
74	// Override the elementType (V or Map value)	76	// Override the elementType (V or Map value)
75	// We need to set the keyType Type that represents the type of the Map key for this mapping	77	// We need to set the keyType Type that represents the type of the Map key for this mapping
76	ContainerPolicy policy = mapping.getContainerPolicy();	78	ContainerPolicy policy = mapping.getContainerPolicy();
		79	ClassDescriptor policyElementDescriptor = policy.getElementDescriptor();
77	Object policyKeyType = policy.getKeyType(); // returns a Class<?> or descriptor (via AggregateObjectMapping)	80	Object policyKeyType = policy.getKeyType(); // returns a Class<?> or descriptor (via AggregateObjectMapping)
78	Type<?> aKeyType = null;	81	Type<?> aKeyType = null;
79	// Default to Object class for any variant cases that are not handled	82	// Default to Object class for any variant cases that are not handled
Lines 82-109 Link Here
82	// No policy key type = IdClass (use CMP3Policy.pkClass)	85	// No policy key type = IdClass (use CMP3Policy.pkClass)
83	if(managedType.isIdentifiableType()) {	86	if(managedType.isIdentifiableType()) {
84	// Use the CMPPolicy on the element not the one on the managedType	87	// Use the CMPPolicy on the element not the one on the managedType
85	if(policy.getElementDescriptor() != null && policy.getElementDescriptor().getCMPPolicy() != null) {	88	if(policyElementDescriptor != null &&
		89	policyElementDescriptor.getCMPPolicy() != null) {
86	javaClass = policy.getElementDescriptor().getCMPPolicy().getPKClass();	90	javaClass = policy.getElementDescriptor().getCMPPolicy().getPKClass();
87	}	91	}
88	if(null == javaClass) {	92	if(null == javaClass) {
89	// check for a @MapKeyClass annotation	93	// check for a @MapKeyClass annotation
90	if(policy.isMappedKeyMapPolicy()) {	94	if(policy.isMappedKeyMapPolicy()) {
91	javaClass = getOwningPrimaryKeyTypeWhenMapKeyAnnotationMissingOrDefaulted((MappedKeyMapContainerPolicy)policy);	95	javaClass = getOwningPKTypeWhenMapKeyAnnotationMissingOrDefaulted(
		96	(MappedKeyMapContainerPolicy)policy);
92	}	97	}
93	}	98	}
94	} else {
95	// TODO: Handle EmbeddableType
96	javaClass = Object.class;
97	}	99	}
98	} else {	100	} else {
99	if(policyKeyType instanceof ClassDescriptor) { // from AggregateObjectMapping	101	if(policyKeyType instanceof ClassDescriptor) { // from AggregateObjectMapping
100	javaClass = ((ClassDescriptor)policyKeyType).getJavaClass();	102	javaClass = ((ClassDescriptor)policyKeyType).getJavaClass();
101	} else {	103	} else {
102	if(policy.isMappedKeyMapPolicy()) {	104	javaClass = (Class<?>)policyKeyType;
103	javaClass = getOwningPrimaryKeyTypeWhenMapKeyAnnotationMissingOrDefaulted((MappedKeyMapContainerPolicy)policy);
104	} else {
105	javaClass = (Class<?>)policyKeyType;
106	}
107	}	105	}
108	}	106	}
109	if(null == javaClass) {	107	if(null == javaClass) {
Lines 120-126 Link Here
120	* Prerequisites: policy on the mapping is of type MappedKeyMapPolicy	118	* Prerequisites: policy on the mapping is of type MappedKeyMapPolicy
121	* @return	119	* @return
122	*/	120	*/
123	private Class getOwningPrimaryKeyTypeWhenMapKeyAnnotationMissingOrDefaulted(MappedKeyMapContainerPolicy policy) {	121	private Class getOwningPKTypeWhenMapKeyAnnotationMissingOrDefaulted(MappedKeyMapContainerPolicy policy) {
124	Class<?> javaClass = null;;	122	Class<?> javaClass = null;;
125	MapKeyMapping mapKeyMapping = policy.getKeyMapping();	123	MapKeyMapping mapKeyMapping = policy.getKeyMapping();
126	RelationalDescriptor descriptor = (RelationalDescriptor)((DatabaseMapping)mapKeyMapping).getDescriptor();	124	RelationalDescriptor descriptor = (RelationalDescriptor)((DatabaseMapping)mapKeyMapping).getDescriptor();

Return to bug 266912

Lines 216-224 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/IdentifiableTypeImpl.java (-5 / +3 lines)
216	// Search the mappings for Id mappings	216	// Search the mappings for Id mappings
217	for(DatabaseMapping aMapping : getDescriptor().getMappings()) {	217	for(DatabaseMapping aMapping : getDescriptor().getMappings()) {
218	if(aMapping.isJPAId()) {	218	if(aMapping.isJPAId()) {
219	String attributeName = aMapping.getAttributeName();
220	// get the attribute Id (declared or not)	219	// get the attribute Id (declared or not)
221	Attribute anAttribute = this.getAttribute(attributeName);	220	Attribute anAttribute = this.getAttribute(aMapping.getAttributeName());
222	if(anAttribute != null) {	221	if(anAttribute != null) {
223	return this.getMetamodel().getType(anAttribute.getJavaType());	222	return this.getMetamodel().getType(anAttribute.getJavaType());
224	}	223	}
Lines 229-236 Link Here
229	if (pkMappings.size() == 1) {	228	if (pkMappings.size() == 1) {
230	Class aClass = pkMappings.get(0).getAttributeClassification(); // null for OneToOneMapping	229	Class aClass = pkMappings.get(0).getAttributeClassification(); // null for OneToOneMapping
231	// lookup class in our types map	230	// lookup class in our types map
232	Type<?> aType = this.metamodel.getType(aClass);	231	return this.metamodel.getType(aClass);
233	return aType;
234	}	232	}
235	}	233	}
236		234
Lines 334-340 Link Here
334	return false;	332	return false;
335	}	333	}
336	} else {	334	} else {
337	// MappedSuperclass descriptors do not have a CMP policy	335	// MappedSuperclass descriptors do not have a CMP policy yet because the are not initialized
338	return pkFields.size() < 2;	336	return pkFields.size() < 2;
339	}	337	}
340	List<String> idClasses = getMetamodel().getProject().getMetamodelIdClassMap().get(getJavaType().getCanonicalName());	338	List<String> idClasses = getMetamodel().getProject().getMetamodelIdClassMap().get(getJavaType().getCanonicalName());

Lines 79-84 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelTableCreator.java (+30 lines)
79	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAPUC4_JOINTable());	79	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAPUC4_JOINTable());
80	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAPUC7_JOINTable());	80	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAPUC7_JOINTable());
81	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAPUC8_JOINTable());	81	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAPUC8_JOINTable());
		82	addTableDefinition(buildMANUFACTURER_ENCLOSURE_MAPUC9_JOINTable());
82	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_HISTORICAL_JOINTable());	83	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_HISTORICAL_JOINTable());
83	addTableDefinition(buildBOARD_MEMORY_JOINTable());	84	addTableDefinition(buildBOARD_MEMORY_JOINTable());
84	addTableDefinition(buildBOARD_PROCESSOR_JOINTable());	85	addTableDefinition(buildBOARD_PROCESSOR_JOINTable());
Lines 1464-1469 Link Here
1464		1465
1465	return table;	1466	return table;
1466	}	1467	}
		1468
		1469	public static TableDefinition buildMANUFACTURER_ENCLOSURE_MAPUC9_JOINTable() {
		1470	TableDefinition table = new TableDefinition();
		1471	table.setName("CMP3_MM_MANUF_MM_ENCL_MAPUC9");
		1472
		1473	FieldDefinition field1 = new FieldDefinition();
		1474	field1.setName("MANUF_ID");
		1475	field1.setTypeName("NUMERIC");
		1476	field1.setSize(15);
		1477	field1.setShouldAllowNull(false);
		1478	field1.setIsPrimaryKey(false);
		1479	field1.setUnique(false);
		1480	field1.setIsIdentity(false);
		1481	field1.setForeignKeyFieldName("CMP3_MM_MANUF.PERSON_ID");
		1482	table.addField(field1);
		1483
		1484	FieldDefinition field2 = new FieldDefinition();
		1485	field2.setName("ENCLOSURE_MAP_ID");
		1486	field2.setTypeName("NUMERIC");
		1487	field2.setSize(15);
		1488	field2.setShouldAllowNull(false);
		1489	field2.setIsPrimaryKey(false);
		1490	field2.setUnique(false);
		1491	field2.setIsIdentity(false);
		1492	field2.setForeignKeyFieldName("CMP3_MM_ENCLOSURE.PERSON_ID");
		1493	table.addField(field2);
		1494
		1495	return table;
		1496	}
1467		1497
1468	public static TableDefinition buildMANUFACTURER_HARDWAREDESIGNER_MAP_JOINTable() {	1498	public static TableDefinition buildMANUFACTURER_HARDWAREDESIGNER_MAP_JOINTable() {
1469	TableDefinition table = new TableDefinition();	1499	TableDefinition table = new TableDefinition();