openjpa-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mik...@apache.org
Subject svn commit: r1044031 - /openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java
Date Thu, 09 Dec 2010 16:53:06 GMT
Author: mikedd
Date: Thu Dec  9 16:53:06 2010
New Revision: 1044031

URL: http://svn.apache.org/viewvc?rev=1044031&view=rev
Log:
OPENJPA-1884: setting svn eol style

Modified:
    openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java
  (contents, props changed)

Modified: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java
URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java?rev=1044031&r1=1044030&r2=1044031&view=diff
==============================================================================
--- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java
(original)
+++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java
Thu Dec  9 16:53:06 2010
@@ -1,223 +1,223 @@
-/*
- * 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.cache.jpa;
-
-import java.util.Random;
-
-import javax.persistence.Cache;
-import javax.persistence.CacheStoreMode;
-import javax.persistence.EntityManager;
-import javax.persistence.EntityManagerFactory;
-import javax.persistence.EntityNotFoundException;
-import javax.persistence.LockModeType;
-
-
-import org.apache.openjpa.persistence.cache.jpa.model.CacheableEntity;
-import org.apache.openjpa.persistence.test.SingleEMFTestCase;
-
-/**
- * Verifies L2 operations using multiple entity manager factories. The EMF which
- * does updates does not have the data cache enabled thus, it does not send
- * sjvm updates upon commit.
- */
-public class TestMultiEMFCacheModes extends SingleEMFTestCase {
-
-    public void setUp() {
-        setUp( CLEAR_TABLES, CacheableEntity.class,
-               "openjpa.ConnectionFactoryProperties", "PrintParameters=true",
-               "openjpa.DataCache", "true");
-    }
-
-    /**
-     * Verifies that the data cache us updated via a em.refresh operation when 
-     * javax.persistence.cache.storeMode = CacheStoreMode.REFRESH and the
-     * entity is updated in the database.
-     */
-    public void testCacheRefreshModeRefresh() {
-
-        EntityManager em = emf.createEntityManager();
-        
-        // Create a new cacheable entity
-        CacheableEntity ce = createEntity(em);
-        int ceid = ce.getId();
-
-        // Clear the L1
-        em.clear();
-        
-        // Clear the L2 cache
-        Cache cache = emf.getCache();
-        cache.evictAll();
-        assertFalse(cache.contains(CacheableEntity.class, ceid));
-
-        // Find the entity, reloading it into the L2 
-        em.getTransaction().begin();
-        ce = em.find(CacheableEntity.class, ceid);
-        assertTrue(em.contains(ce));
-        assertTrue(cache.contains(CacheableEntity.class, ceid));
-        assertTrue(em.getLockMode(ce) == LockModeType.NONE);
-        assertEquals(ce.getName(), "Cached Entity");
-        assertEquals(ce.getVersion(), 1);
-        em.getTransaction().commit();
-
-        // Create a new EMF -WITHOUT- the L2 enabled.  If the L2 was enabled, the
-        // sjvm remote commit provider would evict the entity upon update, throwing
-        // off the intent of this variation.
-        EntityManagerFactory emf2 = this.createEMF(CacheableEntity.class,
-            "openjpa.LockManager", "mixed",
-            "openjpa.ConnectionFactoryProperties", "PrintParameters=true");
-        EntityManager em2 = emf2.createEntityManager();
-        
-        // Find + lock, then update the entity and commit
-        em2.getTransaction().begin();
-        CacheableEntity ce2 = em2.find(CacheableEntity.class, ceid, LockModeType.PESSIMISTIC_FORCE_INCREMENT);
-        ce2.setName("Updated Cached Entity");
-        em2.getTransaction().commit();
-        em2.close();
-        emf2.close();
-
-        // Refresh the entity - this will load the entity into the L1 and with storeMode=REFRESH,

-        // should also refresh it in the L2
-        java.util.Map<String, Object> cacheStoreModeMap = new java.util.HashMap<String,
Object>();
-        cacheStoreModeMap.put("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH);
-        em.refresh(ce, cacheStoreModeMap);
-
-        // Verify the entity was updated
-        verifyUpdatedEntity(ce, ceid);
-
-        // Verify loading from the L1
-        ce = em.find(CacheableEntity.class, ceid);
-        
-        // Verify the entity was updated
-        verifyUpdatedEntity(ce, ceid);
-
-        // Clear the L1
-        em.clear();
-
-        // Assert the L2 contains the entity
-        assertTrue(cache.contains(CacheableEntity.class, ceid));
-
-        // Reload the entity from the L2
-        ce = em.find(CacheableEntity.class, ceid);
-        
-        // Verify the entity in the L2 was updated
-        verifyUpdatedEntity(ce, ceid);
-
-        em.close();
-    }
-
-    /**
-     * Verifies that the data cache us updated via a em.refresh operation when 
-     * javax.persistence.cache.storeMode = CacheStoreMode.REFRESH and the 
-     * record is removed from the database.
-     */
-    public void testCacheRefreshModeRefreshDelete() {
-
-        EntityManager em = emf.createEntityManager();
-
-        // Create a new cachable entity
-        CacheableEntity ce = createEntity(em);
-        int ceid = ce.getId();
-
-        // Clear the L2 cache
-        Cache cache = emf.getCache();
-        cache.evictAll();
-        assertFalse(cache.contains(CacheableEntity.class, ceid));
-
-        // Find the entity, reloading it into the L2 
-        em.getTransaction().begin();
-        ce = em.find(CacheableEntity.class, ceid);
-        assertTrue(em.contains(ce));
-        assertTrue(cache.contains(CacheableEntity.class, ceid));
-        assertTrue(em.getLockMode(ce) == LockModeType.NONE);
-        assertEquals(ce.getName(), "Cached Entity");
-        assertEquals(ce.getVersion(), 1);
-        em.getTransaction().commit();
-
-        // Create a new EMF -WITHOUT- the L2 enabled.  If the L2 was enabled, the
-        // sjvm remote commit provider would evict the entity upon delete, throwing
-        // off the intent of this variation.
-        EntityManagerFactory emf2 = this.createEMF(CacheableEntity.class,
-            "openjpa.LockManager", "mixed",
-            "openjpa.ConnectionFactoryProperties", "PrintParameters=true");
-        EntityManager em2 = emf2.createEntityManager();
-
-        // Find and delete the entity in a separate context with no L2 configured
-        em2.getTransaction().begin();
-        CacheableEntity ce2 = em2.find(CacheableEntity.class, ceid);
-        assertNotNull(ce2);
-        em2.remove(ce2);
-        em2.getTransaction().commit();
-        em2.close();
-        emf2.close();
-
-        // Refresh the entity with storeMode=REFRESH.  The entity has been deleted so it
will be
-        // purged from the L2 cache when the DB load fails.
-        java.util.Map<String, Object> cacheStoreModeMap = new java.util.HashMap<String,
Object>();
-        cacheStoreModeMap.put("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH);
-        try {
-            em.refresh(ce, cacheStoreModeMap);
-            fail("Refresh operation should have thrown an exception");
-        } catch (EntityNotFoundException e) {
-            // expected exception
-        }
-
-        // Try loading from the L1 - OpenJPA will detect the entity was
-        // removed in another transaction.
-        try {
-            ce = em.find(CacheableEntity.class, ceid);
-            fail("OpenJPA should have detected the removed entity");
-        } catch (EntityNotFoundException e) {
-            // expected exception
-        }
-
-        // Clear the L1
-        em.clear();
-
-        // Assert the L2 no longer contains the entity
-        assertFalse(cache.contains(CacheableEntity.class, ceid));
-
-        // Attempt to reload entity from the L2 or database
-        ce = em.find(CacheableEntity.class, ceid);
-
-        // Verify the entity was removed from L2 and DB
-        assertNull(ce);
-
-        em.close();
-	}
-
-	private CacheableEntity createEntity(EntityManager em) {
-        CacheableEntity ce = new CacheableEntity();
-        int ceid = new Random().nextInt();
-        ce.setId(ceid);
-        ce.setName("Cached Entity");
-
-        // Persist the new cachable entity
-        em.getTransaction().begin();
-        em.persist(ce);
-        em.getTransaction().commit();
-        em.clear();
-        return ce;
-    }
-
-    private void verifyUpdatedEntity(CacheableEntity ce, int id) {
-        assertEquals(id, ce.getId());
-        assertEquals("Updated Cached Entity", ce.getName());
-        assertEquals(2, ce.getVersion());
-    }
-}
+/*
+ * 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.cache.jpa;
+
+import java.util.Random;
+
+import javax.persistence.Cache;
+import javax.persistence.CacheStoreMode;
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.EntityNotFoundException;
+import javax.persistence.LockModeType;
+
+
+import org.apache.openjpa.persistence.cache.jpa.model.CacheableEntity;
+import org.apache.openjpa.persistence.test.SingleEMFTestCase;
+
+/**
+ * Verifies L2 operations using multiple entity manager factories. The EMF which
+ * does updates does not have the data cache enabled thus, it does not send
+ * sjvm updates upon commit.
+ */
+public class TestMultiEMFCacheModes extends SingleEMFTestCase {
+
+    public void setUp() {
+        setUp( CLEAR_TABLES, CacheableEntity.class,
+               "openjpa.ConnectionFactoryProperties", "PrintParameters=true",
+               "openjpa.DataCache", "true");
+    }
+
+    /**
+     * Verifies that the data cache us updated via a em.refresh operation when 
+     * javax.persistence.cache.storeMode = CacheStoreMode.REFRESH and the
+     * entity is updated in the database.
+     */
+    public void testCacheRefreshModeRefresh() {
+
+        EntityManager em = emf.createEntityManager();
+        
+        // Create a new cacheable entity
+        CacheableEntity ce = createEntity(em);
+        int ceid = ce.getId();
+
+        // Clear the L1
+        em.clear();
+        
+        // Clear the L2 cache
+        Cache cache = emf.getCache();
+        cache.evictAll();
+        assertFalse(cache.contains(CacheableEntity.class, ceid));
+
+        // Find the entity, reloading it into the L2 
+        em.getTransaction().begin();
+        ce = em.find(CacheableEntity.class, ceid);
+        assertTrue(em.contains(ce));
+        assertTrue(cache.contains(CacheableEntity.class, ceid));
+        assertTrue(em.getLockMode(ce) == LockModeType.NONE);
+        assertEquals(ce.getName(), "Cached Entity");
+        assertEquals(ce.getVersion(), 1);
+        em.getTransaction().commit();
+
+        // Create a new EMF -WITHOUT- the L2 enabled.  If the L2 was enabled, the
+        // sjvm remote commit provider would evict the entity upon update, throwing
+        // off the intent of this variation.
+        EntityManagerFactory emf2 = this.createEMF(CacheableEntity.class,
+            "openjpa.LockManager", "mixed",
+            "openjpa.ConnectionFactoryProperties", "PrintParameters=true");
+        EntityManager em2 = emf2.createEntityManager();
+        
+        // Find + lock, then update the entity and commit
+        em2.getTransaction().begin();
+        CacheableEntity ce2 = em2.find(CacheableEntity.class, ceid, LockModeType.PESSIMISTIC_FORCE_INCREMENT);
+        ce2.setName("Updated Cached Entity");
+        em2.getTransaction().commit();
+        em2.close();
+        emf2.close();
+
+        // Refresh the entity - this will load the entity into the L1 and with storeMode=REFRESH,

+        // should also refresh it in the L2
+        java.util.Map<String, Object> cacheStoreModeMap = new java.util.HashMap<String,
Object>();
+        cacheStoreModeMap.put("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH);
+        em.refresh(ce, cacheStoreModeMap);
+
+        // Verify the entity was updated
+        verifyUpdatedEntity(ce, ceid);
+
+        // Verify loading from the L1
+        ce = em.find(CacheableEntity.class, ceid);
+        
+        // Verify the entity was updated
+        verifyUpdatedEntity(ce, ceid);
+
+        // Clear the L1
+        em.clear();
+
+        // Assert the L2 contains the entity
+        assertTrue(cache.contains(CacheableEntity.class, ceid));
+
+        // Reload the entity from the L2
+        ce = em.find(CacheableEntity.class, ceid);
+        
+        // Verify the entity in the L2 was updated
+        verifyUpdatedEntity(ce, ceid);
+
+        em.close();
+    }
+
+    /**
+     * Verifies that the data cache us updated via a em.refresh operation when 
+     * javax.persistence.cache.storeMode = CacheStoreMode.REFRESH and the 
+     * record is removed from the database.
+     */
+    public void testCacheRefreshModeRefreshDelete() {
+
+        EntityManager em = emf.createEntityManager();
+
+        // Create a new cachable entity
+        CacheableEntity ce = createEntity(em);
+        int ceid = ce.getId();
+
+        // Clear the L2 cache
+        Cache cache = emf.getCache();
+        cache.evictAll();
+        assertFalse(cache.contains(CacheableEntity.class, ceid));
+
+        // Find the entity, reloading it into the L2 
+        em.getTransaction().begin();
+        ce = em.find(CacheableEntity.class, ceid);
+        assertTrue(em.contains(ce));
+        assertTrue(cache.contains(CacheableEntity.class, ceid));
+        assertTrue(em.getLockMode(ce) == LockModeType.NONE);
+        assertEquals(ce.getName(), "Cached Entity");
+        assertEquals(ce.getVersion(), 1);
+        em.getTransaction().commit();
+
+        // Create a new EMF -WITHOUT- the L2 enabled.  If the L2 was enabled, the
+        // sjvm remote commit provider would evict the entity upon delete, throwing
+        // off the intent of this variation.
+        EntityManagerFactory emf2 = this.createEMF(CacheableEntity.class,
+            "openjpa.LockManager", "mixed",
+            "openjpa.ConnectionFactoryProperties", "PrintParameters=true");
+        EntityManager em2 = emf2.createEntityManager();
+
+        // Find and delete the entity in a separate context with no L2 configured
+        em2.getTransaction().begin();
+        CacheableEntity ce2 = em2.find(CacheableEntity.class, ceid);
+        assertNotNull(ce2);
+        em2.remove(ce2);
+        em2.getTransaction().commit();
+        em2.close();
+        emf2.close();
+
+        // Refresh the entity with storeMode=REFRESH.  The entity has been deleted so it
will be
+        // purged from the L2 cache when the DB load fails.
+        java.util.Map<String, Object> cacheStoreModeMap = new java.util.HashMap<String,
Object>();
+        cacheStoreModeMap.put("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH);
+        try {
+            em.refresh(ce, cacheStoreModeMap);
+            fail("Refresh operation should have thrown an exception");
+        } catch (EntityNotFoundException e) {
+            // expected exception
+        }
+
+        // Try loading from the L1 - OpenJPA will detect the entity was
+        // removed in another transaction.
+        try {
+            ce = em.find(CacheableEntity.class, ceid);
+            fail("OpenJPA should have detected the removed entity");
+        } catch (EntityNotFoundException e) {
+            // expected exception
+        }
+
+        // Clear the L1
+        em.clear();
+
+        // Assert the L2 no longer contains the entity
+        assertFalse(cache.contains(CacheableEntity.class, ceid));
+
+        // Attempt to reload entity from the L2 or database
+        ce = em.find(CacheableEntity.class, ceid);
+
+        // Verify the entity was removed from L2 and DB
+        assertNull(ce);
+
+        em.close();
+	}
+
+	private CacheableEntity createEntity(EntityManager em) {
+        CacheableEntity ce = new CacheableEntity();
+        int ceid = new Random().nextInt();
+        ce.setId(ceid);
+        ce.setName("Cached Entity");
+
+        // Persist the new cachable entity
+        em.getTransaction().begin();
+        em.persist(ce);
+        em.getTransaction().commit();
+        em.clear();
+        return ce;
+    }
+
+    private void verifyUpdatedEntity(CacheableEntity ce, int id) {
+        assertEquals(id, ce.getId());
+        assertEquals("Updated Cached Entity", ce.getName());
+        assertEquals(2, ce.getVersion());
+    }
+}

Propchange: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message