<!-- 248780: exclude copies of classes from this eclipselink-annotation-model.jar if weaving is disabled in any other jar -->        	

                               org/eclipse/persistence/testing/models/jpa/metamodel/**            	

        <!-- 248780: Refactor Cache Implementation surrounding evict() and MappedSuperclass support -->        

             <property name="eclipselink.weaving" value="false"/>        

import javax.persistence.Cache;

import org.eclipse.persistence.testing.models.jpa.advanced.fetchgroup.ChestProtector;

import org.eclipse.persistence.testing.models.jpa.advanced.fetchgroup.GoalieGear;

import org.eclipse.persistence.testing.models.jpa.advanced.fetchgroup.Pads;

import org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer;

import org.eclipse.persistence.descriptors.ClassDescriptor;

import org.eclipse.persistence.internal.jpa.CMP3Policy;

import org.eclipse.persistence.internal.jpa.EntityManagerImpl;

    /**

     * Note: These tests are setup with ID generation - but it is not used.

     * We set the Id manually so we can test cache operations like eviction properly.

     * @return

     */

        cache.print();        

    }

    /**

     * In this test we attempt to remove the MappedSuperclass (superclass) from the entity cache.

     * The resulting action removes all implementing subclasses - which has the same effect

     * as just removing the implementing Entity in the first case.

     * 

     * Hierarchy:

     * HockeyGear (Abstract Entity)

     *       +----- GoalieGear (Concrete MappedSuperclass) --- (we will evict this one)

     *                  +----- Chest Protector (Concrete Entity) ---- cacheable (but this will actually be evicted)

     *                  +----- Pads (Concrete Entity) ---- cacheable (as well as this one)

     */

    public void testEvictClass_MappedSuperclass_RemovesAssignableSubclasses() {

        if (! isJPA10()) {        

            int ID_PADS = ID_TEST_BASE + 100;

            int ID_CHESTPROTECTOR = ID_PADS++;

            final EntityManager em = createEntityManager("default1");

            // Persist both implementing subclasses of GoalieGear

            beginTransaction(em);

            // HockeyGear(Abstract Entity) << GoalieGear (Concrete MappedSuperclass) << ChestProtector (Concrete Entity)

            ChestProtector e1 = new ChestProtector();

            e1.setDescription("chest_protector");

            e1.setSerialNumber(new Integer(ID_PADS));

            em.persist(e1);

            commitTransaction(em);

            //  closeEntityManager(em); // do not close the entityManager between transactions or you will get bug# 307445

            beginTransaction(em);

            // HockeyGear(Abstract Entity) << GoalieGear (Concrete MappedSuperclass) << ChestProtector (Concrete Entity)

            Pads p1 = new Pads();

            p1.setDescription("pads");

            p1.setSerialNumber(new Integer(ID_CHESTPROTECTOR));

            em.persist(p1);

            commitTransaction(em);

            closeEntityManager(em);

            EntityManager em1 = createEntityManager("default1");

            EntityManager em2 = createEntityManager("default1");

            try {

                ChestProtector e2 = (ChestProtector) ((EntityManagerFactoryImpl) getEntityManagerFactory("default1"))

                    .getServerSession().getIdentityMapAccessor().getFromIdentityMap(e1);

                Pads p2 = (Pads) ((EntityManagerFactoryImpl) getEntityManagerFactory("default1"))

                    .getServerSession().getIdentityMapAccessor().getFromIdentityMap(p1);

                // change the entity in the cache (only) - later a find() will get the unmodified version in the database

                e2.setDescription("new_chest_protector");

                p2.setDescription("new_pads");

                String expected_chestProtector = em1.find(GoalieGear.class, ID_CHESTPROTECTOR).getDescription();

                String expected_pads = em1.find(GoalieGear.class, ID_PADS).getDescription();

                // evict the inheriting entities via their MappedSuperclass

                getEntityManagerFactory("default1").getCache().evict(GoalieGear.class);            

                // read the inheriting entities directly from the database (because they are no longer in the cache - hopefully)

                GoalieGear g5 = em2.find(GoalieGear.class, ID_CHESTPROTECTOR);

                GoalieGear p5 = em2.find(GoalieGear.class, ID_PADS);            

                // Check that we are not actually getting the supposed "to be evicted" cached version (that was modified)

                String actual_chestProtector = g5.getDescription();

                String actual_pads = p5.getDescription();

                // verify that assignable subclasses (ChestProtector and Pads) are removed from the cache

                assertNotSame("Assertion Error - There should be no modified cached entity instance in the cache - the entity read from the database should be different. "

                    , expected_chestProtector, actual_chestProtector);

                assertNotSame("Assertion Error - There should be no modified cached entity instance in the cache - the entity read from the database should be different. "

                    , expected_pads, actual_pads);            

            } finally {

                closeEntityManager(em1);

                closeEntityManager(em2);

            }

        }

    }

    /**

     * In this test we attempt to remove the MappedSuperclass (superclass) from the entity cache.

     * The resulting action removes all implementing subclasses - which has the same effect

     * as just removing the implementing Entity in the first case.

     * 

     * Hierarchy:

     * HockeyGear (Abstract Entity)

     *       +----- GoalieGear (Concrete MappedSuperclass) --- (we will evict this one)

     *                  +----- Chest Protector (Concrete Entity) ---- cacheable (but this will actually be evicted)

     *                  +----- Pads (Concrete Entity) ---- cacheable (as well as this one)

     */

    public void testEvictClassObject_MappedSuperclass_RemovesAssignableSubclasses() {

        if (! isJPA10()) {        

            int ID_PADS = ID_TEST_BASE + 200;

            int ID_CHESTPROTECTOR = ID_PADS++;

            EntityManager em = createEntityManager("default1");

            // Persist both implementing subclasses of GoalieGear

            beginTransaction(em);

            // HockeyGear(Abstract Entity) << GoalieGear (Concrete MappedSuperclass) << ChestProtector (Concrete Entity)

            ChestProtector e1 = new ChestProtector();

            e1.setDescription("chest_protector");

            e1.setSerialNumber(new Integer(ID_PADS));

            em.persist(e1);

            commitTransaction(em);

            //  closeEntityManager(em); // do not close the entityManager between transactions or you will get bug# 307445

            beginTransaction(em);

            Pads p1 = new Pads();

            p1.setDescription("pads");

            p1.setSerialNumber(new Integer(ID_CHESTPROTECTOR));

            em.persist(p1);

            commitTransaction(em);

            closeEntityManager(em);

            EntityManager em1 = createEntityManager("default1");

            EntityManager em2 = createEntityManager("default1");

            try {

                GoalieGear c2 = (GoalieGear) ((EntityManagerFactoryImpl) getEntityManagerFactory("default1"))

                    .getServerSession().getIdentityMapAccessor().getFromIdentityMap(e1);

                Pads p2 = (Pads) ((EntityManagerFactoryImpl) getEntityManagerFactory("default1"))

                    .getServerSession().getIdentityMapAccessor().getFromIdentityMap(p1);

                // change the entity in the cache (only) - later a find() will get the unmodified version in the database

                c2.setDescription("new_chest_protector");

                p2.setDescription("new_pads");

                String expected_chestProtector = em1.find(GoalieGear.class, ID_CHESTPROTECTOR).getDescription();

                String expected_pads = em1.find(GoalieGear.class, ID_PADS).getDescription();

                // evict the inheriting entity (by Id) via its' MappedSuperclass

                getEntityManagerFactory("default1").getCache().evict(GoalieGear.class, c2.getSerialNumber()); // ChestProtector            

                getEntityManagerFactory("default1").getCache().evict(GoalieGear.class, p2.getSerialNumber()); // Pad

                // read the inheriting entities directly from the database (because they are no longer in the cache - hopefully)

                GoalieGear c5 = em2.find(GoalieGear.class, ID_CHESTPROTECTOR);

                GoalieGear p5 = em2.find(GoalieGear.class, ID_PADS);            

                // Check that we are not actually getting the supposed "to be evicted" cached version (that was modified)

                String actual_chestProtector = c5.getDescription();

                String actual_pads = p5.getDescription();

                // verify that assignable subclasses (ChestProtector and Pads) are removed from the cache

                assertNotSame("Assertion Error - There should be no modified cached entity instance in the cache - the entity read from the database should be different. "

                    , expected_chestProtector, actual_chestProtector);

                assertNotSame("Assertion Error - There should be no modified cached entity instance in the cache - the entity read from the database should be different. "

                    , expected_pads, actual_pads);            

            } finally {

                closeEntityManager(em1);

                closeEntityManager(em2);

            }

        }

    //org.eclipse.persistence.testing.models.jpa.jpaadvancedproperties.Customer

    public void testEvictClass_JavaLangClass_hasNoEffect() {

        if (! isJPA10()) {

            int ID = ID_TEST_BASE + 300;

            boolean _exceptionThrown = false;

            EntityManager em = createEntityManager("default1");

            // Persist

            beginTransaction(em);

            // HockeyGear(Abstract Entity) << GoalieGear (Concrete MappedSuperclass) << ChestProtector (Concrete Entity)

            ChestProtector e1 = new ChestProtector();

            e1.setDescription("gear");

            e1.setSerialNumber(new Integer(ID));

            em.persist(e1);

            commitTransaction(em);

            closeEntityManager(em);

            EntityManager em1 = createEntityManager("default1");

            EntityManager em2 = createEntityManager("default1");

            try {

                GoalieGear e2 = (GoalieGear) ((EntityManagerFactoryImpl) getEntityManagerFactory("default1"))

                    .getServerSession().getIdentityMapAccessor().getFromIdentityMap(e1);

                // change the entity in the cache (only) - later a find() will get the unmodified version in the database

                e2.setDescription("new_gear");

                String expected = em1.find(GoalieGear.class, ID).getDescription();

                // The following dows not throws an IAE on a plain java (Integer) class - it will leave the cached entities as-is in the cache

                getEntityManagerFactory("default1").getCache().evict(Integer.class);

                // read the inheriting entities directly from the cache (because they were not evicted)            

                GoalieGear g5 = em2.find(GoalieGear.class, ID);

                String actual = g5.getDescription();

                assertSame("Assertion Error - There should be a modified cached entity instance in the cache - the entity is not actually read from the database"

                    , expected, actual);

            } catch (IllegalArgumentException iae) {

                _exceptionThrown = true;

            } finally {

                closeEntityManager(em1);

                closeEntityManager(em2);

                assertFalse("IllegalArgumentException was thrown.", _exceptionThrown);            

            }

        }

    }

    // The xml model version is not managed

    public void testGetId_fromUnmanagedMappedSuperclass_handles_null_descriptor() {

        if (!isJPA10()) {        

            int ID = ID_TEST_BASE + 400;

            boolean _exceptionThrown = false;

            EntityManager em = createEntityManager();//"default1");

            // Persist both implementing subclasses of GoalieGear

            beginTransaction(em);

            // CacheableTrueMappedSuperclass (MappedSuperclass with Id) << SubCacheableFalseEntity (Entity)

            org.eclipse.persistence.testing.models.jpa.xml.cacheable.SubCacheableFalseEntity anEntity 

                = new org.eclipse.persistence.testing.models.jpa.xml.cacheable.SubCacheableFalseEntity();

            org.eclipse.persistence.testing.models.jpa.xml.cacheable.CacheableTrueMappedSuperclass aMappedSuperclass 

                = new org.eclipse.persistence.testing.models.jpa.xml.cacheable.CacheableTrueMappedSuperclass();

            anEntity.setId(ID);

            // Can we place non-persistable objects into only the cache (non-entities)?

            // We do not need to persist this entity for this specific test

            //em.persist(anEntity);

            commitTransaction(em);

            closeEntityManager(em);

            EntityManager em1 = createEntityManager("default1");

            EntityManager em2 = createEntityManager("default1");

            Cache aJPACache = getEntityManagerFactory("default1").getCache();

            JpaCache anEclipseLinkCache = (JpaCache)getEntityManagerFactory("default1").getCache();

            Object anId = null;

            try {

                anId = anEclipseLinkCache.getId(anEntity);

            } catch (IllegalArgumentException iae) {

                _exceptionThrown = true;

            } finally {

                closeEntityManager(em1);

                closeEntityManager(em2);

                assertTrue("IllegalArgumentException should have been thrown on the unmanaged entity lacking a descriptor.", _exceptionThrown);            

            }

        }

    }

    public void testGetId_fromUnsupportedJavaLangInteger_throwsIAE_on_null_descriptor() {

        if (!isJPA10()) {

            boolean _exceptionThrown = false;

            EntityManager em1 = createEntityManager("default1");            

            JpaCache anEclipseLinkCache = (JpaCache)getEntityManagerFactory("default1").getCache();

            try {

                anEclipseLinkCache.getId(new Integer(1));

            } catch (IllegalArgumentException iae) {

                _exceptionThrown = true;

            } finally {

                closeEntityManager(em1);                

                assertTrue("IllegalArgumentException should have been thrown on a getId() call on an Integer which obviously has no descriptor.", _exceptionThrown);                

            }

        }

    }

    /**

     * In order to test handling of a null CMP3Policy on the descriptor during a cache.getId() call,

     * we must have an Id on an abstract MappedSuperclass root that is defined via sessions.xml.

     * Or we can simulate a null CMP3Policy by clearing it - so that the alternate code handling is run

     */

    public void testGetId_fromNativeMappedSuperclass_handles_null_cmp3policy_weaving_on() {

        if (!isJPA10()) {

            int ID = ID_TEST_BASE + 500;

            Object originalId = null;

            EntityManager em = createEntityManager();//"default1");

            // Persist both implementing subclasses of GoalieGear

            beginTransaction(em);

            // CacheableTrueMappedSuperclass (MappedSuperclass with Id) << SubCacheableFalseEntity (Entity)

            org.eclipse.persistence.testing.models.jpa.cacheable.SubCacheableFalseEntity anEntity = new org.eclipse.persistence.testing.models.jpa.cacheable.SubCacheableFalseEntity();

            org.eclipse.persistence.testing.models.jpa.cacheable.CacheableTrueMappedSuperclass aMappedSuperclass = new org.eclipse.persistence.testing.models.jpa.cacheable.CacheableTrueMappedSuperclass();

            anEntity.setId(ID);

            // Can we place non-persistable objects into only the cache (non-entities)?

            em.persist(anEntity);

            commitTransaction(em);

            closeEntityManager(em);

            EntityManager em1 = createEntityManager("default1");

            Cache aJPACache = getEntityManagerFactory("default1").getCache();

            JpaCache anEclipseLinkCache = (JpaCache)getEntityManagerFactory("default1").getCache();

            Object anId = null;

            originalId = anEntity.getId();

            // clear the CMP3Policy to simulate a native pojo

            ClassDescriptor cdesc = ((EntityManagerImpl)em1).getSession().getClassDescriptor(anEntity.getClass());

            CMP3Policy policy = (CMP3Policy) (cdesc.getCMPPolicy());

            assertNotNull("CMP3Policy should exist", policy);

            cdesc.setCMPPolicy(null);

            try {

                // This call will test the weaving [on] section of getId()

                anId = anEclipseLinkCache.getId(anEntity);

                assertNotNull("Id instance should not be null", anId);

                assertTrue("Id instance should be of type Integer", anId instanceof Integer);            

                assertEquals(((Integer)anId).intValue(), ID);

                assertEquals(anId, originalId);

            } finally {

                closeEntityManager(em1);

            }

        }

    }

    public void testGetId_fromNativeMappedSuperclass_handles_null_cmp3policy_and_null_pk_with_weaving_on() {

        if (!isJPA10()) {

            //int ID = ID_TEST_BASE + 600;

            Integer ID = null; // keep object as null for unset testing

            Object originalId = null;

            EntityManager em = createEntityManager("metamodel1");

            beginTransaction(em);

            // org.eclipse.persistence.testing.models.jpa.metamodel.Person(Concrete MappedSuperclass) <-- Corporation(Abstract MappedSuperclass) <-- Manufacturer (Entity)

            Manufacturer anEntity = new Manufacturer();

            //anEntity.setId(ID);

            // Can we place non-persistable objects into only the cache (non-entities)?

            em.persist(anEntity);

            commitTransaction(em);

            closeEntityManager(em);

            EntityManager em1 = createEntityManager("metamodel1");

            Cache aJPACache = getEntityManagerFactory("metamodel1").getCache();

            JpaCache anEclipseLinkCache = (JpaCache)getEntityManagerFactory("metamodel1").getCache();

            Object anId = null;

            // The originalId will be set by automatic sequence generation - if we require it

            originalId = anEntity.getId();

            // clear the CMP3Policy to simulate a native pojo

            ClassDescriptor cdesc = ((EntityManagerImpl)em1).getSession().getClassDescriptor(anEntity.getClass());

            CMP3Policy policy = (CMP3Policy) (cdesc.getCMPPolicy());

            assertNotNull("CMP3Policy should exist prior to having been cleared manually for this test", policy);

            cdesc.setCMPPolicy(null);

            try {

                anId = anEclipseLinkCache.getId(anEntity);

                assertNotNull("Id instance should not be null", anId);

                assertTrue("Id instance should be of type Integer", anId instanceof Integer);            

                assertEquals(anId, originalId);

                // set the CMPPolicy back for out of order testing

                cdesc.setCMPPolicy(policy);

            } finally {

                closeEntityManager(em1);

            }

        }

    }

    // We need a MappedSuperclass that is defined by a persistence.xml where eclipselink.weaving="false"

    // This test requires that weaving is off in persistence.xml for metamodel1

    public void testGetId_fromNativeMappedSuperclass_handles_null_cmp3policy_and_null_pk_with_weaving_off() {

        if (!isJPA10()) {

            int ID = ID_TEST_BASE + 700;

            //Integer ID = null; // keep object as null for unset testing

            Object originalId = null;

            EntityManager em = createEntityManager("metamodel1");

            beginTransaction(em);

            Manufacturer anEntity = new Manufacturer();            

            anEntity.setName("test");

            anEntity.setId(ID);

            // Can we place non-persistable objects into only the cache (non-entities)?

            em.persist(anEntity);

            commitTransaction(em);

            //closeEntityManager(em); // keep the EM open

            EntityManager em1 = createEntityManager("metamodel1");

            Cache aJPACache = getEntityManagerFactory("metamodel1").getCache();

            JpaCache anEclipseLinkCache = (JpaCache)getEntityManagerFactory("metamodel1").getCache();

            Object anId = null;

            // The originalId will be set by automatic sequence generation - if we require it

            originalId = anEntity.getId();

            // clear the CMP3Policy to simulate a native pojo

            ClassDescriptor cdesc = ((EntityManagerImpl)em).getSession().getClassDescriptor(anEntity.getClass());

            assertNotNull("ClassDescriptor for Entity must not be null", cdesc); // check that the entityManager is not null

            CMP3Policy policy = (CMP3Policy) (cdesc.getCMPPolicy());

            assertNotNull("CMP3Policy should exist prior to having been cleared manually for this test", policy);

            cdesc.setCMPPolicy(null);

            try {

                anId = anEclipseLinkCache.getId(anEntity);

                assertNotNull("Id instance should not be null", anId);

                assertTrue("Id instance should be of type Integer", anId instanceof Integer);            

                assertEquals(anId, ID);

                assertEquals(anId, originalId);

                // set the CMPPolicy back for out of order testing

                cdesc.setCMPPolicy(policy);

            } finally {

                closeEntityManager(em1);

                closeEntityManager(em);

            }

        }

    }

    // 20100422: 248780: CacheImpl refactor for non-Entity classes

    public static int ID_TEST_BASE = 1136; // change this value during iterative testing

import java.util.Iterator;

import org.eclipse.persistence.internal.localization.ExceptionLocalization;

import org.eclipse.persistence.internal.sessions.AbstractSession;

     * @see Cache#contains(Class, Object)

     * INTERNAL:

     * This private method searches the map of descriptors for possible superclasses to the

     * passed in class parameter and invalidates only entities found in the cache.

     * If the class is not an Entity or MappedSuperclass (such as an Embeddable or plain java class)

     *  - nothing will be evicted  

     * @param possibleSubclass

     * @param id

     */

    private void evictAssignableEntitySuperclass(Class possibleSubclass, Object id) {

        // Check each descriptor's javaClass key in the Map of descriptors on the session

        // We will search all descriptors and evict all implementing subclasses

        Iterator<ClassDescriptor> descriptorIterator = getSession().getDescriptors().values().iterator();

        while(descriptorIterator.hasNext()) {

            ClassDescriptor candidateAssignableDescriptor = descriptorIterator.next();

            if(candidateAssignableDescriptor.isChildDescriptor() && 

                    !candidateAssignableDescriptor.isAggregateDescriptor() && 

                    !candidateAssignableDescriptor.isAggregateCollectionDescriptor() && // Embeddable

                    possibleSubclass.isAssignableFrom(candidateAssignableDescriptor.getJavaClass())) {

                // id will be null if this private function was called from evict(class)

                if(null == id) {

                    // set the invalidationState to -1 in the cache of a type that can be assigned to the class parameter

                    // this call will invalidate all assignable subclasses from the level of [cls] in the subtree

                    // we could either loop through each aDescriptor.getJavaClass()

                    // or

                    // let invalidateClass loop for us by passing in the higher [cls]

                    getAccessor().invalidateClass(candidateAssignableDescriptor.getJavaClass());

                } else {

                    // evict the class instance that corresponds to the id

                    // initialize the cache of a type that can be assigned to the class parameter

                    getAccessor().invalidateObject(createPrimaryKeyFromId(possibleSubclass, id), candidateAssignableDescriptor.getJavaClass());

                }

            }                

        }

    }

    /**

     * If the class is not an Entity or MappedSuperclass (such as an Embeddable or plain java class)

     *  - nothing will be evicted  

     * @see Cache#evict(Class, Object)

     * Remove the data for entities of the specified class (and its

     * subclasses) from the cache.<p>

     * @see Cache#evict(Class) 

     * @param cls - Entity Class

     * @see Cache#evict(Object)

     * @see JpaCache#evict(Object)

    protected EntityManagerFactoryImpl getEntityManagerFactory() {

        return this.emf;

    }

    /**

     * INTERNAL:

     * Return the Session associated with the EntityManagerFactory.

     * @return

     */

    protected Session getSession() {

        return getEntityManagerFactory().getServerSession();

    }

    /**

     * INTERNAL:

     * Return the IdentityMapAccessor associated with the session on the EntityManagerFactory on this CacheImpl.

     * @return

     */

    protected IdentityMapAccessor getAccessor() {

        return getSession().getIdentityMapAccessor();

    }

    /**

     * This method will return the objects's Id.

     * If the descriptor associated with the domain object is null - an IllegalArgumentException is thrown.

     * If the CMPPolicy associated with the domain object's descriptor is null 

     * the Id will be determined using the ObjectBuilder on the descriptor - which may return

     * the Id stored in the weaved _persistence_primaryKey field.

     * @See {@link JpaCache#getId(Object)}

     */

    /**

     * Access the cache that is associated with the entity manager 

     * factory (the "second level cache").

     * @return instance of the <code>Cache</code> interface

     * @throws IllegalStateException if the entity manager factory has been closed

     * @see javax.persistence.EntityManagerFactory#getCache()

     * @since Java Persistence 2.0

     */

    public Object getIdentifier(Object entity) {

        return EntityManagerFactoryImpl.getIdentifier(entity, serverSession);

    }

    /**

     * Returns the id of the entity. A generated id is not guaranteed to be

     * available until after the database insert has occurred. Returns null if

     * the entity does not yet have an id

     * 

     * @param entity

     * @return id of the entity

     * @throws IllegalStateException

     *             if the entity is found not to be an entity.

     */

            // 308950: Alternatively, CacheImpl.getId(entity) handles a null CMPPolicy case for weaved and unweaved domain object

        verifyOpen(); // Throw an IAE if the entityManager is closed

        // Throw IllegalStateException if this entityManager is closed (serverSession is null, isOpen == false)

        verifyOpen();

        // Throw IllegalStateException if entityManager is closed

        this.wrapper.getEntityManager().verifyOpen();