diff --git a/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TestTransactionManager.java b/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TestTransactionManager.java
index 558b183..78c91f3 100644
--- a/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TestTransactionManager.java
+++ b/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TestTransactionManager.java
@@ -18,6 +18,7 @@
 package org.apache.geronimo.transaction.manager;
 
 import javax.transaction.Status;
+import javax.transaction.InvalidTransactionException;
 import javax.transaction.Transaction;
 import javax.transaction.TransactionManager;
 import javax.transaction.xa.XAResource;
diff --git a/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TransactionManagerImplTest.java b/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TransactionManagerImplTest.java
index 5f15a81..d883176 100644
--- a/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TransactionManagerImplTest.java
+++ b/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TransactionManagerImplTest.java
@@ -19,6 +19,7 @@
 
 import java.util.Map;
 
+import javax.transaction.InvalidTransactionException;
 import javax.transaction.RollbackException;
 import javax.transaction.Status;
 import javax.transaction.Transaction;
@@ -290,28 +291,125 @@
         assertEquals(xid, recovered.keySet().iterator().next());
     }
 
-      public void testTimeout() throws Exception
-      {
-          long timeout = tm.getTransactionTimeoutMilliseconds(0L);
-          tm.setTransactionTimeout((int)timeout/4000);
-          tm.begin();
-          System.out.println("Test to sleep for " + timeout + " millisecs");
-          Thread.sleep(timeout);
-          try
-          {
-              tm.commit();
-              fail("Tx Should get Rollback exception");
-          }catch(RollbackException rex)
-          {
-              // Caught expected exception
-          }
+    public void testTimeout() throws Exception
+    {
+        long timeout = tm.getTransactionTimeoutMilliseconds(0L);
+        tm.setTransactionTimeout((int)timeout/4000);
+        tm.begin();
+        System.out.println("Test to sleep for " + timeout + " millisecs");
+        Thread.sleep(timeout);
+        try
+        {
+            tm.commit();
+            fail("Tx Should get Rollback exception");
+        }catch(RollbackException rex)
+        {
+            // Caught expected exception
+        }
 
-          // Now test if the default timeout is active
-          tm.begin();
-          System.out.println("Test to sleep for " + (timeout/2) + " millisecs");
-          Thread.sleep((timeout/2));
-          tm.commit();
-          // Its a failure if exception occurs.
-      }
+        // Now test if the default timeout is active
+        tm.begin();
+        System.out.println("Test to sleep for " + (timeout/2) + " millisecs");
+        Thread.sleep((timeout/2));
+        tm.commit();
+        // Its a failure if exception occurs.
+    }    
+      
+    // resume throws InvalidTransactionException on completed tx (via commit)
+    public void testResume1() throws Exception {
+        Transaction tx;
+        assertEquals(Status.STATUS_NO_TRANSACTION, tm.getStatus());
+        tm.begin();   
+        assertEquals(Status.STATUS_ACTIVE, tm.getStatus());
+        tx = tm.getTransaction();
+        assertNotNull(tx);
+        assertEquals(Status.STATUS_ACTIVE, tx.getStatus());
+        
+        tm.commit();
+        assertEquals(Status.STATUS_NO_TRANSACTION, tm.getStatus());
+        assertNull(tm.getTransaction());
+        
+        try {
+            tm.resume(tx);
+            fail();
+        } catch (InvalidTransactionException e) {
+            // expected
+        }        
+    }
+    
+    // resume throws InvalidTransactionException on completed tx (via rollback)
+    public void testResume2() throws Exception {
+        Transaction tx;
+        assertEquals(Status.STATUS_NO_TRANSACTION, tm.getStatus());
+        tm.begin();
+        assertEquals(Status.STATUS_ACTIVE, tm.getStatus());
+        tx = tm.getTransaction();
+        assertNotNull(tx);
+        assertEquals(Status.STATUS_ACTIVE, tx.getStatus());
 
+        tx = tm.suspend();
+        assertEquals(Status.STATUS_NO_TRANSACTION, tm.getStatus());
+        assertNull(tm.getTransaction());
+
+        tm.resume(tx);
+        assertEquals(Status.STATUS_ACTIVE, tm.getStatus());
+        assertEquals(tx, tm.getTransaction());
+
+        tm.rollback();
+        assertEquals(Status.STATUS_NO_TRANSACTION, tm.getStatus());
+        assertNull(tm.getTransaction());     
+        
+        try {
+            tm.resume(tx);
+            fail();
+        } catch (InvalidTransactionException e) {
+            // expected
+        }   
+    }
+    
+    // resume work on null tx
+    public void testResume3() throws Exception {
+        Transaction tx;
+        assertEquals(Status.STATUS_NO_TRANSACTION, tm.getStatus());
+        tm.begin();
+        assertEquals(Status.STATUS_ACTIVE, tm.getStatus());
+        tx = tm.getTransaction();
+        assertNotNull(tx);
+        assertEquals(Status.STATUS_ACTIVE, tx.getStatus());
+
+        tm.commit();
+        assertEquals(Status.STATUS_NO_TRANSACTION, tm.getStatus());
+        assertNull(tm.getTransaction());
+
+        // tx should be null
+        tx = tm.suspend();
+        assertNull(tx);
+        
+        try {
+            tm.resume(tx);
+        } catch (InvalidTransactionException e) {
+            // null is considered valid so we don't expect InvalidTransactionException here
+            e.printStackTrace();
+            fail();
+        }   
+    }
+    
+    // resume works on any valid tx
+    public void testResume4() throws Exception {
+        Transaction tx;
+        assertEquals(Status.STATUS_NO_TRANSACTION, tm.getStatus());
+        tm.begin();
+        assertEquals(Status.STATUS_ACTIVE, tm.getStatus());
+        tx = tm.getTransaction();
+        assertNotNull(tx);
+        assertEquals(Status.STATUS_ACTIVE, tx.getStatus());
+
+        tm.resume(tx);
+        assertNotNull(tx);
+        assertEquals(Status.STATUS_ACTIVE, tx.getStatus());
+
+        tm.commit();
+        assertEquals(Status.STATUS_NO_TRANSACTION, tm.getStatus());
+        assertNull(tm.getTransaction()); 
+    }
 }
diff --git a/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TransactionSynchronizationRegistryTest.java b/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TransactionSynchronizationRegistryTest.java
index 46b9355..f487887 100644
--- a/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TransactionSynchronizationRegistryTest.java
+++ b/geronimo-transaction/src/test/java/org/apache/geronimo/transaction/manager/TransactionSynchronizationRegistryTest.java
@@ -83,6 +83,15 @@
         tm.rollback();
         checkInterposedSyncCalled();
     }
+    
+    /*public void testNormalSynchIsNotCalledOnRollback() throws Exception {
+    	normalSync = new CountingSync();
+    	tm.begin();
+    	tm.getTransaction().registerSynchronization(normalSync);
+        tm.rollback();
+        assertFalse(normalSync.beforeCompletionCalled());
+        assertTrue(normalSync.afterCompletionCalled());
+    }*/
 
     public void testInterposedSynchIsCalledOnMarkRollback() throws Exception {
         setUpInterposedSync();
@@ -150,12 +159,16 @@
 
         private int beforeCount = -1;
         private int afterCount = -1;
+        private boolean beforeCalled = false;
+        private boolean afterCalled = false;
 
         public void beforeCompletion() {
+        	beforeCalled = true;
             beforeCount = beforeCounter++;
         }
 
         public void afterCompletion(int i) {
+        	afterCalled = true;
             afterCount = afterCounter++;
         }
 
@@ -166,6 +179,14 @@
         public int getAfterCount() {
             return afterCount;
         }
+        
+        public boolean beforeCompletionCalled() {
+        	return beforeCalled;
+        }
+        
+        public boolean afterCompletionCalled() {
+        	return afterCalled;
+        }
     }
 
 }