Removed checkstyle warnings

Removed checkstyle warnings in policy/common/utils

Issue-ID: POLICY-695
Change-Id: I831b74c889d44784d6328619d88eb92fb524ce74
Signed-off-by: mmis <michael.morris@ericsson.com>

6 files changed, 444 insertions, 448 deletions

diff --git a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java
index 2ed54196..3532002e 100644
--- a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java
+++ b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrCloser.java
@@ -23,37 +23,37 @@ package org.onap.policy.common.utils.jpa;
 import javax.persistence.EntityManager;
 
 /**
- * Wrapper for an <i>EntityManager</i>, providing auto-close functionality. This
- * is useful in try-with-resources statements.
+ * Wrapper for an <i>EntityManager</i>, providing auto-close functionality. This is useful in
+ * try-with-resources statements.
  */
 public class EntityMgrCloser implements AutoCloseable {
 
-	/**
-	 * The wrapped manager.
-	 */
-	private final EntityManager em;
-
-	/**
-	 * 
-	 * @param em
-	 *            manager to be auto-closed
-	 */
-	public EntityMgrCloser(EntityManager em) {
-		this.em = em;
-	}
-
-	/**
-	 * Gets the EntityManager wrapped within this object.
-	 * 
-	 * @return the associated EntityManager
-	 */
-	public EntityManager getManager() {
-		return em;
-	}
-
-	@Override
-	public void close() {
-		em.close();
-	}
+    /**
+     * The wrapped manager.
+     */
+    private final EntityManager em;
+
+    /**
+     * Construct an instance with the EntityManager.
+     * 
+     * @param em manager to be auto-closed
+     */
+    public EntityMgrCloser(EntityManager em) {
+        this.em = em;
+    }
+
+    /**
+     * Gets the EntityManager wrapped within this object.
+     * 
+     * @return the associated EntityManager
+     */
+    public EntityManager getManager() {
+        return em;
+    }
+
+    @Override
+    public void close() {
+        em.close();
+    }
 
 }
diff --git a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java
index 8910c087..b046cc55 100644
--- a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java
+++ b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloser.java
@@ -23,37 +23,37 @@ package org.onap.policy.common.utils.jpa;
 import javax.persistence.EntityManagerFactory;
 
 /**
- * Wrapper for an <i>EntityManagerFactory</i>, providing auto-close
- * functionality. This is useful in try-with-resources statements.
+ * Wrapper for an <i>EntityManagerFactory</i>, providing auto-close functionality. This is useful in
+ * try-with-resources statements.
  */
 public class EntityMgrFactoryCloser implements AutoCloseable {
 
-	/**
-	 * The wrapped factory.
-	 */
-	private final EntityManagerFactory emf;
-
-	/**
-	 * 
-	 * @param emf
-	 *            manager to be auto-closed
-	 */
-	public EntityMgrFactoryCloser(EntityManagerFactory emf) {
-		this.emf = emf;
-	}
-
-	/**
-	 * Gets the EntityManagerFactory wrapped within this object.
-	 * 
-	 * @return the associated EntityManagerFactory
-	 */
-	public EntityManagerFactory getFactory() {
-		return emf;
-	}
-
-	@Override
-	public void close() {
-		emf.close();
-	}
+    /**
+     * The wrapped factory.
+     */
+    private final EntityManagerFactory emf;
+
+    /**
+     * Construct an instance with the given EntityManagerFactory.
+     * 
+     * @param emf manager to be auto-closed
+     */
+    public EntityMgrFactoryCloser(EntityManagerFactory emf) {
+        this.emf = emf;
+    }
+
+    /**
+     * Gets the EntityManagerFactory wrapped within this object.
+     * 
+     * @return the associated EntityManagerFactory
+     */
+    public EntityManagerFactory getFactory() {
+        return emf;
+    }
+
+    @Override
+    public void close() {
+        emf.close();
+    }
 
 }
diff --git a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java
index ce300741..3552a6fa 100644
--- a/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java
+++ b/utils/src/main/java/org/onap/policy/common/utils/jpa/EntityTransCloser.java
@@ -23,55 +23,54 @@ package org.onap.policy.common.utils.jpa;
 import javax.persistence.EntityTransaction;
 
 /**
- * Wrapper for an <i>EntityTransaction</i> that is auto-rolled back when closed.
- * This is useful in try-with-resources statements.
+ * Wrapper for an <i>EntityTransaction</i> that is auto-rolled back when closed. This is useful in
+ * try-with-resources statements.
  */
 public class EntityTransCloser implements AutoCloseable {
 
-	/**
-	 * Transaction to be rolled back.
-	 */
-	private final EntityTransaction trans;
+    /**
+     * Transaction to be rolled back.
+     */
+    private final EntityTransaction trans;
 
-	/**
-	 * Begins a transaction.
-	 * 
-	 * @param et
-	 *            transaction to wrap/begin
-	 */
-	public EntityTransCloser(EntityTransaction et) {
-		trans = et;
-		trans.begin();
-	}
+    /**
+     * Begins a transaction.
+     * 
+     * @param et transaction to wrap/begin
+     */
+    public EntityTransCloser(EntityTransaction et) {
+        trans = et;
+        trans.begin();
+    }
 
-	/**
-	 * Gets the wrapped transaction.
-	 * 
-	 * @return the transaction
-	 */
-	public EntityTransaction getTransation() {
-		return trans;
-	}
+    /**
+     * Gets the wrapped transaction.
+     * 
+     * @return the transaction
+     */
+    public EntityTransaction getTransation() {
+        return trans;
+    }
 
-	/**
-	 * Commits the transaction.
-	 */
-	public void commit() {
-		trans.commit();
-	}
+    /**
+     * Commits the transaction.
+     */
+    public void commit() {
+        trans.commit();
+    }
 
-	/**
-	 * Rolls back the transaction.
-	 */
-	public void rollback() {
-		trans.rollback();
-	}
+    /**
+     * Rolls back the transaction.
+     */
+    public void rollback() {
+        trans.rollback();
+    }
 
-	@Override
-	public void close() {
-		if (trans.isActive()) {
-			trans.rollback();
-		}
-	}
+    @Override
+    public void close() {
+        if (trans.isActive()) {
+            trans.rollback();
+        }
+    }
 
 }
diff --git a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java
index abc8d93f..e791e084 100644
--- a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java
+++ b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrCloserTest.java
@@ -29,84 +29,82 @@ import javax.persistence.EntityManager;
 
 import org.junit.Before;
 import org.junit.Test;
-import org.onap.policy.common.utils.jpa.EntityMgrCloser;
 
 public class EntityMgrCloserTest {
-	
-	private EntityManager mgr;
-	
-
-	@Before
-	public void setUp() throws Exception {
-		mgr = mock(EntityManager.class);
-	}
-
-
-	/**
-	 * Verifies that the constructor does not do anything extra before
-	 * being closed.
-	 */
-	@Test
-	public void testEntityMgrCloser() {
-		EntityMgrCloser c = new EntityMgrCloser(mgr);
-		
-		assertEquals(mgr, c.getManager());
-
-		// verify not closed yet
-		verify(mgr, never()).close();
-		
-		c.close();
-
-		verify(mgr).close();
-	}
-
-	@Test
-	public void testGetManager() {
-		try(EntityMgrCloser c = new EntityMgrCloser(mgr)) {
-			assertEquals(mgr, c.getManager());
-		}
-	}
-	
-	/**
-	 * Verifies that the manager gets closed when close() is invoked.
-	 */
-	@Test
-	public void testClose() {
-		EntityMgrCloser c = new EntityMgrCloser(mgr);
-		
-		c.close();
-		
-		// should be closed
-		verify(mgr).close();
-	}
-
-	/**
-	 * Ensures that the manager gets closed when "try" block exits normally.
-	 */
-	@Test
-	public void testClose_TryWithoutExcept() {
-		try(EntityMgrCloser c = new EntityMgrCloser(mgr)) {
-			
-		}
-		
-		verify(mgr).close();
-	}
-
-	/**
-	 * Ensures that the manager gets closed when "try" block throws an
-	 * exception.
-	 */
-	@Test
-	public void testClose_TryWithExcept() {
-		try {
-			try(EntityMgrCloser c = new EntityMgrCloser(mgr)) {
-				throw new Exception("expected exception");
-			}
-			
-		} catch (Exception e) {
-		}
-		
-		verify(mgr).close();
-	}
+
+    private EntityManager mgr;
+
+
+    @Before
+    public void setUp() throws Exception {
+        mgr = mock(EntityManager.class);
+    }
+
+
+    /**
+     * Verifies that the constructor does not do anything extra before being closed.
+     */
+    @Test
+    public void testEntityMgrCloser() {
+        EntityMgrCloser entityMgrCloser = new EntityMgrCloser(mgr);
+
+        assertEquals(mgr, entityMgrCloser.getManager());
+
+        // verify not closed yet
+        verify(mgr, never()).close();
+
+        entityMgrCloser.close();
+
+        verify(mgr).close();
+    }
+
+    @Test
+    public void testGetManager() {
+        try (EntityMgrCloser c = new EntityMgrCloser(mgr)) {
+            assertEquals(mgr, c.getManager());
+        }
+    }
+
+    /**
+     * Verifies that the manager gets closed when close() is invoked.
+     */
+    @Test
+    public void testClose() {
+        EntityMgrCloser entityMgrCloser = new EntityMgrCloser(mgr);
+
+        entityMgrCloser.close();
+
+        // should be closed
+        verify(mgr).close();
+    }
+
+    /**
+     * Ensures that the manager gets closed when "try" block exits normally.
+     */
+    @Test
+    public void testClose_TryWithoutExcept() {
+        try (EntityMgrCloser entityMgrCloser = new EntityMgrCloser(mgr)) {
+            // No need to do anything in the try block
+        }
+
+        verify(mgr).close();
+    }
+
+    /**
+     * Ensures that the manager gets closed when "try" block throws an exception.
+     */
+    @Test
+    public void testClose_TryWithExcept() {
+        try {
+            try (EntityMgrCloser c = new EntityMgrCloser(mgr)) {
+                throw new Exception("expected exception");
+            }
+
+        } catch (Exception exception) {
+            // Ignore the exception
+        }
+
+        verify(mgr).close();
+    }
 
 }
diff --git a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java
index 60ed27d0..8f2c0159 100644
--- a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java
+++ b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityMgrFactoryCloserTest.java
@@ -29,84 +29,82 @@ import javax.persistence.EntityManagerFactory;
 
 import org.junit.Before;
 import org.junit.Test;
-import org.onap.policy.common.utils.jpa.EntityMgrFactoryCloser;
 
 public class EntityMgrFactoryCloserTest {
-	
-	private EntityManagerFactory factory;
-	
-
-	@Before
-	public void setUp() throws Exception {
-		factory = mock(EntityManagerFactory.class);
-	}
-
-
-	/**
-	 * Verifies that the constructor does not do anything extra before
-	 * being closed.
-	 */
-	@Test
-	public void testEntityMgrFactoryCloser() {
-		EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory);
-		
-		assertEquals(factory, c.getFactory());
-
-		// verify not closed yet
-		verify(factory, never()).close();
-		
-		c.close();
-
-		verify(factory).close();
-	}
-
-	@Test
-	public void testgetFactory() {
-		try(EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) {
-			assertEquals(factory, c.getFactory());
-		}
-	}
-	
-	/**
-	 * Verifies that the manager gets closed when close() is invoked.
-	 */
-	@Test
-	public void testClose() {
-		EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory);
-		
-		c.close();
-		
-		// should be closed
-		verify(factory).close();
-	}
-
-	/**
-	 * Ensures that the manager gets closed when "try" block exits normally.
-	 */
-	@Test
-	public void testClose_TryWithoutExcept() {
-		try(EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) {
-			
-		}
-		
-		verify(factory).close();
-	}
-
-	/**
-	 * Ensures that the manager gets closed when "try" block throws an
-	 * exception.
-	 */
-	@Test
-	public void testClose_TryWithExcept() {
-		try {
-			try(EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) {
-				throw new Exception("expected exception");
-			}
-			
-		} catch (Exception e) {
-		}
-		
-		verify(factory).close();
-	}
+
+    private EntityManagerFactory factory;
+
+
+    @Before
+    public void setUp() throws Exception {
+        factory = mock(EntityManagerFactory.class);
+    }
+
+
+    /**
+     * Verifies that the constructor does not do anything extra before being closed.
+     */
+    @Test
+    public void testEntityMgrFactoryCloser() {
+        EntityMgrFactoryCloser entityMgrFactoryCloser = new EntityMgrFactoryCloser(factory);
+
+        assertEquals(factory, entityMgrFactoryCloser.getFactory());
+
+        // verify not closed yet
+        verify(factory, never()).close();
+
+        entityMgrFactoryCloser.close();
+
+        verify(factory).close();
+    }
+
+    @Test
+    public void testgetFactory() {
+        try (EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) {
+            assertEquals(factory, c.getFactory());
+        }
+    }
+
+    /**
+     * Verifies that the manager gets closed when close() is invoked.
+     */
+    @Test
+    public void testClose() {
+        EntityMgrFactoryCloser entityMgrFactoryCloser = new EntityMgrFactoryCloser(factory);
+
+        entityMgrFactoryCloser.close();
+
+        // should be closed
+        verify(factory).close();
+    }
+
+    /**
+     * Ensures that the manager gets closed when "try" block exits normally.
+     */
+    @Test
+    public void testClose_TryWithoutExcept() {
+        try (EntityMgrFactoryCloser entityMgrFactoryCloser = new EntityMgrFactoryCloser(factory)) {
+            // No need to do anything in the try block
+        }
+
+        verify(factory).close();
+    }
+
+    /**
+     * Ensures that the manager gets closed when "try" block throws an exception.
+     */
+    @Test
+    public void testClose_TryWithExcept() {
+        try {
+            try (EntityMgrFactoryCloser c = new EntityMgrFactoryCloser(factory)) {
+                throw new Exception("expected exception");
+            }
+
+        } catch (Exception exception) {
+            // Ignore the exception
+        }
+
+        verify(factory).close();
+    }
 
 }
diff --git a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java
index e7dcf11c..9a499e49 100644
--- a/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java
+++ b/utils/src/test/java/org/onap/policy/common/utils/jpa/EntityTransCloserTest.java
@@ -31,201 +31,202 @@ import javax.persistence.EntityTransaction;
 
 import org.junit.Before;
 import org.junit.Test;
-import org.onap.policy.common.utils.jpa.EntityTransCloser;
 
 public class EntityTransCloserTest {
-	
-	private EntityTransaction trans;
-
-	@Before
-	public void setUp() throws Exception {
-		trans = mock(EntityTransaction.class);
-		
-		when(trans.isActive()).thenReturn(true);
-	}
-
-
-
-	/**
-	 * Verifies that the constructor starts a transaction, but does not do
-	 * anything extra before being closed.
-	 */
-	@Test
-	public void testEntityTransCloser() {
-		EntityTransCloser t = new EntityTransCloser(trans);
-		
-		assertEquals(trans, t.getTransation());
-		
-		// verify that transaction was started
-		verify(trans).begin();
-
-		// verify not closed, committed, or rolled back yet
-		verify(trans, never()).commit();
-		verify(trans, never()).rollback();
-		
-		t.close();
-
-		verify(trans).rollback();
-	}
-	
-	@Test
-	public void testGetTransation() {
-		try(EntityTransCloser t = new EntityTransCloser(trans)) {
-			assertEquals(trans, t.getTransation());
-		}
-	}
-
-	/**
-	 * Verifies that the transaction is rolled back and the manager is
-	 * closed when and a transaction is active.
-	 */
-	@Test
-	public void testClose_Active() {
-		EntityTransCloser t = new EntityTransCloser(trans);
-
-		when(trans.isActive()).thenReturn(true);
-		
-		t.close();
-
-		// closed and rolled back, but not committed
-		verify(trans, never()).commit();
-		verify(trans).rollback();
-	}
-
-	/**
-	 * Verifies that the manager is closed, but that the transaction is
-	 * <i>not</i> rolled back and when and no transaction is active.
-	 */
-	@Test
-	public void testClose_Inactive() {
-		EntityTransCloser t = new EntityTransCloser(trans);
-
-		when(trans.isActive()).thenReturn(false);
-		
-		t.close();
-
-		// closed, but not committed or rolled back
-		verify(trans, never()).commit();
-		verify(trans, never()).rollback();
-	}
-
-	/**
-	 * Verifies that the manager is closed and the transaction rolled back
-	 * when "try" block exits normally and a transaction is active.
-	 */
-	@Test
-	public void testClose_TryWithoutExcept_Active() {
-		when(trans.isActive()).thenReturn(true);
-		
-		try(EntityTransCloser t = new EntityTransCloser(trans)) {
-			
-		}
-
-		// closed and rolled back, but not committed
-		verify(trans, never()).commit();
-		verify(trans).rollback();
-	}
-
-	/**
-	 * Verifies that the manager is closed, but that the transaction is
-	 * <i>not</i> rolled back when "try" block exits normally and no
-	 * transaction is active.
-	 */
-	@Test
-	public void testClose_TryWithoutExcept_Inactive() {
-		when(trans.isActive()).thenReturn(false);
-		
-		try(EntityTransCloser t = new EntityTransCloser(trans)) {
-			
-		}
-
-		// closed, but not rolled back or committed
-		verify(trans, never()).commit();
-		verify(trans, never()).rollback();
-	}
-
-	/**
-	 * Verifies that the manager is closed and the transaction rolled back
-	 * when "try" block throws an exception and a transaction is active.
-	 */
-	@Test
-	public void testClose_TryWithExcept_Active() {
-		when(trans.isActive()).thenReturn(true);
-		
-		try {
-			try(EntityTransCloser t = new EntityTransCloser(trans)) {
-				throw new Exception("expected exception");
-			}
-			
-		} catch (Exception e) {
-		}
-
-		// closed and rolled back, but not committed
-		verify(trans, never()).commit();
-		verify(trans).rollback();
-	}
-
-	/**
-	 * Verifies that the manager is closed, but that the transaction is
-	 * <i>not</i> rolled back when "try" block throws an exception and no
-	 * transaction is active.
-	 */
-	@Test
-	public void testClose_TryWithExcept_Inactive() {
-		when(trans.isActive()).thenReturn(false);
-		
-		try {
-			try(EntityTransCloser t = new EntityTransCloser(trans)) {
-				throw new Exception("expected exception");
-			}
-			
-		} catch (Exception e) {
-		}
-
-		// closed, but not rolled back or committed
-		verify(trans, never()).commit();
-		verify(trans, never()).rollback();
-	}
-
-	/**
-	 * Verifies that commit() only commits, and that the subsequent close()
-	 * does not re-commit.
-	 */
-	@Test
-	public void testCommit() {
-		EntityTransCloser t = new EntityTransCloser(trans);
-		
-		t.commit();
-		
-		// committed, but not closed or rolled back
-		verify(trans).commit();
-		verify(trans, never()).rollback();
-		
-		// closed, but not re-committed
-		t.close();
-
-		verify(trans, times(1)).commit();
-	}
-
-	/**
-	 * Verifies that rollback() only rolls back, and that the subsequent
-	 * close() does not re-roll back.
-	 */
-	@Test
-	public void testRollback() {
-		EntityTransCloser t = new EntityTransCloser(trans);
-		
-		t.rollback();
-		
-		// rolled back, but not closed or committed
-		verify(trans, never()).commit();
-		verify(trans).rollback();
-		
-		// closed, but not re-rolled back
-		when(trans.isActive()).thenReturn(false);
-		t.close();
-
-		verify(trans, times(1)).rollback();
-	}
+
+    private EntityTransaction trans;
+
+    /**
+     * Set up EntityTransaction mock.
+     */
+    @Before
+    public void setUp() throws Exception {
+        trans = mock(EntityTransaction.class);
+
+        when(trans.isActive()).thenReturn(true);
+    }
+
+
+
+    /**
+     * Verifies that the constructor starts a transaction, but does not do anything extra before
+     * being closed.
+     */
+    @Test
+    public void testEntityTransCloser() {
+        EntityTransCloser entityTransCloser = new EntityTransCloser(trans);
+
+        assertEquals(trans, entityTransCloser.getTransation());
+
+        // verify that transaction was started
+        verify(trans).begin();
+
+        // verify not closed, committed, or rolled back yet
+        verify(trans, never()).commit();
+        verify(trans, never()).rollback();
+
+        entityTransCloser.close();
+
+        verify(trans).rollback();
+    }
+
+    @Test
+    public void testGetTransation() {
+        try (EntityTransCloser t = new EntityTransCloser(trans)) {
+            assertEquals(trans, t.getTransation());
+        }
+    }
+
+    /**
+     * Verifies that the transaction is rolled back and the manager is closed when and a transaction
+     * is active.
+     */
+    @Test
+    public void testClose_Active() {
+        EntityTransCloser entityTransCloser = new EntityTransCloser(trans);
+
+        when(trans.isActive()).thenReturn(true);
+
+        entityTransCloser.close();
+
+        // closed and rolled back, but not committed
+        verify(trans, never()).commit();
+        verify(trans).rollback();
+    }
+
+    /**
+     * Verifies that the manager is closed, but that the transaction is <i>not</i> rolled back and
+     * when and no transaction is active.
+     */
+    @Test
+    public void testClose_Inactive() {
+        EntityTransCloser entityTransCloser = new EntityTransCloser(trans);
+
+        when(trans.isActive()).thenReturn(false);
+
+        entityTransCloser.close();
+
+        // closed, but not committed or rolled back
+        verify(trans, never()).commit();
+        verify(trans, never()).rollback();
+    }
+
+    /**
+     * Verifies that the manager is closed and the transaction rolled back when "try" block exits
+     * normally and a transaction is active.
+     */
+    @Test
+    public void testClose_TryWithoutExcept_Active() {
+        when(trans.isActive()).thenReturn(true);
+
+        try (EntityTransCloser entityTransCloser = new EntityTransCloser(trans)) {
+            // No need to do anything in the try block
+        }
+
+        // closed and rolled back, but not committed
+        verify(trans, never()).commit();
+        verify(trans).rollback();
+    }
+
+    /**
+     * Verifies that the manager is closed, but that the transaction is <i>not</i> rolled back when
+     * "try" block exits normally and no transaction is active.
+     */
+    @Test
+    public void testClose_TryWithoutExcept_Inactive() {
+        when(trans.isActive()).thenReturn(false);
+
+        try (EntityTransCloser entityTransCloser = new EntityTransCloser(trans)) {
+            // No need to do anything in the try block
+        }
+
+        // closed, but not rolled back or committed
+        verify(trans, never()).commit();
+        verify(trans, never()).rollback();
+    }
+
+    /**
+     * Verifies that the manager is closed and the transaction rolled back when "try" block throws
+     * an exception and a transaction is active.
+     */
+    @Test
+    public void testClose_TryWithExcept_Active() {
+        when(trans.isActive()).thenReturn(true);
+
+        try {
+            try (EntityTransCloser t = new EntityTransCloser(trans)) {
+                throw new Exception("expected exception");
+            }
+
+        } catch (Exception e) {
+            // Ignore the exception
+        }
+
+        // closed and rolled back, but not committed
+        verify(trans, never()).commit();
+        verify(trans).rollback();
+    }
+
+    /**
+     * Verifies that the manager is closed, but that the transaction is <i>not</i> rolled back when
+     * "try" block throws an exception and no transaction is active.
+     */
+    @Test
+    public void testClose_TryWithExcept_Inactive() {
+        when(trans.isActive()).thenReturn(false);
+
+        try {
+            try (EntityTransCloser t = new EntityTransCloser(trans)) {
+                throw new Exception("expected exception");
+            }
+
+        } catch (Exception e) {
+            // Ignore the exception
+        }
+
+        // closed, but not rolled back or committed
+        verify(trans, never()).commit();
+        verify(trans, never()).rollback();
+    }
+
+    /**
+     * Verifies that commit() only commits, and that the subsequent close() does not re-commit.
+     */
+    @Test
+    public void testCommit() {
+        EntityTransCloser entityTransCloser = new EntityTransCloser(trans);
+
+        entityTransCloser.commit();
+
+        // committed, but not closed or rolled back
+        verify(trans).commit();
+        verify(trans, never()).rollback();
+
+        // closed, but not re-committed
+        entityTransCloser.close();
+
+        verify(trans, times(1)).commit();
+    }
+
+    /**
+     * Verifies that rollback() only rolls back, and that the subsequent close() does not re-roll
+     * back.
+     */
+    @Test
+    public void testRollback() {
+        EntityTransCloser entityTransCloser = new EntityTransCloser(trans);
+
+        entityTransCloser.rollback();
+
+        // rolled back, but not closed or committed
+        verify(trans, never()).commit();
+        verify(trans).rollback();
+
+        // closed, but not re-rolled back
+        when(trans.isActive()).thenReturn(false);
+        entityTransCloser.close();
+
+        verify(trans, times(1)).rollback();
+    }
 
 }