Author: smarlow(a)redhat.com Date: 2010-03-08 16:18:03 -0500 (Mon, 08 Mar 2010) New Revision: 18936 Modified: core/trunk/entitymanager/src/test/java/org/hibernate/ejb/test/lock/LockTest.java Log: HHH-4972 javax.persistence.query.timeout and javax.persistence.lock.timeout can be passed when creating an EMF Modified: core/trunk/entitymanager/src/test/java/org/hibernate/ejb/test/lock/LockTest.java =================================================================== --- core/trunk/entitymanager/src/test/java/org/hibernate/ejb/test/lock/LockTest.java 2010-03-08 18:26:51 UTC (rev 18935) +++ core/trunk/entitymanager/src/test/java/org/hibernate/ejb/test/lock/LockTest.java 2010-03-08 21:18:03 UTC (rev 18936) @@ -691,6 +691,92 @@ } + public void testLockTimeoutEMProps() throws Exception { + + EntityManager em = getOrCreateEntityManager(); + Map TimeoutProps = new HashMap(); + TimeoutProps.put("javax.persistence.lock.timeout", new Integer(1000) ); // 1 second timeout + final EntityManager em2 = createIsolatedEntityManager(TimeoutProps); + // TODO: replace dialect instanceof test with a Dialect.hasCapability (e.g. supportsPessimisticLockTimeout) + if ( ! (getDialect() instanceof Oracle10gDialect)) { + log.info("skipping testLockTimeoutEMProps"); + return; + } + Lock lock = new Lock(); + Thread t = null; + FutureTask<Boolean> bgTask = null; + final CountDownLatch latch = new CountDownLatch(1); + try { + lock.setName( "testLockTimeoutEMProps" ); + + em.getTransaction().begin(); + em.persist( lock ); + em.getTransaction().commit(); + em.clear(); + + em.getTransaction().begin(); + lock = em.getReference( Lock.class, lock.getId() ); + em.lock( lock, LockModeType.PESSIMISTIC_WRITE ); + final Integer id = lock.getId(); + lock.getName(); // force entity to be read + log.info("testLockTimeoutEMProps: got write lock"); + + bgTask = new FutureTask<Boolean>( new Callable() { + public Boolean call() { + try { + boolean timedOut = false; // true (success) if LockTimeoutException occurred + em2.getTransaction().begin(); + log.info("testLockTimeoutEMProps: (BG) about to read write-locked entity"); + // we should block on the following read + Lock lock2 = em2.getReference( Lock.class, id ); + lock2.getName(); // force entity to be read + log.info("testLockTimeoutEMProps: (BG) read write-locked entity"); + // em2 already has javax.persistence.lock.timeout of 1 second applied + try { + em2.lock( lock2, LockModeType.PESSIMISTIC_WRITE); + } + catch( LockTimeoutException e) { + // success + log.info("testLockTimeoutEMProps: (BG) got expected timeout exception"); + timedOut = true; + } + catch ( Throwable e) { + log.info("Expected LockTimeoutException but got unexpected exception", e); + } + em2.getTransaction().commit(); + return new Boolean(timedOut); + } + finally { + latch.countDown(); // signal that we finished + } + } + } ); + t = new Thread(bgTask); + t.setDaemon( true ); + t.setName("Lock timeout Test (bg)"); + t.start(); + boolean latchSet = latch.await( 10, TimeUnit.SECONDS ); // should return quickly on success + assertTrue( "background test thread finished (lock timeout is broken)", latchSet); + assertTrue( "background test thread timed out on lock attempt", bgTask.get().booleanValue() ); + em.getTransaction().commit(); + } + finally { + if ( em.getTransaction().isActive() ) { + em.getTransaction().rollback(); + } + if ( t != null) { // wait for background thread to finish before deleting entity + t.join(); + } + em.getTransaction().begin(); + lock = em.getReference( Lock.class, lock.getId() ); + em.remove( lock ); + em.getTransaction().commit(); + em.close(); + em2.close(); + } + } + + public Class[] getAnnotatedClasses() { return new Class[]{ Lock.class,