openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/meta/TestMetamodel.java - openjpa - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package org.apache.openjpa.persistence.meta;

 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;

 import javax.persistence.metamodel.Attribute;
 import javax.persistence.metamodel.Attribute.PersistentAttributeType;
 import javax.persistence.metamodel.Bindable.BindableType;
 import javax.persistence.metamodel.CollectionAttribute;
 import javax.persistence.metamodel.EntityType;
 import javax.persistence.metamodel.IdentifiableType;
 import javax.persistence.metamodel.ListAttribute;
 import javax.persistence.metamodel.ManagedType;
 import javax.persistence.metamodel.PluralAttribute.CollectionType;
 import javax.persistence.metamodel.SetAttribute;
 import javax.persistence.metamodel.SingularAttribute;
 import javax.persistence.metamodel.Type.PersistenceType;

 import org.apache.openjpa.meta.ClassMetaData;
 import org.apache.openjpa.persistence.embed.Address;
 import org.apache.openjpa.persistence.embed.Geocode;
 import org.apache.openjpa.persistence.enhance.identity.Book;
 import org.apache.openjpa.persistence.enhance.identity.BookId;
 import org.apache.openjpa.persistence.enhance.identity.Library;
 import org.apache.openjpa.persistence.enhance.identity.Page;
 import org.apache.openjpa.persistence.relations.OneOneChild;
 import org.apache.openjpa.persistence.relations.OneOneParent;
 import org.apache.openjpa.persistence.test.SingleEMFTestCase;

 /**
  * Tests JPA 2.0 Metamodel.
  *
  * @author Pinaki Poddar
  *
  */
 public class TestMetamodel extends SingleEMFTestCase {
     private static MetamodelImpl model;

     @Override
     public void setUp() {
         if (model == null) {
     	super.setUp(
     	        "openjpa.RuntimeUnenhancedClasses", "unsupported",
     	        "openjpa.DynamicEnhancementAgent", "false",
     			ImplicitFieldAccessMappedSuperclass.class,
     	        ImplicitFieldAccessBase.class,
     	        ImplicitFieldAccessSubclass.class,
     	        ExplicitFieldAccess.class,
     	        ExplicitPropertyAccess.class,
     	        Embed0.class,
     	        Embed1.class,
     	        OneOneParent.class,
     	        OneOneChild.class,
     	        Book.class,
     	        Library.class,
     	        Page.class,
     	        Address.class,
     	        Geocode.class);
     	emf.createEntityManager();
         model = (MetamodelImpl)emf.getMetamodel();
         }
     }

     public void testMetaModelForDomainClassesExist() {
         assertFalse(model.getEntities().isEmpty());
         assertFalse(model.getEmbeddables().isEmpty());
         assertFalse(model.getManagedTypes().isEmpty());
     }

     public void testMetaClassFieldsArePopulated() {
         EntityType<ImplicitFieldAccessSubclass> m =  model.entity(ImplicitFieldAccessSubclass.class);
         assertNotNull(m);
         Class<?> mCls = m.getJavaType();
         assertSame(ImplicitFieldAccessSubclass.class, mCls);

         Class<?> m2Cls = model.getRepository().getMetaModel(mCls, true);
         assertNotNull(m2Cls);
         try {
             Field f2 = getStaticField(m2Cls, "base");
             assertNotNull(f2);
             Object value = f2.get(null);
             assertNotNull(value);
             assertTrue(Attribute.class.isAssignableFrom(value.getClass()));
         } catch (Throwable t) {
             t.printStackTrace();
             fail();
         }
     }

     public void testDomainClassCategorizedInPersistentCategory() {
     	assertCategory(PersistenceType.MAPPED_SUPERCLASS, ImplicitFieldAccessMappedSuperclass.class);
     	assertCategory(PersistenceType.ENTITY, ImplicitFieldAccessBase.class);
     	assertCategory(PersistenceType.ENTITY, ImplicitFieldAccessSubclass.class);
     	assertCategory(PersistenceType.EMBEDDABLE, Embed0.class);
     	assertCategory(PersistenceType.EMBEDDABLE, Embed1.class);

         assertNotNull(model.entity(ImplicitFieldAccessBase.class));
         assertNotNull(model.entity(ImplicitFieldAccessSubclass.class));
         assertNotNull(model.embeddable(Embed0.class));
         assertNotNull(model.embeddable(Embed1.class));

         java.util.Set<ManagedType<?>> managedTypes = model.getManagedTypes();
         managedTypes.removeAll(model.getEmbeddables());
         managedTypes.removeAll(model.getEntities());
         assertNotNull(model.managedType(ImplicitFieldAccessMappedSuperclass.class));
         assertTrue(managedTypes.contains(model.managedType(ImplicitFieldAccessMappedSuperclass.class)));
     }

     public void testGetAttributeByNameAndTypeFromMetaClass() {
         ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
         assertNotNull(e0.getAttribute("f0"));
         assertNotNull(e0.getSingularAttribute("f0", String.class));
         assertSame(e0.getAttribute("f0"), e0.getSingularAttribute("f0", String.class));
         try {
             e0.getSingularAttribute("f0", ExplicitFieldAccess.class);
             fail("Expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
             // good
         }
         ManagedType<ImplicitFieldAccessSubclass> e1 = model.entity(ImplicitFieldAccessSubclass.class);
         assertNotNull(e1.getAttribute("f0"));
     }

     public void testAttributeByDeclaration() {
         ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
         ManagedType<ImplicitFieldAccessSubclass> e1 = model.entity(ImplicitFieldAccessSubclass.class);
         assertNotNull(e0.getAttribute("f0"));
         assertNotNull(e1.getAttribute("f0"));
         System.err.println(e0.getAttribute("f0"));
         assertNotNull(e0.getSingularAttribute("f0", String.class));
         assertNotNull(e1.getSingularAttribute("f0", String.class));
         assertSame(e0.getAttribute("f0"), e0.getSingularAttribute("f0", String.class));
         assertSame(e1.getAttribute("f0"), e1.getSingularAttribute("f0", String.class));
         assertNotSame(e0.getAttribute("f0"), e1.getAttribute("f0"));
         assertNotSame(e0.getSingularAttribute("f0", String.class), e1.getSingularAttribute("f0", String.class));
         assertNotNull(e0.getDeclaredAttribute("f0"));
         try {
             e1.getDeclaredAttribute("f0");
             fail("Expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
             // good
         }
     }

     public void testPCCollection() {
         ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
         ManagedType<ExplicitFieldAccess> r1 = model.entity(ExplicitFieldAccess.class);
         CollectionAttribute<?,?> relColl = e0.getCollection("collectionRelation", ExplicitFieldAccess.class);
         assertEquals(javax.persistence.metamodel.PluralAttribute.CollectionType.COLLECTION,
                 relColl.getCollectionType());
         assertEquals(e0, relColl.getDeclaringType());
         assertEquals(r1, relColl.getElementType());
         assertEquals(ExplicitFieldAccess.class, relColl.getBindableJavaType());
         assertEquals(BindableType.PLURAL_ATTRIBUTE, relColl.getBindableType());
         assertEquals(Attribute.PersistentAttributeType.ONE_TO_MANY, relColl.getPersistentAttributeType());
     }

     public void testPCList() {
         ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
         ManagedType<ExplicitFieldAccess> r1 = model.entity(ExplicitFieldAccess.class);
         ListAttribute<?, ?> relList = e0.getList("listRelation", ExplicitFieldAccess.class);

         assertEquals(CollectionType.LIST, relList.getCollectionType());
         assertEquals(e0, relList.getDeclaringType());
         assertEquals(r1, relList.getElementType());
         assertEquals(ExplicitFieldAccess.class, relList.getBindableJavaType());
         assertEquals(BindableType.PLURAL_ATTRIBUTE, relList.getBindableType());
         assertEquals(PersistentAttributeType.ONE_TO_MANY, relList.getPersistentAttributeType());
     }

     public void testPCSet() {
         ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
         ManagedType<ExplicitFieldAccess> r1 = model.entity(ExplicitFieldAccess.class);
         SetAttribute<?, ?> relSet = e0.getSet("setRelation", ExplicitFieldAccess.class);
         assertEquals(javax.persistence.metamodel.PluralAttribute.CollectionType.SET, relSet.getCollectionType());
         assertEquals(e0, relSet.getDeclaringType());
         assertEquals(r1, relSet.getElementType());
         assertEquals(ExplicitFieldAccess.class, relSet.getBindableJavaType());
         assertEquals(BindableType.PLURAL_ATTRIBUTE, relSet.getBindableType());
         assertEquals(PersistentAttributeType.ONE_TO_MANY, relSet.getPersistentAttributeType());
     }

     public void testDeclaredFields() {
         ManagedType<ImplicitFieldAccessSubclass> e1 = model.entity(ImplicitFieldAccessSubclass.class);
         java.util.Set<?> all = e1.getAttributes();
         java.util.Set<?> decl = e1.getDeclaredAttributes();
         assertTrue("All fields " + all + "\r\nDeclared fields " + decl + "\r\n"+
          "expecetd not all fields as declared", all.size() > decl.size());
     }

     public void testNonExistentField() {
         ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
         ManagedType<ImplicitFieldAccessSubclass> e1 = model.entity(ImplicitFieldAccessSubclass.class);
         assertFails(e0, "xyz", false);
         assertFails(e1, "f0", true);
     }

     /**
      * Test all attribute getters of ManagedType for valid inputs.
      */
     public void testAttributeGettersForValidInput() {
         IdentifiableType<ImplicitFieldAccessSubclass> subClass = model.entity(ImplicitFieldAccessSubclass.class);
         IdentifiableType<ImplicitFieldAccessBase> superClass = model.entity(ImplicitFieldAccessBase.class);

         assertEquals(superClass, subClass.getSupertype());

         assertNotNull(subClass.getAttribute("f0"));
         assertNotNull(superClass.getAttribute("f0"));
         assertNotNull(subClass.getAttribute("mapRelationKeyEmbedded"));

         assertNotNull(subClass.getAttributes());
         assertNotNull(superClass.getAttributes());
         assertEquals(14, subClass.getAttributes().size());
         assertEquals(12, superClass.getAttributes().size());

         assertNotNull(superClass.getCollection("collectionRelation"));
         assertNotNull(superClass.getCollection("collectionRelation", ExplicitFieldAccess.class));

         assertNotNull(subClass.getPluralAttributes());
         assertNotNull(superClass.getPluralAttributes());
         assertEquals(6, subClass.getPluralAttributes().size());
         assertEquals(5, superClass.getPluralAttributes().size());

         assertNotNull(subClass.getDeclaredAttribute("mapRelationKeyEmbedded"));

         assertNotNull(subClass.getDeclaredAttributes());
         assertNotNull(superClass.getDeclaredAttributes());
         assertEquals(2, subClass.getDeclaredAttributes().size());
         assertEquals(9, superClass.getDeclaredAttributes().size());

         assertNotNull(superClass.getDeclaredCollection("collectionRelation"));

         assertNotNull(subClass.getDeclaredPluralAttributes());
         assertNotNull(superClass.getDeclaredPluralAttributes());
         assertEquals(1, subClass.getDeclaredPluralAttributes().size());
         assertEquals(5, superClass.getDeclaredPluralAttributes().size());

         assertNotNull(superClass.getDeclaredList("listRelation"));
         assertNotNull(superClass.getDeclaredList("listRelation", ExplicitFieldAccess.class));
         assertNotNull(superClass.getDeclaredMap("mapRelationKeyBasic"));
         assertNotNull(superClass.getDeclaredMap("mapRelationKeyBasic", Integer.class, ExplicitFieldAccess.class));
         assertNotNull(superClass.getDeclaredSet("setRelation"));
         assertNotNull(superClass.getDeclaredSet("setRelation", ExplicitFieldAccess.class));
         assertNotNull(superClass.getDeclaredSingularAttribute("one2oneRelation"));
         assertNotNull(superClass.getDeclaredSingularAttribute("one2oneRelation", ExplicitFieldAccess.class));
         assertNotNull(superClass.getDeclaredSingularAttributes());


         assertNotNull(subClass.getList("listRelation"));
         assertNotNull(subClass.getList("listRelation", ExplicitFieldAccess.class));
         assertNotNull(subClass.getMap("mapRelationKeyBasic"));
         assertNotNull(subClass.getMap("mapRelationKeyBasic", Integer.class, ExplicitFieldAccess.class));
         assertNotNull(subClass.getPersistenceType());
         assertNotNull(subClass.getSet("setRelation"));
         assertNotNull(subClass.getSet("setRelation", ExplicitFieldAccess.class));
         assertNotNull(subClass.getSingularAttribute("one2oneRelation"));
         assertNotNull(subClass.getSingularAttribute("one2oneRelation", ExplicitFieldAccess.class));
         assertNotNull(subClass.getSingularAttributes());
     }

     public void testSimpleIdAttributes() {
         IdentifiableType<OneOneParent> entity = model.entity(OneOneParent.class);
         for (Attribute<? super OneOneParent,?> a : entity.getAttributes()) {
             System.err.println(a.getName());
         }
         assertNotNull(entity.getId(long.class));
         assertNotNull(entity.getDeclaredId(long.class));
         assertTrue(entity.hasSingleIdAttribute());
         assertEquals(long.class, entity.getIdType().getJavaType());
     }

     public void testVersionAttributes() {
         IdentifiableType<OneOneParent> entity = model.entity(OneOneParent.class);
         for (Attribute<? super OneOneParent,?> a : entity.getAttributes()) {
             System.err.println(a.getName());
         }
         assertNotNull(entity.getVersion(Integer.class));
         assertNotNull(entity.getDeclaredVersion(Integer.class));
         assertTrue(entity.hasVersionAttribute());
     }

     public void testIdClassAttributes() {
         IdentifiableType<Book> entity = model.entity(Book.class);

         assertEquals(2, entity.getIdClassAttributes().size());
         assertNotNull(entity.getId(String.class));
         assertNotNull(entity.getId(Library.class));
         assertNotNull(entity.getDeclaredId(String.class));
         assertNotNull(entity.getDeclaredId(Library.class));
         assertEquals(BookId.class, entity.getIdType().getJavaType());
         assertFalse(entity.hasSingleIdAttribute());
     }

     public void testBasicAttributeType() {
         ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
         SingularAttribute<ImplicitFieldAccessBase,?> pInt = e0.getDeclaredSingularAttribute("primitiveInt");
         assertEquals(PersistentAttributeType.BASIC, pInt.getPersistentAttributeType());
     }

     public void testEmbeddedAttributeType() {
         ManagedType<Address> type = model.entity(Address.class);
         Attribute.PersistentAttributeType attr = type.getAttribute("geocode").getPersistentAttributeType();
         assertEquals(PersistentAttributeType.EMBEDDED, attr);
     }

     public void testNotFoundErrorMessage() {
         IdentifiableType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
         String name = "unknown";
         try {
           Method[] getters = {
             e0.getClass().getMethod("getAttribute",          new Class<?>[]{String.class}),
             e0.getClass().getMethod("getCollection",         new Class<?>[]{String.class}),
             e0.getClass().getMethod("getList",               new Class<?>[]{String.class}),
             e0.getClass().getMethod("getSet",                new Class<?>[]{String.class}),
             e0.getClass().getMethod("getSingularAttribute",  new Class<?>[]{String.class}),

             e0.getClass().getMethod("getDeclaredAttribute",  new Class<?>[]{String.class}),
             e0.getClass().getMethod("getDeclaredCollection", new Class<?>[]{String.class}),
             e0.getClass().getMethod("getDeclaredList",       new Class<?>[]{String.class}),
             e0.getClass().getMethod("getDeclaredSet",        new Class<?>[]{String.class}),
             e0.getClass().getMethod("getDeclaredSingularAttribute", new Class<?>[]{String.class}),

             e0.getClass().getMethod("getAttribute",          new Class<?>[]{String.class, Class.class}),
             e0.getClass().getMethod("getCollection",         new Class<?>[]{String.class, Class.class}),
             e0.getClass().getMethod("getList",               new Class<?>[]{String.class, Class.class}),
             e0.getClass().getMethod("getSet",                new Class<?>[]{String.class, Class.class}),
             e0.getClass().getMethod("getSingularAttribute",  new Class<?>[]{String.class, Class.class}),

             e0.getClass().getMethod("getDeclaredAttribute",  new Class<?>[]{String.class, Class.class}),
             e0.getClass().getMethod("getDeclaredCollection", new Class<?>[]{String.class, Class.class}),
             e0.getClass().getMethod("getDeclaredList",       new Class<?>[]{String.class, Class.class}),
             e0.getClass().getMethod("getDeclaredSet",        new Class<?>[]{String.class, Class.class}),
             e0.getClass().getMethod("getDeclaredSingularAttribute", new Class<?>[]{String.class, Class.class}),

             e0.getClass().getMethod("getMap",          new Class<?>[]{String.class}),
             e0.getClass().getMethod("getMap",          new Class<?>[]{String.class, Class.class, Class.class}),
             e0.getClass().getMethod("getDeclaredMap",  new Class<?>[]{String.class}),
             e0.getClass().getMethod("getDeclaredMap",  new Class<?>[]{String.class, Class.class, Class.class}),
           };
 //                 e0.getClass().getMethod("getDeclaredVersion", new Class<?>[]{Class.class}),

         for (int i = 0; i < getters.length; i++) {
             Object[] args;
             if (i < 10) {
                 args = new Object[]{name};
             } else if (i < 20) {
                 args = new Object[]{name, Object.class};
             } else if (i%2 == 0) {
                 args = new Object[]{name};
             } else {
                 args = new Object[]{name, Object.class, String.class};
             }
             try {
                 getters[i].invoke(e0, args);
                 fail();
             }  catch (InvocationTargetException e) {
                System.err.println("Expeceted:" + e.getTargetException());
             }
         }
         } catch (Exception e) {
             e.printStackTrace();
             fail();
         }
     }

     void assertFails(ManagedType<?> type, String name, boolean dec) {
         try {
             Attribute<?,?> a = dec ? type.getDeclaredAttribute(name)
                 : type.getAttribute(name);
             fail("Expected to fail " + name + " on " + type);
         } catch (IllegalArgumentException e) {
             System.err.println("Expeceted:" + e);
         }
     }

     PersistenceType categorize(Class<?> c) {
         AbstractManagedType<?> type = (AbstractManagedType<?>)model.getType(c);
         ClassMetaData meta = type.meta;
         return MetamodelImpl.getPersistenceType(meta);
     }

     void assertCategory(PersistenceType category, Class<?> cls) {
     	assertEquals(cls.toString(), category, categorize(cls));
     }

     Field getStaticField(Class<?> cls, String name) {
         try {
             Field[] fds = cls.getDeclaredFields();
             for (Field f : fds) {
                 int mods = f.getModifiers();
                 if (f.getName().equals(name) && Modifier.isStatic(mods))
                     return f;
             }
         } catch (Exception e) {
         }
         return null;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package org.apache.openjpa.persistence.meta;

	import java.lang.reflect.Field;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.lang.reflect.Modifier;

	import javax.persistence.metamodel.Attribute;
	import javax.persistence.metamodel.Attribute.PersistentAttributeType;
	import javax.persistence.metamodel.Bindable.BindableType;
	import javax.persistence.metamodel.CollectionAttribute;
	import javax.persistence.metamodel.EntityType;
	import javax.persistence.metamodel.IdentifiableType;
	import javax.persistence.metamodel.ListAttribute;
	import javax.persistence.metamodel.ManagedType;
	import javax.persistence.metamodel.PluralAttribute.CollectionType;
	import javax.persistence.metamodel.SetAttribute;
	import javax.persistence.metamodel.SingularAttribute;
	import javax.persistence.metamodel.Type.PersistenceType;

	import org.apache.openjpa.meta.ClassMetaData;
	import org.apache.openjpa.persistence.embed.Address;
	import org.apache.openjpa.persistence.embed.Geocode;
	import org.apache.openjpa.persistence.enhance.identity.Book;
	import org.apache.openjpa.persistence.enhance.identity.BookId;
	import org.apache.openjpa.persistence.enhance.identity.Library;
	import org.apache.openjpa.persistence.enhance.identity.Page;
	import org.apache.openjpa.persistence.relations.OneOneChild;
	import org.apache.openjpa.persistence.relations.OneOneParent;
	import org.apache.openjpa.persistence.test.SingleEMFTestCase;

	/**
	* Tests JPA 2.0 Metamodel.
	*
	* @author Pinaki Poddar
	*
	*/
	public class TestMetamodel extends SingleEMFTestCase {
	private static MetamodelImpl model;

	@Override
	public void setUp() {
	if (model == null) {
	super.setUp(
	"openjpa.RuntimeUnenhancedClasses", "unsupported",
	"openjpa.DynamicEnhancementAgent", "false",
	ImplicitFieldAccessMappedSuperclass.class,
	ImplicitFieldAccessBase.class,
	ImplicitFieldAccessSubclass.class,
	ExplicitFieldAccess.class,
	ExplicitPropertyAccess.class,
	Embed0.class,
	Embed1.class,
	OneOneParent.class,
	OneOneChild.class,
	Book.class,
	Library.class,
	Page.class,
	Address.class,
	Geocode.class);
	emf.createEntityManager();
	model = (MetamodelImpl)emf.getMetamodel();
	}
	}

	public void testMetaModelForDomainClassesExist() {
	assertFalse(model.getEntities().isEmpty());
	assertFalse(model.getEmbeddables().isEmpty());
	assertFalse(model.getManagedTypes().isEmpty());
	}

	public void testMetaClassFieldsArePopulated() {
	EntityType<ImplicitFieldAccessSubclass> m = model.entity(ImplicitFieldAccessSubclass.class);
	assertNotNull(m);
	Class<?> mCls = m.getJavaType();
	assertSame(ImplicitFieldAccessSubclass.class, mCls);

	Class<?> m2Cls = model.getRepository().getMetaModel(mCls, true);
	assertNotNull(m2Cls);
	try {
	Field f2 = getStaticField(m2Cls, "base");
	assertNotNull(f2);
	Object value = f2.get(null);
	assertNotNull(value);
	assertTrue(Attribute.class.isAssignableFrom(value.getClass()));
	} catch (Throwable t) {
	t.printStackTrace();
	fail();
	}
	}

	public void testDomainClassCategorizedInPersistentCategory() {
	assertCategory(PersistenceType.MAPPED_SUPERCLASS, ImplicitFieldAccessMappedSuperclass.class);
	assertCategory(PersistenceType.ENTITY, ImplicitFieldAccessBase.class);
	assertCategory(PersistenceType.ENTITY, ImplicitFieldAccessSubclass.class);
	assertCategory(PersistenceType.EMBEDDABLE, Embed0.class);
	assertCategory(PersistenceType.EMBEDDABLE, Embed1.class);

	assertNotNull(model.entity(ImplicitFieldAccessBase.class));
	assertNotNull(model.entity(ImplicitFieldAccessSubclass.class));
	assertNotNull(model.embeddable(Embed0.class));
	assertNotNull(model.embeddable(Embed1.class));

	java.util.Set<ManagedType<?>> managedTypes = model.getManagedTypes();
	managedTypes.removeAll(model.getEmbeddables());
	managedTypes.removeAll(model.getEntities());
	assertNotNull(model.managedType(ImplicitFieldAccessMappedSuperclass.class));
	assertTrue(managedTypes.contains(model.managedType(ImplicitFieldAccessMappedSuperclass.class)));
	}

	public void testGetAttributeByNameAndTypeFromMetaClass() {
	ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
	assertNotNull(e0.getAttribute("f0"));
	assertNotNull(e0.getSingularAttribute("f0", String.class));
	assertSame(e0.getAttribute("f0"), e0.getSingularAttribute("f0", String.class));
	try {
	e0.getSingularAttribute("f0", ExplicitFieldAccess.class);
	fail("Expected IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	// good
	}
	ManagedType<ImplicitFieldAccessSubclass> e1 = model.entity(ImplicitFieldAccessSubclass.class);
	assertNotNull(e1.getAttribute("f0"));
	}

	public void testAttributeByDeclaration() {
	ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
	ManagedType<ImplicitFieldAccessSubclass> e1 = model.entity(ImplicitFieldAccessSubclass.class);
	assertNotNull(e0.getAttribute("f0"));
	assertNotNull(e1.getAttribute("f0"));
	System.err.println(e0.getAttribute("f0"));
	assertNotNull(e0.getSingularAttribute("f0", String.class));
	assertNotNull(e1.getSingularAttribute("f0", String.class));
	assertSame(e0.getAttribute("f0"), e0.getSingularAttribute("f0", String.class));
	assertSame(e1.getAttribute("f0"), e1.getSingularAttribute("f0", String.class));
	assertNotSame(e0.getAttribute("f0"), e1.getAttribute("f0"));
	assertNotSame(e0.getSingularAttribute("f0", String.class), e1.getSingularAttribute("f0", String.class));
	assertNotNull(e0.getDeclaredAttribute("f0"));
	try {
	e1.getDeclaredAttribute("f0");
	fail("Expected IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	// good
	}
	}

	public void testPCCollection() {
	ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
	ManagedType<ExplicitFieldAccess> r1 = model.entity(ExplicitFieldAccess.class);
	CollectionAttribute<?,?> relColl = e0.getCollection("collectionRelation", ExplicitFieldAccess.class);
	assertEquals(javax.persistence.metamodel.PluralAttribute.CollectionType.COLLECTION,
	relColl.getCollectionType());
	assertEquals(e0, relColl.getDeclaringType());
	assertEquals(r1, relColl.getElementType());
	assertEquals(ExplicitFieldAccess.class, relColl.getBindableJavaType());
	assertEquals(BindableType.PLURAL_ATTRIBUTE, relColl.getBindableType());
	assertEquals(Attribute.PersistentAttributeType.ONE_TO_MANY, relColl.getPersistentAttributeType());
	}

	public void testPCList() {
	ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
	ManagedType<ExplicitFieldAccess> r1 = model.entity(ExplicitFieldAccess.class);
	ListAttribute<?, ?> relList = e0.getList("listRelation", ExplicitFieldAccess.class);

	assertEquals(CollectionType.LIST, relList.getCollectionType());
	assertEquals(e0, relList.getDeclaringType());
	assertEquals(r1, relList.getElementType());
	assertEquals(ExplicitFieldAccess.class, relList.getBindableJavaType());
	assertEquals(BindableType.PLURAL_ATTRIBUTE, relList.getBindableType());
	assertEquals(PersistentAttributeType.ONE_TO_MANY, relList.getPersistentAttributeType());
	}

	public void testPCSet() {
	ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
	ManagedType<ExplicitFieldAccess> r1 = model.entity(ExplicitFieldAccess.class);
	SetAttribute<?, ?> relSet = e0.getSet("setRelation", ExplicitFieldAccess.class);
	assertEquals(javax.persistence.metamodel.PluralAttribute.CollectionType.SET, relSet.getCollectionType());
	assertEquals(e0, relSet.getDeclaringType());
	assertEquals(r1, relSet.getElementType());
	assertEquals(ExplicitFieldAccess.class, relSet.getBindableJavaType());
	assertEquals(BindableType.PLURAL_ATTRIBUTE, relSet.getBindableType());
	assertEquals(PersistentAttributeType.ONE_TO_MANY, relSet.getPersistentAttributeType());
	}

	public void testDeclaredFields() {
	ManagedType<ImplicitFieldAccessSubclass> e1 = model.entity(ImplicitFieldAccessSubclass.class);
	java.util.Set<?> all = e1.getAttributes();
	java.util.Set<?> decl = e1.getDeclaredAttributes();
	assertTrue("All fields " + all + "\r\nDeclared fields " + decl + "\r\n"+
	"expecetd not all fields as declared", all.size() > decl.size());
	}

	public void testNonExistentField() {
	ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
	ManagedType<ImplicitFieldAccessSubclass> e1 = model.entity(ImplicitFieldAccessSubclass.class);
	assertFails(e0, "xyz", false);
	assertFails(e1, "f0", true);
	}

	/**
	* Test all attribute getters of ManagedType for valid inputs.
	*/
	public void testAttributeGettersForValidInput() {
	IdentifiableType<ImplicitFieldAccessSubclass> subClass = model.entity(ImplicitFieldAccessSubclass.class);
	IdentifiableType<ImplicitFieldAccessBase> superClass = model.entity(ImplicitFieldAccessBase.class);

	assertEquals(superClass, subClass.getSupertype());

	assertNotNull(subClass.getAttribute("f0"));
	assertNotNull(superClass.getAttribute("f0"));
	assertNotNull(subClass.getAttribute("mapRelationKeyEmbedded"));

	assertNotNull(subClass.getAttributes());
	assertNotNull(superClass.getAttributes());
	assertEquals(14, subClass.getAttributes().size());
	assertEquals(12, superClass.getAttributes().size());

	assertNotNull(superClass.getCollection("collectionRelation"));
	assertNotNull(superClass.getCollection("collectionRelation", ExplicitFieldAccess.class));

	assertNotNull(subClass.getPluralAttributes());
	assertNotNull(superClass.getPluralAttributes());
	assertEquals(6, subClass.getPluralAttributes().size());
	assertEquals(5, superClass.getPluralAttributes().size());

	assertNotNull(subClass.getDeclaredAttribute("mapRelationKeyEmbedded"));

	assertNotNull(subClass.getDeclaredAttributes());
	assertNotNull(superClass.getDeclaredAttributes());
	assertEquals(2, subClass.getDeclaredAttributes().size());
	assertEquals(9, superClass.getDeclaredAttributes().size());

	assertNotNull(superClass.getDeclaredCollection("collectionRelation"));

	assertNotNull(subClass.getDeclaredPluralAttributes());
	assertNotNull(superClass.getDeclaredPluralAttributes());
	assertEquals(1, subClass.getDeclaredPluralAttributes().size());
	assertEquals(5, superClass.getDeclaredPluralAttributes().size());

	assertNotNull(superClass.getDeclaredList("listRelation"));
	assertNotNull(superClass.getDeclaredList("listRelation", ExplicitFieldAccess.class));
	assertNotNull(superClass.getDeclaredMap("mapRelationKeyBasic"));
	assertNotNull(superClass.getDeclaredMap("mapRelationKeyBasic", Integer.class, ExplicitFieldAccess.class));
	assertNotNull(superClass.getDeclaredSet("setRelation"));
	assertNotNull(superClass.getDeclaredSet("setRelation", ExplicitFieldAccess.class));
	assertNotNull(superClass.getDeclaredSingularAttribute("one2oneRelation"));
	assertNotNull(superClass.getDeclaredSingularAttribute("one2oneRelation", ExplicitFieldAccess.class));
	assertNotNull(superClass.getDeclaredSingularAttributes());


	assertNotNull(subClass.getList("listRelation"));
	assertNotNull(subClass.getList("listRelation", ExplicitFieldAccess.class));
	assertNotNull(subClass.getMap("mapRelationKeyBasic"));
	assertNotNull(subClass.getMap("mapRelationKeyBasic", Integer.class, ExplicitFieldAccess.class));
	assertNotNull(subClass.getPersistenceType());
	assertNotNull(subClass.getSet("setRelation"));
	assertNotNull(subClass.getSet("setRelation", ExplicitFieldAccess.class));
	assertNotNull(subClass.getSingularAttribute("one2oneRelation"));
	assertNotNull(subClass.getSingularAttribute("one2oneRelation", ExplicitFieldAccess.class));
	assertNotNull(subClass.getSingularAttributes());
	}

	public void testSimpleIdAttributes() {
	IdentifiableType<OneOneParent> entity = model.entity(OneOneParent.class);
	for (Attribute<? super OneOneParent,?> a : entity.getAttributes()) {
	System.err.println(a.getName());
	}
	assertNotNull(entity.getId(long.class));
	assertNotNull(entity.getDeclaredId(long.class));
	assertTrue(entity.hasSingleIdAttribute());
	assertEquals(long.class, entity.getIdType().getJavaType());
	}

	public void testVersionAttributes() {
	IdentifiableType<OneOneParent> entity = model.entity(OneOneParent.class);
	for (Attribute<? super OneOneParent,?> a : entity.getAttributes()) {
	System.err.println(a.getName());
	}
	assertNotNull(entity.getVersion(Integer.class));
	assertNotNull(entity.getDeclaredVersion(Integer.class));
	assertTrue(entity.hasVersionAttribute());
	}

	public void testIdClassAttributes() {
	IdentifiableType<Book> entity = model.entity(Book.class);

	assertEquals(2, entity.getIdClassAttributes().size());
	assertNotNull(entity.getId(String.class));
	assertNotNull(entity.getId(Library.class));
	assertNotNull(entity.getDeclaredId(String.class));
	assertNotNull(entity.getDeclaredId(Library.class));
	assertEquals(BookId.class, entity.getIdType().getJavaType());
	assertFalse(entity.hasSingleIdAttribute());
	}

	public void testBasicAttributeType() {
	ManagedType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
	SingularAttribute<ImplicitFieldAccessBase,?> pInt = e0.getDeclaredSingularAttribute("primitiveInt");
	assertEquals(PersistentAttributeType.BASIC, pInt.getPersistentAttributeType());
	}

	public void testEmbeddedAttributeType() {
	ManagedType<Address> type = model.entity(Address.class);
	Attribute.PersistentAttributeType attr = type.getAttribute("geocode").getPersistentAttributeType();
	assertEquals(PersistentAttributeType.EMBEDDED, attr);
	}

	public void testNotFoundErrorMessage() {
	IdentifiableType<ImplicitFieldAccessBase> e0 = model.entity(ImplicitFieldAccessBase.class);
	String name = "unknown";
	try {
	Method[] getters = {
	e0.getClass().getMethod("getAttribute", new Class<?>[]{String.class}),
	e0.getClass().getMethod("getCollection", new Class<?>[]{String.class}),
	e0.getClass().getMethod("getList", new Class<?>[]{String.class}),
	e0.getClass().getMethod("getSet", new Class<?>[]{String.class}),
	e0.getClass().getMethod("getSingularAttribute", new Class<?>[]{String.class}),

	e0.getClass().getMethod("getDeclaredAttribute", new Class<?>[]{String.class}),
	e0.getClass().getMethod("getDeclaredCollection", new Class<?>[]{String.class}),
	e0.getClass().getMethod("getDeclaredList", new Class<?>[]{String.class}),
	e0.getClass().getMethod("getDeclaredSet", new Class<?>[]{String.class}),
	e0.getClass().getMethod("getDeclaredSingularAttribute", new Class<?>[]{String.class}),

	e0.getClass().getMethod("getAttribute", new Class<?>[]{String.class, Class.class}),
	e0.getClass().getMethod("getCollection", new Class<?>[]{String.class, Class.class}),
	e0.getClass().getMethod("getList", new Class<?>[]{String.class, Class.class}),
	e0.getClass().getMethod("getSet", new Class<?>[]{String.class, Class.class}),
	e0.getClass().getMethod("getSingularAttribute", new Class<?>[]{String.class, Class.class}),

	e0.getClass().getMethod("getDeclaredAttribute", new Class<?>[]{String.class, Class.class}),
	e0.getClass().getMethod("getDeclaredCollection", new Class<?>[]{String.class, Class.class}),
	e0.getClass().getMethod("getDeclaredList", new Class<?>[]{String.class, Class.class}),
	e0.getClass().getMethod("getDeclaredSet", new Class<?>[]{String.class, Class.class}),
	e0.getClass().getMethod("getDeclaredSingularAttribute", new Class<?>[]{String.class, Class.class}),

	e0.getClass().getMethod("getMap", new Class<?>[]{String.class}),
	e0.getClass().getMethod("getMap", new Class<?>[]{String.class, Class.class, Class.class}),
	e0.getClass().getMethod("getDeclaredMap", new Class<?>[]{String.class}),
	e0.getClass().getMethod("getDeclaredMap", new Class<?>[]{String.class, Class.class, Class.class}),
	};
	// e0.getClass().getMethod("getDeclaredVersion", new Class<?>[]{Class.class}),

	for (int i = 0; i < getters.length; i++) {
	Object[] args;
	if (i < 10) {
	args = new Object[]{name};
	} else if (i < 20) {
	args = new Object[]{name, Object.class};
	} else if (i%2 == 0) {
	args = new Object[]{name};
	} else {
	args = new Object[]{name, Object.class, String.class};
	}
	try {
	getters[i].invoke(e0, args);
	fail();
	} catch (InvocationTargetException e) {
	System.err.println("Expeceted:" + e.getTargetException());
	}
	}
	} catch (Exception e) {
	e.printStackTrace();
	fail();
	}
	}

	void assertFails(ManagedType<?> type, String name, boolean dec) {
	try {
	Attribute<?,?> a = dec ? type.getDeclaredAttribute(name)
	: type.getAttribute(name);
	fail("Expected to fail " + name + " on " + type);
	} catch (IllegalArgumentException e) {
	System.err.println("Expeceted:" + e);
	}
	}

	PersistenceType categorize(Class<?> c) {
	AbstractManagedType<?> type = (AbstractManagedType<?>)model.getType(c);
	ClassMetaData meta = type.meta;
	return MetamodelImpl.getPersistenceType(meta);
	}

	void assertCategory(PersistenceType category, Class<?> cls) {
	assertEquals(cls.toString(), category, categorize(cls));
	}

	Field getStaticField(Class<?> cls, String name) {
	try {
	Field[] fds = cls.getDeclaredFields();
	for (Field f : fds) {
	int mods = f.getModifiers();
	if (f.getName().equals(name) && Modifier.isStatic(mods))
	return f;
	}
	} catch (Exception e) {
	}
	return null;
	}
	}