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>

3 files changed, 345 insertions, 348 deletions

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();
+    }
 
 }