Removed checkstyle warnings

Removed checkstyle warnings in policy/common/ia

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

20 files changed, 5196 insertions, 5242 deletions

diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/AuditThread.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/AuditThread.java
index efa1b1d3..f1839b12 100644
--- a/integrity-audit/src/main/java/org/onap/policy/common/ia/AuditThread.java
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/AuditThread.java
@@ -35,869 +35,794 @@ import org.onap.policy.common.logging.flexlogger.FlexLogger;
 import org.onap.policy.common.logging.flexlogger.Logger;
 
 /**
- * AuditThread is the main thread for the IntegrityAudit
+ * AuditThread is the main thread for the IntegrityAudit.
  * 
  */
 public class AuditThread extends Thread {
 
-	private static final Logger logger = FlexLogger.getLogger(AuditThread.class);
-
-	/*
-	 * Number of milliseconds that must elapse for audit to be considered
-	 * complete. It's public for access by JUnit test logic.
-	 */
-	public static final long AUDIT_COMPLETION_INTERVAL = 30000;
-
-	/*
-	 * Number of iterations for audit simulation.
-	 */
-	public static final long AUDIT_SIMULATION_ITERATIONS = 3;
-
-	/*
-	 * Number of milliseconds to sleep between audit simulation iterations. It's
-	 * public for access by JUnit test logic.
-	 */
-	public static final long AUDIT_SIMULATION_SLEEP_INTERVAL = 5000;
-
-	/*
-	 * Unless audit has already been run on this entity, number of milliseconds
-	 * to sleep between audit thread iterations. If audit has already been run,
-	 * we sleep integrityAuditPeriodMillis.  May be modified by JUnit tests.
-	 */
-	private static long auditThreadSleepIntervalMillis = 5000;
-
-	/*
-	 * Number of milliseconds that must elapse for audit to be considered
-	 * complete.  May be modified by JUnit tests.
-	 */
-	private static long auditCompletionIntervalMillis = AUDIT_COMPLETION_INTERVAL;
-
-	/*
-	 * DB access class.
-	 */
-	private DbDAO dbDAO;
-
-	/*
-	 * E.g. pdp_xacml
-	 */
-	private String nodeType;
-
-	/*
-	 * Persistence unit for which this audit is being run.
-	 */
-	private String persistenceUnit;
-
-	/*
-	 * Name of this resource
-	 */
-	private String resourceName;
-
-	/*
-	 * E.g. DB_DRIVER, SITE_NAME, NODE_TYPE
-	 */
-	private Properties properties;
-
-	/*
-	 * See IntegrityAudit class for usage.
-	 */
-	private long integrityAuditPeriodMillis;
-	
-	/*
-	 * The containing IntegrityAudit instance
-	 */
-	private IntegrityAudit integrityAudit;
-
-	/**
-	 * A latch is taken from this queue before starting an audit.  May be
-	 * {@code null}. Used by JUnit tests.
-	 */
-	private BlockingQueue<CountDownLatch> auditLatchQueue;
-
-	/**
-	 * Latch to be decremented when the next audit completes.  May be
-	 * {@code null}. Used by JUnit tests to wait for an audit to complete.
-	 */
-	private CountDownLatch auditCompletionLatch = null;
-
-	/**
-	 * AuditThread constructor
-	 * @param resourceName
-	 * @param persistenceUnit
-	 * @param properties
-	 * @param integrityAuditPeriodSeconds
-	 * @param integrityAudit
-	 * @throws IntegrityAuditException
-	 */
-	public AuditThread(String resourceName, String persistenceUnit,
-			Properties properties, int integrityAuditPeriodSeconds, IntegrityAudit integrityAudit)
-			throws IntegrityAuditException {
-
-		this(resourceName, persistenceUnit, properties, TimeUnit.SECONDS.toMillis(integrityAuditPeriodSeconds),
-				integrityAudit, null);
-	}
-
-	/**
-	 * AuditThread constructor
-	 * @param resourceName
-	 * @param persistenceUnit
-	 * @param properties
-	 * @param integrityAuditMillis
-	 * @param integrityAudit
-	 * @param queue 
-	 * @throws IntegrityAuditException
-	 */
-	public AuditThread(String resourceName, String persistenceUnit,
-			Properties properties, long integrityAuditMillis, IntegrityAudit integrityAudit,
-			BlockingQueue<CountDownLatch> queue)
-			throws IntegrityAuditException {
-		this.resourceName = resourceName;
-		this.persistenceUnit = persistenceUnit;
-		this.properties = properties;
-		this.integrityAuditPeriodMillis = integrityAuditMillis;
-		this.integrityAudit = integrityAudit;
-		this.auditLatchQueue = queue;
-
-		/*
-		 * The DbDAO Constructor registers this node in the IntegrityAuditEntity
-		 * table. Each resource (node) inserts its own name, persistenceUnit, DB
-		 * access properties and other pertinent properties in the table. This
-		 * allows the audit on each node to compare its own version of the
-		 * entities for the persistenceUnit in question with the versions from
-		 * all other nodes of similar type.
-		 */
-		dbDAO = new DbDAO(this.resourceName, this.persistenceUnit,
-				this.properties);
-		this.nodeType = properties.getProperty(IntegrityAuditProperties.NODE_TYPE);
-
-	}
-
-	@Override
-	public void run() {
-
-		logger.info("AuditThread.run: Entering");
-
-		try {			
-			/*
-			 * For JUnit testing: wait for the first latch, decrement it to
-			 * indicate that the thread has started, and then wait for the
-			 * next latch, before we actually start doing anything. These
-			 * simply return if there is no latch queue defined.
-			 */
-			getNextLatch();
-			decrementLatch();
-			getNextLatch();
-			
-			/*
-			 * Triggers change in designation, unless no other viable candidate.
-			 */
-			boolean auditCompleted = false;
-
-			DbAudit dbAudit = new DbAudit(dbDAO);
-
-			IntegrityAuditEntity entityCurrentlyDesignated;
-			IntegrityAuditEntity thisEntity;
-			integrityAudit.setThreadInitialized(true); // An exception will set
-														// it to false
-
-			while (true) {
-				try{
-					/*
-					 * It may have been awhile since we last cycled through this
-					 * loop, so refresh the list of IntegrityAuditEntities.
-					 */
-					List<IntegrityAuditEntity> integrityAuditEntityList = getIntegrityAuditEntityList();
-
-					/*
-					 * We could've set entityCurrentlyDesignated as a side effect of
-					 * getIntegrityAuditEntityList(), but then we would've had to
-					 * make entityCurrentlyDesignated a class level attribute. Using
-					 * this approach, we can keep it local to the run() method.
-					 */
-					entityCurrentlyDesignated = getEntityCurrentlyDesignated(integrityAuditEntityList);
-
-					/*
-					 * Need to refresh thisEntity each time through loop, because we
-					 * need a fresh version of lastUpdated.
-					 */
-					thisEntity = getThisEntity(integrityAuditEntityList);
-
-					/*
-					 * If we haven't done the audit yet, note that we're current and
-					 * see if we're designated.
-					 */
-					if (!auditCompleted) {
-						dbDAO.setLastUpdated();
-
-						/*
-						 * If no current designation or currently designated node is
-						 * stale, see if we're the next node to be designated.
-						 */
-						if (entityCurrentlyDesignated == null
-								|| isStale(entityCurrentlyDesignated)) {
-							IntegrityAuditEntity designationCandidate = getDesignationCandidate(integrityAuditEntityList);
-
-							/*
-							 * If we're the next node to be designated, run the
-							 * audit.
-							 */
-							if (designationCandidate.getResourceName().equals(
-									this.resourceName)) {
-								runAudit(dbAudit);
-								auditCompleted = true;
-							} else {
-								if (logger.isDebugEnabled()) {
-									logger.debug("AuditThread.run: designationCandidate, "
-											+ designationCandidate
-											.getResourceName()
-											+ ", not this entity, "
-											+ thisEntity.getResourceName());
-								}
-							}
-
-							/*
-							 * Application may have been stopped and restarted, in
-							 * which case we might be designated but auditCompleted
-							 * will have been reset to false, so account for this.
-							 */
-						} else if (thisEntity.getResourceName().equals(
-								entityCurrentlyDesignated.getResourceName())) {
-
-							if (logger.isDebugEnabled()) {
-								logger.debug("AuditThread.run: Re-running audit for "
-										+ thisEntity.getResourceName());
-							}
-							runAudit(dbAudit);
-							auditCompleted = true;
-
-						} else {
-							if (logger.isDebugEnabled()) {
-								logger.debug("AuditThread.run: Currently designated node, "
-										+ entityCurrentlyDesignated
-										.getResourceName()
-										+ ", not yet stale and not this node");
-							}
-						}
-
-
-						/*
-						 * Audit already completed on this node, so allow the node
-						 * to go stale until twice the AUDIT_COMPLETION_PERIOD has
-						 * elapsed. This should give plenty of time for another node
-						 * (if another node is out there) to pick up designation.
-						 */
-					} else {
-
-						auditCompleted = resetAuditCompleted(auditCompleted,
-								thisEntity);
-
-					}
-
-					/*
-					 * If we've just run audit, sleep per the
-					 * integrity_audit_period_seconds property, otherwise just sleep
-					 * the normal interval.
-					 */
-					if (auditCompleted) {
-						// indicate that an audit has completed
-						decrementLatch();
-
-						// don't start the next audit cycle until a latch has been provided
-						getNextLatch();
-
-						if (logger.isDebugEnabled()) {
-							logger.debug("AuditThread.run: Audit completed; resourceName="
-									+ this.resourceName
-									+ " sleeping "
-									+ integrityAuditPeriodMillis + "ms");
-						}
-						Thread.sleep(integrityAuditPeriodMillis);
-						if (logger.isDebugEnabled()) {
-							logger.debug("AuditThread.run: resourceName="
-									+ this.resourceName + " awaking from "
-									+ integrityAuditPeriodMillis + "ms sleep");
-						}
-
-					} else {
-
-						if (logger.isDebugEnabled()) {
-							logger.debug("AuditThread.run: resourceName="
-									+ this.resourceName + ": Sleeping "
-									+ AuditThread.auditThreadSleepIntervalMillis
-									+ "ms");
-						}
-						Thread.sleep(AuditThread.auditThreadSleepIntervalMillis);
-						if (logger.isDebugEnabled()) {
-							logger.debug("AuditThread.run: resourceName="
-									+ this.resourceName + ": Awaking from "
-									+ AuditThread.auditThreadSleepIntervalMillis
-									+ "ms sleep");
-						}
-
-					}
-				
-				} catch (Exception e){
-					if(isInterruptedException(e)) {
-						String msg = "AuditThread.run loop - Exception thrown: " + e.getMessage() 
-								+ "; Stopping.";
-						logger.error(MessageCodes.EXCEPTION_ERROR, e, msg);
-						break;
-					}
-					
-					String msg = "AuditThread.run loop - Exception thrown: " + e.getMessage() 
-							+ "; Will try audit again in " + (integrityAuditPeriodMillis/1000) + " seconds";
-					logger.error(MessageCodes.EXCEPTION_ERROR, e, msg);
-					// Sleep and try again later
-					Thread.sleep(integrityAuditPeriodMillis);
-				}
-
-			}
-
-		} catch (Exception e) {
-			String msg = "AuditThread.run: Could not start audit loop. Exception thrown; message="+ e.getMessage();
-			logger.error(MessageCodes.EXCEPTION_ERROR, e, msg);
-			integrityAudit.setThreadInitialized(false);
-		}
-		
-		dbDAO.destroy();
-
-		logger.info("AuditThread.run: Exiting");
-	}
-
-	/**
-	 * Gets the next audit-completion latch from the queue. Blocks, if the
-	 * queue is empty.
-	 * @throws InterruptedException
-	 */
-	private void getNextLatch() throws InterruptedException {
-		BlockingQueue<CountDownLatch> queue = this.auditLatchQueue;
-		if(queue != null) {
-			this.auditCompletionLatch = queue.take();
-		}
-	}
-
-	/**
-	 * Decrements the current audit-completion latch, if any.
-	 */
-	private void decrementLatch() {
-		CountDownLatch latch = this.auditCompletionLatch;
-		if(latch != null) {
-			this.auditCompletionLatch = null;
-			latch.countDown();
-		}
-	}
-
-	/**
-	 * Determines if an exception is an InterruptedException or was caused
-	 * by an InterruptedException.
-	 * @param ex	exception to be examined
-	 * @return {@code true} if it's an InterruptedException, {@code false} otherwise
-	 */
-	private boolean isInterruptedException(Throwable ex) {
-		while(ex != null) {
-			if(ex instanceof InterruptedException) {
-				return true;
-			}
-			
-			ex = ex.getCause();
-		}
-		
-		return false;
-	}
-
-	/*
-	 * Used to create a list that is sorted lexicographically by resourceName.
-	 */
-	Comparator<IntegrityAuditEntity> comparator = new Comparator<IntegrityAuditEntity>() {
-		@Override
-		public int compare(final IntegrityAuditEntity r1,
-				final IntegrityAuditEntity r2) {
-			return r1.getResourceName().compareTo(r2.getResourceName());
-		}
-	};
-
-	/**
-	 * getDesignationCandidate()
-	 * Using round robin algorithm, gets next candidate to be designated. Assumes
-	 * list is sorted lexicographically by resourceName.
-	 */
-	private IntegrityAuditEntity getDesignationCandidate(
-			List<IntegrityAuditEntity> integrityAuditEntityList) {
-		
-		//Note: assumes integrityAuditEntityList is already lexicographically sorted by resourceName
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("getDesignationCandidate: Entering, integrityAuditEntityList.size()="
-					+ integrityAuditEntityList.size());
-		}
-
-		IntegrityAuditEntity designationCandidate;
-		IntegrityAuditEntity thisEntity = null;
-
-		int designatedEntityIndex = -1;
-		int entityIndex = 0;
-		int priorCandidateIndex = -1;
-		int subsequentCandidateIndex = -1;
-
-		for (IntegrityAuditEntity integrityAuditEntity : integrityAuditEntityList) {
-
-			if (logger.isDebugEnabled()) {
-				logIntegrityAuditEntity(integrityAuditEntity);
-			}
-
-			if (integrityAuditEntity.getResourceName()
-					.equals(this.resourceName)) {
-				if (logger.isDebugEnabled()) {
-					logger.debug("getDesignationCandidate: thisEntity="
-							+ integrityAuditEntity.getResourceName());
-				}
-				thisEntity = integrityAuditEntity;
-			}
-
-			if (integrityAuditEntity.isDesignated()) {
-				if (logger.isDebugEnabled()) {
-					logger.debug("getDesignationCandidate: Currently designated entity resourceName="
-							+ integrityAuditEntity.getResourceName()
-							+ ", persistenceUnit="
-							+ integrityAuditEntity.getPersistenceUnit()
-							+ ", lastUpdated="
-							+ integrityAuditEntity.getLastUpdated()
-							+ ", entityIndex=" + entityIndex);
-				}
-				designatedEntityIndex = entityIndex;
-
-				/*
-				 * Entity not currently designated
-				 */
-			} else {
-
-				/*
-				 * See if non-designated entity is stale.
-				 */
-				if (isStale(integrityAuditEntity)) {
-
-					if (logger.isDebugEnabled()) {
-						logger.debug("getDesignationCandidate: Entity is stale; resourceName="
-								+ integrityAuditEntity.getResourceName()
-								+ ", persistenceUnit="
-								+ integrityAuditEntity.getPersistenceUnit()
-								+ ", lastUpdated="
-								+ integrityAuditEntity.getLastUpdated()
-								+ ", entityIndex=" + entityIndex);
-					}
-
-					/*
-					 * Entity is current.
-					 */
-				} else {
-
-					if (designatedEntityIndex == -1) {
-
-						if (priorCandidateIndex == -1) {
-							if (logger.isDebugEnabled()) {
-								logger.debug("getDesignationCandidate: Prior candidate found, resourceName="
-										+ integrityAuditEntity
-												.getResourceName()
-										+ ", persistenceUnit="
-										+ integrityAuditEntity
-												.getPersistenceUnit()
-										+ ", lastUpdated="
-										+ integrityAuditEntity.getLastUpdated()
-										+ ", entityIndex=" + entityIndex);
-							}
-							priorCandidateIndex = entityIndex;
-						} else {
-							if (logger.isDebugEnabled()) {
-								logger.debug("getDesignationCandidate: Prior entity current but prior candidate already found; resourceName="
-										+ integrityAuditEntity
-												.getResourceName()
-										+ ", persistenceUnit="
-										+ integrityAuditEntity
-												.getPersistenceUnit()
-										+ ", lastUpdated="
-										+ integrityAuditEntity.getLastUpdated()
-										+ ", entityIndex=" + entityIndex);
-							}
-						}
-					} else {
-						if (subsequentCandidateIndex == -1) {
-							if (logger.isDebugEnabled()) {
-								logger.debug("getDesignationCandidate: Subsequent candidate found, resourceName="
-										+ integrityAuditEntity
-												.getResourceName()
-										+ ", persistenceUnit="
-										+ integrityAuditEntity
-												.getPersistenceUnit()
-										+ ", lastUpdated="
-										+ integrityAuditEntity.getLastUpdated()
-										+ ", entityIndex=" + entityIndex);
-							}
-							subsequentCandidateIndex = entityIndex;
-						} else {
-							if (logger.isDebugEnabled()) {
-								logger.debug("getDesignationCandidate: Subsequent entity current but subsequent candidate already found; resourceName="
-										+ integrityAuditEntity
-												.getResourceName()
-										+ ", persistenceUnit="
-										+ integrityAuditEntity
-												.getPersistenceUnit()
-										+ ", lastUpdated="
-										+ integrityAuditEntity.getLastUpdated()
-										+ ", entityIndex=" + entityIndex);
-							}
-						}
-					}
-
-				} // end entity is current
-
-			} // end entity not currently designated
-
-			entityIndex++;
-
-		} // end for loop
-
-		/*
-		 * Per round robin algorithm, if a current entity is found that is
-		 * lexicographically after the currently designated entity, this entity
-		 * becomes the designation candidate. If no current entity is found that
-		 * is lexicographically after currently designated entity, we cycle back
-		 * to beginning of list and pick the first current entity as the
-		 * designation candidate.
-		 */
-		if (subsequentCandidateIndex != -1) {
-			designationCandidate = integrityAuditEntityList
-					.get(subsequentCandidateIndex);
-			if (logger.isDebugEnabled()) {
-				logger.debug("getDesignationCandidate: Exiting and returning subsequent designationCandidate="
-						+ designationCandidate.getResourceName());
-			}
-		} else {
-			if (priorCandidateIndex != -1) {
-				designationCandidate = integrityAuditEntityList
-						.get(priorCandidateIndex);
-				if (logger.isDebugEnabled()) {
-					logger.debug("getDesignationCandidate: Exiting and returning prior designationCandidate="
-							+ designationCandidate.getResourceName());
-				}
-			} else {
-				logger.debug("getDesignationCandidate: No subsequent or prior candidate found; designating thisEntity, resourceName="
-						+ thisEntity.getResourceName());
-				designationCandidate = thisEntity;
-			}
-		}
-
-		return designationCandidate;
-
-	}
-
-	/**
-	 * getEntityCurrentlyDesignated()
-	 * Returns entity that is currently designated.
-	 * @param integrityAuditEntityList
-	 * @return
-	 */
-	private IntegrityAuditEntity getEntityCurrentlyDesignated(
-			List<IntegrityAuditEntity> integrityAuditEntityList) {
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("getEntityCurrentlyDesignated: Entering, integrityAuditEntityList.size="
-					+ integrityAuditEntityList.size());
-		}
-
-		IntegrityAuditEntity entityCurrentlyDesignated = null;
-
-		for (IntegrityAuditEntity integrityAuditEntity : integrityAuditEntityList) {
-
-			if (integrityAuditEntity.isDesignated()) {
-				if (logger.isDebugEnabled()) {
-					logger.debug("getEntityCurrentlyDesignated: Currently designated entity resourceName="
-							+ integrityAuditEntity.getResourceName()
-							+ ", persistenceUnit="
-							+ integrityAuditEntity.getPersistenceUnit()
-							+ ", lastUpdated="
-							+ integrityAuditEntity.getLastUpdated());
-				}
-				entityCurrentlyDesignated = integrityAuditEntity;
-			}
-
-		} // end for loop
-
-		if (logger.isDebugEnabled()) {
-			if (entityCurrentlyDesignated != null) {
-				logger.debug("getEntityCurrentlyDesignated: Exiting and returning entityCurrentlyDesignated="
-						+ entityCurrentlyDesignated.getResourceName());
-			} else {
-				logger.debug("getEntityCurrentlyDesignated: Exiting and returning entityCurrentlyDesignated="
-						+ entityCurrentlyDesignated);
-			}
-		}
-		return entityCurrentlyDesignated;
-
-	}
-
-	/**
-	 * getIntegrityAuditEnityList gets the list of IntegrityAuditEntity 
-	 * @return
-	 * @throws DbDaoTransactionException
-	 */
-	private List<IntegrityAuditEntity> getIntegrityAuditEntityList()
-			throws DbDaoTransactionException {
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("getIntegrityAuditEntityList: Entering");
-		}
-
-		/*
-		 * Get all records for this nodeType and persistenceUnit and then sort
-		 * them lexicographically by resourceName. Get index of designated
-		 * entity, if any.
-		 */
-		/*
-		 * Sorted list of entities for a particular nodeType and
-		 * persistenceUnit.
-		 */
-		List<IntegrityAuditEntity> integrityAuditEntityList = dbDAO.getIntegrityAuditEntities(
-				this.persistenceUnit, this.nodeType);
-		int listSize = integrityAuditEntityList.size();
-		if (logger.isDebugEnabled()) {
-			logger.debug("getIntegrityAuditEntityList: Got " + listSize
-					+ " IntegrityAuditEntity records");
-		}
-		Collections.sort((List<IntegrityAuditEntity>) integrityAuditEntityList,
-				comparator);
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("getIntegrityAuditEntityList: Exiting and returning integrityAuditEntityList, size="
-					+ listSize);
-		}
-		return integrityAuditEntityList;
-
-	}
-
-
-	/**
-	 * Returns the IntegrityAuditEntity for this entity.
-	 * @param integrityAuditEntityList
-	 * @return
-	 */
-	private IntegrityAuditEntity getThisEntity(
-			List<IntegrityAuditEntity> integrityAuditEntityList) {
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("getThisEntity: Entering, integrityAuditEntityList.size="
-					+ integrityAuditEntityList.size());
-		}
-
-		IntegrityAuditEntity thisEntity = null;
-
-		for (IntegrityAuditEntity integrityAuditEntity : integrityAuditEntityList) {
-
-			if (integrityAuditEntity.getResourceName().equals(this.resourceName)) {
-				if (logger.isDebugEnabled()) {
-					logger.debug("getThisEntity: For this entity, resourceName="
-							+ integrityAuditEntity.getResourceName()
-							+ ", persistenceUnit="
-							+ integrityAuditEntity.getPersistenceUnit()
-							+ ", lastUpdated="
-							+ integrityAuditEntity.getLastUpdated());
-				}
-				thisEntity = integrityAuditEntity;
-			}
-
-		} // end for loop
-
-		if (logger.isDebugEnabled()) {
-			if (thisEntity != null) {
-				logger.debug("getThisEntity: Exiting and returning thisEntity="
-						+ thisEntity.getResourceName());
-			} else {
-				logger.debug("getThisEntity: Exiting and returning thisEntity="
-						+ thisEntity);
-			}
-		}
-		return thisEntity;
-
-	}
-
-
-	/**
-	 * Returns false if the lastUpdated time for the record in question is more
-	 * than auditCompletionIntervalMillis seconds ago. During an audit, lastUpdated is updated every five
-	 * seconds or so, but when an audit finishes, the node doing the audit stops
-	 * updating lastUpdated.
-	 * @param integrityAuditEntity
-	 * @return
-	 */
-	private boolean isStale(IntegrityAuditEntity integrityAuditEntity) {
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("isStale: Entering, resourceName="
-					+ integrityAuditEntity.getResourceName()
-					+ ", persistenceUnit="
-					+ integrityAuditEntity.getPersistenceUnit()
-					+ ", lastUpdated=" + integrityAuditEntity.getLastUpdated());
-		}
-
-		boolean stale = false;
-
-		Date currentTime = new Date();
-		Date lastUpdated = integrityAuditEntity.getLastUpdated();
-
-		/*
-		 * If lastUpdated is null, we assume that the audit never ran for that
-		 * node.
-		 */
-		long lastUpdatedTime = 0;
-		if (lastUpdated != null) {
-			lastUpdatedTime = lastUpdated.getTime();
-		}
-		long timeDifference = currentTime.getTime() - lastUpdatedTime;
-		if (timeDifference > auditCompletionIntervalMillis) {
-			stale = true;
-		}
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("isStale: Exiting and returning stale=" + stale
-					+ ", timeDifference=" + timeDifference);
-		}
-
-		return stale;
-	}
-
-	private void logIntegrityAuditEntity(
-			IntegrityAuditEntity integrityAuditEntity) {
-
-		logger.debug("logIntegrityAuditEntity: id="
-				+ integrityAuditEntity.getId() + ", jdbcDriver="
-				+ integrityAuditEntity.getJdbcDriver() + ", jdbcPassword="
-				+ integrityAuditEntity.getJdbcPassword() + ", jdbcUrl="
-				+ integrityAuditEntity.getJdbcUrl() + ", jdbcUser="
-				+ integrityAuditEntity.getJdbcUser() + ", nodeType="
-				+ integrityAuditEntity.getNodeType() + ", persistenceUnit="
-				+ integrityAuditEntity.getPersistenceUnit() + ", resourceName="
-				+ integrityAuditEntity.getResourceName() + ", site="
-				+ integrityAuditEntity.getSite() + ", createdDate="
-				+ integrityAuditEntity.getCreatedDate() + ", lastUpdated="
-				+ integrityAuditEntity.getLastUpdated() + ", designated="
-				+ integrityAuditEntity.isDesignated());
-	}
-	
-	/*
-	 * If more than (auditCompletionIntervalMillis * 2) milliseconds have elapsed
-	 * since we last ran the audit, reset auditCompleted, so
-	 * 
-	 * 1) we'll eventually re-run the audit, if no other node picks up the
-	 * designation.
-	 * 
-	 * or
-	 * 
-	 * 2) We'll run the audit when the round robin comes back to us.
-	 */
-	private boolean resetAuditCompleted(boolean auditCompleted,
-			IntegrityAuditEntity thisEntity) {
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("resetAuditCompleted: auditCompleted="
-					+ auditCompleted + "; for thisEntity, resourceName="
-					+ thisEntity.getResourceName() + ", persistenceUnit="
-					+ thisEntity.getPersistenceUnit() + ", lastUpdated="
-					+ thisEntity.getLastUpdated());
-		}
-
-		long timeDifference;
-
-		Date currentTime = new Date();
-		Date lastUpdated = thisEntity.getLastUpdated();
-
-		long lastUpdatedTime = lastUpdated.getTime();
-		timeDifference = currentTime.getTime() - lastUpdatedTime;
-
-		if (timeDifference > (auditCompletionIntervalMillis * 2)) {
-			if (logger.isDebugEnabled()) {
-				logger.debug("resetAuditCompleted: Resetting auditCompleted for resourceName="
-						+ this.resourceName);
-			}
-			auditCompleted = false;
-		} else {
-			if (logger.isDebugEnabled()) {
-				logger.debug("resetAuditCompleted: For resourceName="
-						+ resourceName
-						+ ", time since last update is only "
-						+ timeDifference + "; retaining current value for auditCompleted");
-			}
-		}
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("resetAuditCompleted: Exiting and returning auditCompleted="
-					+ auditCompleted + ", timeDifference=" + timeDifference);
-		}
-		return auditCompleted;
-	}
-
-	private void runAudit(DbAudit dbAudit) throws IntegrityAuditException {
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("runAudit: Entering, dbAudit=" + dbAudit
-					+ "; notifying other resources that resourceName="
-					+ this.resourceName + " is current");
-		}
-
-		/*
-		 * changeDesignated marks all other nodes as non-designated and this
-		 * node as designated.
-		 */
-		dbDAO.changeDesignated(this.resourceName, this.persistenceUnit,
-				this.nodeType);
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("runAudit: Running audit for persistenceUnit="
-					+ this.persistenceUnit + " on resourceName="
-					+ this.resourceName);
-		}
-		if (IntegrityAudit.isUnitTesting()) {
-			dbAudit.dbAuditSimulate(this.resourceName, this.persistenceUnit, AuditThread.AUDIT_SIMULATION_ITERATIONS, AuditThread.auditThreadSleepIntervalMillis);
-		} else {
-			dbAudit.dbAudit(this.resourceName, this.persistenceUnit,
-					this.nodeType);
-		}
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("runAudit: Exiting");
-		}
-
-	}
-
-	/**
-	 * Adjusts the thread-sleep-interval to be used when an audit has
-	 * <i>not</i> been completed.  Used by JUnit tests.
-	 * @param auditThreadSleepIntervalMillis
-	 */
-	protected static void setAuditThreadSleepIntervalMillis(long auditThreadSleepIntervalMillis) {
-		AuditThread.auditThreadSleepIntervalMillis = auditThreadSleepIntervalMillis;
-	}
-
-	/**
-	 * Gets the current thread-sleep-interval to be used when an audit has
-	 * <i>not</i> been completed.  Used by JUnit tests.
-	 * @return the current sleep interval, in milli-seconds
-	 */
-	protected static long getAuditThreadSleepIntervalMillis() {
-		return auditThreadSleepIntervalMillis;
-	}
-
-	/**
-	 * Adjusts the audit-completion-interval.  Used by JUnit tests.
-	 * @param auditThreadSleepIntervalMillis
-	 */
-	protected static void setAuditCompletionIntervalMillis(long auditThreadSleepIntervalMillis) {
-		AuditThread.auditCompletionIntervalMillis = auditThreadSleepIntervalMillis;
-	}
-
-	/**
-	 * Gets the audit-completion-interval.  Used by JUnit tests.
-	 * @return the current audit-completion interval, in milli-seconds
-	 */
-	protected static long getAuditCompletionIntervalMillis() {
-		return auditCompletionIntervalMillis;
-	}
+    private static final Logger logger = FlexLogger.getLogger(AuditThread.class);
+
+    /*
+     * Number of milliseconds that must elapse for audit to be considered complete. It's public for
+     * access by JUnit test logic.
+     */
+    public static final long AUDIT_COMPLETION_INTERVAL = 30000;
+
+    /*
+     * Number of iterations for audit simulation.
+     */
+    public static final long AUDIT_SIMULATION_ITERATIONS = 3;
+
+    /*
+     * Number of milliseconds to sleep between audit simulation iterations. It's public for access
+     * by JUnit test logic.
+     */
+    public static final long AUDIT_SIMULATION_SLEEP_INTERVAL = 5000;
+
+    /*
+     * Unless audit has already been run on this entity, number of milliseconds to sleep between
+     * audit thread iterations. If audit has already been run, we sleep integrityAuditPeriodMillis.
+     * May be modified by JUnit tests.
+     */
+    private static long auditThreadSleepIntervalMillis = 5000;
+
+    /*
+     * Number of milliseconds that must elapse for audit to be considered complete. May be modified
+     * by JUnit tests.
+     */
+    private static long auditCompletionIntervalMillis = AUDIT_COMPLETION_INTERVAL;
+
+    /*
+     * DB access class.
+     */
+    private DbDAO dbDao;
+
+    /*
+     * E.g. pdp_xacml
+     */
+    private String nodeType;
+
+    /*
+     * Persistence unit for which this audit is being run.
+     */
+    private String persistenceUnit;
+
+    /*
+     * Name of this resource
+     */
+    private String resourceName;
+
+    /*
+     * E.g. DB_DRIVER, SITE_NAME, NODE_TYPE
+     */
+    private Properties properties;
+
+    /*
+     * See IntegrityAudit class for usage.
+     */
+    private long integrityAuditPeriodMillis;
+
+    /*
+     * The containing IntegrityAudit instance
+     */
+    private IntegrityAudit integrityAudit;
+
+    /**
+     * A latch is taken from this queue before starting an audit. May be {@code null}. Used by JUnit
+     * tests.
+     */
+    private BlockingQueue<CountDownLatch> auditLatchQueue;
+
+    /**
+     * Latch to be decremented when the next audit completes. May be {@code null}. Used by JUnit
+     * tests to wait for an audit to complete.
+     */
+    private CountDownLatch auditCompletionLatch = null;
+
+    /**
+     * AuditThread constructor.
+     * 
+     * @param resourceName the resource name
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @param integrityAuditPeriodSeconds the integrity audit period in seconds
+     * @param integrityAudit the integrity audit
+     * @throws IntegrityAuditException if an error occurs
+     */
+    public AuditThread(String resourceName, String persistenceUnit, Properties properties,
+            int integrityAuditPeriodSeconds, IntegrityAudit integrityAudit) throws IntegrityAuditException {
+
+        this(resourceName, persistenceUnit, properties, TimeUnit.SECONDS.toMillis(integrityAuditPeriodSeconds),
+                integrityAudit, null);
+    }
+
+    /**
+     * AuditThread constructor.
+     * 
+     * @param resourceName the resource name
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @param integrityAuditMillis the integrity audit period in milliseconds
+     * @param integrityAudit the integrity audit
+     * @param queue the queue
+     * @throws IntegrityAuditException if an error occurs
+     */
+    public AuditThread(String resourceName, String persistenceUnit, Properties properties, long integrityAuditMillis,
+            IntegrityAudit integrityAudit, BlockingQueue<CountDownLatch> queue) throws IntegrityAuditException {
+        this.resourceName = resourceName;
+        this.persistenceUnit = persistenceUnit;
+        this.properties = properties;
+        this.integrityAuditPeriodMillis = integrityAuditMillis;
+        this.integrityAudit = integrityAudit;
+        this.auditLatchQueue = queue;
+
+        /*
+         * The DbDAO Constructor registers this node in the IntegrityAuditEntity table. Each
+         * resource (node) inserts its own name, persistenceUnit, DB access properties and other
+         * pertinent properties in the table. This allows the audit on each node to compare its own
+         * version of the entities for the persistenceUnit in question with the versions from all
+         * other nodes of similar type.
+         */
+        dbDao = new DbDAO(this.resourceName, this.persistenceUnit, this.properties);
+        this.nodeType = properties.getProperty(IntegrityAuditProperties.NODE_TYPE);
+
+    }
+
+    @Override
+    public void run() {
+
+        logger.info("AuditThread.run: Entering");
+
+        try {
+            /*
+             * For JUnit testing: wait for the first latch, decrement it to indicate that the thread
+             * has started, and then wait for the next latch, before we actually start doing
+             * anything. These simply return if there is no latch queue defined.
+             */
+            getNextLatch();
+            decrementLatch();
+            getNextLatch();
+
+            /*
+             * Triggers change in designation, unless no other viable candidate.
+             */
+            boolean auditCompleted = false;
+
+            DbAudit dbAudit = new DbAudit(dbDao);
+
+            IntegrityAuditEntity entityCurrentlyDesignated;
+            IntegrityAuditEntity thisEntity;
+            integrityAudit.setThreadInitialized(true); // An exception will set it to false
+
+            while (true) {
+                try {
+                    /*
+                     * It may have been awhile since we last cycled through this loop, so refresh
+                     * the list of IntegrityAuditEntities.
+                     */
+                    List<IntegrityAuditEntity> integrityAuditEntityList = getIntegrityAuditEntityList();
+
+                    /*
+                     * We could've set entityCurrentlyDesignated as a side effect of
+                     * getIntegrityAuditEntityList(), but then we would've had to make
+                     * entityCurrentlyDesignated a class level attribute. Using this approach, we
+                     * can keep it local to the run() method.
+                     */
+                    entityCurrentlyDesignated = getEntityCurrentlyDesignated(integrityAuditEntityList);
+
+                    /*
+                     * Need to refresh thisEntity each time through loop, because we need a fresh
+                     * version of lastUpdated.
+                     */
+                    thisEntity = getThisEntity(integrityAuditEntityList);
+
+                    /*
+                     * If we haven't done the audit yet, note that we're current and see if we're
+                     * designated.
+                     */
+                    if (!auditCompleted) {
+                        dbDao.setLastUpdated();
+
+                        /*
+                         * If no current designation or currently designated node is stale, see if
+                         * we're the next node to be designated.
+                         */
+                        if (entityCurrentlyDesignated == null || isStale(entityCurrentlyDesignated)) {
+                            IntegrityAuditEntity designationCandidate =
+                                    getDesignationCandidate(integrityAuditEntityList);
+
+                            /*
+                             * If we're the next node to be designated, run the audit.
+                             */
+                            if (designationCandidate.getResourceName().equals(this.resourceName)) {
+                                runAudit(dbAudit);
+                                auditCompleted = true;
+                            } else {
+                                if (logger.isDebugEnabled()) {
+                                    logger.debug("AuditThread.run: designationCandidate, "
+                                            + designationCandidate.getResourceName() + ", not this entity, "
+                                            + thisEntity.getResourceName());
+                                }
+                            }
+
+                            /*
+                             * Application may have been stopped and restarted, in which case we
+                             * might be designated but auditCompleted will have been reset to false,
+                             * so account for this.
+                             */
+                        } else if (thisEntity.getResourceName().equals(entityCurrentlyDesignated.getResourceName())) {
+
+                            if (logger.isDebugEnabled()) {
+                                logger.debug("AuditThread.run: Re-running audit for " + thisEntity.getResourceName());
+                            }
+                            runAudit(dbAudit);
+                            auditCompleted = true;
+
+                        } else {
+                            if (logger.isDebugEnabled()) {
+                                logger.debug("AuditThread.run: Currently designated node, "
+                                        + entityCurrentlyDesignated.getResourceName()
+                                        + ", not yet stale and not this node");
+                            }
+                        }
+
+
+                        /*
+                         * Audit already completed on this node, so allow the node to go stale until
+                         * twice the AUDIT_COMPLETION_PERIOD has elapsed. This should give plenty of
+                         * time for another node (if another node is out there) to pick up
+                         * designation.
+                         */
+                    } else {
+
+                        auditCompleted = resetAuditCompleted(auditCompleted, thisEntity);
+
+                    }
+
+                    /*
+                     * If we've just run audit, sleep per the integrity_audit_period_seconds
+                     * property, otherwise just sleep the normal interval.
+                     */
+                    if (auditCompleted) {
+                        // indicate that an audit has completed
+                        decrementLatch();
+
+                        // don't start the next audit cycle until a latch has been provided
+                        getNextLatch();
+
+                        if (logger.isDebugEnabled()) {
+                            logger.debug("AuditThread.run: Audit completed; resourceName=" + this.resourceName
+                                    + " sleeping " + integrityAuditPeriodMillis + "ms");
+                        }
+                        Thread.sleep(integrityAuditPeriodMillis);
+                        if (logger.isDebugEnabled()) {
+                            logger.debug("AuditThread.run: resourceName=" + this.resourceName + " awaking from "
+                                    + integrityAuditPeriodMillis + "ms sleep");
+                        }
+
+                    } else {
+
+                        if (logger.isDebugEnabled()) {
+                            logger.debug("AuditThread.run: resourceName=" + this.resourceName + ": Sleeping "
+                                    + AuditThread.auditThreadSleepIntervalMillis + "ms");
+                        }
+                        Thread.sleep(AuditThread.auditThreadSleepIntervalMillis);
+                        if (logger.isDebugEnabled()) {
+                            logger.debug("AuditThread.run: resourceName=" + this.resourceName + ": Awaking from "
+                                    + AuditThread.auditThreadSleepIntervalMillis + "ms sleep");
+                        }
+
+                    }
+
+                } catch (Exception e) {
+                    if (isInterruptedException(e)) {
+                        String msg = "AuditThread.run loop - Exception thrown: " + e.getMessage() + "; Stopping.";
+                        logger.error(MessageCodes.EXCEPTION_ERROR, e, msg);
+                        break;
+                    }
+
+                    String msg = "AuditThread.run loop - Exception thrown: " + e.getMessage()
+                            + "; Will try audit again in " + (integrityAuditPeriodMillis / 1000) + " seconds";
+                    logger.error(MessageCodes.EXCEPTION_ERROR, e, msg);
+                    // Sleep and try again later
+                    Thread.sleep(integrityAuditPeriodMillis);
+                }
+
+            }
+
+        } catch (Exception e) {
+            String msg = "AuditThread.run: Could not start audit loop. Exception thrown; message=" + e.getMessage();
+            logger.error(MessageCodes.EXCEPTION_ERROR, e, msg);
+            integrityAudit.setThreadInitialized(false);
+        }
+
+        dbDao.destroy();
+
+        logger.info("AuditThread.run: Exiting");
+    }
+
+    /**
+     * Gets the next audit-completion latch from the queue. Blocks, if the queue is empty.
+     * 
+     * @throws InterruptedException if interrupted while waiting
+     */
+    private void getNextLatch() throws InterruptedException {
+        BlockingQueue<CountDownLatch> queue = this.auditLatchQueue;
+        if (queue != null) {
+            this.auditCompletionLatch = queue.take();
+        }
+    }
+
+    /**
+     * Decrements the current audit-completion latch, if any.
+     */
+    private void decrementLatch() {
+        CountDownLatch latch = this.auditCompletionLatch;
+        if (latch != null) {
+            this.auditCompletionLatch = null;
+            latch.countDown();
+        }
+    }
+
+    /**
+     * Determines if an exception is an InterruptedException or was caused by an
+     * InterruptedException.
+     * 
+     * @param ex exception to be examined
+     * @return {@code true} if it's an InterruptedException, {@code false} otherwise
+     */
+    private boolean isInterruptedException(Throwable ex) {
+        while (ex != null) {
+            if (ex instanceof InterruptedException) {
+                return true;
+            }
+
+            ex = ex.getCause();
+        }
+
+        return false;
+    }
+
+    /*
+     * Used to create a list that is sorted lexicographically by resourceName.
+     */
+    Comparator<IntegrityAuditEntity> comparator = new Comparator<IntegrityAuditEntity>() {
+        @Override
+        public int compare(final IntegrityAuditEntity r1, final IntegrityAuditEntity r2) {
+            return r1.getResourceName().compareTo(r2.getResourceName());
+        }
+    };
+
+    /**
+     * getDesignationCandidate() Using round robin algorithm, gets next candidate to be designated.
+     * Assumes list is sorted lexicographically by resourceName.
+     */
+    private IntegrityAuditEntity getDesignationCandidate(List<IntegrityAuditEntity> integrityAuditEntityList) {
+
+        // Note: assumes integrityAuditEntityList is already lexicographically sorted by
+        // resourceName
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("getDesignationCandidate: Entering, integrityAuditEntityList.size()="
+                    + integrityAuditEntityList.size());
+        }
+
+        IntegrityAuditEntity designationCandidate;
+        IntegrityAuditEntity thisEntity = null;
+
+        int designatedEntityIndex = -1;
+        int entityIndex = 0;
+        int priorCandidateIndex = -1;
+        int subsequentCandidateIndex = -1;
+
+        for (IntegrityAuditEntity integrityAuditEntity : integrityAuditEntityList) {
+
+            if (logger.isDebugEnabled()) {
+                logIntegrityAuditEntity(integrityAuditEntity);
+            }
+
+            if (integrityAuditEntity.getResourceName().equals(this.resourceName)) {
+                if (logger.isDebugEnabled()) {
+                    logger.debug("getDesignationCandidate: thisEntity=" + integrityAuditEntity.getResourceName());
+                }
+                thisEntity = integrityAuditEntity;
+            }
+
+            if (integrityAuditEntity.isDesignated()) {
+                if (logger.isDebugEnabled()) {
+                    logger.debug("getDesignationCandidate: Currently designated entity resourceName="
+                            + integrityAuditEntity.getResourceName() + ", persistenceUnit="
+                            + integrityAuditEntity.getPersistenceUnit() + ", lastUpdated="
+                            + integrityAuditEntity.getLastUpdated() + ", entityIndex=" + entityIndex);
+                }
+                designatedEntityIndex = entityIndex;
+
+                /*
+                 * Entity not currently designated
+                 */
+            } else {
+
+                /*
+                 * See if non-designated entity is stale.
+                 */
+                if (isStale(integrityAuditEntity)) {
+
+                    if (logger.isDebugEnabled()) {
+                        logger.debug("getDesignationCandidate: Entity is stale; resourceName="
+                                + integrityAuditEntity.getResourceName() + ", persistenceUnit="
+                                + integrityAuditEntity.getPersistenceUnit() + ", lastUpdated="
+                                + integrityAuditEntity.getLastUpdated() + ", entityIndex=" + entityIndex);
+                    }
+
+                    /*
+                     * Entity is current.
+                     */
+                } else {
+
+                    if (designatedEntityIndex == -1) {
+
+                        if (priorCandidateIndex == -1) {
+                            if (logger.isDebugEnabled()) {
+                                logger.debug("getDesignationCandidate: Prior candidate found, resourceName="
+                                        + integrityAuditEntity.getResourceName() + ", persistenceUnit="
+                                        + integrityAuditEntity.getPersistenceUnit() + ", lastUpdated="
+                                        + integrityAuditEntity.getLastUpdated() + ", entityIndex=" + entityIndex);
+                            }
+                            priorCandidateIndex = entityIndex;
+                        } else {
+                            if (logger.isDebugEnabled()) {
+                                logger.debug(
+                                        "getDesignationCandidate: Prior entity current but prior candidate already "
+                                                + "found; resourceName=" + integrityAuditEntity.getResourceName()
+                                                + ", persistenceUnit=" + integrityAuditEntity.getPersistenceUnit()
+                                                + ", lastUpdated=" + integrityAuditEntity.getLastUpdated()
+                                                + ", entityIndex=" + entityIndex);
+                            }
+                        }
+                    } else {
+                        if (subsequentCandidateIndex == -1) {
+                            if (logger.isDebugEnabled()) {
+                                logger.debug("getDesignationCandidate: Subsequent candidate found, resourceName="
+                                        + integrityAuditEntity.getResourceName() + ", persistenceUnit="
+                                        + integrityAuditEntity.getPersistenceUnit() + ", lastUpdated="
+                                        + integrityAuditEntity.getLastUpdated() + ", entityIndex=" + entityIndex);
+                            }
+                            subsequentCandidateIndex = entityIndex;
+                        } else {
+                            if (logger.isDebugEnabled()) {
+                                logger.debug(
+                                        "getDesignationCandidate: Subsequent entity current but subsequent candidate "
+                                                + "already found; resourceName="
+                                                + integrityAuditEntity.getResourceName() + ", persistenceUnit="
+                                                + integrityAuditEntity.getPersistenceUnit() + ", lastUpdated="
+                                                + integrityAuditEntity.getLastUpdated() + ", entityIndex="
+                                                + entityIndex);
+                            }
+                        }
+                    }
+
+                } // end entity is current
+
+            } // end entity not currently designated
+
+            entityIndex++;
+
+        } // end for loop
+
+        /*
+         * Per round robin algorithm, if a current entity is found that is lexicographically after
+         * the currently designated entity, this entity becomes the designation candidate. If no
+         * current entity is found that is lexicographically after currently designated entity, we
+         * cycle back to beginning of list and pick the first current entity as the designation
+         * candidate.
+         */
+        if (subsequentCandidateIndex != -1) {
+            designationCandidate = integrityAuditEntityList.get(subsequentCandidateIndex);
+            if (logger.isDebugEnabled()) {
+                logger.debug("getDesignationCandidate: Exiting and returning subsequent designationCandidate="
+                        + designationCandidate.getResourceName());
+            }
+        } else {
+            if (priorCandidateIndex != -1) {
+                designationCandidate = integrityAuditEntityList.get(priorCandidateIndex);
+                if (logger.isDebugEnabled()) {
+                    logger.debug("getDesignationCandidate: Exiting and returning prior designationCandidate="
+                            + designationCandidate.getResourceName());
+                }
+            } else {
+                logger.debug("getDesignationCandidate: No subsequent or prior candidate found; designating thisEntity, "
+                        + "resourceName=" + thisEntity.getResourceName());
+                designationCandidate = thisEntity;
+            }
+        }
+
+        return designationCandidate;
+
+    }
+
+    /**
+     * getEntityCurrentlyDesignated() Returns entity that is currently designated.
+     * 
+     * @param integrityAuditEntityList the integrity audit entity list
+     * @return the currently designated integrity audit entity
+     */
+    private IntegrityAuditEntity getEntityCurrentlyDesignated(List<IntegrityAuditEntity> integrityAuditEntityList) {
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("getEntityCurrentlyDesignated: Entering, integrityAuditEntityList.size="
+                    + integrityAuditEntityList.size());
+        }
+
+        IntegrityAuditEntity entityCurrentlyDesignated = null;
+
+        for (IntegrityAuditEntity integrityAuditEntity : integrityAuditEntityList) {
+
+            if (integrityAuditEntity.isDesignated()) {
+                if (logger.isDebugEnabled()) {
+                    logger.debug("getEntityCurrentlyDesignated: Currently designated entity resourceName="
+                            + integrityAuditEntity.getResourceName() + ", persistenceUnit="
+                            + integrityAuditEntity.getPersistenceUnit() + ", lastUpdated="
+                            + integrityAuditEntity.getLastUpdated());
+                }
+                entityCurrentlyDesignated = integrityAuditEntity;
+            }
+
+        } // end for loop
+
+        if (logger.isDebugEnabled()) {
+            if (entityCurrentlyDesignated != null) {
+                logger.debug("getEntityCurrentlyDesignated: Exiting and returning entityCurrentlyDesignated="
+                        + entityCurrentlyDesignated.getResourceName());
+            } else {
+                logger.debug("getEntityCurrentlyDesignated: Exiting and returning entityCurrentlyDesignated="
+                        + entityCurrentlyDesignated);
+            }
+        }
+        return entityCurrentlyDesignated;
+
+    }
+
+    /**
+     * getIntegrityAuditEnityList gets the list of IntegrityAuditEntity.
+     * 
+     * @return the list of IntegrityAuditEntity
+     * @throws DbDaoTransactionException if an error occurs getting the list of IntegrityAuditEntity
+     */
+    private List<IntegrityAuditEntity> getIntegrityAuditEntityList() throws DbDaoTransactionException {
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("getIntegrityAuditEntityList: Entering");
+        }
+
+        /*
+         * Get all records for this nodeType and persistenceUnit and then sort them
+         * lexicographically by resourceName. Get index of designated entity, if any.
+         */
+        /*
+         * Sorted list of entities for a particular nodeType and persistenceUnit.
+         */
+        List<IntegrityAuditEntity> integrityAuditEntityList =
+                dbDao.getIntegrityAuditEntities(this.persistenceUnit, this.nodeType);
+        int listSize = integrityAuditEntityList.size();
+        if (logger.isDebugEnabled()) {
+            logger.debug("getIntegrityAuditEntityList: Got " + listSize + " IntegrityAuditEntity records");
+        }
+        Collections.sort(integrityAuditEntityList, comparator);
+
+        if (logger.isDebugEnabled()) {
+            logger.debug(
+                    "getIntegrityAuditEntityList: Exiting and returning integrityAuditEntityList, size=" + listSize);
+        }
+        return integrityAuditEntityList;
+
+    }
+
+
+    /**
+     * Returns the IntegrityAuditEntity for this entity.
+     * 
+     * @param integrityAuditEntityList the list of IntegrityAuditEntity
+     * @return the IntegrityAuditEntity for this entity
+     */
+    private IntegrityAuditEntity getThisEntity(List<IntegrityAuditEntity> integrityAuditEntityList) {
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("getThisEntity: Entering, integrityAuditEntityList.size=" + integrityAuditEntityList.size());
+        }
+
+        IntegrityAuditEntity thisEntity = null;
+
+        for (IntegrityAuditEntity integrityAuditEntity : integrityAuditEntityList) {
+
+            if (integrityAuditEntity.getResourceName().equals(this.resourceName)) {
+                if (logger.isDebugEnabled()) {
+                    logger.debug(
+                            "getThisEntity: For this entity, resourceName=" + integrityAuditEntity.getResourceName()
+                                    + ", persistenceUnit=" + integrityAuditEntity.getPersistenceUnit()
+                                    + ", lastUpdated=" + integrityAuditEntity.getLastUpdated());
+                }
+                thisEntity = integrityAuditEntity;
+            }
+
+        } // end for loop
+
+        if (logger.isDebugEnabled()) {
+            if (thisEntity != null) {
+                logger.debug("getThisEntity: Exiting and returning thisEntity=" + thisEntity.getResourceName());
+            } else {
+                logger.debug("getThisEntity: Exiting and returning thisEntity=" + thisEntity);
+            }
+        }
+        return thisEntity;
+
+    }
+
+
+    /**
+     * Returns false if the lastUpdated time for the record in question is more than
+     * auditCompletionIntervalMillis seconds ago. During an audit, lastUpdated is updated every five
+     * seconds or so, but when an audit finishes, the node doing the audit stops updating
+     * lastUpdated.
+     * 
+     * @param integrityAuditEntity the integrityAuditEntity
+     * @return false if the lastUpdated time for the record in question is more than
+     *         auditCompletionIntervalMillis seconds ago
+     */
+    private boolean isStale(IntegrityAuditEntity integrityAuditEntity) {
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("isStale: Entering, resourceName=" + integrityAuditEntity.getResourceName()
+                    + ", persistenceUnit=" + integrityAuditEntity.getPersistenceUnit() + ", lastUpdated="
+                    + integrityAuditEntity.getLastUpdated());
+        }
+
+        boolean stale = false;
+
+        Date currentTime = new Date();
+        Date lastUpdated = integrityAuditEntity.getLastUpdated();
+
+        /*
+         * If lastUpdated is null, we assume that the audit never ran for that node.
+         */
+        long lastUpdatedTime = 0;
+        if (lastUpdated != null) {
+            lastUpdatedTime = lastUpdated.getTime();
+        }
+        long timeDifference = currentTime.getTime() - lastUpdatedTime;
+        if (timeDifference > auditCompletionIntervalMillis) {
+            stale = true;
+        }
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("isStale: Exiting and returning stale=" + stale + ", timeDifference=" + timeDifference);
+        }
+
+        return stale;
+    }
+
+    private void logIntegrityAuditEntity(IntegrityAuditEntity integrityAuditEntity) {
+
+        logger.debug("logIntegrityAuditEntity: id=" + integrityAuditEntity.getId() + ", jdbcDriver="
+                + integrityAuditEntity.getJdbcDriver() + ", jdbcPassword=" + integrityAuditEntity.getJdbcPassword()
+                + ", jdbcUrl=" + integrityAuditEntity.getJdbcUrl() + ", jdbcUser=" + integrityAuditEntity.getJdbcUser()
+                + ", nodeType=" + integrityAuditEntity.getNodeType() + ", persistenceUnit="
+                + integrityAuditEntity.getPersistenceUnit() + ", resourceName=" + integrityAuditEntity.getResourceName()
+                + ", site=" + integrityAuditEntity.getSite() + ", createdDate=" + integrityAuditEntity.getCreatedDate()
+                + ", lastUpdated=" + integrityAuditEntity.getLastUpdated() + ", designated="
+                + integrityAuditEntity.isDesignated());
+    }
+
+    /*
+     * If more than (auditCompletionIntervalMillis * 2) milliseconds have elapsed since we last ran
+     * the audit, reset auditCompleted, so
+     * 
+     * 1) we'll eventually re-run the audit, if no other node picks up the designation.
+     * 
+     * or
+     * 
+     * 2) We'll run the audit when the round robin comes back to us.
+     */
+    private boolean resetAuditCompleted(boolean auditCompleted, IntegrityAuditEntity thisEntity) {
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("resetAuditCompleted: auditCompleted=" + auditCompleted + "; for thisEntity, resourceName="
+                    + thisEntity.getResourceName() + ", persistenceUnit=" + thisEntity.getPersistenceUnit()
+                    + ", lastUpdated=" + thisEntity.getLastUpdated());
+        }
+
+        long timeDifference;
+
+        Date currentTime = new Date();
+        Date lastUpdated = thisEntity.getLastUpdated();
+
+        long lastUpdatedTime = lastUpdated.getTime();
+        timeDifference = currentTime.getTime() - lastUpdatedTime;
+
+        if (timeDifference > (auditCompletionIntervalMillis * 2)) {
+            if (logger.isDebugEnabled()) {
+                logger.debug("resetAuditCompleted: Resetting auditCompleted for resourceName=" + this.resourceName);
+            }
+            auditCompleted = false;
+        } else {
+            if (logger.isDebugEnabled()) {
+                logger.debug(
+                        "resetAuditCompleted: For resourceName=" + resourceName + ", time since last update is only "
+                                + timeDifference + "; retaining current value for auditCompleted");
+            }
+        }
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("resetAuditCompleted: Exiting and returning auditCompleted=" + auditCompleted
+                    + ", timeDifference=" + timeDifference);
+        }
+        return auditCompleted;
+    }
+
+    private void runAudit(DbAudit dbAudit) throws IntegrityAuditException {
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("runAudit: Entering, dbAudit=" + dbAudit + "; notifying other resources that resourceName="
+                    + this.resourceName + " is current");
+        }
+
+        /*
+         * changeDesignated marks all other nodes as non-designated and this node as designated.
+         */
+        dbDao.changeDesignated(this.resourceName, this.persistenceUnit, this.nodeType);
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("runAudit: Running audit for persistenceUnit=" + this.persistenceUnit + " on resourceName="
+                    + this.resourceName);
+        }
+        if (IntegrityAudit.isUnitTesting()) {
+            dbAudit.dbAuditSimulate(this.resourceName, this.persistenceUnit, AuditThread.AUDIT_SIMULATION_ITERATIONS,
+                    AuditThread.auditThreadSleepIntervalMillis);
+        } else {
+            dbAudit.dbAudit(this.resourceName, this.persistenceUnit, this.nodeType);
+        }
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("runAudit: Exiting");
+        }
+
+    }
+
+    /**
+     * Adjusts the thread-sleep-interval to be used when an audit has <i>not</i> been completed.
+     * Used by JUnit tests.
+     * 
+     * @param auditThreadSleepIntervalMillis the interval to use in milliseconds
+     */
+    protected static void setAuditThreadSleepIntervalMillis(long auditThreadSleepIntervalMillis) {
+        AuditThread.auditThreadSleepIntervalMillis = auditThreadSleepIntervalMillis;
+    }
+
+    /**
+     * Gets the current thread-sleep-interval to be used when an audit has <i>not</i> been
+     * completed. Used by JUnit tests.
+     * 
+     * @return the current sleep interval, in milli-seconds
+     */
+    protected static long getAuditThreadSleepIntervalMillis() {
+        return auditThreadSleepIntervalMillis;
+    }
+
+    /**
+     * Adjusts the audit-completion-interval. Used by JUnit tests.
+     * 
+     * @param auditThreadSleepIntervalMillis the interval to use in milliseconds
+     */
+    protected static void setAuditCompletionIntervalMillis(long auditThreadSleepIntervalMillis) {
+        AuditThread.auditCompletionIntervalMillis = auditThreadSleepIntervalMillis;
+    }
+
+    /**
+     * Gets the audit-completion-interval. Used by JUnit tests.
+     * 
+     * @return the current audit-completion interval, in milli-seconds
+     */
+    protected static long getAuditCompletionIntervalMillis() {
+        return auditCompletionIntervalMillis;
+    }
 
 }
diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/DbAudit.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/DbAudit.java
index 6fb619e4..4c4104f6 100644
--- a/integrity-audit/src/main/java/org/onap/policy/common/ia/DbAudit.java
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/DbAudit.java
@@ -36,492 +36,501 @@ import org.apache.commons.lang3.SerializationUtils;
 import org.apache.commons.lang3.builder.RecursiveToStringStyle;
 import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
 import org.apache.commons.lang3.builder.ToStringStyle;
-
-
-
-
-
 import org.onap.policy.common.ia.jpa.IntegrityAuditEntity;
 import org.onap.policy.common.logging.eelf.MessageCodes;
-import org.onap.policy.common.logging.flexlogger.FlexLogger; 
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
 import org.onap.policy.common.logging.flexlogger.Logger;
 
 /**
  * class DbAudit does actual auditing of DB tables.
  */
 public class DbAudit {
-	
-	private static final Logger logger = FlexLogger.getLogger(DbAudit.class);
-	
-	private static long dbAuditUpdateMillis = 5000l;
-	private static long dbAuditSleepMillis = 2000l;
-	
-	DbDAO dbDAO = null;
-	
-	public DbAudit(DbDAO dbDAO) {
-		
-		if (logger.isDebugEnabled()) {
-			logger.debug("Constructor: Entering");
-		}
-
-		this.dbDAO = dbDAO;
-		
-		if (logger.isDebugEnabled()) {
-			logger.debug("Constructor: Exiting");
-		}
-
-	}
-	
-	/**
-	 * dbAudit actually does the audit
-	 * @param resourceName
-	 * @param persistenceUnit
-	 * @param nodeType
-	 * @throws Exception
-	 */
-	public void dbAudit(String resourceName, String persistenceUnit, String nodeType) throws IntegrityAuditException {
-		
-		if (logger.isDebugEnabled()) {
-			logger.debug("dbAudit: Entering, resourceName=" + resourceName
-					+ ", persistenceUnit=" + persistenceUnit + ", nodeType="
-					+ nodeType);
-		}
-	
-		// Get all IntegrityAudit entries so we can get the DB access info
-		List<IntegrityAuditEntity> iaeList = dbDAO.getIntegrityAuditEntities(persistenceUnit, nodeType);
-		if(iaeList == null || iaeList.isEmpty()){
-			
-			String msg = "DbAudit: for node " + resourceName + " Found no IntegrityAuditEntity entries";
-			logger.error(MessageCodes.ERROR_AUDIT,  msg);
-			throw new DbAuditException(msg);
-			
-		}else if(iaeList.size() == 1){
-			
-			Long iaeId = null;
-			String iaeRN = null;
-			String iaeNT = null;
-			String iaeS = null;
-			for (IntegrityAuditEntity iae : iaeList){
-				iaeId = iae.getId();
-				iaeRN = iae.getResourceName();
-				iaeNT = iae.getNodeType();
-				iaeS = iae.getSite();
-			}
-			String msg = "DbAudit: Found only one IntegrityAuditEntity entry:"
-					+ " ID = " + iaeId
-					+ " ResourceName = " + iaeRN
-					+ " NodeType = " + iaeNT
-					+ " Site = " + iaeS;
-			logger.warn(msg);
-			return;
-		}
-		
-		// Obtain all persistence class names for the PU we are auditing
-		Set<String> classNameSet = dbDAO.getPersistenceClassNames();
-		if(classNameSet == null || classNameSet.isEmpty()){
-			
-			String msg = "DbAudit: For node " + resourceName + " Found no persistence class names";
-			logger.error(MessageCodes.ERROR_AUDIT,  msg);
-			throw new DbAuditException(msg);
-			
-		}
-		
-		/*
-		 * Retrieve myIae.  We are going to compare the local class entries against
-		 * all other DB nodes. Since the audit is run in a round-robin, every instance
-		 * will be compared against every other instance.
-		 */
-		IntegrityAuditEntity myIae = dbDAO.getMyIntegrityAuditEntity();
-
-		if(myIae == null){
-			
-			String msg = "DbAudit: Found no IntegrityAuditEntity entry for resourceName: " + resourceName
-					+ " persistenceUnit: " + persistenceUnit;
-			logger.error(MessageCodes.ERROR_AUDIT,  msg);
-			throw new DbAuditException(msg);
-			
-		}
-		/*
-		 * This is the map of mismatched entries indexed by className. For
-		 * each class name there is a list of mismatched entries
-		 */
-		Map<String,Set<Object>> misMatchedMap = new HashMap<>();
-		
-		// We need to keep track of how long the audit is taking
-		long startTime = System.currentTimeMillis();
-		
-		// Retrieve all instances of the class for each node			
-		if (logger.isDebugEnabled()) {
-			logger.debug("dbAudit: Traversing classNameSet, size=" + classNameSet.size());
-		}
-		for(String clazzName: classNameSet){
-			
-			if (logger.isDebugEnabled()) {
-				logger.debug("dbAudit: clazzName=" + clazzName);
-			}
-	
-			// all instances of the class for myIae
-			Map<Object,Object> myEntries = dbDAO.getAllMyEntries(clazzName);
-			//get a map of the objects indexed by id. Does not necessarily have any entries
-			
-			if (logger.isDebugEnabled()) {
-				logger.debug("dbAudit: Traversing iaeList, size=" + iaeList.size());
-			}
-			for (IntegrityAuditEntity iae : iaeList){
-				if(iae.getId() == myIae.getId()){
-					if (logger.isDebugEnabled()) {
-						logger.debug("dbAudit: My Id=" + iae.getId()
-								+ ", resourceName=" + iae.getResourceName());
-					}
-					continue; //no need to compare with self
-				} else {
-					if (logger.isDebugEnabled()) {
-						logger.debug("dbAudit: Id=" + iae.getId()
-								+ ", resourceName=" + iae.getResourceName());
-					}
-				}
-				// Create properties for the other db node
-				Properties theirProperties = new Properties();
-				theirProperties.put(IntegrityAuditProperties.DB_DRIVER, iae.getJdbcDriver());
-				theirProperties.put(IntegrityAuditProperties.DB_URL, iae.getJdbcUrl());
-				theirProperties.put(IntegrityAuditProperties.DB_USER, iae.getJdbcUser());
-				theirProperties.put(IntegrityAuditProperties.DB_PWD, iae.getJdbcPassword());
-				theirProperties.put(IntegrityAuditProperties.SITE_NAME, iae.getSite());
-				theirProperties.put(IntegrityAuditProperties.NODE_TYPE, iae.getNodeType());
-				
-				//get a map of the instances for their iae indexed by id
-				Map<Object,Object> theirEntries = dbDAO.getAllEntries(persistenceUnit, theirProperties, clazzName);
-				if (logger.isDebugEnabled()) {
-					logger.debug("dbAudit: For persistenceUnit="
-							+ persistenceUnit + ", clazzName=" + clazzName
-							+ ", theirEntries.size()="
-							+ theirEntries.size());
-				}
-				
-				/*
-				 * Compare myEntries with theirEntries and get back a set of mismatched IDs.
-				 * Collect the IDs for the class where a mismatch occurred.  We will check
-				 * them again for all nodes later.
-				 */
-				Set<Object> misMatchedKeySet = compareEntries(myEntries, theirEntries);
-				if(!misMatchedKeySet.isEmpty()){
-					Set<Object> misMatchedEntry = misMatchedMap.get(clazzName);
-					if(misMatchedEntry == null){
-						misMatchedMap.put(clazzName, misMatchedKeySet);
-					}else{
-						misMatchedEntry.addAll(misMatchedKeySet);
-						misMatchedMap.put(clazzName, misMatchedEntry);
-					}
-				}
-			} //end for (IntegrityAuditEntity iae : iaeList)
-			//Time check
-			if((System.currentTimeMillis() - startTime) >= dbAuditUpdateMillis){
-				//update the timestamp
-				dbDAO.setLastUpdated();
-				//reset the startTime
-				startTime=System.currentTimeMillis();
-			}else{
-				//sleep a couple seconds to break up the activity
-				if (logger.isDebugEnabled()) {
-					logger.debug("dbAudit: Sleeping " + dbAuditSleepMillis + "ms");
-				}
-				sleep();
-				if (logger.isDebugEnabled()) {
-					logger.debug("dbAudit: Waking from sleep");
-				}
-			}
-		}//end: for(String clazzName: classNameList)
-		
-		//check if misMatchedMap is empty
-		if(misMatchedMap.isEmpty()){
-			
-			if (logger.isDebugEnabled()) {
-				logger.debug("dbAudit: Exiting, misMatchedMap is empty");
-			}
-			//we are done
-			return;
-		} else {
-			if (logger.isDebugEnabled()) {
-				logger.debug("dbAudit: Doing another comparison; misMatchedMap.size()=" + misMatchedMap.size());
-			}
-		}
-		
-		// If misMatchedMap is not empty, retrieve the entries in each misMatched list and compare again
-		classNameSet = new HashSet<>(misMatchedMap.keySet());
-		// We need to keep track of how long the audit is taking
-		startTime = System.currentTimeMillis();
-		
-		// Retrieve all instances of the class for each node			
-		if (logger.isDebugEnabled()) {
-			logger.debug("dbAudit: Second comparison; traversing classNameSet, size=" + classNameSet.size());
-		}
-		
-		int errorCount = 0;
-		
-		for(String clazzName: classNameSet){
-			
-			if (logger.isDebugEnabled()) {
-				logger.debug("dbAudit: Second comparison; clazzName=" + clazzName);
-			}
-	
-			// all instances of the class for myIae
-			Set<Object> keySet = misMatchedMap.get(clazzName);
-			Map<Object,Object> myEntries = dbDAO.getAllMyEntries(clazzName, keySet);
-			//get a map of the objects indexed by id
-			
-			if (logger.isDebugEnabled()) {
-				logger.debug("dbAudit: Second comparison; traversing iaeList, size=" + iaeList.size());
-			}
-			for (IntegrityAuditEntity iae : iaeList){
-				if(iae.getId() == myIae.getId()){
-					if (logger.isDebugEnabled()) {
-						logger.debug("dbAudit: Second comparison; My Id=" + iae.getId()
-								+ ", resourceName=" + iae.getResourceName());
-					}
-					continue; //no need to compare with self
-				} else {
-					if (logger.isDebugEnabled()) {
-						logger.debug("dbAudit: Second comparison; Id=" + iae.getId()
-								+ ", resourceName=" + iae.getResourceName());
-					}
-				}
-				// Create properties for the other db node
-				Properties theirProperties = new Properties();
-				theirProperties.put(IntegrityAuditProperties.DB_DRIVER, iae.getJdbcDriver());
-				theirProperties.put(IntegrityAuditProperties.DB_URL, iae.getJdbcUrl());
-				theirProperties.put(IntegrityAuditProperties.DB_USER, iae.getJdbcUser());
-				theirProperties.put(IntegrityAuditProperties.DB_PWD, iae.getJdbcPassword());
-				theirProperties.put(IntegrityAuditProperties.SITE_NAME, iae.getSite());
-				theirProperties.put(IntegrityAuditProperties.NODE_TYPE, iae.getNodeType());
-				
-				//get a map of the instances for their iae indexed by id
-				Map<Object,Object> theirEntries = dbDAO.getAllEntries(persistenceUnit, theirProperties, clazzName, keySet);
-				
-				/*
-				 * Compare myEntries with theirEntries and get back a set of mismatched IDs.
-				 * Collect the IDs for the class where a mismatch occurred.  We will now
-				 * write an error log for each.
-				 */
-				Set<Object> misMatchedKeySet = compareEntries(myEntries, theirEntries);
-				if(!misMatchedKeySet.isEmpty()){
-					String keysString = "";
-					for(Object key: misMatchedKeySet){
-						keysString = keysString.concat(key.toString() + ", ");
-						errorCount ++;
-					}
-					writeAuditSummaryLog(clazzName, resourceName, iae.getResourceName(), keysString);
-					if(logger.isDebugEnabled()){
-						for(Object key : misMatchedKeySet){
-							writeAuditDebugLog(clazzName, resourceName, iae.getResourceName(), myEntries.get(key), theirEntries.get(key));
-						}
-					}
-				}
-			}
-			//Time check
-			if((System.currentTimeMillis() - startTime) >= dbAuditUpdateMillis){
-				//update the timestamp
-				dbDAO.setLastUpdated();
-				//reset the startTime
-				startTime=System.currentTimeMillis();
-			}else{
-				//sleep a couple seconds to break up the activity
-				if (logger.isDebugEnabled()) {
-					logger.debug("dbAudit: Second comparison; sleeping " + dbAuditSleepMillis + "ms");
-				}
-				sleep();
-				if (logger.isDebugEnabled()) {
-					logger.debug("dbAudit: Second comparison; waking from sleep");
-				}
-			}
-		}//end: for(String clazzName: classNameList)
-		
-		if(errorCount != 0){
-			String msg = " DB Audit: " + errorCount + " errors found. A large number of errors may indicate DB replication has stopped";
-			logger.error(MessageCodes.ERROR_AUDIT,  msg);
-		}
-		
-		if (logger.isDebugEnabled()) {
-			logger.debug("dbAudit: Exiting");
-		}
-	
-		return; //all done
-	}
-
-	/**
-	 * Sleeps a bit.
-	 * @throws IntegrityAuditException
-	 */
-	private void sleep() throws IntegrityAuditException {
-		try {
-			Thread.sleep(dbAuditSleepMillis);
-			
-		} catch (InterruptedException e) {
-			Thread.currentThread().interrupt();
-			throw new IntegrityAuditException(e);
-		}
-	}
-
-	/**
-	 * dbAuditSimulate simulates the DB audit
-	 * @param resourceName
-	 * @param persistenceUnit 
-	 * @param simulationIterations
-	 * @param simulationIntervalMs 
-	 * @param nodeType
-	 * @throws DbAuditException
-	 */
-	public void dbAuditSimulate(String resourceName, String persistenceUnit, long simulationIterations, long simulationIntervalMs) throws DbAuditException {
-
-		try {
-			logger.info("dbAuditSimulate: Starting audit simulation for resourceName="
-					+ resourceName + ", persistenceUnit=" + persistenceUnit);
-
-			for (int i = 0; i < simulationIterations; i++) {
-				dbDAO.setLastUpdated();
-				logger.info("dbAuditSimulate: i=" + i + ", sleeping "
-						+ simulationIntervalMs + "ms");
-				Thread.sleep(simulationIntervalMs);
-			}
-
-			logger.info("dbAuditSimulate: Finished audit simulation for resourceName="
-					+ resourceName + ", persistenceUnit=" + persistenceUnit);
-			
-		} catch(DbDaoTransactionException e) {
-			throw new DbAuditException(e);
-			
-		} catch (InterruptedException e) {
-			Thread.currentThread().interrupt();
-			throw new DbAuditException(e);
-		}
-	}
-	
-	/**
-	 * compareEntries() will compare the lists of entries from the DB
-	 * @param myEntries
-	 * @param theirEntries
-	 * @return
-	 */
-	public Set<Object> compareEntries(Map<Object,Object> myEntries, Map<Object,Object> theirEntries){
-		/*
-		 * Compare the entries for the same key in each of the hashmaps.  The comparison will be done by serializing the objects 
-		 * (create a byte array) and then do a byte array comparison.  The audit will walk the local repository hash map comparing 
-		 * to the remote cluster hashmap and then turn it around and walk the remote hashmap and look for any entries that are not 
-		 * present in the local cluster hashmap. 
-		 * 
-		 * If the objects are not identical, the audit will put the object IDs on a list to try after completing the audit of the table 
-		 * it is currently working on.
-		 * 
-		 */
-		HashSet<Object> misMatchedKeySet = new HashSet<>();
-		for(Entry<Object, Object> ent: myEntries.entrySet()) {
-			Object key = ent.getKey();
-			byte[] mySerializedEntry = SerializationUtils.serialize((Serializable) ent.getValue());
-			byte[] theirSerializedEntry = SerializationUtils.serialize((Serializable) theirEntries.get(key));
-			if(!Arrays.equals(mySerializedEntry, theirSerializedEntry)){
-				logger.debug("compareEntries: For myEntries.key=" + key + ", entries do not match");
-				misMatchedKeySet.add(key);
-			} else {
-				logger.debug("compareEntries: For myEntries.key=" + key + ", entries match");
-			}
-		}
-		//now compare it in the other direction to catch entries in their set that is not in my set
-		for(Entry<Object, Object> ent: theirEntries.entrySet()) {
-			Object key = ent.getKey();
-			byte[] mySerializedEntry = SerializationUtils.serialize((Serializable) myEntries.get(key));
-			byte[] theirSerializedEntry = SerializationUtils.serialize((Serializable) ent.getValue());
-			if(!Arrays.equals(mySerializedEntry, theirSerializedEntry)){
-				logger.debug("compareEntries: For theirEntries.key=" + key + ", entries do not match");
-				misMatchedKeySet.add(key);
-			} else {
-				logger.debug("compareEntries: For theirEntries.key=" + key + ", entries match");
-			}
-		}
-		
-		//return a Set of the object IDs
-		logger.debug("compareEntries: misMatchedKeySet.size()=" + misMatchedKeySet.size());
-		return misMatchedKeySet;
-	}
-	
-	/**
-	 * writeAuditDebugLog() writes the mismatched entry details to the debug log
-	 * @param clazzName
-	 * @param resourceName1
-	 * @param resourceName2
-	 * @param entry1
-	 * @param entry2
-	 * @throws IntegrityAuditException
-	 */
-	public void writeAuditDebugLog(String clazzName, String resourceName1,
-			String resourceName2, Object entry1, Object entry2) throws IntegrityAuditException{
-		try {
-			Class<?> entityClass = Class.forName(clazzName);
-			String tableName = entityClass.getAnnotation(Table.class).name();
-			String msg = "\nDB Audit Error: "
-					+ "\n    Table Name: " + tableName
-					+ "\n    Entry 1 (short prefix style): " + resourceName1 + ": " + new ReflectionToStringBuilder(entry1,ToStringStyle.SHORT_PREFIX_STYLE).toString()
-					+ "\n    Entry 2 (short prefix style): " + resourceName2 + ": " + new ReflectionToStringBuilder(entry2,ToStringStyle.SHORT_PREFIX_STYLE).toString()
-					+ "\n    Entry 1 (recursive style): " + resourceName1 + ": " + new ReflectionToStringBuilder(entry1, new RecursiveToStringStyle()).toString()
-					+ "\n    Entry 2 (recursive style): " + resourceName2 + ": " + new ReflectionToStringBuilder(entry2, new RecursiveToStringStyle()).toString();
-			logger.debug(msg);
-			
-		} catch (ClassNotFoundException e) {
-			throw new IntegrityAuditException(e);
-		}
-		
-	}
-	
-	/**
-	 * writeAuditSummaryLog() writes a summary of the DB mismatches to the error log
-	 * @param clazzName
-	 * @param resourceName1
-	 * @param resourceName2
-	 * @param keys
-	 * @throws IntegrityAuditException
-	 */
-	public void writeAuditSummaryLog(String clazzName, String resourceName1, 
-			String resourceName2, String keys) throws IntegrityAuditException{
-		try {
-			Class<?> entityClass = Class.forName(clazzName);
-			String tableName = entityClass.getAnnotation(Table.class).name();
-			String msg = " DB Audit Error: Table Name: " + tableName
-					+ ";  Mismatch between nodes: " + resourceName1 +" and " + resourceName2
-					+ ";  Mismatched entries (keys): " + keys;
-			logger.info(msg);
-		} catch (ClassNotFoundException e) {
-			throw new IntegrityAuditException(e);
-		}
-	}
-
-	/**
-	 * Gets the audit-update time.
-	 * @return the audit-update time, in milliseconds
-	 */
-	protected static long getDbAuditUpdateMillis() {
-		return dbAuditUpdateMillis;
-	}
-
-	/**
-	 * Sets the audit-update time.
-	 * @param dbAuditUpdateMillis	the new audit update time, in milliseconds
-	 */
-	protected static void setDbAuditUpdateMillis(long dbAuditUpdateMillis) {
-		DbAudit.dbAuditUpdateMillis = dbAuditUpdateMillis;
-	}
-
-	/**
-	 * Gets the audit-sleep time.
-	 * @return the audit-sleep time, in milliseconds
-	 */
-	protected static long getDbAuditSleepMillis() {
-		return dbAuditSleepMillis;
-	}
-
-	/**
-	 * Sets the audit-sleep time.
-	 * @param dbAuditSleepMillis	the new audit sleep time, in milliseconds
-	 */
-	protected static void setDbAuditSleepMillis(long dbAuditSleepMillis) {
-		DbAudit.dbAuditSleepMillis = dbAuditSleepMillis;
-	}
+
+    private static final Logger logger = FlexLogger.getLogger(DbAudit.class);
+
+    private static long dbAuditUpdateMillis = 5000L;
+    private static long dbAuditSleepMillis = 2000L;
+
+    DbDAO dbDao = null;
+
+    /**
+     * Construct an instance with the given DbDAO.
+     * 
+     * @param dbDao the DbDAO
+     */
+    public DbAudit(DbDAO dbDao) {
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("Constructor: Entering");
+        }
+
+        this.dbDao = dbDao;
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("Constructor: Exiting");
+        }
+
+    }
+
+    /**
+     * dbAudit actually does the audit.
+     * 
+     * @param resourceName the resource name
+     * @param persistenceUnit the persistence unit
+     * @param nodeType the node type
+     * @throws IntegrityAuditException if an error occurs
+     */
+    public void dbAudit(String resourceName, String persistenceUnit, String nodeType) throws IntegrityAuditException {
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("dbAudit: Entering, resourceName=" + resourceName + ", persistenceUnit=" + persistenceUnit
+                    + ", nodeType=" + nodeType);
+        }
+
+        // Get all IntegrityAudit entries so we can get the DB access info
+        List<IntegrityAuditEntity> iaeList = dbDao.getIntegrityAuditEntities(persistenceUnit, nodeType);
+        if (iaeList == null || iaeList.isEmpty()) {
+
+            String msg = "DbAudit: for node " + resourceName + " Found no IntegrityAuditEntity entries";
+            logger.error(MessageCodes.ERROR_AUDIT, msg);
+            throw new DbAuditException(msg);
+
+        } else if (iaeList.size() == 1) {
+
+            Long iaeId = null;
+            String iaeRn = null;
+            String iaeNt = null;
+            String iaeS = null;
+            for (IntegrityAuditEntity iae : iaeList) {
+                iaeId = iae.getId();
+                iaeRn = iae.getResourceName();
+                iaeNt = iae.getNodeType();
+                iaeS = iae.getSite();
+            }
+            String msg = "DbAudit: Found only one IntegrityAuditEntity entry:" + " ID = " + iaeId + " ResourceName = "
+                    + iaeRn + " NodeType = " + iaeNt + " Site = " + iaeS;
+            logger.warn(msg);
+            return;
+        }
+
+        // Obtain all persistence class names for the PU we are auditing
+        Set<String> classNameSet = dbDao.getPersistenceClassNames();
+        if (classNameSet == null || classNameSet.isEmpty()) {
+
+            String msg = "DbAudit: For node " + resourceName + " Found no persistence class names";
+            logger.error(MessageCodes.ERROR_AUDIT, msg);
+            throw new DbAuditException(msg);
+
+        }
+
+        /*
+         * Retrieve myIae. We are going to compare the local class entries against all other DB
+         * nodes. Since the audit is run in a round-robin, every instance will be compared against
+         * every other instance.
+         */
+        IntegrityAuditEntity myIae = dbDao.getMyIntegrityAuditEntity();
+
+        if (myIae == null) {
+
+            String msg = "DbAudit: Found no IntegrityAuditEntity entry for resourceName: " + resourceName
+                    + " persistenceUnit: " + persistenceUnit;
+            logger.error(MessageCodes.ERROR_AUDIT, msg);
+            throw new DbAuditException(msg);
+
+        }
+        /*
+         * This is the map of mismatched entries indexed by className. For each class name there is
+         * a list of mismatched entries
+         */
+        Map<String, Set<Object>> misMatchedMap = new HashMap<>();
+
+        // We need to keep track of how long the audit is taking
+        long startTime = System.currentTimeMillis();
+
+        // Retrieve all instances of the class for each node
+        if (logger.isDebugEnabled()) {
+            logger.debug("dbAudit: Traversing classNameSet, size=" + classNameSet.size());
+        }
+        for (String clazzName : classNameSet) {
+
+            if (logger.isDebugEnabled()) {
+                logger.debug("dbAudit: clazzName=" + clazzName);
+            }
+
+            // all instances of the class for myIae
+            Map<Object, Object> myEntries = dbDao.getAllMyEntries(clazzName);
+            // get a map of the objects indexed by id. Does not necessarily have any entries
+
+            if (logger.isDebugEnabled()) {
+                logger.debug("dbAudit: Traversing iaeList, size=" + iaeList.size());
+            }
+            for (IntegrityAuditEntity iae : iaeList) {
+                if (iae.getId() == myIae.getId()) {
+                    if (logger.isDebugEnabled()) {
+                        logger.debug("dbAudit: My Id=" + iae.getId() + ", resourceName=" + iae.getResourceName());
+                    }
+                    continue; // no need to compare with self
+                } else {
+                    if (logger.isDebugEnabled()) {
+                        logger.debug("dbAudit: Id=" + iae.getId() + ", resourceName=" + iae.getResourceName());
+                    }
+                }
+                // Create properties for the other db node
+                Properties theirProperties = new Properties();
+                theirProperties.put(IntegrityAuditProperties.DB_DRIVER, iae.getJdbcDriver());
+                theirProperties.put(IntegrityAuditProperties.DB_URL, iae.getJdbcUrl());
+                theirProperties.put(IntegrityAuditProperties.DB_USER, iae.getJdbcUser());
+                theirProperties.put(IntegrityAuditProperties.DB_PWD, iae.getJdbcPassword());
+                theirProperties.put(IntegrityAuditProperties.SITE_NAME, iae.getSite());
+                theirProperties.put(IntegrityAuditProperties.NODE_TYPE, iae.getNodeType());
+
+                // get a map of the instances for their iae indexed by id
+                Map<Object, Object> theirEntries = dbDao.getAllEntries(persistenceUnit, theirProperties, clazzName);
+                if (logger.isDebugEnabled()) {
+                    logger.debug("dbAudit: For persistenceUnit=" + persistenceUnit + ", clazzName=" + clazzName
+                            + ", theirEntries.size()=" + theirEntries.size());
+                }
+
+                /*
+                 * Compare myEntries with theirEntries and get back a set of mismatched IDs. Collect
+                 * the IDs for the class where a mismatch occurred. We will check them again for all
+                 * nodes later.
+                 */
+                Set<Object> misMatchedKeySet = compareEntries(myEntries, theirEntries);
+                if (!misMatchedKeySet.isEmpty()) {
+                    Set<Object> misMatchedEntry = misMatchedMap.get(clazzName);
+                    if (misMatchedEntry == null) {
+                        misMatchedMap.put(clazzName, misMatchedKeySet);
+                    } else {
+                        misMatchedEntry.addAll(misMatchedKeySet);
+                        misMatchedMap.put(clazzName, misMatchedEntry);
+                    }
+                }
+            } // end for (IntegrityAuditEntity iae : iaeList)
+
+            // Time check
+            if ((System.currentTimeMillis() - startTime) >= dbAuditUpdateMillis) {
+                // update the timestamp
+                dbDao.setLastUpdated();
+                // reset the startTime
+                startTime = System.currentTimeMillis();
+            } else {
+                // sleep a couple seconds to break up the activity
+                if (logger.isDebugEnabled()) {
+                    logger.debug("dbAudit: Sleeping " + dbAuditSleepMillis + "ms");
+                }
+                sleep();
+                if (logger.isDebugEnabled()) {
+                    logger.debug("dbAudit: Waking from sleep");
+                }
+            }
+        } // end: for(String clazzName: classNameList)
+
+        // check if misMatchedMap is empty
+        if (misMatchedMap.isEmpty()) {
+
+            if (logger.isDebugEnabled()) {
+                logger.debug("dbAudit: Exiting, misMatchedMap is empty");
+            }
+            // we are done
+            return;
+        } else {
+            if (logger.isDebugEnabled()) {
+                logger.debug("dbAudit: Doing another comparison; misMatchedMap.size()=" + misMatchedMap.size());
+            }
+        }
+
+        // If misMatchedMap is not empty, retrieve the entries in each misMatched list and compare
+        // again
+        classNameSet = new HashSet<>(misMatchedMap.keySet());
+        // We need to keep track of how long the audit is taking
+        startTime = System.currentTimeMillis();
+
+        // Retrieve all instances of the class for each node
+        if (logger.isDebugEnabled()) {
+            logger.debug("dbAudit: Second comparison; traversing classNameSet, size=" + classNameSet.size());
+        }
+
+        int errorCount = 0;
+
+        for (String clazzName : classNameSet) {
+
+            if (logger.isDebugEnabled()) {
+                logger.debug("dbAudit: Second comparison; clazzName=" + clazzName);
+            }
+
+            // all instances of the class for myIae
+            Set<Object> keySet = misMatchedMap.get(clazzName);
+            Map<Object, Object> myEntries = dbDao.getAllMyEntries(clazzName, keySet);
+            // get a map of the objects indexed by id
+
+            if (logger.isDebugEnabled()) {
+                logger.debug("dbAudit: Second comparison; traversing iaeList, size=" + iaeList.size());
+            }
+            for (IntegrityAuditEntity iae : iaeList) {
+                if (iae.getId() == myIae.getId()) {
+                    if (logger.isDebugEnabled()) {
+                        logger.debug("dbAudit: Second comparison; My Id=" + iae.getId() + ", resourceName="
+                                + iae.getResourceName());
+                    }
+                    continue; // no need to compare with self
+                } else {
+                    if (logger.isDebugEnabled()) {
+                        logger.debug("dbAudit: Second comparison; Id=" + iae.getId() + ", resourceName="
+                                + iae.getResourceName());
+                    }
+                }
+                // Create properties for the other db node
+                Properties theirProperties = new Properties();
+                theirProperties.put(IntegrityAuditProperties.DB_DRIVER, iae.getJdbcDriver());
+                theirProperties.put(IntegrityAuditProperties.DB_URL, iae.getJdbcUrl());
+                theirProperties.put(IntegrityAuditProperties.DB_USER, iae.getJdbcUser());
+                theirProperties.put(IntegrityAuditProperties.DB_PWD, iae.getJdbcPassword());
+                theirProperties.put(IntegrityAuditProperties.SITE_NAME, iae.getSite());
+                theirProperties.put(IntegrityAuditProperties.NODE_TYPE, iae.getNodeType());
+
+                // get a map of the instances for their iae indexed by id
+                Map<Object, Object> theirEntries =
+                        dbDao.getAllEntries(persistenceUnit, theirProperties, clazzName, keySet);
+
+                /*
+                 * Compare myEntries with theirEntries and get back a set of mismatched IDs. Collect
+                 * the IDs for the class where a mismatch occurred. We will now write an error log
+                 * for each.
+                 */
+                Set<Object> misMatchedKeySet = compareEntries(myEntries, theirEntries);
+                if (!misMatchedKeySet.isEmpty()) {
+                    String keysString = "";
+                    for (Object key : misMatchedKeySet) {
+                        keysString = keysString.concat(key.toString() + ", ");
+                        errorCount++;
+                    }
+                    writeAuditSummaryLog(clazzName, resourceName, iae.getResourceName(), keysString);
+                    if (logger.isDebugEnabled()) {
+                        for (Object key : misMatchedKeySet) {
+                            writeAuditDebugLog(clazzName, resourceName, iae.getResourceName(), myEntries.get(key),
+                                    theirEntries.get(key));
+                        }
+                    }
+                }
+            }
+            // Time check
+            if ((System.currentTimeMillis() - startTime) >= dbAuditUpdateMillis) {
+                // update the timestamp
+                dbDao.setLastUpdated();
+                // reset the startTime
+                startTime = System.currentTimeMillis();
+            } else {
+                // sleep a couple seconds to break up the activity
+                if (logger.isDebugEnabled()) {
+                    logger.debug("dbAudit: Second comparison; sleeping " + dbAuditSleepMillis + "ms");
+                }
+                sleep();
+                if (logger.isDebugEnabled()) {
+                    logger.debug("dbAudit: Second comparison; waking from sleep");
+                }
+            }
+        } // end: for(String clazzName: classNameList)
+
+        if (errorCount != 0) {
+            String msg = " DB Audit: " + errorCount
+                    + " errors found. A large number of errors may indicate DB replication has stopped";
+            logger.error(MessageCodes.ERROR_AUDIT, msg);
+        }
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("dbAudit: Exiting");
+        }
+
+        return; // all done
+    }
+
+    /**
+     * Sleeps a bit.
+     * 
+     * @throws IntegrityAuditException if interrupted
+     */
+    private void sleep() throws IntegrityAuditException {
+        try {
+            Thread.sleep(dbAuditSleepMillis);
+
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new IntegrityAuditException(e);
+        }
+    }
+
+    /**
+     * dbAuditSimulate simulates the DB audit.
+     * 
+     * @param resourceName the resouce name
+     * @param persistenceUnit the persistence unit
+     * @param simulationIterations the simulations iterations
+     * @param simulationIntervalMs the simulation interval in milliseconds
+     * @throws DbAuditException if an error occurs
+     */
+    public void dbAuditSimulate(String resourceName, String persistenceUnit, long simulationIterations,
+            long simulationIntervalMs) throws DbAuditException {
+
+        try {
+            logger.info("dbAuditSimulate: Starting audit simulation for resourceName=" + resourceName
+                    + ", persistenceUnit=" + persistenceUnit);
+
+            for (int i = 0; i < simulationIterations; i++) {
+                dbDao.setLastUpdated();
+                logger.info("dbAuditSimulate: i=" + i + ", sleeping " + simulationIntervalMs + "ms");
+                Thread.sleep(simulationIntervalMs);
+            }
+
+            logger.info("dbAuditSimulate: Finished audit simulation for resourceName=" + resourceName
+                    + ", persistenceUnit=" + persistenceUnit);
+
+        } catch (DbDaoTransactionException e) {
+            throw new DbAuditException(e);
+
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new DbAuditException(e);
+        }
+    }
+
+    /**
+     * compareEntries() will compare the lists of entries from the DB.
+     * 
+     * @param myEntries the entries
+     * @param theirEntries the entries to compare against myEntries
+     * @return the set of differences
+     */
+    public Set<Object> compareEntries(Map<Object, Object> myEntries, Map<Object, Object> theirEntries) {
+        /*
+         * Compare the entries for the same key in each of the hashmaps. The comparison will be done
+         * by serializing the objects (create a byte array) and then do a byte array comparison. The
+         * audit will walk the local repository hash map comparing to the remote cluster hashmap and
+         * then turn it around and walk the remote hashmap and look for any entries that are not
+         * present in the local cluster hashmap.
+         * 
+         * If the objects are not identical, the audit will put the object IDs on a list to try
+         * after completing the audit of the table it is currently working on.
+         * 
+         */
+        HashSet<Object> misMatchedKeySet = new HashSet<>();
+        for (Entry<Object, Object> ent : myEntries.entrySet()) {
+            Object key = ent.getKey();
+            byte[] mySerializedEntry = SerializationUtils.serialize((Serializable) ent.getValue());
+            byte[] theirSerializedEntry = SerializationUtils.serialize((Serializable) theirEntries.get(key));
+            if (!Arrays.equals(mySerializedEntry, theirSerializedEntry)) {
+                logger.debug("compareEntries: For myEntries.key=" + key + ", entries do not match");
+                misMatchedKeySet.add(key);
+            } else {
+                logger.debug("compareEntries: For myEntries.key=" + key + ", entries match");
+            }
+        }
+        // now compare it in the other direction to catch entries in their set that is not in my set
+        for (Entry<Object, Object> ent : theirEntries.entrySet()) {
+            Object key = ent.getKey();
+            byte[] mySerializedEntry = SerializationUtils.serialize((Serializable) myEntries.get(key));
+            byte[] theirSerializedEntry = SerializationUtils.serialize((Serializable) ent.getValue());
+            if (!Arrays.equals(mySerializedEntry, theirSerializedEntry)) {
+                logger.debug("compareEntries: For theirEntries.key=" + key + ", entries do not match");
+                misMatchedKeySet.add(key);
+            } else {
+                logger.debug("compareEntries: For theirEntries.key=" + key + ", entries match");
+            }
+        }
+
+        // return a Set of the object IDs
+        logger.debug("compareEntries: misMatchedKeySet.size()=" + misMatchedKeySet.size());
+        return misMatchedKeySet;
+    }
+
+    /**
+     * writeAuditDebugLog() writes the mismatched entry details to the debug log.
+     * 
+     * @param clazzName the class name
+     * @param resourceName1 resource name 1
+     * @param resourceName2 resource name 2
+     * @param entry1 entry 1
+     * @param entry2 entry 2
+     * @throws IntegrityAuditException if the given class cannot be found
+     */
+    public void writeAuditDebugLog(String clazzName, String resourceName1, String resourceName2, Object entry1,
+            Object entry2) throws IntegrityAuditException {
+        try {
+            Class<?> entityClass = Class.forName(clazzName);
+            String tableName = entityClass.getAnnotation(Table.class).name();
+            String msg = "\nDB Audit Error: " + "\n    Table Name: " + tableName
+                    + "\n    Entry 1 (short prefix style): " + resourceName1 + ": "
+                    + new ReflectionToStringBuilder(entry1, ToStringStyle.SHORT_PREFIX_STYLE).toString()
+                    + "\n    Entry 2 (short prefix style): " + resourceName2 + ": "
+                    + new ReflectionToStringBuilder(entry2, ToStringStyle.SHORT_PREFIX_STYLE).toString()
+                    + "\n    Entry 1 (recursive style): " + resourceName1 + ": "
+                    + new ReflectionToStringBuilder(entry1, new RecursiveToStringStyle()).toString()
+                    + "\n    Entry 2 (recursive style): " + resourceName2 + ": "
+                    + new ReflectionToStringBuilder(entry2, new RecursiveToStringStyle()).toString();
+            logger.debug(msg);
+
+        } catch (ClassNotFoundException e) {
+            throw new IntegrityAuditException(e);
+        }
+
+    }
+
+    /**
+     * writeAuditSummaryLog() writes a summary of the DB mismatches to the error log.
+     * 
+     * @param clazzName the name of the class
+     * @param resourceName1 resource name 1
+     * @param resourceName2 resource name 2
+     * @param keys the mismatched entry keys
+     * @throws IntegrityAuditException if the given class cannot be found
+     */
+    public void writeAuditSummaryLog(String clazzName, String resourceName1, String resourceName2, String keys)
+            throws IntegrityAuditException {
+        try {
+            Class<?> entityClass = Class.forName(clazzName);
+            String tableName = entityClass.getAnnotation(Table.class).name();
+            String msg = " DB Audit Error: Table Name: " + tableName + ";  Mismatch between nodes: " + resourceName1
+                    + " and " + resourceName2 + ";  Mismatched entries (keys): " + keys;
+            logger.info(msg);
+        } catch (ClassNotFoundException e) {
+            throw new IntegrityAuditException(e);
+        }
+    }
+
+    /**
+     * Gets the audit-update time.
+     * 
+     * @return the audit-update time, in milliseconds
+     */
+    protected static long getDbAuditUpdateMillis() {
+        return dbAuditUpdateMillis;
+    }
+
+    /**
+     * Sets the audit-update time.
+     * 
+     * @param dbAuditUpdateMillis the new audit update time, in milliseconds
+     */
+    protected static void setDbAuditUpdateMillis(long dbAuditUpdateMillis) {
+        DbAudit.dbAuditUpdateMillis = dbAuditUpdateMillis;
+    }
+
+    /**
+     * Gets the audit-sleep time.
+     * 
+     * @return the audit-sleep time, in milliseconds
+     */
+    protected static long getDbAuditSleepMillis() {
+        return dbAuditSleepMillis;
+    }
+
+    /**
+     * Sets the audit-sleep time.
+     * 
+     * @param dbAuditSleepMillis the new audit sleep time, in milliseconds
+     */
+    protected static void setDbAuditSleepMillis(long dbAuditSleepMillis) {
+        DbAudit.dbAuditSleepMillis = dbAuditSleepMillis;
+    }
 
 }
diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/DbAuditException.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/DbAuditException.java
index dc629c65..a539f6bd 100644
--- a/integrity-audit/src/main/java/org/onap/policy/common/ia/DbAuditException.java
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/DbAuditException.java
@@ -21,18 +21,21 @@
 package org.onap.policy.common.ia;
 
 public class DbAuditException extends IntegrityAuditException {
-	private static final long serialVersionUID = 1L;
-	public DbAuditException() {
-		super();
-	}
-	public DbAuditException(String message) {
-		super(message);
-	}
+    private static final long serialVersionUID = 1L;
 
-	public DbAuditException(Throwable cause) {
-		super(cause);
-	}
-	public DbAuditException(String message, Throwable cause) {
-		super(message, cause);
-	}
+    public DbAuditException() {
+        super();
+    }
+
+    public DbAuditException(String message) {
+        super(message);
+    }
+
+    public DbAuditException(Throwable cause) {
+        super(cause);
+    }
+
+    public DbAuditException(String message, Throwable cause) {
+        super(message, cause);
+    }
 }
diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDAO.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDAO.java
index 73beda78..864adacb 100644
--- a/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDAO.java
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDAO.java
@@ -42,9 +42,8 @@ import javax.persistence.criteria.Root;
 import javax.persistence.metamodel.ManagedType;
 import javax.persistence.metamodel.Metamodel;
 
-
 import org.onap.policy.common.ia.jpa.IntegrityAuditEntity;
-import org.onap.policy.common.logging.flexlogger.FlexLogger; 
+import org.onap.policy.common.logging.flexlogger.FlexLogger;
 import org.onap.policy.common.logging.flexlogger.Logger;
 
 /**
@@ -52,703 +51,718 @@ import org.onap.policy.common.logging.flexlogger.Logger;
  * 
  */
 public class DbDAO {
-	private static final Logger logger = FlexLogger.getLogger(DbDAO.class.getName());
-	private String resourceName;
-	private String persistenceUnit;
-	private String dbDriver;
-	private String dbUrl;
-	private String dbUser;
-	private String siteName;
-	private String nodeType;
-	private Properties properties=null;
-	
-	private EntityManagerFactory emf;
-	
-	/*
-	 * Supports designation serialization.
-	 */
+    private static final Logger logger = FlexLogger.getLogger(DbDAO.class.getName());
+    private String resourceName;
+    private String persistenceUnit;
+    private String dbDriver;
+    private String dbUrl;
+    private String dbUser;
+    private String siteName;
+    private String nodeType;
+    private Properties properties = null;
+
+    private EntityManagerFactory emf;
+
+    /*
+     * Supports designation serialization.
+     */
     private static final Object lock = new Object();
 
-	/**
-	 * DbDAO Constructor
-	 * 
-	 * @param resourceName
-	 * @param persistenceUnit
-	 * @param properties
-	 * @throws IntegrityAuditException
-	 */
-	public DbDAO(String resourceName, String persistenceUnit, Properties properties) throws IntegrityAuditException {
-		this(resourceName, persistenceUnit, properties, null);
-	}
-
-	/**
-	 * DbDAO Constructor
-	 * 
-	 * @param resourceName
-	 * @param persistenceUnit
-	 * @param properties
-	 * @param lastUpdateDate	may be {@code null}
-	 * @param altDbUrl			may be {@code null}
-	 * @throws IntegrityAuditException
-	 */
-	protected DbDAO(String resourceName, String persistenceUnit, Properties properties, String altDbUrl)
-			throws IntegrityAuditException {
-		logger.debug("DbDAO contructor: enter");
-
-		validateProperties(resourceName, persistenceUnit, properties);
-
-		emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
-
-		register(altDbUrl);
-
-		logger.debug("DbDAO contructor: exit");
-	}
-	
-	/**
-	 * Release resources (i.e., the EntityManagerFactory).
-	 */
-	public void destroy() {
-		emf.close();
-	}
-	
-	/**
-	 * validateProperties will validate the properties
-	 * @param resourceName
-	 * @param persistenceUnit
-	 * @param properties
-	 * @throws IntegrityAuditPropertiesException
-	 */
-	private void validateProperties(String resourceName, String persistenceUnit, Properties properties) throws IntegrityAuditPropertiesException{
-		StringBuilder badparams= new StringBuilder();
-		if(IntegrityAudit.parmsAreBad(resourceName, persistenceUnit, properties, badparams)){
-			String msg = "DbDAO: Bad parameters: badparams" + badparams;
-			throw new IntegrityAuditPropertiesException(msg);
-		}
-		this.resourceName = resourceName;
-		this.persistenceUnit = persistenceUnit;
-		this.dbDriver = properties.getProperty(IntegrityAuditProperties.DB_DRIVER).trim();
-		this.dbUrl = properties.getProperty(IntegrityAuditProperties.DB_URL).trim();
-		this.dbUser = properties.getProperty(IntegrityAuditProperties.DB_USER).trim();
-		this.siteName = properties.getProperty(IntegrityAuditProperties.SITE_NAME).trim();
-		this.nodeType = properties.getProperty(IntegrityAuditProperties.NODE_TYPE).trim();
-		this.properties = properties;
-		logger.debug("DbDAO.assignProperties: exit:" 
-				+ "\nresourceName: " + this.resourceName
-				+ "\npersistenceUnit: " + this.persistenceUnit
-				+ "\nproperties: " + this.properties);
-	}
-	
-	/**
-	 * getAllMyEntries gets all the DB entries for a particular class
-	 * @param className
-	 * @return
-	 */
-	public Map<Object, Object> getAllMyEntries(String className) {
-		logger.debug("getAllMyEntries: Entering, className="
-				+ className);
-		HashMap<Object, Object> resultMap = new HashMap<>();
-		EntityManager em = emf.createEntityManager();
-		try{
-			CriteriaBuilder cb = em.getCriteriaBuilder();
-			CriteriaQuery<Object> cq = cb.createQuery();
-			Root<?> rootEntry = cq.from(Class.forName(className));
-			CriteriaQuery<Object> all = cq.select(rootEntry);
-			TypedQuery<Object> allQuery = em.createQuery(all);
-			List<Object> objectList = allQuery.getResultList();
-			//Now create the map
-
-			PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
-			for (Object o: objectList){
-				Object key = util.getIdentifier(o);
-				resultMap.put(key, o);
-			}
-		}catch(Exception e){
-			logger.error("getAllEntries encountered exception: ", e);
-		}
-		em.close();
-		logger.debug("getAllMyEntries: Exit, resultMap.keySet()=" + resultMap.keySet());
-		return resultMap;		
-	}
-	
-	/**
-	 * getAllMyEntries gets all entries for a class
-	 * @param className
-	 * @param keySet
-	 * @return
-	 */
-	public Map<Object, Object> getAllMyEntries(String className, Set<Object> keySet){
-		logger.debug("getAllMyEntries: Entering, className="
-				+ className + ",\n keySet=" + keySet);
-
-		HashMap<Object, Object> resultMap = new HashMap<>();
-		EntityManager em = emf.createEntityManager();
-		try{
-			Class<?> clazz = Class.forName(className);
-			for(Object key : keySet){
-				Object entry = em.find(clazz, key);
-				resultMap.put(key, entry);
-			}
-		}catch(Exception e){
-			logger.error("getAllMyEntries encountered exception: ", e);
-		}
-		em.close();
-
-		logger.debug("getAllMyEntries: Returning resultMap, size=" + resultMap.size());
-		return resultMap;
-	}
-	
-	/**
-	 * getAllEntries gets all entriesfor a particular persistence unit adn className
-	 * @param persistenceUnit
-	 * @param properties
-	 * @param className
-	 * @return
-	 */
-	public Map<Object,Object> getAllEntries(String persistenceUnit, Properties properties, String className){
-		
-		logger.debug("getAllEntries: Entering, persistenceUnit="
-				+ persistenceUnit + ",\n className=" + className);
-		HashMap<Object, Object> resultMap = new HashMap<>();
-
-		EntityManagerFactory theEmf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
-		EntityManager em = theEmf.createEntityManager();
-		try{
-			CriteriaBuilder cb = em.getCriteriaBuilder();
-			CriteriaQuery<Object> cq = cb.createQuery();
-			Root<?> rootEntry = cq.from(Class.forName(className));
-			CriteriaQuery<Object> all = cq.select(rootEntry);
-			TypedQuery<Object> allQuery = em.createQuery(all);
-			List<Object> objectList = allQuery.getResultList();
-
-			PersistenceUnitUtil util = theEmf.getPersistenceUnitUtil();
-			for (Object o: objectList){
-				Object key = util.getIdentifier(o);
-				resultMap.put(key, o);
-			}
-		}catch(Exception e){
-			logger.error("getAllEntries encountered exception:", e);
-		}
-		em.close();
-		theEmf.close();
-		
-		logger.debug("getAllEntries: Returning resultMap, size=" + resultMap.size());
-		
-		return resultMap;		
-	}
-	
-
-	/**
-	 * getAllEntries gest all entries for a persistence unit
-	 * @param persistenceUnit
-	 * @param properties
-	 * @param className
-	 * @param keySet
-	 * @return
-	 */
-
-	public Map<Object,Object> getAllEntries(String persistenceUnit, Properties properties, String className, Set<Object> keySet){
-		logger.debug("getAllEntries: Entering, persistenceUnit="
-				+ persistenceUnit + ",\n properties= " + properties + ",\n className=" + className + ",\n keySet= " + keySet);
-		EntityManagerFactory theEmf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
-		EntityManager em = theEmf.createEntityManager();
-		HashMap<Object, Object> resultMap = new HashMap<>();
-		try{
-			Class<?> clazz = Class.forName(className);
-			for(Object key : keySet){
-				Object entry = em.find(clazz, key);
-				resultMap.put(key, entry);
-			}
-		}catch(Exception e){
-			String msg = "getAllEntries encountered exception: " + e;
-			logger.error(msg, e);
-		}
-		em.close();
-		theEmf.close();
-		logger.debug("getAllEntries: Exit, resultMap, size=" + resultMap.size());
-		return resultMap;	
-	}
-	
-	/**
-	 * getIntegrityAuditEntities() Get all the IntegrityAuditEntities for a particular persistence unit
-	 * and node type
-	 * @param persistenceUnit
-	 * @param nodeType
-	 * @return
-	 * @throws DbDaoTransactionException
-	 */
-	@SuppressWarnings("unchecked")
-	public List<IntegrityAuditEntity> getIntegrityAuditEntities(String persistenceUnit, String nodeType) throws DbDaoTransactionException {
-		logger.debug("getIntegrityAuditEntities: Entering, persistenceUnit="
-				+ persistenceUnit + ",\n nodeType= " + nodeType);
-		try{
-			EntityManager em = emf.createEntityManager();
-			// Start a transaction
-			EntityTransaction et = em.getTransaction();
-
-			et.begin();
-
-			// if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
-			Query iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.persistenceUnit=:pu and i.nodeType=:nt");
-			iaequery.setParameter("pu", persistenceUnit);
-			iaequery.setParameter("nt", nodeType);
-
-			List<IntegrityAuditEntity> iaeList = iaequery.getResultList();
-
-			// commit transaction
-			et.commit();
-			em.close();
-			logger.debug("getIntegrityAuditEntities: Exit, iaeList=" + iaeList);
-			return iaeList;
-		}catch (Exception e){
-			String msg = "DbDAO: " + "getIntegrityAuditEntities() " + "ecountered a problem in execution: ";
-			logger.error(msg, e);
-			throw new DbDaoTransactionException(e);
-		}
-		
-	}
-
-	/**
-	 * getMyIntegrityAuditEntity() gets my IntegrityAuditEntity
-	 * @return
-	 * @throws DbDaoTransactionException
-	 */
-	public IntegrityAuditEntity getMyIntegrityAuditEntity() throws DbDaoTransactionException{
-		try{
-			EntityManager em = emf.createEntityManager();
-
-			// Start a transaction
-			EntityTransaction et = em.getTransaction();
-
-			et.begin();
-
-			// if IntegrityAuditEntity entry exists for resourceName and PU, retrieve it
-			Query iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
-			iaequery.setParameter("rn", this.resourceName);
-			iaequery.setParameter("pu", this.persistenceUnit);
-
-			@SuppressWarnings("rawtypes")
-			List iaeList = iaequery.getResultList();
-			IntegrityAuditEntity iae = null;
-
-			if(!iaeList.isEmpty()){
-				//ignores multiple results
-				iae = (IntegrityAuditEntity) iaeList.get(0);
-				// refresh the object from DB in case cached data was returned
-				em.refresh(iae);
-				logger.info("Resource: " + this.resourceName + " with PersistenceUnit: " + this.persistenceUnit
-						+ " exists");
-			}else{
-				// If it does not exist, log an error
-				logger.error("Attempting to setLastUpdated"
-						+ " on an entry that does not exist:"
-						+" resource " + this.resourceName + " with PersistenceUnit: " + this.persistenceUnit);
-			}
-
-			// close the transaction
-			et.commit();
-			// close the EntityManager
-			em.close();
-			
-			return iae;
-		}catch (Exception e){
-			String msg = "DbDAO: " + "setLastUpdated() " + "ecountered a problem in execution: ";
-			logger.error(msg + e);
-			throw new DbDaoTransactionException(e);
-		}	
-	}
-
-	
-	/**
-	 * getIntegrityAuditEntity() gets the IntegrityAuditEntity with a particular ID
-	 * @param id
-	 * @return
-	 * @throws DbDaoTransactionException
-	 */
-	public IntegrityAuditEntity getIntegrityAuditEntity(long id) throws DbDaoTransactionException{
-		try{
-			EntityManager em = emf.createEntityManager();
-
-			// Start a transaction
-			EntityTransaction et = em.getTransaction();
-
-			et.begin();
-
-			IntegrityAuditEntity iae = em.find(IntegrityAuditEntity.class, id);
-
-			et.commit();
-			em.close();
-
-			return iae;
-		}catch (Exception e){
-			String msg = "DbDAO: " + "getIntegrityAuditEntity() " + "ecountered a problem in execution: ";
-			logger.error(msg + e);
-			throw new DbDaoTransactionException(e);
-		}
-	}
-	
-	/**
-	 * getPersistenceClassNames() gets all the persistence class names.
-	 * @return
-	 */
-	public Set<String> getPersistenceClassNames(){
-		logger.debug("DbDAO: getPersistenceClassNames() entry");
-		HashSet<String> returnList = new HashSet<>();
-		final Metamodel mm = emf.getMetamodel();
-		logger.debug("\n" + persistenceUnit +" persistence unit classes:");
-		for (final ManagedType<?> managedType : mm.getManagedTypes()) {
-			Class<?> c = managedType.getJavaType();
-			logger.debug("    " + c.getSimpleName());
-			returnList.add(c.getName()); //the full class name needed to make a query using jpa
-		}
-		logger.debug("DbDAO: getPersistenceClassNames() exit");
-		return returnList;
-	}
-	
-	/**
-	 * Register the IntegrityAudit instance
-	 * @param altDbUrl			alternate DB URL to be placed into the record,
-	 * 							or {@code null} to use the default
-	 */
-	private void register(String altDbUrl) throws DbDaoTransactionException {
-		try{
-			EntityManager em = emf.createEntityManager();
-
-			// Start a transaction
-			EntityTransaction et = em.getTransaction();
-
-			et.begin();
-
-			// if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
-			Query iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
-			iaequery.setParameter("rn", this.resourceName);
-			iaequery.setParameter("pu", this.persistenceUnit);
-
-			@SuppressWarnings("rawtypes")
-			List iaeList = iaequery.getResultList();
-			IntegrityAuditEntity iae;
-
-			//If it already exists, we just want to update the properties and lastUpdated date
-			if(!iaeList.isEmpty()){
-				//ignores multiple results
-				iae = (IntegrityAuditEntity) iaeList.get(0);
-				// refresh the object from DB in case cached data was returned
-				em.refresh(iae);
-				logger.info("Resource: " + this.resourceName + " with PersistenceUnit: " + this.persistenceUnit 
-						+ " exists and entry be updated");
-			}else{
-				// If it does not exist, we also must add teh resourceName, persistenceUnit and designated values
-				logger.info("Adding resource " + resourceName + " with PersistenceUnit: " + this.persistenceUnit
-						+ " to IntegrityAuditEntity table");  	
-				iae = new IntegrityAuditEntity();
-				iae.setResourceName(this.resourceName);
-				iae.setPersistenceUnit(this.persistenceUnit);
-				iae.setDesignated(false);
-			}
-			//update/set properties in entry
-			iae.setSite(this.siteName);
-			iae.setNodeType(this.nodeType);
-			iae.setJdbcDriver(this.dbDriver);
-			iae.setJdbcPassword(properties.getProperty(IntegrityAuditProperties.DB_PWD).trim());
-			iae.setJdbcUrl(altDbUrl == null ? this.dbUrl : altDbUrl);
-			iae.setJdbcUser(dbUser);
-
-			em.persist(iae);
-			// flush to the DB
-			em.flush();
-
-			// commit transaction
-			et.commit();
-			em.close();
-		}catch (Exception e){
-			String msg = "DbDAO: " + "register() " + "encountered a problem in execution: ";
-			logger.error(msg + e);
-			throw new DbDaoTransactionException(e);
-		}
-
-	}
-	
-	public void setDesignated(boolean designated) throws DbDaoTransactionException{
-		setDesignated(this.resourceName, this.persistenceUnit, designated);
-	}
-	
-
-	public void setDesignated(String rName, String pUnit, boolean desig) throws DbDaoTransactionException{
-		logger.debug("setDesignated: enter, resourceName: " + rName + ", persistenceUnit: " 
-				+ pUnit + ", designated: " + desig);
-		try{
-
-			EntityManager em = emf.createEntityManager();
-
-			// Start a transaction
-			EntityTransaction et = em.getTransaction();
-
-			et.begin();
-
-			// if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
-			Query iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
-			iaequery.setParameter("rn", rName);
-			iaequery.setParameter("pu", pUnit);
-
-			@SuppressWarnings("rawtypes")
-			List iaeList = iaequery.getResultList();
-			IntegrityAuditEntity iae;
-
-			if(!iaeList.isEmpty()){
-				//ignores multiple results
-				iae = (IntegrityAuditEntity) iaeList.get(0);
-				// refresh the object from DB in case cached data was returned
-				em.refresh(iae);
-				logger.info("Resource: " + rName + " with PersistenceUnit: " + pUnit 
-						+ " exists and designated be updated");
-				iae.setDesignated(desig);
-
-				em.persist(iae);
-				// flush to the DB
-				em.flush();
-			}else{
-				// If it does not exist, log an error
-				logger.error("Attempting to setDesignated("
-						+ desig + ") on an entry that does not exist:"
-						+" resource " + rName + " with PersistenceUnit: " + pUnit);
-			}
-
-			// close the transaction
-			et.commit();
-			// close the EntityManager
-			em.close();
-		}catch (Exception e){
-			String msg = "DbDAO: " + "setDesignated() " + "ecountered a problem in execution: ";
-			logger.error(msg + e);
-			throw new DbDaoTransactionException(e);
-		}
-
-	}
-	
-	public void setLastUpdated() throws DbDaoTransactionException{
-		logger.debug("setLastUpdated: enter, resourceName: " + this.resourceName + ", persistenceUnit: " 
-				+ this.persistenceUnit);
-		try{
-			EntityManager em = emf.createEntityManager();
-
-			// Start a transaction
-			EntityTransaction et = em.getTransaction();
-
-			et.begin();
-
-			// if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
-			Query iaequery = em.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
-			iaequery.setParameter("rn", this.resourceName);
-			iaequery.setParameter("pu", this.persistenceUnit);
-
-			@SuppressWarnings("rawtypes")
-			List iaeList = iaequery.getResultList();
-			IntegrityAuditEntity iae;
-
-			if(!iaeList.isEmpty()){
-				//ignores multiple results
-				iae = (IntegrityAuditEntity) iaeList.get(0);
-				// refresh the object from DB in case cached data was returned
-				em.refresh(iae);
-				logger.info("Resource: " + this.resourceName + " with PersistenceUnit: " + this.persistenceUnit
-						+ " exists and lastUpdated be updated");
-				iae.setLastUpdated(new Date());
-
-				em.persist(iae);
-				// flush to the DB
-				em.flush();
-			}else{
-				// If it does not exist, log an error
-				logger.error("Attempting to setLastUpdated"
-						+ " on an entry that does not exist:"
-						+" resource " + this.resourceName + " with PersistenceUnit: " + this.persistenceUnit);
-			}
-
-			// close the transaction
-			et.commit();
-			// close the EntityManager
-			em.close();
-		}catch (Exception e){
-			String msg = "DbDAO: " + "setLastUpdated() " + "ecountered a problem in execution: ";
-			logger.error(msg + e);
-			throw new DbDaoTransactionException(e);
-		}
-
-	}
-	
-	/**
-	 * Normally this method should only be used in a JUnit test environment.
-	 * Manually deletes all PDP records in droolspdpentity table.
-	 */
-	public int deleteAllIntegrityAuditEntities() throws DbDaoTransactionException {
-		
-		try{
-			
-			if (!IntegrityAudit.isUnitTesting()) {
-				String msg = "DbDAO: " + "deleteAllIntegrityAuditEntities() " + "should only be invoked during JUnit testing";
-				logger.error(msg);
-				throw new DbDaoTransactionException(msg);
-			}
-			
-			EntityManager em = emf.createEntityManager();
-			// Start a transaction
-			EntityTransaction et = em.getTransaction();
-
-			et.begin();
-
-			// if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not found, create a new entry
-			Query iaequery = em.createQuery("Delete from IntegrityAuditEntity");
-
-			int returnCode = iaequery.executeUpdate();
-
-			// commit transaction
-			et.commit();
-			em.close();
-			
-			logger.info("deleteAllIntegrityAuditEntities: returnCode=" + returnCode);
-
-			return returnCode;
-
-		}catch (Exception e){
-			String msg = "DbDAO: " + "deleteAllIntegrityAuditEntities() " + "encountered a problem in execution: ";
-			logger.error(msg + e);
-			throw new DbDaoTransactionException(e);
-		}
-		
-	}
-	
-	/**
-	 * Changes designation to specified resourceName
-	 * 
-	 * static lock object in conjunction with synchronized keyword ensures that
-	 * designation changes are done serially within a resource. I.e. static lock
-	 * ensures that multiple instantiations of DbDAO don't interleave
-	 * changeDesignated() invocations and potentially produce simultaneous
-	 * designations.
-	 * 
-	 * Optimistic locking (the default, versus pessimistic) is sufficient to
-	 * avoid simultaneous designations from interleaved changeDesignated()
-	 * invocations from different resources (entities), because it prevents
-	 * "dirty" and "non-repeatable" reads.
-	 * 
-	 * See http://www.objectdb.com/api/java/jpa/LockModeType
-	 * 
-	 * and
-	 * 
-	 * http://stackoverflow.com/questions/2120248/how-to-synchronize-a-static-
-	 * variable-among-threads-running-different-instances-o
-	 */
-	public void changeDesignated(String resourceName, String persistenceUnit,
-			String nodeType) throws DbDaoTransactionException {
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("changeDesignated: Entering, resourceName="
-					+ resourceName + ", persistenceUnit=" + persistenceUnit
-					+ ", nodeType=" + nodeType);
-		}
-
-		long startTime = System.currentTimeMillis();
-
-		synchronized (lock) {
-
-			EntityManager em = null;
-			try {
-
-				em = emf.createEntityManager();
-				em.getTransaction().begin();
-
-				/*
-				 * Define query
-				 */
-				Query query = em
-						.createQuery("Select i from IntegrityAuditEntity i where i.persistenceUnit=:pu and i.nodeType=:nt");
-				query.setParameter("pu", persistenceUnit);
-				query.setParameter("nt", nodeType);
-
-				/*
-				 * Execute query using pessimistic write lock.  This ensures that if anyone else is currently reading
-				 * the records we'll throw a LockTimeoutException.
-				 */
-				@SuppressWarnings("unchecked")
-				List<IntegrityAuditEntity> integrityAuditEntityList = (List<IntegrityAuditEntity>) query
-						.getResultList();
-				for (Object o : integrityAuditEntityList) {
-					if (o instanceof IntegrityAuditEntity) {
-						IntegrityAuditEntity integrityAuditEntity = (IntegrityAuditEntity) o;
-						if (integrityAuditEntity.getResourceName().equals(
-								resourceName)) {
-							if (logger.isDebugEnabled()) {
-								logger.debug("changeDesignated: Designating resourceName="
-										+ integrityAuditEntity
-												.getResourceName());
-							}
-							integrityAuditEntity.setDesignated(true);
-						} else {
-							if (logger.isDebugEnabled()) {
-								logger.debug("changeDesignated: Removing designation from resourceName="
-										+ integrityAuditEntity
-												.getResourceName());
-							}
-							integrityAuditEntity.setDesignated(false);
-						}
-					}
-				}
-				
-				if (logger.isDebugEnabled()) {
-					logger.debug("changeDesignated: Committing designation to resourceName="
-							+ resourceName);
-				}
-				em.getTransaction().commit();
-
-				/*
-				 * If we get a LockTimeoutException, no harm done really. We'll
-				 * probably be successful on the next attempt. The odds of
-				 * another DbDAO instance on this entity or another entity
-				 * attempting a simultaneous IntegrityAuditEntity table
-				 * read/update are pretty slim (we're only in this method for
-				 * two or three milliseconds)
-				 */
-			} catch (LockTimeoutException e) {
-				if (em != null) {
-					em.getTransaction().rollback();
-				
-					String msg = "DbDAO: " + "changeDesignated() "
-							+ "caught LockTimeoutException, message=" + e.getMessage();
-					logger.error(msg + e);
-					throw new DbDaoTransactionException(msg, e);
-				}
-				else {
-					String msg = "DbDAO: " + "changeDesignated() "
-							+ "caught LockTimeoutException, message=" + e.getMessage()
-							+ ". Error rolling back transaction.";
-					logger.error(msg + e);
-					throw new DbDaoTransactionException(msg, e);	
-				}
-			} catch (Exception e) {
-				if (em != null) {
-					em.getTransaction().rollback();
-				
-					String msg = "DbDAO: " + "changeDesignated() "
-							+ "caught Exception, message=" + e.getMessage();
-					logger.error(msg + e);
-					throw new DbDaoTransactionException(msg, e);
-				}
-				else {
-					String msg = "DbDAO: " + "changeDesignated() "
-							+ "caught LockTimeoutException, message=" + e.getMessage()
-							+ ". Error rolling back transaction.";
-					logger.error(msg + e);
-					throw new DbDaoTransactionException(msg, e);	
-				}
-			}
-
-		} // end synchronized block
-
-		if (logger.isDebugEnabled()) {
-			logger.debug("changeDesignated: Exiting; time expended="
-					+ (System.currentTimeMillis() - startTime) + "ms");
-		}
-
-	}
+    /**
+     * DbDAO Constructor.
+     * 
+     * @param resourceName the resource name
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @throws IntegrityAuditException if an error occurs
+     */
+    public DbDAO(String resourceName, String persistenceUnit, Properties properties) throws IntegrityAuditException {
+        this(resourceName, persistenceUnit, properties, null);
+    }
+
+    /**
+     * DbDAO Constructor.
+     * 
+     * @param resourceName the resource name
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @param lastUpdateDate may be {@code null}
+     * @param altDbUrl may be {@code null}
+     * @throws IntegrityAuditException if an error occurs
+     */
+    protected DbDAO(String resourceName, String persistenceUnit, Properties properties, String altDbUrl)
+            throws IntegrityAuditException {
+        logger.debug("DbDAO contructor: enter");
+
+        validateProperties(resourceName, persistenceUnit, properties);
+
+        emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+
+        register(altDbUrl);
+
+        logger.debug("DbDAO contructor: exit");
+    }
+
+    /**
+     * Release resources (i.e., the EntityManagerFactory).
+     */
+    public void destroy() {
+        emf.close();
+    }
+
+    /**
+     * validateProperties will validate the properties.
+     * 
+     * @param resourceName the rseource name
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @throws IntegrityAuditPropertiesException if an error occurs
+     */
+    private void validateProperties(String resourceName, String persistenceUnit, Properties properties)
+            throws IntegrityAuditPropertiesException {
+        StringBuilder badparams = new StringBuilder();
+        if (IntegrityAudit.parmsAreBad(resourceName, persistenceUnit, properties, badparams)) {
+            String msg = "DbDAO: Bad parameters: badparams" + badparams;
+            throw new IntegrityAuditPropertiesException(msg);
+        }
+        this.resourceName = resourceName;
+        this.persistenceUnit = persistenceUnit;
+        this.dbDriver = properties.getProperty(IntegrityAuditProperties.DB_DRIVER).trim();
+        this.dbUrl = properties.getProperty(IntegrityAuditProperties.DB_URL).trim();
+        this.dbUser = properties.getProperty(IntegrityAuditProperties.DB_USER).trim();
+        this.siteName = properties.getProperty(IntegrityAuditProperties.SITE_NAME).trim();
+        this.nodeType = properties.getProperty(IntegrityAuditProperties.NODE_TYPE).trim();
+        this.properties = properties;
+        logger.debug("DbDAO.assignProperties: exit:" + "\nresourceName: " + this.resourceName + "\npersistenceUnit: "
+                + this.persistenceUnit + "\nproperties: " + this.properties);
+    }
+
+    /**
+     * getAllMyEntries gets all the DB entries for a particular class.
+     * 
+     * @param className the class name
+     * @return all the DB entries for the given class
+     */
+    public Map<Object, Object> getAllMyEntries(String className) {
+        logger.debug("getAllMyEntries: Entering, className=" + className);
+        HashMap<Object, Object> resultMap = new HashMap<>();
+        EntityManager em = emf.createEntityManager();
+        try {
+            CriteriaBuilder cb = em.getCriteriaBuilder();
+            CriteriaQuery<Object> cq = cb.createQuery();
+            Root<?> rootEntry = cq.from(Class.forName(className));
+            CriteriaQuery<Object> all = cq.select(rootEntry);
+            TypedQuery<Object> allQuery = em.createQuery(all);
+            List<Object> objectList = allQuery.getResultList();
+            // Now create the map
+
+            PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
+            for (Object o : objectList) {
+                Object key = util.getIdentifier(o);
+                resultMap.put(key, o);
+            }
+        } catch (Exception e) {
+            logger.error("getAllEntries encountered exception: ", e);
+        }
+        em.close();
+        logger.debug("getAllMyEntries: Exit, resultMap.keySet()=" + resultMap.keySet());
+        return resultMap;
+    }
+
+    /**
+     * getAllMyEntries gets all entries for a class.
+     * 
+     * @param className the name of the class
+     * @param keySet the keys to get the entries for
+     * @return the map of requested entries
+     */
+    public Map<Object, Object> getAllMyEntries(String className, Set<Object> keySet) {
+        logger.debug("getAllMyEntries: Entering, className=" + className + ",\n keySet=" + keySet);
+
+        HashMap<Object, Object> resultMap = new HashMap<>();
+        EntityManager em = emf.createEntityManager();
+        try {
+            Class<?> clazz = Class.forName(className);
+            for (Object key : keySet) {
+                Object entry = em.find(clazz, key);
+                resultMap.put(key, entry);
+            }
+        } catch (Exception e) {
+            logger.error("getAllMyEntries encountered exception: ", e);
+        }
+        em.close();
+
+        logger.debug("getAllMyEntries: Returning resultMap, size=" + resultMap.size());
+        return resultMap;
+    }
+
+    /**
+     * getAllEntries gets all entriesfor a particular persistence unit adn className.
+     * 
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @param className the class name
+     * @return the map of entries
+     */
+    public Map<Object, Object> getAllEntries(String persistenceUnit, Properties properties, String className) {
+
+        logger.debug("getAllEntries: Entering, persistenceUnit=" + persistenceUnit + ",\n className=" + className);
+        HashMap<Object, Object> resultMap = new HashMap<>();
+
+        EntityManagerFactory theEmf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+        EntityManager em = theEmf.createEntityManager();
+        try {
+            CriteriaBuilder cb = em.getCriteriaBuilder();
+            CriteriaQuery<Object> cq = cb.createQuery();
+            Root<?> rootEntry = cq.from(Class.forName(className));
+            CriteriaQuery<Object> all = cq.select(rootEntry);
+            TypedQuery<Object> allQuery = em.createQuery(all);
+            List<Object> objectList = allQuery.getResultList();
+
+            PersistenceUnitUtil util = theEmf.getPersistenceUnitUtil();
+            for (Object o : objectList) {
+                Object key = util.getIdentifier(o);
+                resultMap.put(key, o);
+            }
+        } catch (Exception e) {
+            logger.error("getAllEntries encountered exception:", e);
+        }
+        em.close();
+        theEmf.close();
+
+        logger.debug("getAllEntries: Returning resultMap, size=" + resultMap.size());
+
+        return resultMap;
+    }
+
+
+    /**
+     * getAllEntries gets all entries for a persistence unit.
+     * 
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @param className the class name
+     * @param keySet the keys
+     * @return the map of entries
+     */
+
+    public Map<Object, Object> getAllEntries(String persistenceUnit, Properties properties, String className,
+            Set<Object> keySet) {
+        logger.debug("getAllEntries: Entering, persistenceUnit=" + persistenceUnit + ",\n properties= " + properties
+                + ",\n className=" + className + ",\n keySet= " + keySet);
+        EntityManagerFactory theEmf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
+        EntityManager em = theEmf.createEntityManager();
+        HashMap<Object, Object> resultMap = new HashMap<>();
+        try {
+            Class<?> clazz = Class.forName(className);
+            for (Object key : keySet) {
+                Object entry = em.find(clazz, key);
+                resultMap.put(key, entry);
+            }
+        } catch (Exception e) {
+            String msg = "getAllEntries encountered exception: " + e;
+            logger.error(msg, e);
+        }
+        em.close();
+        theEmf.close();
+        logger.debug("getAllEntries: Exit, resultMap, size=" + resultMap.size());
+        return resultMap;
+    }
+
+    /**
+     * getIntegrityAuditEntities() Get all the IntegrityAuditEntities for a particular persistence
+     * unit and node type.
+     * 
+     * @param persistenceUnit the persistence unit
+     * @param nodeType the node type
+     * @return the list of IntegrityAuditEntity
+     * @throws DbDaoTransactionException if an error occurs
+     */
+    @SuppressWarnings("unchecked")
+    public List<IntegrityAuditEntity> getIntegrityAuditEntities(String persistenceUnit, String nodeType)
+            throws DbDaoTransactionException {
+        logger.debug("getIntegrityAuditEntities: Entering, persistenceUnit=" + persistenceUnit + ",\n nodeType= "
+                + nodeType);
+        try {
+            EntityManager em = emf.createEntityManager();
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not
+            // found, create a new entry
+            Query iaequery = em
+                    .createQuery("Select i from IntegrityAuditEntity i where i.persistenceUnit=:pu and i.nodeType=:nt");
+            iaequery.setParameter("pu", persistenceUnit);
+            iaequery.setParameter("nt", nodeType);
+
+            List<IntegrityAuditEntity> iaeList = iaequery.getResultList();
+
+            // commit transaction
+            et.commit();
+            em.close();
+            logger.debug("getIntegrityAuditEntities: Exit, iaeList=" + iaeList);
+            return iaeList;
+        } catch (Exception e) {
+            String msg = "DbDAO: " + "getIntegrityAuditEntities() " + "ecountered a problem in execution: ";
+            logger.error(msg, e);
+            throw new DbDaoTransactionException(e);
+        }
+
+    }
+
+    /**
+     * getMyIntegrityAuditEntity() gets my IntegrityAuditEntity.
+     * 
+     * @return the IntegrityAuditEntity
+     * @throws DbDaoTransactionException if an error occurs
+     */
+    public IntegrityAuditEntity getMyIntegrityAuditEntity() throws DbDaoTransactionException {
+        try {
+            EntityManager em = emf.createEntityManager();
+
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, retrieve it
+            Query iaequery = em.createQuery(
+                    "Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+            iaequery.setParameter("rn", this.resourceName);
+            iaequery.setParameter("pu", this.persistenceUnit);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae = null;
+
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+                // refresh the object from DB in case cached data was returned
+                em.refresh(iae);
+                logger.info("Resource: " + this.resourceName + " with PersistenceUnit: " + this.persistenceUnit
+                        + " exists");
+            } else {
+                // If it does not exist, log an error
+                logger.error("Attempting to setLastUpdated" + " on an entry that does not exist:" + " resource "
+                        + this.resourceName + " with PersistenceUnit: " + this.persistenceUnit);
+            }
+
+            // close the transaction
+            et.commit();
+            // close the EntityManager
+            em.close();
+
+            return iae;
+        } catch (Exception e) {
+            String msg = "DbDAO: " + "setLastUpdated() " + "ecountered a problem in execution: ";
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+    }
+
+
+    /**
+     * getIntegrityAuditEntity() gets the IntegrityAuditEntity with a particular ID.
+     * 
+     * @param id the ID
+     * @return the IntegrityAuditEntity
+     * @throws DbDaoTransactionException if an error occurs
+     */
+    public IntegrityAuditEntity getIntegrityAuditEntity(long id) throws DbDaoTransactionException {
+        try {
+            EntityManager em = emf.createEntityManager();
+
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            IntegrityAuditEntity iae = em.find(IntegrityAuditEntity.class, id);
+
+            et.commit();
+            em.close();
+
+            return iae;
+        } catch (Exception e) {
+            String msg = "DbDAO: " + "getIntegrityAuditEntity() " + "ecountered a problem in execution: ";
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+    }
+
+    /**
+     * getPersistenceClassNames() gets all the persistence class names.
+     * 
+     * @return the persistence class names
+     */
+    public Set<String> getPersistenceClassNames() {
+        logger.debug("DbDAO: getPersistenceClassNames() entry");
+        HashSet<String> returnList = new HashSet<>();
+        final Metamodel mm = emf.getMetamodel();
+        logger.debug("\n" + persistenceUnit + " persistence unit classes:");
+        for (final ManagedType<?> managedType : mm.getManagedTypes()) {
+            Class<?> clazz = managedType.getJavaType();
+            logger.debug("    " + clazz.getSimpleName());
+            returnList.add(clazz.getName()); // the full class name needed to make a query using jpa
+        }
+        logger.debug("DbDAO: getPersistenceClassNames() exit");
+        return returnList;
+    }
+
+    /**
+     * Register the IntegrityAudit instance.
+     * 
+     * @param altDbUrl alternate DB URL to be placed into the record, or {@code null} to use the
+     *        default
+     */
+    private void register(String altDbUrl) throws DbDaoTransactionException {
+        try {
+            EntityManager em = emf.createEntityManager();
+
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not
+            // found, create a new entry
+            Query iaequery = em.createQuery(
+                    "Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+            iaequery.setParameter("rn", this.resourceName);
+            iaequery.setParameter("pu", this.persistenceUnit);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae;
+
+            // If it already exists, we just want to update the properties and lastUpdated date
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+                // refresh the object from DB in case cached data was returned
+                em.refresh(iae);
+                logger.info("Resource: " + this.resourceName + " with PersistenceUnit: " + this.persistenceUnit
+                        + " exists and entry be updated");
+            } else {
+                // If it does not exist, we also must add teh resourceName, persistenceUnit and
+                // designated values
+                logger.info("Adding resource " + resourceName + " with PersistenceUnit: " + this.persistenceUnit
+                        + " to IntegrityAuditEntity table");
+                iae = new IntegrityAuditEntity();
+                iae.setResourceName(this.resourceName);
+                iae.setPersistenceUnit(this.persistenceUnit);
+                iae.setDesignated(false);
+            }
+            // update/set properties in entry
+            iae.setSite(this.siteName);
+            iae.setNodeType(this.nodeType);
+            iae.setJdbcDriver(this.dbDriver);
+            iae.setJdbcPassword(properties.getProperty(IntegrityAuditProperties.DB_PWD).trim());
+            iae.setJdbcUrl(altDbUrl == null ? this.dbUrl : altDbUrl);
+            iae.setJdbcUser(dbUser);
+
+            em.persist(iae);
+            // flush to the DB
+            em.flush();
+
+            // commit transaction
+            et.commit();
+            em.close();
+        } catch (Exception e) {
+            String msg = "DbDAO: " + "register() " + "encountered a problem in execution: ";
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+
+    }
+
+    public void setDesignated(boolean designated) throws DbDaoTransactionException {
+        setDesignated(this.resourceName, this.persistenceUnit, designated);
+    }
+
+    /**
+     * Set designated.
+     * 
+     * @param resourceName the resource name
+     * @param persistenceUnit the persistence unit
+     * @param desig true if is designated
+     * @throws DbDaoTransactionException if an error occurs
+     */
+    public void setDesignated(String resourceName, String persistenceUnit, boolean desig)
+            throws DbDaoTransactionException {
+        logger.debug("setDesignated: enter, resourceName: " + resourceName + ", persistenceUnit: " + persistenceUnit
+                + ", designated: " + desig);
+        try {
+
+            EntityManager em = emf.createEntityManager();
+
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not
+            // found, create a new entry
+            Query iaequery = em.createQuery(
+                    "Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+            iaequery.setParameter("rn", resourceName);
+            iaequery.setParameter("pu", persistenceUnit);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae;
+
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+                // refresh the object from DB in case cached data was returned
+                em.refresh(iae);
+                logger.info("Resource: " + resourceName + " with PersistenceUnit: " + persistenceUnit
+                        + " exists and designated be updated");
+                iae.setDesignated(desig);
+
+                em.persist(iae);
+                // flush to the DB
+                em.flush();
+            } else {
+                // If it does not exist, log an error
+                logger.error("Attempting to setDesignated(" + desig + ") on an entry that does not exist:"
+                        + " resource " + resourceName + " with PersistenceUnit: " + persistenceUnit);
+            }
+
+            // close the transaction
+            et.commit();
+            // close the EntityManager
+            em.close();
+        } catch (Exception e) {
+            String msg = "DbDAO: " + "setDesignated() " + "ecountered a problem in execution: ";
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+
+    }
+
+    /**
+     * Set last updated.
+     * 
+     * @throws DbDaoTransactionException if an error occurs
+     */
+    public void setLastUpdated() throws DbDaoTransactionException {
+        logger.debug("setLastUpdated: enter, resourceName: " + this.resourceName + ", persistenceUnit: "
+                + this.persistenceUnit);
+        try {
+            EntityManager em = emf.createEntityManager();
+
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not
+            // found, create a new entry
+            Query iaequery = em.createQuery(
+                    "Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+            iaequery.setParameter("rn", this.resourceName);
+            iaequery.setParameter("pu", this.persistenceUnit);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae;
+
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+                // refresh the object from DB in case cached data was returned
+                em.refresh(iae);
+                logger.info("Resource: " + this.resourceName + " with PersistenceUnit: " + this.persistenceUnit
+                        + " exists and lastUpdated be updated");
+                iae.setLastUpdated(new Date());
+
+                em.persist(iae);
+                // flush to the DB
+                em.flush();
+            } else {
+                // If it does not exist, log an error
+                logger.error("Attempting to setLastUpdated" + " on an entry that does not exist:" + " resource "
+                        + this.resourceName + " with PersistenceUnit: " + this.persistenceUnit);
+            }
+
+            // close the transaction
+            et.commit();
+            // close the EntityManager
+            em.close();
+        } catch (Exception e) {
+            String msg = "DbDAO: " + "setLastUpdated() " + "ecountered a problem in execution: ";
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+
+    }
+
+    /**
+     * Normally this method should only be used in a JUnit test environment. Manually deletes all
+     * PDP records in droolspdpentity table.
+     */
+    public int deleteAllIntegrityAuditEntities() throws DbDaoTransactionException {
+
+        try {
+
+            if (!IntegrityAudit.isUnitTesting()) {
+                String msg = "DbDAO: " + "deleteAllIntegrityAuditEntities() "
+                        + "should only be invoked during JUnit testing";
+                logger.error(msg);
+                throw new DbDaoTransactionException(msg);
+            }
+
+            EntityManager em = emf.createEntityManager();
+            // Start a transaction
+            EntityTransaction et = em.getTransaction();
+
+            et.begin();
+
+            // if IntegrityAuditEntity entry exists for resourceName and PU, update it. If not
+            // found, create a new entry
+            Query iaequery = em.createQuery("Delete from IntegrityAuditEntity");
+
+            int returnCode = iaequery.executeUpdate();
+
+            // commit transaction
+            et.commit();
+            em.close();
+
+            logger.info("deleteAllIntegrityAuditEntities: returnCode=" + returnCode);
+
+            return returnCode;
+
+        } catch (Exception e) {
+            String msg = "DbDAO: " + "deleteAllIntegrityAuditEntities() " + "encountered a problem in execution: ";
+            logger.error(msg + e);
+            throw new DbDaoTransactionException(e);
+        }
+
+    }
+
+    /**
+     * Changes designation to specified resourceName
+     * 
+     * <p>static lock object in conjunction with synchronized keyword ensures that designation
+     * changes are done serially within a resource. I.e. static lock ensures that multiple
+     * instantiations of DbDAO don't interleave changeDesignated() invocations and potentially
+     * produce simultaneous designations.
+     * 
+     * <p>Optimistic locking (the default, versus pessimistic) is sufficient to avoid simultaneous
+     * designations from interleaved changeDesignated() invocations from different resources
+     * (entities), because it prevents "dirty" and "non-repeatable" reads.
+     * 
+     * <p>See http://www.objectdb.com/api/java/jpa/LockModeType
+     * 
+     * <p>and
+     * 
+     * <p>http://stackoverflow.com/questions/2120248/how-to-synchronize-a-static-
+     * variable-among-threads-running-different-instances-o
+     */
+    public void changeDesignated(String resourceName, String persistenceUnit, String nodeType)
+            throws DbDaoTransactionException {
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("changeDesignated: Entering, resourceName=" + resourceName + ", persistenceUnit="
+                    + persistenceUnit + ", nodeType=" + nodeType);
+        }
+
+        long startTime = System.currentTimeMillis();
+
+        synchronized (lock) {
+
+            EntityManager em = null;
+            try {
+
+                em = emf.createEntityManager();
+                em.getTransaction().begin();
+
+                /*
+                 * Define query
+                 */
+                Query query = em.createQuery(
+                        "Select i from IntegrityAuditEntity i where i.persistenceUnit=:pu and i.nodeType=:nt");
+                query.setParameter("pu", persistenceUnit);
+                query.setParameter("nt", nodeType);
+
+                /*
+                 * Execute query using pessimistic write lock. This ensures that if anyone else is
+                 * currently reading the records we'll throw a LockTimeoutException.
+                 */
+                @SuppressWarnings("unchecked")
+                List<IntegrityAuditEntity> integrityAuditEntityList = query.getResultList();
+                for (Object o : integrityAuditEntityList) {
+                    if (o instanceof IntegrityAuditEntity) {
+                        IntegrityAuditEntity integrityAuditEntity = (IntegrityAuditEntity) o;
+                        if (integrityAuditEntity.getResourceName().equals(resourceName)) {
+                            if (logger.isDebugEnabled()) {
+                                logger.debug("changeDesignated: Designating resourceName="
+                                        + integrityAuditEntity.getResourceName());
+                            }
+                            integrityAuditEntity.setDesignated(true);
+                        } else {
+                            if (logger.isDebugEnabled()) {
+                                logger.debug("changeDesignated: Removing designation from resourceName="
+                                        + integrityAuditEntity.getResourceName());
+                            }
+                            integrityAuditEntity.setDesignated(false);
+                        }
+                    }
+                }
+
+                if (logger.isDebugEnabled()) {
+                    logger.debug("changeDesignated: Committing designation to resourceName=" + resourceName);
+                }
+                em.getTransaction().commit();
+
+                /*
+                 * If we get a LockTimeoutException, no harm done really. We'll probably be
+                 * successful on the next attempt. The odds of another DbDAO instance on this entity
+                 * or another entity attempting a simultaneous IntegrityAuditEntity table
+                 * read/update are pretty slim (we're only in this method for two or three
+                 * milliseconds)
+                 */
+            } catch (LockTimeoutException e) {
+                if (em != null) {
+                    em.getTransaction().rollback();
+
+                    String msg = "DbDAO: " + "changeDesignated() " + "caught LockTimeoutException, message="
+                            + e.getMessage();
+                    logger.error(msg + e);
+                    throw new DbDaoTransactionException(msg, e);
+                } else {
+                    String msg = "DbDAO: " + "changeDesignated() " + "caught LockTimeoutException, message="
+                            + e.getMessage() + ". Error rolling back transaction.";
+                    logger.error(msg + e);
+                    throw new DbDaoTransactionException(msg, e);
+                }
+            } catch (Exception e) {
+                if (em != null) {
+                    em.getTransaction().rollback();
+
+                    String msg = "DbDAO: " + "changeDesignated() " + "caught Exception, message=" + e.getMessage();
+                    logger.error(msg + e);
+                    throw new DbDaoTransactionException(msg, e);
+                } else {
+                    String msg = "DbDAO: " + "changeDesignated() " + "caught LockTimeoutException, message="
+                            + e.getMessage() + ". Error rolling back transaction.";
+                    logger.error(msg + e);
+                    throw new DbDaoTransactionException(msg, e);
+                }
+            }
+
+        } // end synchronized block
+
+        if (logger.isDebugEnabled()) {
+            logger.debug("changeDesignated: Exiting; time expended=" + (System.currentTimeMillis() - startTime) + "ms");
+        }
+
+    }
 
 
 }
diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDaoTransactionException.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDaoTransactionException.java
index 72716279..dc1c6f14 100644
--- a/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDaoTransactionException.java
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/DbDaoTransactionException.java
@@ -21,18 +21,21 @@
 package org.onap.policy.common.ia;
 
 public class DbDaoTransactionException extends IntegrityAuditException {
-	private static final long serialVersionUID = 1L;
-	public DbDaoTransactionException() {
-		super();
-	}
-	public DbDaoTransactionException(String message) {
-		super(message);
-	}
+    private static final long serialVersionUID = 1L;
 
-	public DbDaoTransactionException(Throwable cause) {
-		super(cause);
-	}
-	public DbDaoTransactionException(String message, Throwable cause) {
-		super(message, cause);
-	}
+    public DbDaoTransactionException() {
+        super();
+    }
+
+    public DbDaoTransactionException(String message) {
+        super(message);
+    }
+
+    public DbDaoTransactionException(Throwable cause) {
+        super(cause);
+    }
+
+    public DbDaoTransactionException(String message, Throwable cause) {
+        super(message, cause);
+    }
 }
diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAudit.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAudit.java
index cab08610..9abdbe52 100644
--- a/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAudit.java
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAudit.java
@@ -26,275 +26,277 @@ import java.util.concurrent.CountDownLatch;
 
 import org.onap.policy.common.ia.IntegrityAuditProperties.NodeTypeEnum;
 import org.onap.policy.common.logging.flexlogger.FlexLogger;
-import org.onap.policy.common.logging.flexlogger.Logger; 
+import org.onap.policy.common.logging.flexlogger.Logger;
 
 /**
- * class IntegrityAudit
- * Audits all persisted entities for all resource clusters for all sites and logs any anomalies.
+ * class IntegrityAudit Audits all persisted entities for all resource clusters for all sites and
+ * logs any anomalies.
  */
 public class IntegrityAudit {
-	
-	private static final Logger logger = FlexLogger.getLogger(IntegrityAudit.class);
-
-	private static boolean isUnitTesting;
-	private boolean isThreadInitialized = false; 
-	
-	AuditThread auditThread = null;
-		
-	private String persistenceUnit;
-	private Properties properties;
-	private String resourceName;
-	
-	
-	/*
-	 * This is the audit period in milliseconds. For example, if it had a value of 3600000, the audit
-	 * can only run once per hour.  If it has a value of 6000, it can run once per minute.
-	 * 
-	 * Values: 
-	 *    integrityAuditPeriodMillis < 0 (negative number) indicates the audit is off
-	 *    integrityAuditPeriodMillis == 0 indicates the audit is to run continuously
-	 *    integrityAuditPeriodMillis > 0 indicates the audit is to run at most once during the indicated period
-	 * 
-	 */
-	private int integrityAuditPeriodMillis;
-	
-	/**
-	 * IntegrityAudit constructor
-	 * @param resourceName
-	 * @param persistenceUnit
-	 * @param properties
-	 * @throws IntegrityAuditException
-	 */
-	public IntegrityAudit(String resourceName, String persistenceUnit, Properties properties) throws IntegrityAuditException {
-		
-		logger.info("Constructor: Entering and checking for nulls");
-		StringBuilder parmList = new StringBuilder();
-		if (parmsAreBad(resourceName, persistenceUnit, properties, parmList)) {
-			logger.error("Constructor: Parms contain nulls; cannot run audit for resourceName="
-					+ resourceName + ", persistenceUnit=" + persistenceUnit
-					+ ", bad parameters: " + parmList);
-			throw new IntegrityAuditException(
-					"Constructor: Parms contain nulls; cannot run audit for resourceName="
-							+ resourceName + ", persistenceUnit="
-							+ persistenceUnit
-							+ ", bad parameters: " + parmList);
-		}
-		
-		this.persistenceUnit = persistenceUnit;
-		this.properties = properties;
-		this.resourceName = resourceName;
-		
-		if(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS) != null){ //It is allowed to be null
-			this.integrityAuditPeriodMillis= 1000 * Integer.parseInt(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS).trim());
-		} else if(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS) != null){ //It is allowed to be null
-				this.integrityAuditPeriodMillis= Integer.parseInt(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS).trim());
-		} else{
-			//If it is null, set it to the default value
-			this.integrityAuditPeriodMillis = 1000 * IntegrityAuditProperties.DEFAULT_AUDIT_PERIOD_SECONDS;
-		}
-		logger.info("Constructor: Exiting");
-		
-	}
-	
-	/**
-	 * Used during JUnit testing by AuditPeriodTest.java
-	 */
-	public int getIntegrityAuditPeriodSeconds() {
-		return (integrityAuditPeriodMillis / 1000);
-	}
-
-	/**
-	 * Determine if the nodeType conforms to the required node types
-	 */
-	public static boolean isNodeTypeEnum(String nt) {
-		for (NodeTypeEnum n : NodeTypeEnum.values()) {
-			if (n.toString().equals(nt)) {
-				return true;
-			}
-		}
-		return false;
-	}
-	
-
-	/**
-	 * Makes sure we don't try to run the audit with bad parameters.
-	 */
-	public static boolean parmsAreBad(String resourceName, String persistenceUnit,
-			Properties properties, StringBuilder badparams) {
-
-		boolean parmsAreBad = false;
-		
-		if(resourceName == null || resourceName.isEmpty()){
-			badparams.append("resourceName ");
-			parmsAreBad = true;
-		}
-		
-		if(persistenceUnit == null || persistenceUnit.isEmpty()){
-			badparams.append("persistenceUnit ");
-			parmsAreBad = true;
-		}
-		
-		if(properties == null || properties.isEmpty()){
-			badparams.append("properties ");
-			parmsAreBad = true;
-		}
-		else{
-			String dbDriver = properties.getProperty(IntegrityAuditProperties.DB_DRIVER);
-			if(dbDriver == null || dbDriver.isEmpty()){
-				badparams.append("dbDriver ");
-				parmsAreBad = true;
-			}
-	
-			String dbUrl = properties.getProperty(IntegrityAuditProperties.DB_URL);
-			if(dbUrl == null || dbUrl.isEmpty()){
-				badparams.append("dbUrl ");
-				parmsAreBad = true;
-			}
-			
-			String dbUser = properties.getProperty(IntegrityAuditProperties.DB_USER);
-			if(dbUser == null || dbUser.isEmpty()){
-				badparams.append("dbUser ");
-				parmsAreBad = true;
-			}
-			
-			String dbPwd = properties.getProperty(IntegrityAuditProperties.DB_PWD);
-			if(dbPwd == null){ //may be empty
-				badparams.append("dbPwd ");
-				parmsAreBad = true;
-			}
-			
-			String siteName = properties.getProperty(IntegrityAuditProperties.SITE_NAME);
-			if(siteName == null || siteName.isEmpty()){
-				badparams.append("siteName ");
-				parmsAreBad = true;
-			}
-			
-			String nodeType = properties.getProperty(IntegrityAuditProperties.NODE_TYPE);
-			if(nodeType == null || nodeType.isEmpty()){
-				badparams.append("nodeType ");
-				parmsAreBad = true;
-			} else {
-				nodeType = nodeType.trim();
-				if (!isNodeTypeEnum(nodeType)) {
-					String nodetypes = "nodeType must be one of[";
-					for (NodeTypeEnum n : NodeTypeEnum.values()) {
-						nodetypes = nodetypes.concat(n.toString() + " ");
-					}
-					badparams.append(nodetypes + "] ");
-					parmsAreBad = true;
-				}
-			}
-			if(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS) != null){ //It is allowed to be null
-				try{
-					Integer.parseInt(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS).trim());
-				}catch(NumberFormatException nfe){
-					badparams.append(", auditPeriodSeconds=" 
-							+ properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS).trim());
-					parmsAreBad = true;
-				}
-			}
-			else if(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS) != null){ //It is allowed to be null
-				try{
-					Integer.parseInt(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS).trim());
-				}catch(NumberFormatException nfe){
-					badparams.append(", auditPeriodMilliSeconds=" 
-							+ properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS).trim());
-					parmsAreBad = true;
-				}
-			}
-		} // End else
-		logger.debug("parmsAreBad: exit:" 
-				+ "\nresourceName: " + resourceName
-				+ "\npersistenceUnit: " + persistenceUnit
-				+ "\nproperties: " + properties);
-		
-		return parmsAreBad;
-	}	
-	/**
-	 * Starts the audit thread
-	 * @throws IntegrityAuditException
-	 */
-	public void startAuditThread() throws IntegrityAuditException {
-		startAuditThread(null);
-	}
-	/**
-	 * Starts the audit thread
-	 * @param queue 
-	 * @return {@code true} if the thread was started, {@code false} otherwise
-	 * @throws IntegrityAuditException
-	 */
-	protected boolean startAuditThread(BlockingQueue<CountDownLatch> queue) throws IntegrityAuditException {
-
-		logger.info("startAuditThread: Entering");
-		
-		boolean success = false;
-		
-		if (integrityAuditPeriodMillis >= 0) {
-			this.auditThread = new AuditThread(this.resourceName,
-					this.persistenceUnit, this.properties,
-					integrityAuditPeriodMillis, this, queue);
-			logger.info("startAuditThread: Audit started and will run every "
-					+ integrityAuditPeriodMillis/1000 + " seconds");
-			this.auditThread.start();
-			success = true;
-		} else {
-			logger.info("startAuditThread: Suppressing integrity audit, integrityAuditPeriodSeconds="
-					+ integrityAuditPeriodMillis/1000);
-		}
-
-		logger.info("startAuditThread: Exiting");
-		
-		return success;
-	}
-	/**
-	 * Stops the audit thread
-	 */
-	public void stopAuditThread() {
-
-		logger.info("stopAuditThread: Entering");
-		
-		if (this.auditThread != null) {
-			this.auditThread.interrupt();
-		} else {
-			logger.info("stopAuditThread: auditThread never instantiated; no need to interrupt");
-		}
-		
-		logger.info("stopAuditThread: Exiting");
-	}
-
-	public boolean isThreadInitialized() {
-		return isThreadInitialized;
-	}
-
-	public void setThreadInitialized(boolean isThreadInitialized) {
-		logger.info("setThreadInitialized: Setting isThreadInitialized=" + isThreadInitialized);
-		this.isThreadInitialized = isThreadInitialized;
-	}
-
-	public static boolean isUnitTesting() {
-		return isUnitTesting;
-	}
-
-	public static void setUnitTesting(boolean isUnitTesting) {
-		IntegrityAudit.isUnitTesting = isUnitTesting;
-	}
-
-	/**
-	 * Waits a bit for the AuditThread to complete. Used by JUnit tests.
-	 * 
-	 * @param twaitms
-	 *            wait time, in milliseconds
-	 * @return {@code true} if the thread stopped within the given time,
-	 *         {@code false} otherwise
-	 * @throws InterruptedException
-	 */
-	protected boolean joinAuditThread(long twaitms) throws InterruptedException {
-		if(this.auditThread == null) {
-			return true;
-			
-		} else {
-			this.auditThread.join(twaitms);
-			return ! this.auditThread.isAlive();
-		}
-	}
+
+    private static final Logger logger = FlexLogger.getLogger(IntegrityAudit.class);
+
+    private static boolean isUnitTesting;
+    private boolean isThreadInitialized = false;
+
+    AuditThread auditThread = null;
+
+    private String persistenceUnit;
+    private Properties properties;
+    private String resourceName;
+
+
+    /*
+     * This is the audit period in milliseconds. For example, if it had a value of 3600000, the
+     * audit can only run once per hour. If it has a value of 6000, it can run once per minute.
+     * 
+     * Values: integrityAuditPeriodMillis < 0 (negative number) indicates the audit is off
+     * integrityAuditPeriodMillis == 0 indicates the audit is to run continuously
+     * integrityAuditPeriodMillis > 0 indicates the audit is to run at most once during the
+     * indicated period
+     * 
+     */
+    private int integrityAuditPeriodMillis;
+
+    /**
+     * IntegrityAudit constructor.
+     * 
+     * @param resourceName the resource name
+     * @param persistenceUnit the persistence unit
+     * @param properties the properties
+     * @throws IntegrityAuditException if an error occurs
+     */
+    public IntegrityAudit(String resourceName, String persistenceUnit, Properties properties)
+            throws IntegrityAuditException {
+
+        logger.info("Constructor: Entering and checking for nulls");
+        StringBuilder parmList = new StringBuilder();
+        if (parmsAreBad(resourceName, persistenceUnit, properties, parmList)) {
+            logger.error("Constructor: Parms contain nulls; cannot run audit for resourceName=" + resourceName
+                    + ", persistenceUnit=" + persistenceUnit + ", bad parameters: " + parmList);
+            throw new IntegrityAuditException("Constructor: Parms contain nulls; cannot run audit for resourceName="
+                    + resourceName + ", persistenceUnit=" + persistenceUnit + ", bad parameters: " + parmList);
+        }
+
+        this.persistenceUnit = persistenceUnit;
+        this.properties = properties;
+        this.resourceName = resourceName;
+
+        // IntegrityAuditProperties.AUDIT_PERIOD_SECONDS and
+        // IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS are allowed to be null
+        if (properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS) != null) {
+            this.integrityAuditPeriodMillis = 1000
+                    * Integer.parseInt(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS).trim());
+        } else if (properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS) != null) {
+            this.integrityAuditPeriodMillis =
+                    Integer.parseInt(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS).trim());
+        } else {
+            // If it is null, set it to the default value
+            this.integrityAuditPeriodMillis = 1000 * IntegrityAuditProperties.DEFAULT_AUDIT_PERIOD_SECONDS;
+        }
+        logger.info("Constructor: Exiting");
+
+    }
+
+    /**
+     * Used during JUnit testing by AuditPeriodTest.java
+     */
+    public int getIntegrityAuditPeriodSeconds() {
+        return (integrityAuditPeriodMillis / 1000);
+    }
+
+    /**
+     * Determine if the nodeType conforms to the required node types.
+     */
+    public static boolean isNodeTypeEnum(String nt) {
+        for (NodeTypeEnum n : NodeTypeEnum.values()) {
+            if (n.toString().equals(nt)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
+    /**
+     * Makes sure we don't try to run the audit with bad parameters.
+     */
+    public static boolean parmsAreBad(String resourceName, String persistenceUnit, Properties properties,
+            StringBuilder badparams) {
+
+        boolean parmsAreBad = false;
+
+        if (resourceName == null || resourceName.isEmpty()) {
+            badparams.append("resourceName ");
+            parmsAreBad = true;
+        }
+
+        if (persistenceUnit == null || persistenceUnit.isEmpty()) {
+            badparams.append("persistenceUnit ");
+            parmsAreBad = true;
+        }
+
+        if (properties == null || properties.isEmpty()) {
+            badparams.append("properties ");
+            parmsAreBad = true;
+        } else {
+            String dbDriver = properties.getProperty(IntegrityAuditProperties.DB_DRIVER);
+            if (dbDriver == null || dbDriver.isEmpty()) {
+                badparams.append("dbDriver ");
+                parmsAreBad = true;
+            }
+
+            String dbUrl = properties.getProperty(IntegrityAuditProperties.DB_URL);
+            if (dbUrl == null || dbUrl.isEmpty()) {
+                badparams.append("dbUrl ");
+                parmsAreBad = true;
+            }
+
+            String dbUser = properties.getProperty(IntegrityAuditProperties.DB_USER);
+            if (dbUser == null || dbUser.isEmpty()) {
+                badparams.append("dbUser ");
+                parmsAreBad = true;
+            }
+
+            String dbPwd = properties.getProperty(IntegrityAuditProperties.DB_PWD);
+            if (dbPwd == null) { // may be empty
+                badparams.append("dbPwd ");
+                parmsAreBad = true;
+            }
+
+            String siteName = properties.getProperty(IntegrityAuditProperties.SITE_NAME);
+            if (siteName == null || siteName.isEmpty()) {
+                badparams.append("siteName ");
+                parmsAreBad = true;
+            }
+
+            String nodeType = properties.getProperty(IntegrityAuditProperties.NODE_TYPE);
+            if (nodeType == null || nodeType.isEmpty()) {
+                badparams.append("nodeType ");
+                parmsAreBad = true;
+            } else {
+                nodeType = nodeType.trim();
+                if (!isNodeTypeEnum(nodeType)) {
+                    String nodetypes = "nodeType must be one of[";
+                    for (NodeTypeEnum n : NodeTypeEnum.values()) {
+                        nodetypes = nodetypes.concat(n.toString() + " ");
+                    }
+                    badparams.append(nodetypes + "] ");
+                    parmsAreBad = true;
+                }
+            }
+            // IntegrityAuditProperties.AUDIT_PERIOD_SECONDS and
+            // IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS are allowed to be null
+            if (properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS) != null) {
+                try {
+                    Integer.parseInt(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS).trim());
+                } catch (NumberFormatException nfe) {
+                    badparams.append(", auditPeriodSeconds="
+                            + properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS).trim());
+                    parmsAreBad = true;
+                }
+            } else if (properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS) != null) {
+                try {
+                    Integer.parseInt(properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS).trim());
+                } catch (NumberFormatException nfe) {
+                    badparams.append(", auditPeriodMilliSeconds="
+                            + properties.getProperty(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS).trim());
+                    parmsAreBad = true;
+                }
+            }
+        } // End else
+        logger.debug("parmsAreBad: exit:" + "\nresourceName: " + resourceName + "\npersistenceUnit: " + persistenceUnit
+                + "\nproperties: " + properties);
+
+        return parmsAreBad;
+    }
+
+    /**
+     * Starts the audit thread.
+     * 
+     * @throws IntegrityAuditException if an error occurs
+     */
+    public void startAuditThread() throws IntegrityAuditException {
+        startAuditThread(null);
+    }
+
+    /**
+     * Starts the audit thread.
+     * 
+     * @param queue the queue
+     * @return {@code true} if the thread was started, {@code false} otherwise
+     * @throws IntegrityAuditException if an error occurs
+     */
+    protected boolean startAuditThread(BlockingQueue<CountDownLatch> queue) throws IntegrityAuditException {
+
+        logger.info("startAuditThread: Entering");
+
+        boolean success = false;
+
+        if (integrityAuditPeriodMillis >= 0) {
+            this.auditThread = new AuditThread(this.resourceName, this.persistenceUnit, this.properties,
+                    integrityAuditPeriodMillis, this, queue);
+            logger.info("startAuditThread: Audit started and will run every " + integrityAuditPeriodMillis / 1000
+                    + " seconds");
+            this.auditThread.start();
+            success = true;
+        } else {
+            logger.info("startAuditThread: Suppressing integrity audit, integrityAuditPeriodSeconds="
+                    + integrityAuditPeriodMillis / 1000);
+        }
+
+        logger.info("startAuditThread: Exiting");
+
+        return success;
+    }
+
+    /**
+     * Stops the audit thread.
+     */
+    public void stopAuditThread() {
+
+        logger.info("stopAuditThread: Entering");
+
+        if (this.auditThread != null) {
+            this.auditThread.interrupt();
+        } else {
+            logger.info("stopAuditThread: auditThread never instantiated; no need to interrupt");
+        }
+
+        logger.info("stopAuditThread: Exiting");
+    }
+
+    public boolean isThreadInitialized() {
+        return isThreadInitialized;
+    }
+
+    public void setThreadInitialized(boolean isThreadInitialized) {
+        logger.info("setThreadInitialized: Setting isThreadInitialized=" + isThreadInitialized);
+        this.isThreadInitialized = isThreadInitialized;
+    }
+
+    public static boolean isUnitTesting() {
+        return isUnitTesting;
+    }
+
+    public static void setUnitTesting(boolean isUnitTesting) {
+        IntegrityAudit.isUnitTesting = isUnitTesting;
+    }
+
+    /**
+     * Waits a bit for the AuditThread to complete. Used by JUnit tests.
+     * 
+     * @param twaitms wait time, in milliseconds
+     * @return {@code true} if the thread stopped within the given time, {@code false} otherwise
+     * @throws InterruptedException if the thread is interrupted
+     */
+    protected boolean joinAuditThread(long twaitms) throws InterruptedException {
+        if (this.auditThread == null) {
+            return true;
+
+        } else {
+            this.auditThread.join(twaitms);
+            return !this.auditThread.isAlive();
+        }
+    }
 }
diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditException.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditException.java
index a62c837c..81e8b90c 100644
--- a/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditException.java
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditException.java
@@ -2,7 +2,7 @@
  * ============LICENSE_START=======================================================
  * Integrity Audit
  * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
  * ================================================================================
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,19 +20,22 @@
 
 package org.onap.policy.common.ia;
 
-public class IntegrityAuditException extends Exception{
-	private static final long serialVersionUID = 1L;
-	public IntegrityAuditException() {
-		super();
-	}
-	public IntegrityAuditException(String message) {
-		super(message);
-	}
+public class IntegrityAuditException extends Exception {
+    private static final long serialVersionUID = 1L;
 
-	public IntegrityAuditException(Throwable cause) {
-		super(cause);
-	}
-	public IntegrityAuditException(String message, Throwable cause) {
-		super(message, cause);
-	}
+    public IntegrityAuditException() {
+        super();
+    }
+
+    public IntegrityAuditException(String message) {
+        super(message);
+    }
+
+    public IntegrityAuditException(Throwable cause) {
+        super(cause);
+    }
+
+    public IntegrityAuditException(String message, Throwable cause) {
+        super(message, cause);
+    }
 }
diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditProperties.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditProperties.java
index b8db3ac2..2708c090 100644
--- a/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditProperties.java
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditProperties.java
@@ -22,34 +22,26 @@ package org.onap.policy.common.ia;
 
 public class IntegrityAuditProperties {
 
-	public static final int DEFAULT_AUDIT_PERIOD_SECONDS = -1; // Audit does not run
-	
-	public static final String DB_DRIVER = "javax.persistence.jdbc.driver";
-	public static final String DB_URL = "javax.persistence.jdbc.url";
-	public static final String DB_USER = "javax.persistence.jdbc.user";
-	public static final String DB_PWD = "javax.persistence.jdbc.password";
-	public static final String AUDIT_PERIOD_SECONDS = "integrity_audit_period_seconds";
-	public static final String AUDIT_PERIOD_MILLISECONDS = "integrity_audit_period_milliseconds";
-	
-	
-	public static final String SITE_NAME = "site_name";
-	public static final String NODE_TYPE = "node_type";
-	
-	public enum NodeTypeEnum {
-		pdp_xacml,
-		pdp_drools,
-		pap,
-		pap_admin,
-		logparser,
-		brms_gateway,
-		astra_gateway,
-		elk_server,
-		pypdp
-
-	}
-	
-	private IntegrityAuditProperties() {
-		
-	}
-	
+    public static final int DEFAULT_AUDIT_PERIOD_SECONDS = -1; // Audit does not run
+
+    public static final String DB_DRIVER = "javax.persistence.jdbc.driver";
+    public static final String DB_URL = "javax.persistence.jdbc.url";
+    public static final String DB_USER = "javax.persistence.jdbc.user";
+    public static final String DB_PWD = "javax.persistence.jdbc.password";
+    public static final String AUDIT_PERIOD_SECONDS = "integrity_audit_period_seconds";
+    public static final String AUDIT_PERIOD_MILLISECONDS = "integrity_audit_period_milliseconds";
+
+
+    public static final String SITE_NAME = "site_name";
+    public static final String NODE_TYPE = "node_type";
+
+    public enum NodeTypeEnum {
+        pdp_xacml, pdp_drools, pap, pap_admin, logparser, brms_gateway, astra_gateway, elk_server, pypdp
+
+    }
+
+    private IntegrityAuditProperties() {
+
+    }
+
 }
diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditPropertiesException.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditPropertiesException.java
index 766268bc..d3c92fa5 100644
--- a/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditPropertiesException.java
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/IntegrityAuditPropertiesException.java
@@ -21,18 +21,21 @@
 package org.onap.policy.common.ia;
 
 public class IntegrityAuditPropertiesException extends IntegrityAuditException {
-	private static final long serialVersionUID = 1L;
-	public IntegrityAuditPropertiesException() {
-		super();
-	}
-	public IntegrityAuditPropertiesException(String message) {
-		super(message);
-	}
+    private static final long serialVersionUID = 1L;
 
-	public IntegrityAuditPropertiesException(Throwable cause) {
-		super(cause);
-	}
-	public IntegrityAuditPropertiesException(String message, Throwable cause) {
-		super(message, cause);
-	}
+    public IntegrityAuditPropertiesException() {
+        super();
+    }
+
+    public IntegrityAuditPropertiesException(String message) {
+        super(message);
+    }
+
+    public IntegrityAuditPropertiesException(Throwable cause) {
+        super(cause);
+    }
+
+    public IntegrityAuditPropertiesException(String message, Throwable cause) {
+        super(message, cause);
+    }
 }
diff --git a/integrity-audit/src/main/java/org/onap/policy/common/ia/jpa/IntegrityAuditEntity.java b/integrity-audit/src/main/java/org/onap/policy/common/ia/jpa/IntegrityAuditEntity.java
index da69f2de..23b90efc 100644
--- a/integrity-audit/src/main/java/org/onap/policy/common/ia/jpa/IntegrityAuditEntity.java
+++ b/integrity-audit/src/main/java/org/onap/policy/common/ia/jpa/IntegrityAuditEntity.java
@@ -42,184 +42,185 @@ import javax.persistence.TemporalType;
  */
 
 @Entity
-@Table(name="IntegrityAuditEntity")
-@NamedQueries({
-	@NamedQuery(name=" IntegrityAuditEntity.findAll", query="SELECT e FROM IntegrityAuditEntity e "),
-	@NamedQuery(name="IntegrityAuditEntity.deleteAll", query="DELETE FROM IntegrityAuditEntity WHERE 1=1")
-})
+@Table(name = "IntegrityAuditEntity")
+@NamedQueries({@NamedQuery(name = " IntegrityAuditEntity.findAll", query = "SELECT e FROM IntegrityAuditEntity e "),
+        @NamedQuery(name = "IntegrityAuditEntity.deleteAll", query = "DELETE FROM IntegrityAuditEntity WHERE 1=1")})
 
 public class IntegrityAuditEntity implements Serializable {
-	private static final long serialVersionUID = 1L;
-
-	private static boolean isUnitTesting;
-	
-	@Id
-	@GeneratedValue(strategy = GenerationType.AUTO)
-	@Column(name="id")
-	private long id;
-	
-	@Column(name="persistenceUnit", nullable=false)
-	private String persistenceUnit;
-	
-	@Column(name="site", nullable=true)
-	private String site;
-	
-	@Column(name="nodeType", nullable=true)
-	private String nodeType;
-	
-	@Column(name="resourceName", nullable=false, unique=true)
-	private String resourceName;
-	
-	@Column(name="designated", nullable=true)
-	private boolean designated = false;
-
-	@Column(name="jdbcDriver", nullable=false)
-	private String jdbcDriver;
-	
-	@Column(name="jdbcUrl", nullable=false)
-	private String jdbcUrl;
-	
-	@Column(name="jdbcUser", nullable=false)
-	private String jdbcUser;
-	
-	@Column(name="jdbcPassword", nullable=false)
-	private String jdbcPassword;
-	
-	@Temporal(TemporalType.TIMESTAMP)
-	@Column(name="createdDate", updatable=true)
-	private Date createdDate;
-	
-	@Temporal(TemporalType.TIMESTAMP)
-	@Column(name="lastUpdated")
-	private Date lastUpdated;
-
-	
-	public IntegrityAuditEntity() {
-		// Empty constructor
-	}
-
-	@PrePersist
-	public void	prePersist() {
-		Date date = new Date();
-		this.createdDate = date;
-		this.lastUpdated = date;
-	}
-	
-	@PreUpdate
-	public void preUpdate() {
-		this.lastUpdated = new Date();
-	}
-
-	public long getId() {
-		return id;
-	}
-
-	public String getPersistenceUnit() {
-		return persistenceUnit;
-	}
-
-	public void setPersistenceUnit(String persistenceUnit) {
-		this.persistenceUnit = persistenceUnit;
-	}
-
-	public String getSite() {
-		return site;
-	}
-
-	public void setSite(String site) {
-		this.site = site;
-	}
-
-	public String getNodeType() {
-		return nodeType;
-	}
-
-	public void setNodeType(String nodeType) {
-		this.nodeType = nodeType;
-	}
-
-	public String getResourceName() {
-		return resourceName;
-	}
-
-	public void setResourceName(String resourceName) {
-		this.resourceName = resourceName;
-	}
-
-	public boolean isDesignated() {
-		return designated;
-	}
-
-	public void setDesignated(boolean designated) {
-		this.designated = designated;
-	}
-
-	public String getJdbcDriver() {
-		return jdbcDriver;
-	}
-
-	public void setJdbcDriver(String jdbcDriver) {
-		this.jdbcDriver = jdbcDriver;
-	}
-
-	public String getJdbcUrl() {
-		return jdbcUrl;
-	}
-
-	public void setJdbcUrl(String jdbcUrl) {
-		this.jdbcUrl = jdbcUrl;
-	}
-
-	public String getJdbcUser() {
-		return jdbcUser;
-	}
-
-	public void setJdbcUser(String jdbcUser) {
-		this.jdbcUser = jdbcUser;
-	}
-
-	public String getJdbcPassword() {
-		return jdbcPassword;
-	}
-
-	public void setJdbcPassword(String jdbcPassword) {
-		this.jdbcPassword = jdbcPassword;
-	}
-
-	public Date getLastUpdated() {
-		return lastUpdated;
-	}
-
-	public void setLastUpdated(Date lastUpdated) {
-		this.lastUpdated = lastUpdated;
-	}
-
-	public Date getCreatedDate() {
-		return createdDate;
-	}
-	
-	public void setCreatedDate(Date created) {
-		this.createdDate = created;
-	}
-
-	public static boolean isUnitTesting() {
-		return isUnitTesting;
-	}
-
-	public static void setUnitTesting(boolean isUnitTesting) {
-		IntegrityAuditEntity.isUnitTesting = isUnitTesting;
-	}
-
-	private void writeObject(ObjectOutputStream out) throws IOException {
-		if(isUnitTesting()) {
-			/*
-			 * Note: other fields may be added here, as long as the
-			 * created-date and last-updated date are not included.
-			 */
-			out.writeObject(jdbcUrl);
-			
-		} else {
-			out.defaultWriteObject();
-		}
-	}
+    private static final long serialVersionUID = 1L;
+
+    private static boolean isUnitTesting;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(name = "id")
+    private long id;
+
+    @Column(name = "persistenceUnit", nullable = false)
+    private String persistenceUnit;
+
+    @Column(name = "site", nullable = true)
+    private String site;
+
+    @Column(name = "nodeType", nullable = true)
+    private String nodeType;
+
+    @Column(name = "resourceName", nullable = false, unique = true)
+    private String resourceName;
+
+    @Column(name = "designated", nullable = true)
+    private boolean designated = false;
+
+    @Column(name = "jdbcDriver", nullable = false)
+    private String jdbcDriver;
+
+    @Column(name = "jdbcUrl", nullable = false)
+    private String jdbcUrl;
+
+    @Column(name = "jdbcUser", nullable = false)
+    private String jdbcUser;
+
+    @Column(name = "jdbcPassword", nullable = false)
+    private String jdbcPassword;
+
+    @Temporal(TemporalType.TIMESTAMP)
+    @Column(name = "createdDate", updatable = true)
+    private Date createdDate;
+
+    @Temporal(TemporalType.TIMESTAMP)
+    @Column(name = "lastUpdated")
+    private Date lastUpdated;
+
+
+    public IntegrityAuditEntity() {
+        // Empty constructor
+    }
+
+    /**
+     * Pre persist.
+     */
+    @PrePersist
+    public void prePersist() {
+        Date date = new Date();
+        this.createdDate = date;
+        this.lastUpdated = date;
+    }
+
+    @PreUpdate
+    public void preUpdate() {
+        this.lastUpdated = new Date();
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    public String getPersistenceUnit() {
+        return persistenceUnit;
+    }
+
+    public void setPersistenceUnit(String persistenceUnit) {
+        this.persistenceUnit = persistenceUnit;
+    }
+
+    public String getSite() {
+        return site;
+    }
+
+    public void setSite(String site) {
+        this.site = site;
+    }
+
+    public String getNodeType() {
+        return nodeType;
+    }
+
+    public void setNodeType(String nodeType) {
+        this.nodeType = nodeType;
+    }
+
+    public String getResourceName() {
+        return resourceName;
+    }
+
+    public void setResourceName(String resourceName) {
+        this.resourceName = resourceName;
+    }
+
+    public boolean isDesignated() {
+        return designated;
+    }
+
+    public void setDesignated(boolean designated) {
+        this.designated = designated;
+    }
+
+    public String getJdbcDriver() {
+        return jdbcDriver;
+    }
+
+    public void setJdbcDriver(String jdbcDriver) {
+        this.jdbcDriver = jdbcDriver;
+    }
+
+    public String getJdbcUrl() {
+        return jdbcUrl;
+    }
+
+    public void setJdbcUrl(String jdbcUrl) {
+        this.jdbcUrl = jdbcUrl;
+    }
+
+    public String getJdbcUser() {
+        return jdbcUser;
+    }
+
+    public void setJdbcUser(String jdbcUser) {
+        this.jdbcUser = jdbcUser;
+    }
+
+    public String getJdbcPassword() {
+        return jdbcPassword;
+    }
+
+    public void setJdbcPassword(String jdbcPassword) {
+        this.jdbcPassword = jdbcPassword;
+    }
+
+    public Date getLastUpdated() {
+        return lastUpdated;
+    }
+
+    public void setLastUpdated(Date lastUpdated) {
+        this.lastUpdated = lastUpdated;
+    }
+
+    public Date getCreatedDate() {
+        return createdDate;
+    }
+
+    public void setCreatedDate(Date created) {
+        this.createdDate = created;
+    }
+
+    public static boolean isUnitTesting() {
+        return isUnitTesting;
+    }
+
+    public static void setUnitTesting(boolean isUnitTesting) {
+        IntegrityAuditEntity.isUnitTesting = isUnitTesting;
+    }
+
+    private void writeObject(ObjectOutputStream out) throws IOException {
+        if (isUnitTesting()) {
+            /*
+             * Note: other fields may be added here, as long as the created-date and last-updated
+             * date are not included.
+             */
+            out.writeObject(jdbcUrl);
+
+        } else {
+            out.defaultWriteObject();
+        }
+    }
 }
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/AuditPeriodTest.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/AuditPeriodTest.java
index b627977b..232468d6 100644
--- a/integrity-audit/src/test/java/org/onap/policy/common/ia/AuditPeriodTest.java
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/AuditPeriodTest.java
@@ -44,217 +44,222 @@ import org.onap.policy.common.utils.test.log.logback.ExtractAppender;
  */
 public class AuditPeriodTest extends IntegrityAuditTestBase {
 
-	private static Logger logger = FlexLogger.getLogger(AuditPeriodTest.class);
+    private static Logger logger = FlexLogger.getLogger(AuditPeriodTest.class);
 
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		IntegrityAuditTestBase.setUpBeforeClass(DEFAULT_DB_URL_PREFIX + AuditPeriodTest.class.getSimpleName());
-	}
+    @BeforeClass
+    public static void setUpBeforeClass() throws Exception {
+        IntegrityAuditTestBase.setUpBeforeClass(DEFAULT_DB_URL_PREFIX + AuditPeriodTest.class.getSimpleName());
+    }
 
-	@AfterClass
-	public static void tearDownAfterClass() {
-		IntegrityAuditTestBase.tearDownAfterClass();
-	}
+    @AfterClass
+    public static void tearDownAfterClass() {
+        IntegrityAuditTestBase.tearDownAfterClass();
+    }
 
-	@Before
-	public void setUp() {
-		logger.info("setUp: Entering");
+    /**
+     * Set up for test case.
+     */
+    @Override
+    @Before
+    public void setUp() {
+        logger.info("setUp: Entering");
 
-		super.setUp();
+        super.setUp();
 
-		logger.info("setUp: Exiting");
+        logger.info("setUp: Exiting");
 
-	}
+    }
 
-	@After
-	public void tearDown() {
-		logger.info("tearDown: Entering");
+    /**
+     * Tear down after test cases.
+     */
+    @Override
+    @After
+    public void tearDown() {
+        logger.info("tearDown: Entering");
 
-		super.tearDown();
+        super.tearDown();
 
-		logger.info("tearDown: Exiting");
-	}
+        logger.info("tearDown: Exiting");
+    }
 
-	/*
-	 * Verifies (via log parsing) that when a negative audit period is
-	 * specified, the audit is suppressed.
-	 */
-	@Test
-	public void testNegativeAuditPeriod() throws Exception {
+    /*
+     * Verifies (via log parsing) that when a negative audit period is specified, the audit is
+     * suppressed.
+     */
+    @Test
+    public void testNegativeAuditPeriod() throws Exception {
 
-		logger.info("testNegativeAuditPeriod: Entering");
+        logger.info("testNegativeAuditPeriod: Entering");
 
-		properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "-1");
+        properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "-1");
 
-		ExtractAppender logA = watch(debugLogger, "Suppressing integrity audit, integrityAuditPeriodSeconds=([^,]*)");
+        ExtractAppender logA = watch(debugLogger, "Suppressing integrity audit, integrityAuditPeriodSeconds=([^,]*)");
 
-		MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
+        MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
 
-		/*
-		 * Sleep long enough to allow
-		 * 
-		 * 1) audit to immediately terminate.
-		 */
-		waitThread(integrityAudit);
+        /*
+         * Sleep long enough to allow
+         * 
+         * 1) audit to immediately terminate.
+         */
+        waitThread(integrityAudit);
 
-		verifyItemsInLog(logA, "-1");
+        verifyItemsInLog(logA, "-1");
 
-		logger.info("testNegativeAuditPeriod: Exiting");
-
-	}
-
-	/*
-	 * Verifies (via log parsing) that when an audit period of zero is
-	 * specified, the audit runs continuously, generating a number of sleep/wake
-	 * sequences in a short period of time (e.g. 100ms).
-	 */
-	@Test
-	public void testZeroAuditPeriod() throws Exception {
-
-		logger.info("testZeroAuditPeriod: Entering");
-
-		properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "0");
-
-		ExtractAppender logA = watch(debugLogger, "[Aa]waking from (0ms) sleep");
-
-		MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
-
-		/*
-		 * Wait for
-		 * 
-		 * 1) audit to generate a bunch of sleep wake sequences.
-		 */
-		String[] awakings = new String[10];
-		for (int x = 0; x < awakings.length; ++x) {
-			awakings[x] = "0ms";
-			runAudit(integrityAudit);
-		}
-
-		// run a couple more audits
-		runAudit(integrityAudit);
-		runAudit(integrityAudit);
-
-		/*
-		 * We should get at least 10 sleep/wake sequences.
-		 */
-
-		verifyItemsInLog(logA, awakings);
-
-		logger.info("testZeroAuditPeriod: Exiting");
-
-	}
-
-	/**
-	 * Verifies that when different audit periods are specified, there is an
-	 * appropriate interval between the audits.
-	 */
-	@Test
-	public void testLongAuditPeriod() throws Exception {
-
-		logger.info("testLongAuditPeriod: Entering");
-
-		testAuditPeriod(100);
-		testAuditPeriod(200);
-
-		logger.info("testLongAuditPeriod: Exiting");
-	}
-
-	/**
-	 * Verifies that audits actually take as long as expected, even with
-	 * multiple auditors running simultaneously.
-	 * 
-	 * @param periodms
-	 *            audit period, in milliseconds
-	 * @throws Exception
-	 * @throws InterruptedException
-	 */
-	private void testAuditPeriod(long periodms) throws Exception, InterruptedException {
-
-		properties.put(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS, String.valueOf(periodms));
-
-		/*
-		 * Start several auditors.
-		 */
-		MyIntegrityAudit[] ia = new MyIntegrityAudit[3];
-		for (int x = 0; x < ia.length; ++x) {
-			ia[x] = makeAuditor("pdp" + x, A_SEQ_PU);
-		}
-
-		/*
-		 * Run an audit on all of them.
-		 */
-		runAudit(ia);
-
-		/*
-		 * Now run again and ensure it waited long enough between runs.
-		 */
-		long tmin = minAuditTime(ia);
-		assertTrue(tmin >= periodms + AUDIT_SIMULATION_MS);
-
-		/*
-		 * Now run again and ensure it waited long enough between runs.
-		 */
-		tmin = minAuditTime(ia);
-		assertTrue(tmin >= periodms + AUDIT_SIMULATION_MS);
-	}
-
-	/**
-	 * Runs simultaneous audits on several auditors.
-	 * 
-	 * @param auditors
-	 * @return the minimum time, in milliseconds, elapsed for any given auditor
-	 * @throws InterruptedException
-	 */
-	private long minAuditTime(MyIntegrityAudit... auditors) throws InterruptedException {
-		List<Thread> threads = new ArrayList<>(auditors.length);
-		AtomicLong tfirst = new AtomicLong(Long.MAX_VALUE);
-		long tbeg = System.currentTimeMillis();
-
-		// create the threads
-		for (MyIntegrityAudit p : auditors) {
-			Thread t = new Thread() {
-
-				@Override
-				public void run() {
-					try {
-						runAudit(p);
-						setMinTime(tfirst);
-
-					} catch (InterruptedException e) {
-						;
-					}
-				}
-			};
-
-			t.setDaemon(true);
-			threads.add(t);
-		}
-
-		// start the threads
-		for (Thread t : threads) {
-			t.start();
-		}
-
-		// wait for them to complete
-		for (Thread t : threads) {
-			t.join();
-		}
-
-		return (tfirst.get() - tbeg);
-	}
-
-	/**
-	 * Sets a value to the minimum between the current value and the current
-	 * time.
-	 * 
-	 * @param tmin
-	 *            current minimum value/value to be set
-	 */
-	private static void setMinTime(AtomicLong tmin) {
-		long tcur = System.currentTimeMillis();
-		long t;
-		while ((t = tmin.get()) > tcur) {
-			tmin.compareAndSet(t, tcur);
-		}
-	}
+        logger.info("testNegativeAuditPeriod: Exiting");
+
+    }
+
+    /*
+     * Verifies (via log parsing) that when an audit period of zero is specified, the audit runs
+     * continuously, generating a number of sleep/wake sequences in a short period of time (e.g.
+     * 100ms).
+     */
+    @Test
+    public void testZeroAuditPeriod() throws Exception {
+
+        logger.info("testZeroAuditPeriod: Entering");
+
+        properties.put(IntegrityAuditProperties.AUDIT_PERIOD_SECONDS, "0");
+
+        final ExtractAppender logA = watch(debugLogger, "[Aa]waking from (0ms) sleep");
+
+        MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
+
+        /*
+         * Wait for
+         * 
+         * 1) audit to generate a bunch of sleep wake sequences.
+         */
+        String[] awakings = new String[10];
+        for (int x = 0; x < awakings.length; ++x) {
+            awakings[x] = "0ms";
+            runAudit(integrityAudit);
+        }
+
+        // run a couple more audits
+        runAudit(integrityAudit);
+        runAudit(integrityAudit);
+
+        /*
+         * We should get at least 10 sleep/wake sequences.
+         */
+
+        verifyItemsInLog(logA, awakings);
+
+        logger.info("testZeroAuditPeriod: Exiting");
+
+    }
+
+    /**
+     * Verifies that when different audit periods are specified, there is an appropriate interval
+     * between the audits.
+     */
+    @Test
+    public void testLongAuditPeriod() throws Exception {
+
+        logger.info("testLongAuditPeriod: Entering");
+
+        testAuditPeriod(100);
+        testAuditPeriod(200);
+
+        logger.info("testLongAuditPeriod: Exiting");
+    }
+
+    /**
+     * Verifies that audits actually take as long as expected, even with multiple auditors running
+     * simultaneously.
+     * 
+     * @param periodms audit period, in milliseconds
+     * @throws Exception if an error occurs
+     * @throws InterruptedException if the thread is interrupted
+     */
+    private void testAuditPeriod(long periodms) throws Exception, InterruptedException {
+
+        properties.put(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS, String.valueOf(periodms));
+
+        /*
+         * Start several auditors.
+         */
+        MyIntegrityAudit[] ia = new MyIntegrityAudit[3];
+        for (int x = 0; x < ia.length; ++x) {
+            ia[x] = makeAuditor("pdp" + x, A_SEQ_PU);
+        }
+
+        /*
+         * Run an audit on all of them.
+         */
+        runAudit(ia);
+
+        /*
+         * Now run again and ensure it waited long enough between runs.
+         */
+        long tmin = minAuditTime(ia);
+        assertTrue(tmin >= periodms + AUDIT_SIMULATION_MS);
+
+        /*
+         * Now run again and ensure it waited long enough between runs.
+         */
+        tmin = minAuditTime(ia);
+        assertTrue(tmin >= periodms + AUDIT_SIMULATION_MS);
+    }
+
+    /**
+     * Runs simultaneous audits on several auditors.
+     * 
+     * @param auditors the auditors
+     * @return the minimum time, in milliseconds, elapsed for any given auditor
+     * @throws InterruptedException if the thread is interrupted
+     */
+    private long minAuditTime(MyIntegrityAudit... auditors) throws InterruptedException {
+        List<Thread> threads = new ArrayList<>(auditors.length);
+        AtomicLong tfirst = new AtomicLong(Long.MAX_VALUE);
+        final long tbeg = System.currentTimeMillis();
+
+        // create the threads
+        for (MyIntegrityAudit p : auditors) {
+            Thread auditThread = new Thread() {
+
+                @Override
+                public void run() {
+                    try {
+                        runAudit(p);
+                        setMinTime(tfirst);
+
+                    } catch (InterruptedException e) {
+                        ;
+                    }
+                }
+            };
+
+            auditThread.setDaemon(true);
+            threads.add(auditThread);
+        }
+
+        // start the threads
+        for (Thread t : threads) {
+            t.start();
+        }
+
+        // wait for them to complete
+        for (Thread t : threads) {
+            t.join();
+        }
+
+        return (tfirst.get() - tbeg);
+    }
+
+    /**
+     * Sets a value to the minimum between the current value and the current time.
+     * 
+     * @param tmin current minimum value/value to be set
+     */
+    private static void setMinTime(AtomicLong tmin) {
+        long tcur = System.currentTimeMillis();
+        long time;
+        while ((time = tmin.get()) > tcur) {
+            tmin.compareAndSet(time, tcur);
+        }
+    }
 }
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/DbAuditCompareEntriesTest.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/DbAuditCompareEntriesTest.java
index 3a48b20c..6335482a 100644
--- a/integrity-audit/src/test/java/org/onap/policy/common/ia/DbAuditCompareEntriesTest.java
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/DbAuditCompareEntriesTest.java
@@ -50,505 +50,507 @@ import org.onap.policy.common.logging.flexlogger.Logger;
  */
 public class DbAuditCompareEntriesTest extends IntegrityAuditTestBase {
 
-	private static Logger logger = FlexLogger.getLogger(DbAuditCompareEntriesTest.class);
-
-	private DbDAO dbDAO;
-	private static String resourceName = "pdp1";
-
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		IntegrityAuditTestBase
-				.setUpBeforeClass(DEFAULT_DB_URL_PREFIX + DbAuditCompareEntriesTest.class.getSimpleName());
-	}
-
-	@AfterClass
-	public static void tearDownAfterClass() {
-		IntegrityAuditTestBase.tearDownAfterClass();
-	}
-
-	@Before
-	public void setUp() {
-
-		logger.info("setUp: Entering");
-
-		super.setUp();
-
-		truncateTables(makeProperties());
-
-		logger.info("setUp: Exiting");
-	}
-
-	/*
-	 * Clean up DB after each test.
-	 */
-	@After
-	public void tearDown() {
-		logger.info("tearDown: Entering");
-		
-		dbDAO.destroy();
-
-		super.tearDown();
-
-		logger.info("tearDown: Exiting");
-	}
-
-	/*
-	 * Tests that a comparison between hashsets is successful if the entries
-	 * match
-	 */
-	// @Ignore
-	@Test
-	public void testSuccessfulComparison() throws Exception {
-		logger.info("testSuccessfulComparison: Entering");
-
-		dbDAO = new DbDAO(resourceName, A_SEQ_PU, makeProperties());
-		DbAudit dbAudit = new DbAudit(dbDAO);
-
-		String className = null;
-		// There is only one entry IntegrityAuditEntity, but we will check
-		// anyway
-		Set<String> classNameSet = dbDAO.getPersistenceClassNames();
-		for (String c : classNameSet) {
-			if (c.equals("org.onap.policy.common.ia.jpa.IntegrityAuditEntity")) {
-				className = c;
-			}
-		}
-		String resourceName1 = resourceName;
-		String resourceName2 = resourceName;
-
-		IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
-		IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
-		Date date = new Date();
-
-		/*
-		 * Two entries with the same field values
-		 */
-		entry1.setDesignated(false);
-		entry1.setJdbcDriver(dbDriver);
-		entry1.setJdbcPassword(dbPwd);
-		entry1.setJdbcUrl(dbUrl);
-		entry1.setJdbcUser(dbUser);
-		entry1.setLastUpdated(date);
-		entry1.setNodeType(nodeType);
-		entry1.setPersistenceUnit(A_SEQ_PU);
-		entry1.setResourceName(resourceName1);
-		entry1.setSite(siteName);
-
-		entry2.setDesignated(false);
-		entry2.setJdbcDriver(dbDriver);
-		entry2.setJdbcPassword(dbPwd);
-		entry2.setJdbcUrl(dbUrl);
-		entry2.setJdbcUser(dbUser);
-		entry2.setLastUpdated(date);
-		entry2.setNodeType(nodeType);
-		entry2.setPersistenceUnit(A_SEQ_PU);
-		entry2.setResourceName(resourceName2);
-		entry2.setSite(siteName);
-
-		dbAudit.writeAuditDebugLog(className, resourceName1, resourceName2, entry1, entry2);
-
-		HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
-		HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
-
-		myEntries.put("pdp1", entry1);
-		theirEntries.put("pdp1", entry2);
-
-		Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
-
-		/*
-		 * Assert that there are no mismatches returned
-		 */
-		assertTrue(result.isEmpty());
-
-		logger.info("testSuccessfulComparison: Exit");
-	}
-
-	/*
-	 * Tests that an error is detected if an entry in one hashset doesn't match
-	 * the other
-	 */
-	// @Ignore
-	@Test
-	public void testComparisonError() throws Exception {
-		logger.info("testComparisonError: Entering");
-
-		dbDAO = new DbDAO(resourceName, A_SEQ_PU, makeProperties());
-		DbAudit dbAudit = new DbAudit(dbDAO);
-
-		String resourceName1 = resourceName;
-		String resourceName2 = resourceName;
-
-		IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
-		IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
-		Date date = new Date();
-
-		/*
-		 * Create two entries with different designated values
-		 */
-		entry1.setDesignated(false);
-		entry1.setJdbcDriver(dbDriver);
-		entry1.setJdbcPassword(dbPwd);
-		entry1.setJdbcUrl(dbUrl);
-		entry1.setJdbcUser(dbUser);
-		entry1.setLastUpdated(date);
-		entry1.setNodeType(nodeType);
-		entry1.setPersistenceUnit(A_SEQ_PU);
-		entry1.setResourceName(resourceName1);
-		entry1.setSite(siteName);
-
-		entry2.setDesignated(true);
-		entry2.setJdbcDriver(dbDriver);
-		entry2.setJdbcPassword(dbPwd);
-		entry2.setJdbcUrl(dbUrl);
-		entry2.setJdbcUser(dbUser);
-		entry2.setLastUpdated(date);
-		entry2.setNodeType(nodeType);
-		entry2.setPersistenceUnit(A_SEQ_PU);
-		entry2.setResourceName(resourceName2);
-		entry2.setSite(siteName);
-
-		HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
-		HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
-
-		myEntries.put("pdp1", entry1);
-		theirEntries.put("pdp1", entry2);
-
-		Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
-
-		/*
-		 * Assert that there was one mismatch
-		 */
-		assertEquals(1, result.size());
-
-		logger.info("testComparisonError: Exit");
-	}
-
-	/*
-	 * Tests that a mismatch/miss entry is detected if there are missing entries
-	 * in one or both of the hashsets
-	 */
-	// @Ignore
-	@Test
-	public void testCompareMissingEntries() throws Exception {
-		logger.info("testCompareMissingEntries: Entering");
-
-		dbDAO = new DbDAO(resourceName, A_SEQ_PU, makeProperties());
-		DbAudit dbAudit = new DbAudit(dbDAO);
-
-		String resourceName1 = resourceName;
-		String resourceName2 = resourceName;
-
-		IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
-		IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
-		IntegrityAuditEntity entry3 = new IntegrityAuditEntity();
-		IntegrityAuditEntity entry4 = new IntegrityAuditEntity();
-
-		Date date = new Date();
-
-		/*
-		 * 4 entries, one mismatch, two miss entries
-		 */
-		entry1.setDesignated(false);
-		entry1.setJdbcDriver(dbDriver);
-		entry1.setJdbcPassword(dbPwd);
-		entry1.setJdbcUrl(dbUrl);
-		entry1.setJdbcUser(dbUser);
-		entry1.setLastUpdated(date);
-		entry1.setNodeType(nodeType);
-		entry1.setPersistenceUnit(A_SEQ_PU);
-		entry1.setResourceName(resourceName1);
-		entry1.setSite(siteName);
-
-		entry2.setDesignated(true);
-		entry2.setJdbcDriver(dbDriver);
-		entry2.setJdbcPassword(dbPwd);
-		entry2.setJdbcUrl(dbUrl);
-		entry2.setJdbcUser(dbUser);
-		entry2.setLastUpdated(date);
-		entry2.setNodeType(nodeType);
-		entry2.setPersistenceUnit(A_SEQ_PU);
-		entry2.setResourceName(resourceName2);
-		entry2.setSite(siteName);
-
-		entry3.setDesignated(false);
-		entry3.setJdbcDriver(dbDriver);
-		entry3.setJdbcPassword(dbPwd);
-		entry3.setJdbcUrl(dbUrl);
-		entry3.setJdbcUser(dbUser);
-		entry3.setLastUpdated(date);
-		entry3.setNodeType(nodeType);
-		entry3.setPersistenceUnit(A_SEQ_PU);
-		entry3.setResourceName(resourceName2);
-		entry3.setSite("SiteB");
-
-		entry4.setDesignated(false);
-		entry4.setJdbcDriver(dbDriver);
-		entry4.setJdbcPassword(dbPwd);
-		entry4.setJdbcUrl(dbUrl);
-		entry4.setJdbcUser(dbUser);
-		entry4.setLastUpdated(date);
-		entry4.setNodeType(nodeType);
-		entry4.setPersistenceUnit(A_SEQ_PU);
-		entry4.setResourceName(resourceName2);
-		entry4.setSite("SiteB");
-
-		HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
-		HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
-
-		myEntries.put("0", entry1);
-		myEntries.put("1", entry3);
-		theirEntries.put("0", entry2);
-		theirEntries.put("2", entry4);
-
-		Set<Object> mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
-
-		/*
-		 * Assert 3 mismatches/missing entries were found
-		 */
-		assertEquals(3, mismatchResult.size());
-
-		logger.info("testCompareMissingEntries: Exit");
-	}
-
-	/*
-	 * Tests that comparison algorithm works for each entity in the hashsets
-	 */
-	// @Ignore
-	@Test
-	public void testCompareAllHashEntities() throws Exception {
-		logger.info("testCompareAllHashEntities: Entering");
-
-		dbDAO = new DbDAO(resourceName, A_SEQ_PU, makeProperties());
-		DbAudit dbAudit = new DbAudit(dbDAO);
-
-		Set<String> classNameSet = dbDAO.getPersistenceClassNames();
-		Set<Object> mismatchResult = new HashSet<Object>();
-		for (String c : classNameSet) {
-			if (c.equals("org.onap.policy.common.ia.jpa.IntegrityAuditEntity")) {
-				String resourceName1 = resourceName;
-				String resourceName2 = resourceName;
-
-				IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
-				IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
-				Date date = new Date();
-
-				/*
-				 * Two entries with the same field values
-				 */
-				entry1.setDesignated(false);
-				entry1.setJdbcDriver(dbDriver);
-				entry1.setJdbcPassword(dbPwd);
-				entry1.setJdbcUrl(dbUrl);
-				entry1.setJdbcUser(dbUser);
-				entry1.setLastUpdated(date);
-				entry1.setNodeType(nodeType);
-				entry1.setPersistenceUnit(A_SEQ_PU);
-				entry1.setResourceName(resourceName1);
-				entry1.setSite(siteName);
-
-				entry2.setDesignated(false);
-				entry2.setJdbcDriver(dbDriver);
-				entry2.setJdbcPassword(dbPwd);
-				entry2.setJdbcUrl(dbUrl);
-				entry2.setJdbcUser(dbUser);
-				entry2.setLastUpdated(date);
-				entry2.setNodeType(nodeType);
-				entry2.setPersistenceUnit(A_SEQ_PU);
-				entry2.setResourceName(resourceName2);
-				entry2.setSite(siteName);
-
-				HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
-				HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
-
-				myEntries.put("pdp1", entry1);
-				theirEntries.put("pdp1", entry2);
-
-				mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
-
-				/*
-				 * Assert there was no mismatches
-				 */
-				assertTrue(mismatchResult.isEmpty());
-			} else if (c.equals("org.onap.policy.common.ia.jpa.IaTestEntity")) {
-				IaTestEntity iate = new IaTestEntity();
-				IaTestEntity iate2 = new IaTestEntity();
-				IaTestEntity iate3 = new IaTestEntity();
-				IaTestEntity iate4 = new IaTestEntity();
-
-				Date date = new Date();
-
-				/*
-				 * Four entries, 2 mismatches
-				 */
-				iate.setCreatedBy("Ford");
-				iate.setModifiedBy("Ford");
-				iate.setModifiedDate(date);
-
-				iate2.setCreatedBy("Ford");
-				iate2.setModifiedBy("Zaphod");
-				iate2.setModifiedDate(date);
-
-				iate3.setCreatedBy("Zaphod");
-				iate3.setModifiedBy("Ford");
-				iate3.setModifiedDate(date);
-
-				iate4.setCreatedBy("Ford");
-				iate4.setModifiedBy("Ford");
-				iate4.setModifiedDate(date);
-
-				HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
-				HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
-
-				myEntries.put("0", iate);
-				myEntries.put("1", iate2);
-				theirEntries.put("0", iate3);
-				theirEntries.put("1", iate4);
-
-				mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
-
-				/*
-				 * Assert that there is 2 mismatches
-				 */
-				assertEquals(2, mismatchResult.size());
-			}
-		}
-
-		logger.info("testCompareAllHashEntities: Exit");
-	}
-
-	/*
-	 * Tests that comparison algorithm works for each entity in the database
-	 */
-	@Ignore
-	@Test
-	public void testCompareAllDbEntities() throws Exception {
-		logger.info("testCompareAllDbEntities: Entering");
-
-		logger.info("Setting up DB");
-
-		IntegrityAudit.setUnitTesting(true);
-
-		Properties properties = makeProperties();
-
-		Properties properties2 = makeProperties();
-		properties2.put(IntegrityAuditProperties.DB_URL,
-				"jdbc:h2:mem:" + DbAuditCompareEntriesTest.class.getSimpleName() + "2");
-
-		// Clean up the two DBs
-		truncateTables(properties);
-		truncateTables(properties2);
-
-		// Add entries into DB1
-		dbDAO = new DbDAO(resourceName, A_SEQ_PU, properties);
-		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
-		DbAudit dbAudit = new DbAudit(dbDAO);
-
-		// Add entries into DB2
-		DbDAO dbDAO3 = new DbDAO(resourceName, A_SEQ_PU, properties2);
-		new DbDAO("pdp2", A_SEQ_PU, properties2).destroy();
-
-		// Pull all entries and compare
-		Set<String> classNameSet = dbDAO.getPersistenceClassNames();
-		Map<Object, Object> myEntries;
-		Map<Object, Object> theirEntries;
-		Set<Object> mismatchResult = new HashSet<Object>();
-		String className;
-		for (String c : classNameSet) {
-			className = c;
-			logger.info("classNameSet entry = " + c);
-			myEntries = dbDAO.getAllEntries(A_SEQ_PU, properties, className);
-			theirEntries = dbDAO3.getAllEntries(A_SEQ_PU, properties2, className);
-			mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
-			if (className.contains("IntegrityAuditEntity")) {
-				break;
-			}
-		}
-		
-		dbDAO3.destroy();
-
-		// Assert that there is 2 mismatches between IntegrityAuditEntity tables
-		assertEquals(2, mismatchResult.size());
-
-		logger.info("testCompareAllDbEntities: Exit");
-	}
-
-	/**
-	 * @param properties
-	 */
-	private void truncateTables(Properties properties) {
-		truncateTable(properties, A_SEQ_PU, "IntegrityAuditEntity");
-		truncateTable(properties, A_SEQ_PU, "IaTestEntity");
-	}
-
-	/*
-	 * Tests that differences in embedded classes are still caught
-	 */
-	// @Ignore
-	@Test
-	public void testEmbeddedClass() throws Exception {
-		logger.info("testEmbeddedClasses: Entering");
-
-		dbDAO = new DbDAO(resourceName, A_SEQ_PU, properties);
-		DbAudit dbAudit = new DbAudit(dbDAO);
-
-		String className = null;
-		// There is only one entry IntegrityAuditEntity, but we will check
-		// anyway
-		Set<String> classNameSet = dbDAO.getPersistenceClassNames();
-		for (String c : classNameSet) {
-			if (c.equals("org.onap.policy.common.ia.jpa.IaTestEntity")) {
-				className = c;
-			}
-		}
-
-		IaTestEntity iate = new IaTestEntity();
-		IaTestEntity iate2 = new IaTestEntity();
-
-		Date date = new Date();
-
-		PersonSample person = new PersonSample("Ford", "Prefect", 21);
-		PersonSample person2 = new PersonSample("Zaphod", "Beeblebrox", 25);
-
-		/*
-		 * Silly tests to bump coverage stats, not sure why they are counting
-		 * PersonSample to begin with. Will have to look into that at some
-		 * point.
-		 */
-		assertNotEquals(person.getAge(), person2.getAge());
-		assertNotEquals(person.getFirstName(), person2.getFirstName());
-		assertNotEquals(person.getLasttName(), person2.getLasttName());
-		PersonSample personTest = new PersonSample(null, null, 0);
-		personTest.setAge(person.getAge());
-		personTest.setFirstName(person.getFirstName());
-		personTest.setLastName(person.getLasttName());
-		/*
-		 * Two entries, 1 mismatch
-		 */
-		iate.setCreatedBy("Ford");
-		iate.setModifiedBy("Zaphod");
-		iate.setModifiedDate(date);
-		iate.setPersonTest(person);
-
-		iate2.setCreatedBy("Ford");
-		iate2.setModifiedBy("Zaphod");
-		iate2.setModifiedDate(date);
-		iate2.setPersonTest(person2);
-
-		dbAudit.writeAuditDebugLog(className, "resource1", "resource2", iate, iate2);
-
-		HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
-		HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
-
-		myEntries.put("0", iate);
-		theirEntries.put("0", iate2);
-
-		Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
-
-		/*
-		 * Assert that there are no mismatches returned
-		 */
-		assertTrue(!result.isEmpty());
-
-		logger.info("testEmbeddedClasses: Exit");
-	}
+    private static Logger logger = FlexLogger.getLogger(DbAuditCompareEntriesTest.class);
+
+    private DbDAO dbDao;
+    private static String resourceName = "pdp1";
+
+    @BeforeClass
+    public static void setUpBeforeClass() throws Exception {
+        IntegrityAuditTestBase
+                .setUpBeforeClass(DEFAULT_DB_URL_PREFIX + DbAuditCompareEntriesTest.class.getSimpleName());
+    }
+
+    @AfterClass
+    public static void tearDownAfterClass() {
+        IntegrityAuditTestBase.tearDownAfterClass();
+    }
+
+    /**
+     * Set up for test cases.
+     */
+    @Override
+    @Before
+    public void setUp() {
+
+        logger.info("setUp: Entering");
+
+        super.setUp();
+
+        truncateTables(makeProperties());
+
+        logger.info("setUp: Exiting");
+    }
+
+    /**
+     * Clean up DB after each test.
+     */
+    @Override
+    @After
+    public void tearDown() {
+        logger.info("tearDown: Entering");
+
+        dbDao.destroy();
+
+        super.tearDown();
+
+        logger.info("tearDown: Exiting");
+    }
+
+    /*
+     * Tests that a comparison between hashsets is successful if the entries match
+     */
+    // @Ignore
+    @Test
+    public void testSuccessfulComparison() throws Exception {
+        logger.info("testSuccessfulComparison: Entering");
+
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, makeProperties());
+        final DbAudit dbAudit = new DbAudit(dbDao);
+
+        String className = null;
+        // There is only one entry IntegrityAuditEntity, but we will check
+        // anyway
+        Set<String> classNameSet = dbDao.getPersistenceClassNames();
+        for (String c : classNameSet) {
+            if (c.equals("org.onap.policy.common.ia.jpa.IntegrityAuditEntity")) {
+                className = c;
+            }
+        }
+        final String resourceName1 = resourceName;
+        final String resourceName2 = resourceName;
+
+        final IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
+        final IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
+        Date date = new Date();
+
+        /*
+         * Two entries with the same field values
+         */
+        entry1.setDesignated(false);
+        entry1.setJdbcDriver(dbDriver);
+        entry1.setJdbcPassword(dbPwd);
+        entry1.setJdbcUrl(dbUrl);
+        entry1.setJdbcUser(dbUser);
+        entry1.setLastUpdated(date);
+        entry1.setNodeType(nodeType);
+        entry1.setPersistenceUnit(A_SEQ_PU);
+        entry1.setResourceName(resourceName1);
+        entry1.setSite(siteName);
+
+        entry2.setDesignated(false);
+        entry2.setJdbcDriver(dbDriver);
+        entry2.setJdbcPassword(dbPwd);
+        entry2.setJdbcUrl(dbUrl);
+        entry2.setJdbcUser(dbUser);
+        entry2.setLastUpdated(date);
+        entry2.setNodeType(nodeType);
+        entry2.setPersistenceUnit(A_SEQ_PU);
+        entry2.setResourceName(resourceName2);
+        entry2.setSite(siteName);
+
+        dbAudit.writeAuditDebugLog(className, resourceName1, resourceName2, entry1, entry2);
+
+        HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+        HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+        myEntries.put("pdp1", entry1);
+        theirEntries.put("pdp1", entry2);
+
+        Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
+
+        /*
+         * Assert that there are no mismatches returned
+         */
+        assertTrue(result.isEmpty());
+
+        logger.info("testSuccessfulComparison: Exit");
+    }
+
+    /*
+     * Tests that an error is detected if an entry in one hashset doesn't match the other
+     */
+    // @Ignore
+    @Test
+    public void testComparisonError() throws Exception {
+        logger.info("testComparisonError: Entering");
+
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, makeProperties());
+        final DbAudit dbAudit = new DbAudit(dbDao);
+
+        final String resourceName1 = resourceName;
+        final String resourceName2 = resourceName;
+
+        final IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
+        final IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
+        Date date = new Date();
+
+        /*
+         * Create two entries with different designated values
+         */
+        entry1.setDesignated(false);
+        entry1.setJdbcDriver(dbDriver);
+        entry1.setJdbcPassword(dbPwd);
+        entry1.setJdbcUrl(dbUrl);
+        entry1.setJdbcUser(dbUser);
+        entry1.setLastUpdated(date);
+        entry1.setNodeType(nodeType);
+        entry1.setPersistenceUnit(A_SEQ_PU);
+        entry1.setResourceName(resourceName1);
+        entry1.setSite(siteName);
+
+        entry2.setDesignated(true);
+        entry2.setJdbcDriver(dbDriver);
+        entry2.setJdbcPassword(dbPwd);
+        entry2.setJdbcUrl(dbUrl);
+        entry2.setJdbcUser(dbUser);
+        entry2.setLastUpdated(date);
+        entry2.setNodeType(nodeType);
+        entry2.setPersistenceUnit(A_SEQ_PU);
+        entry2.setResourceName(resourceName2);
+        entry2.setSite(siteName);
+
+        HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+        HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+        myEntries.put("pdp1", entry1);
+        theirEntries.put("pdp1", entry2);
+
+        Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
+
+        /*
+         * Assert that there was one mismatch
+         */
+        assertEquals(1, result.size());
+
+        logger.info("testComparisonError: Exit");
+    }
+
+    /*
+     * Tests that a mismatch/miss entry is detected if there are missing entries in one or both of
+     * the hashsets
+     */
+    // @Ignore
+    @Test
+    public void testCompareMissingEntries() throws Exception {
+        logger.info("testCompareMissingEntries: Entering");
+
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, makeProperties());
+        final DbAudit dbAudit = new DbAudit(dbDao);
+
+        final String resourceName1 = resourceName;
+        final String resourceName2 = resourceName;
+
+        final IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
+        final IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
+        final IntegrityAuditEntity entry3 = new IntegrityAuditEntity();
+        final IntegrityAuditEntity entry4 = new IntegrityAuditEntity();
+
+        Date date = new Date();
+
+        /*
+         * 4 entries, one mismatch, two miss entries
+         */
+        entry1.setDesignated(false);
+        entry1.setJdbcDriver(dbDriver);
+        entry1.setJdbcPassword(dbPwd);
+        entry1.setJdbcUrl(dbUrl);
+        entry1.setJdbcUser(dbUser);
+        entry1.setLastUpdated(date);
+        entry1.setNodeType(nodeType);
+        entry1.setPersistenceUnit(A_SEQ_PU);
+        entry1.setResourceName(resourceName1);
+        entry1.setSite(siteName);
+
+        entry2.setDesignated(true);
+        entry2.setJdbcDriver(dbDriver);
+        entry2.setJdbcPassword(dbPwd);
+        entry2.setJdbcUrl(dbUrl);
+        entry2.setJdbcUser(dbUser);
+        entry2.setLastUpdated(date);
+        entry2.setNodeType(nodeType);
+        entry2.setPersistenceUnit(A_SEQ_PU);
+        entry2.setResourceName(resourceName2);
+        entry2.setSite(siteName);
+
+        entry3.setDesignated(false);
+        entry3.setJdbcDriver(dbDriver);
+        entry3.setJdbcPassword(dbPwd);
+        entry3.setJdbcUrl(dbUrl);
+        entry3.setJdbcUser(dbUser);
+        entry3.setLastUpdated(date);
+        entry3.setNodeType(nodeType);
+        entry3.setPersistenceUnit(A_SEQ_PU);
+        entry3.setResourceName(resourceName2);
+        entry3.setSite("SiteB");
+
+        entry4.setDesignated(false);
+        entry4.setJdbcDriver(dbDriver);
+        entry4.setJdbcPassword(dbPwd);
+        entry4.setJdbcUrl(dbUrl);
+        entry4.setJdbcUser(dbUser);
+        entry4.setLastUpdated(date);
+        entry4.setNodeType(nodeType);
+        entry4.setPersistenceUnit(A_SEQ_PU);
+        entry4.setResourceName(resourceName2);
+        entry4.setSite("SiteB");
+
+        HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+        HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+        myEntries.put("0", entry1);
+        myEntries.put("1", entry3);
+        theirEntries.put("0", entry2);
+        theirEntries.put("2", entry4);
+
+        Set<Object> mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
+
+        /*
+         * Assert 3 mismatches/missing entries were found
+         */
+        assertEquals(3, mismatchResult.size());
+
+        logger.info("testCompareMissingEntries: Exit");
+    }
+
+    /*
+     * Tests that comparison algorithm works for each entity in the hashsets
+     */
+    // @Ignore
+    @Test
+    public void testCompareAllHashEntities() throws Exception {
+        logger.info("testCompareAllHashEntities: Entering");
+
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, makeProperties());
+        DbAudit dbAudit = new DbAudit(dbDao);
+
+        Set<String> classNameSet = dbDao.getPersistenceClassNames();
+        Set<Object> mismatchResult = new HashSet<Object>();
+        for (String className : classNameSet) {
+            if (className.equals("org.onap.policy.common.ia.jpa.IntegrityAuditEntity")) {
+                final String resourceName1 = resourceName;
+                final String resourceName2 = resourceName;
+
+                final IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
+                final IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
+                Date date = new Date();
+
+                /*
+                 * Two entries with the same field values
+                 */
+                entry1.setDesignated(false);
+                entry1.setJdbcDriver(dbDriver);
+                entry1.setJdbcPassword(dbPwd);
+                entry1.setJdbcUrl(dbUrl);
+                entry1.setJdbcUser(dbUser);
+                entry1.setLastUpdated(date);
+                entry1.setNodeType(nodeType);
+                entry1.setPersistenceUnit(A_SEQ_PU);
+                entry1.setResourceName(resourceName1);
+                entry1.setSite(siteName);
+
+                entry2.setDesignated(false);
+                entry2.setJdbcDriver(dbDriver);
+                entry2.setJdbcPassword(dbPwd);
+                entry2.setJdbcUrl(dbUrl);
+                entry2.setJdbcUser(dbUser);
+                entry2.setLastUpdated(date);
+                entry2.setNodeType(nodeType);
+                entry2.setPersistenceUnit(A_SEQ_PU);
+                entry2.setResourceName(resourceName2);
+                entry2.setSite(siteName);
+
+                HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+                HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+                myEntries.put("pdp1", entry1);
+                theirEntries.put("pdp1", entry2);
+
+                mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
+
+                /*
+                 * Assert there was no mismatches
+                 */
+                assertTrue(mismatchResult.isEmpty());
+            } else if (className.equals("org.onap.policy.common.ia.jpa.IaTestEntity")) {
+                final IaTestEntity iate = new IaTestEntity();
+                final IaTestEntity iate2 = new IaTestEntity();
+                final IaTestEntity iate3 = new IaTestEntity();
+                final IaTestEntity iate4 = new IaTestEntity();
+
+                Date date = new Date();
+
+                /*
+                 * Four entries, 2 mismatches
+                 */
+                iate.setCreatedBy("Ford");
+                iate.setModifiedBy("Ford");
+                iate.setModifiedDate(date);
+
+                iate2.setCreatedBy("Ford");
+                iate2.setModifiedBy("Zaphod");
+                iate2.setModifiedDate(date);
+
+                iate3.setCreatedBy("Zaphod");
+                iate3.setModifiedBy("Ford");
+                iate3.setModifiedDate(date);
+
+                iate4.setCreatedBy("Ford");
+                iate4.setModifiedBy("Ford");
+                iate4.setModifiedDate(date);
+
+                HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+                HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+                myEntries.put("0", iate);
+                myEntries.put("1", iate2);
+                theirEntries.put("0", iate3);
+                theirEntries.put("1", iate4);
+
+                mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
+
+                /*
+                 * Assert that there is 2 mismatches
+                 */
+                assertEquals(2, mismatchResult.size());
+            }
+        }
+
+        logger.info("testCompareAllHashEntities: Exit");
+    }
+
+    /*
+     * Tests that comparison algorithm works for each entity in the database
+     */
+    @Ignore
+    @Test
+    public void testCompareAllDbEntities() throws Exception {
+        logger.info("testCompareAllDbEntities: Entering");
+
+        logger.info("Setting up DB");
+
+        IntegrityAudit.setUnitTesting(true);
+
+        Properties properties = makeProperties();
+
+        Properties properties2 = makeProperties();
+        properties2.put(IntegrityAuditProperties.DB_URL,
+                "jdbc:h2:mem:" + DbAuditCompareEntriesTest.class.getSimpleName() + "2");
+
+        // Clean up the two DBs
+        truncateTables(properties);
+        truncateTables(properties2);
+
+        // Add entries into DB1
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+        DbAudit dbAudit = new DbAudit(dbDao);
+
+        // Add entries into DB2
+        DbDAO dbDao3 = new DbDAO(resourceName, A_SEQ_PU, properties2);
+        new DbDAO("pdp2", A_SEQ_PU, properties2).destroy();
+
+        // Pull all entries and compare
+        Set<String> classNameSet = dbDao.getPersistenceClassNames();
+        Map<Object, Object> myEntries;
+        Map<Object, Object> theirEntries;
+        Set<Object> mismatchResult = new HashSet<Object>();
+        for (String className : classNameSet) {
+            logger.info("classNameSet entry = " + className);
+            myEntries = dbDao.getAllEntries(A_SEQ_PU, properties, className);
+            theirEntries = dbDao3.getAllEntries(A_SEQ_PU, properties2, className);
+            mismatchResult = dbAudit.compareEntries(myEntries, theirEntries);
+            if (className.contains("IntegrityAuditEntity")) {
+                break;
+            }
+        }
+
+        dbDao3.destroy();
+
+        // Assert that there is 2 mismatches between IntegrityAuditEntity tables
+        assertEquals(2, mismatchResult.size());
+
+        logger.info("testCompareAllDbEntities: Exit");
+    }
+
+    /**
+     * Truncate the tables.
+     * 
+     * @param properties the properties
+     */
+    private void truncateTables(Properties properties) {
+        truncateTable(properties, A_SEQ_PU, "IntegrityAuditEntity");
+        truncateTable(properties, A_SEQ_PU, "IaTestEntity");
+    }
+
+    /*
+     * Tests that differences in embedded classes are still caught
+     */
+    // @Ignore
+    @Test
+    public void testEmbeddedClass() throws Exception {
+        logger.info("testEmbeddedClasses: Entering");
+
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        final DbAudit dbAudit = new DbAudit(dbDao);
+
+        String className = null;
+        // There is only one entry IntegrityAuditEntity, but we will check
+        // anyway
+        Set<String> classNameSet = dbDao.getPersistenceClassNames();
+        for (String classNameInClassNameSet : classNameSet) {
+            if (classNameInClassNameSet.equals("org.onap.policy.common.ia.jpa.IaTestEntity")) {
+                className = classNameInClassNameSet;
+            }
+        }
+
+        final IaTestEntity iate = new IaTestEntity();
+        final IaTestEntity iate2 = new IaTestEntity();
+
+        final Date date = new Date();
+
+        PersonSample person = new PersonSample("Ford", "Prefect", 21);
+        PersonSample person2 = new PersonSample("Zaphod", "Beeblebrox", 25);
+
+        /*
+         * Silly tests to bump coverage stats, not sure why they are counting PersonSample to begin
+         * with. Will have to look into that at some point.
+         */
+        assertNotEquals(person.getAge(), person2.getAge());
+        assertNotEquals(person.getFirstName(), person2.getFirstName());
+        assertNotEquals(person.getLasttName(), person2.getLasttName());
+        PersonSample personTest = new PersonSample(null, null, 0);
+        personTest.setAge(person.getAge());
+        personTest.setFirstName(person.getFirstName());
+        personTest.setLastName(person.getLasttName());
+        /*
+         * Two entries, 1 mismatch
+         */
+        iate.setCreatedBy("Ford");
+        iate.setModifiedBy("Zaphod");
+        iate.setModifiedDate(date);
+        iate.setPersonTest(person);
+
+        iate2.setCreatedBy("Ford");
+        iate2.setModifiedBy("Zaphod");
+        iate2.setModifiedDate(date);
+        iate2.setPersonTest(person2);
+
+        dbAudit.writeAuditDebugLog(className, "resource1", "resource2", iate, iate2);
+
+        HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
+        HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
+
+        myEntries.put("0", iate);
+        theirEntries.put("0", iate2);
+
+        Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
+
+        /*
+         * Assert that there are no mismatches returned
+         */
+        assertTrue(!result.isEmpty());
+
+        logger.info("testEmbeddedClasses: Exit");
+    }
 }
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/DbAuditTest.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/DbAuditTest.java
index ad4041f5..cfbf90cb 100644
--- a/integrity-audit/src/test/java/org/onap/policy/common/ia/DbAuditTest.java
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/DbAuditTest.java
@@ -53,230 +53,236 @@ import org.onap.policy.common.utils.test.log.logback.ExtractAppender;
  */
 public class DbAuditTest extends IntegrityAuditTestBase {
 
-	private static Logger logger = FlexLogger.getLogger(DbAuditTest.class);
+    private static Logger logger = FlexLogger.getLogger(DbAuditTest.class);
+
+    private static final String resourceName = "pdp1";
+
+    private EntityManagerFactory emf2;
+    private EntityManager em2;
+    private DbDAO dbDao;
+
+    @BeforeClass
+    public static void setUpBeforeClass() throws Exception {
+        IntegrityAuditTestBase.setUpBeforeClass(DEFAULT_DB_URL_PREFIX + DbAuditTest.class.getSimpleName());
+        IntegrityAuditEntity.setUnitTesting(true);
+    }
+
+    @AfterClass
+    public static void tearDownAfterClass() {
+        IntegrityAuditTestBase.tearDownAfterClass();
+        IntegrityAuditEntity.setUnitTesting(false);
+    }
+
+    /**
+     * Set up for test cases.
+     */
+    @Override
+    @Before
+    public void setUp() {
+        logger.info("setUp: Entering");
+
+        super.setUp();
+
+        dbDao = null;
+        emf2 = null;
+        em2 = null;
+
+        logger.info("setUp: Exiting");
+    }
+
+    /**
+     * Tear down after test cases.
+     */
+    @Override
+    @After
+    public void tearDown() {
+        logger.info("tearDown: Entering");
+
+        if (dbDao != null) {
+            dbDao.destroy();
+        }
+
+        if (em2 != null) {
+            em2.close();
+        }
+
+        if (emf2 != null) {
+            emf2.close();
+        }
+
+        super.tearDown();
 
-	private static final String resourceName = "pdp1";
+        logger.info("tearDown: Exiting");
+    }
+
+    private void createDb(Properties properties) {
+        if (emf2 != null) {
+            throw new IllegalStateException("DB2 has already been created");
+        }
+
+        // open the DB and ensure it stays open until the test completes
+        emf2 = Persistence.createEntityManagerFactory(A_SEQ_PU, properties);
+        em2 = emf2.createEntityManager();
+
+        truncateTable(properties, A_SEQ_PU, "IntegrityAuditEntity");
+    }
+
+    /*
+     * Tests printing an error to the log in the event where there are no entities saved in the
+     * database
+     */
+    @Test
+    public void noEntitiesTest() throws Exception {
+        Properties properties = makeProperties();
+
+        logger.info("noEntitiesTest: Entering");
+
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        dbDao.deleteAllIntegrityAuditEntities();
+        try {
+            DbAudit dbAudit = new DbAudit(dbDao);
+            dbAudit.dbAudit(resourceName, A_SEQ_PU, nodeType);
+            fail("found unexpected entities");
+
+        } catch (DbAuditException e) {
+            // Ignore expected exception
+        }
+
+        logger.info("noEntitiesTest: Exit");
+    }
+
+    /*
+     * Tests the detection of only one entry in the database
+     */
+    @Test
+    public void oneEntityTest() throws Exception {
+        Properties properties = makeProperties();
+
+        logger.info("oneEntityTest: Entering");
+
+        final ExtractAppender log = watch(debugLogger, "DbAudit: Found only (one) IntegrityAuditEntity entry:");
+
+        // Add one entry in the database
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        DbAudit dbAudit = new DbAudit(dbDao);
+        dbAudit.dbAudit(resourceName, A_SEQ_PU, nodeType);
+
+        List<IntegrityAuditEntity> iaeList = dbDao.getIntegrityAuditEntities(A_SEQ_PU, nodeType);
+        logger.info("List size: " + iaeList.size());
+
+        verifyItemsInLog(log, "one");
+
+        logger.info("oneEntityTest: Exit");
+    }
+
+    /*
+     * Tests reporting mismatches and missing entries using the error log
+     */
+    @Test
+    public void mismatchTest() throws Exception {
+        logger.info("mismatchTest: Entering");
+
+        // use new URLs so we get a completely new DB
+        String dbUrl = DbAuditTest.dbUrl + "_mismatchTest";
+        String dbUrl2 = dbUrl + "2";
+
+        Properties properties = makeProperties();
+        properties.put(IntegrityAuditProperties.DB_URL, dbUrl);
+
+        // Properties for DB2
+        Properties properties2 = makeProperties();
+        properties2.put(IntegrityAuditProperties.DB_URL, dbUrl2);
+
+        /*
+         * We must drop and re-create DB1 so that it's sequence generator is in step with the
+         * sequence generator for DB2.
+         */
+        recreateDb1(properties);
+
+        // create/open DB2
+        createDb(properties2);
 
-	private EntityManagerFactory emf2;
-	private EntityManager em2;
-	private DbDAO dbDAO;
+        final ExtractAppender dbglog = watch(debugLogger, "Mismatched entries [(]keys[)]:(.*)");
+        final ExtractAppender errlog = watch(errorLogger, "DB Audit: ([0-9])");
+
+        /*
+         * Create entries in DB1 & DB2 for the resource of interest
+         */
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
 
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		IntegrityAuditTestBase.setUpBeforeClass(DEFAULT_DB_URL_PREFIX + DbAuditTest.class.getSimpleName());
-		IntegrityAuditEntity.setUnitTesting(true);
-	}
+        new DbDAO(resourceName, A_SEQ_PU, properties2).destroy();
+
+        /*
+         * Entries in DB1, pointing to DB2, except for pdp3
+         */
+        new DbDAO("pdp2", A_SEQ_PU, properties, dbUrl2).destroy();
+        new DbDAO("pdp1", A_SEQ_PU, properties, dbUrl2).destroy();
+        new DbDAO("pdp3", A_SEQ_PU, properties).destroy(); // mismatched URL
+        new DbDAO("pdp4", A_SEQ_PU, properties, dbUrl2).destroy();
+
+        /*
+         * Identical entries in DB2, all pointing to DB2, including pdp3, but leaving out pdp4
+         */
+        new DbDAO("pdp2", A_SEQ_PU, properties2).destroy();
+        new DbDAO("pdp1", A_SEQ_PU, properties2).destroy();
+        new DbDAO("pdp3", A_SEQ_PU, properties2).destroy();
+
+        /*
+         * Run the DB Audit, once it finds a mismatch and sleeps, update DB1 to have the same entry
+         * as DB2 it can be confirmed that the mismatch is resolved
+         */
+        DbAudit dbAudit = new DbAudit(dbDao);
+        dbAudit.dbAudit(resourceName, A_SEQ_PU, nodeType);
 
-	@AfterClass
-	public static void tearDownAfterClass() {
-		IntegrityAuditTestBase.tearDownAfterClass();
-		IntegrityAuditEntity.setUnitTesting(false);
-	}
+        // update pdp3 entry in DB1 to point to DB2
+        new DbDAO("pdp3", A_SEQ_PU, properties, dbUrl2).destroy();
+
+        /*
+         * Run the audit again and correct the mismatch, the result should be one entry in the
+         * mismatchKeySet because of the missing entry from the beginning of the test
+         */
+        dbAudit.dbAudit(resourceName, A_SEQ_PU, nodeType);
 
-	@Before
-	public void setUp() {
-		logger.info("setUp: Entering");
+        assertFalse(dbglog.getExtracted().isEmpty());
+
+        String mismatchIndex = dbglog.getExtracted().get(dbglog.getExtracted().size() - 1);
+        int mismatchEntries = mismatchIndex.trim().split(",").length;
+        logger.info("mismatchTest: mismatchIndex found: '" + mismatchIndex + "'" + " mismatachEntries = "
+                + mismatchEntries);
 
-		super.setUp();
+        // Assert there is only one entry index
+        assertEquals(1, mismatchEntries);
+
+        // Now check the entry in the error.log
+        assertFalse(errlog.getExtracted().isEmpty());
 
-		dbDAO = null;
-		emf2 = null;
-		em2 = null;
+        String mismatchNum = errlog.getExtracted().get(errlog.getExtracted().size() - 1);
 
-		logger.info("setUp: Exiting");
-	}
+        logger.info("mismatchTest: mismatchNum found: '" + mismatchNum + "'");
 
-	@After
-	public void tearDown() {
-		logger.info("tearDown: Entering");
+        // Assert that there are a total of 3 mismatches - 1 between each
+        // comparison node.
+        assertEquals("3", mismatchNum);
+
+        logger.info("mismatchTest: Exit");
+    }
 
-		if (dbDAO != null) {
-			dbDAO.destroy();
-		}
-
-		if (em2 != null) {
-			em2.close();
-		}
-
-		if (emf2 != null) {
-			emf2.close();
-		}
-
-		super.tearDown();
-
-		logger.info("tearDown: Exiting");
-	}
-
-	private void createDb(Properties properties) {
-		if (emf2 != null) {
-			throw new IllegalStateException("DB2 has already been created");
-		}
-
-		// open the DB and ensure it stays open until the test completes
-		emf2 = Persistence.createEntityManagerFactory(A_SEQ_PU, properties);
-		em2 = emf2.createEntityManager();
-
-		truncateTable(properties, A_SEQ_PU, "IntegrityAuditEntity");
-	}
-
-	/*
-	 * Tests printing an error to the log in the event where there are no
-	 * entities saved in the database
-	 */
-	@Test
-	public void noEntitiesTest() throws Exception {
-		Properties properties = makeProperties();
-
-		logger.info("noEntitiesTest: Entering");
-
-		dbDAO = new DbDAO(resourceName, A_SEQ_PU, properties);
-		dbDAO.deleteAllIntegrityAuditEntities();
-		try {
-			DbAudit dbAudit = new DbAudit(dbDAO);
-			dbAudit.dbAudit(resourceName, A_SEQ_PU, nodeType);
-			fail("found unexpected entities");
-
-		} catch (DbAuditException e) {
-
-		}
-
-		logger.info("noEntitiesTest: Exit");
-	}
-
-	/*
-	 * Tests the detection of only one entry in the database
-	 */
-	@Test
-	public void oneEntityTest() throws Exception {
-		Properties properties = makeProperties();
-
-		logger.info("oneEntityTest: Entering");
-
-		ExtractAppender log = watch(debugLogger, "DbAudit: Found only (one) IntegrityAuditEntity entry:");
-
-		// Add one entry in the database
-		dbDAO = new DbDAO(resourceName, A_SEQ_PU, properties);
-		DbAudit dbAudit = new DbAudit(dbDAO);
-		dbAudit.dbAudit(resourceName, A_SEQ_PU, nodeType);
-
-		List<IntegrityAuditEntity> iaeList = dbDAO.getIntegrityAuditEntities(A_SEQ_PU, nodeType);
-		logger.info("List size: " + iaeList.size());
-
-		verifyItemsInLog(log, "one");
-
-		logger.info("oneEntityTest: Exit");
-	}
-
-	/*
-	 * Tests reporting mismatches and missing entries using the error log
-	 */
-	@Test
-	public void mismatchTest() throws Exception {
-		logger.info("mismatchTest: Entering");
-		
-		// use new URLs so we get a completely new DB
-		String dbUrl = DbAuditTest.dbUrl + "_mismatchTest";
-		String dbUrl2 = dbUrl + "2";
-
-		Properties properties = makeProperties();
-		properties.put(IntegrityAuditProperties.DB_URL, dbUrl);
-
-		// Properties for DB2
-		Properties properties2 = makeProperties();
-		properties2.put(IntegrityAuditProperties.DB_URL, dbUrl2);
-
-		/*
-		 * We must drop and re-create DB1 so that it's sequence generator is in
-		 * step with the sequence generator for DB2.
-		 */		
-		recreateDb1(properties);
-
-		// create/open DB2
-		createDb(properties2);
-
-		ExtractAppender dbglog = watch(debugLogger, "Mismatched entries [(]keys[)]:(.*)");
-		ExtractAppender errlog = watch(errorLogger, "DB Audit: ([0-9])");
-
-		/*
-		 * Create entries in DB1 & DB2 for the resource of interest
-		 */
-		dbDAO = new DbDAO(resourceName, A_SEQ_PU, properties);
-
-		new DbDAO(resourceName, A_SEQ_PU, properties2).destroy();
-
-		/*
-		 * Entries in DB1, pointing to DB2, except for pdp3
-		 */
-		new DbDAO("pdp2", A_SEQ_PU, properties, dbUrl2).destroy();
-		new DbDAO("pdp1", A_SEQ_PU, properties, dbUrl2).destroy();
-		new DbDAO("pdp3", A_SEQ_PU, properties).destroy(); // mismatched URL
-		new DbDAO("pdp4", A_SEQ_PU, properties, dbUrl2).destroy();
-
-		/*
-		 * Identical entries in DB2, all pointing to DB2, including pdp3, but
-		 * leaving out pdp4
-		 */
-		new DbDAO("pdp2", A_SEQ_PU, properties2).destroy();
-		new DbDAO("pdp1", A_SEQ_PU, properties2).destroy();
-		new DbDAO("pdp3", A_SEQ_PU, properties2).destroy();
-
-		/*
-		 * Run the DB Audit, once it finds a mismatch and sleeps, update DB1 to
-		 * have the same entry as DB2 it can be confirmed that the mismatch is
-		 * resolved
-		 */
-		DbAudit dbAudit = new DbAudit(dbDAO);
-		dbAudit.dbAudit(resourceName, A_SEQ_PU, nodeType);
-
-		// update pdp3 entry in DB1 to point to DB2
-		new DbDAO("pdp3", A_SEQ_PU, properties, dbUrl2).destroy();
-
-		/*
-		 * Run the audit again and correct the mismatch, the result should be
-		 * one entry in the mismatchKeySet because of the missing entry from the
-		 * beginning of the test
-		 */
-		dbAudit.dbAudit(resourceName, A_SEQ_PU, nodeType);
-
-		assertFalse(dbglog.getExtracted().isEmpty());
-
-		String mismatchIndex = dbglog.getExtracted().get(dbglog.getExtracted().size() - 1);
-		int mismatchEntries = mismatchIndex.trim().split(",").length;
-		logger.info("mismatchTest: mismatchIndex found: '" + mismatchIndex + "'" + " mismatachEntries = "
-				+ mismatchEntries);
-
-		// Assert there is only one entry index
-		assertEquals(1, mismatchEntries);
-
-		// Now check the entry in the error.log
-		assertFalse(errlog.getExtracted().isEmpty());
-
-		String mismatchNum = errlog.getExtracted().get(errlog.getExtracted().size() - 1);
-
-		logger.info("mismatchTest: mismatchNum found: '" + mismatchNum + "'");
-
-		// Assert that there are a total of 3 mismatches - 1 between each
-		// comparison node.
-		assertEquals("3", mismatchNum);
-
-		logger.info("mismatchTest: Exit");
-	}
-
-	/**
-	 * Re-creates DB1, using the specified properties.
-	 * @param properties
-	 */
-	private void recreateDb1(Properties properties) {
-		em.close();
-		emf.close();
-		
-		createDb(properties);
-		
-		em = em2;
-		emf = emf2;
-		
-		em2 = null;
-		emf2 = null;
-	}
+    /**
+     * Re-creates DB1, using the specified properties.
+     * 
+     * @param properties the properties
+     */
+    private void recreateDb1(Properties properties) {
+        em.close();
+        emf.close();
+
+        createDb(properties);
+
+        em = em2;
+        emf = emf2;
+
+        em2 = null;
+        emf2 = null;
+    }
 
 }
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/DbDAOTest.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/DbDAOTest.java
index c4cba280..01e2f2b0 100644
--- a/integrity-audit/src/test/java/org/onap/policy/common/ia/DbDAOTest.java
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/DbDAOTest.java
@@ -30,6 +30,7 @@ import static org.junit.Assert.assertTrue;
  * where they have write privileges and can execute time-sensitive
  * tasks.
  */
+
 import java.util.Date;
 import java.util.HashSet;
 import java.util.List;
@@ -58,393 +59,399 @@ import org.onap.policy.common.utils.jpa.EntityTransCloser;
  * tasks.
  */
 public class DbDAOTest extends IntegrityAuditTestBase {
-	private static String resourceName = "pdp0";
-
-	private DbDAO d;
-
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		IntegrityAuditTestBase.setUpBeforeClass(DEFAULT_DB_URL_PREFIX + DbDAOTest.class.getSimpleName());
-	}
-
-	@AfterClass
-	public static void tearDownAfterClass() {
-		IntegrityAuditTestBase.tearDownAfterClass();
-	}
-
-	@Before
-	public void setUp() {
-		super.setUp();
-		d = null;
-	}
-
-	@After
-	public void tearDown() {
-		if(d != null) {
-			d.destroy();
-		}
-		
-		super.tearDown();
-	}
-
-	/* Tests registering a new IntegrityAuditEntity object in the DB */
-	@Test
-	public void testNewRegistration() throws Exception {
-		Properties properties = makeProperties();
-
-		try(EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
-			d = new DbDAO(resourceName, A_SEQ_PU, properties);
-
-			// Find the proper entry in the database
-			Query iaequery = em
-					.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
-			iaequery.setParameter("rn", DbDAOTest.resourceName);
-			iaequery.setParameter("pu", DbDAOTest.A_SEQ_PU);
-
-			@SuppressWarnings("rawtypes")
-			List iaeList = iaequery.getResultList();
-
-			// Assert that the IntegrityAuditEntity object was found
-			assertNotNull(iaeList);
-
-			// flush to the DB
-			em.flush();
-			et.commit();
-		}
-	}
-
-	/*
-	 * Tests updating an IntegrityAuditEntity if it has already been registered
-	 */
-	@Test
-	public void testUpdateRegistration() throws Exception {
-		Properties properties = makeProperties();
-
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-
-		// Change site_name in properties to test that an update was made to
-		// an existing entry in the table
-		properties.put(IntegrityAuditProperties.SITE_NAME, "SiteB");
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-
-		try(EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
-			// Find the proper entry in the database
-			Query iaequery = em
-					.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
-			iaequery.setParameter("rn", DbDAOTest.resourceName);
-			iaequery.setParameter("pu", DbDAOTest.A_SEQ_PU);
-
-			@SuppressWarnings("rawtypes")
-			List iaeList = iaequery.getResultList();
-			IntegrityAuditEntity iae = null;
-			if (!iaeList.isEmpty()) {
-				// ignores multiple results
-				iae = (IntegrityAuditEntity) iaeList.get(0);
-
-				em.refresh(iae);
-				em.persist(iae);
-
-				// flush to the DB
-				em.flush();
-
-				// commit transaction
-				et.commit();
-
-				// Assert that the site_name for the existing entry was updated
-				assertEquals("SiteB", iae.getSite());
-			}
-		}
-	}
-
-	/* Tests obtaining all Integrity Audit Entities from a table */
-	@Test
-	public void testGetIntegrityAuditEntities() throws Exception {
-		Properties properties = makeProperties();
-
-		// Add some entries to the DB
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
-		properties.put(IntegrityAuditProperties.NODE_TYPE, "pdp_drools");
-		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
-
-		List<IntegrityAuditEntity> entities;
-		// Obtain entries based on persistenceUnit and nodeType
-		entities = d.getIntegrityAuditEntities(A_SEQ_PU, "pdp_xacml");
-		assertEquals(2, entities.size());
-	}
-
-	/* Tests retrieving a DbDAO instance's IntegrityAuditEntity */
-	@Test
-	public void testGetMyIntegrityAuditEntity() throws Exception {
-		Properties properties = makeProperties();
-
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-		IntegrityAuditEntity iae = d.getMyIntegrityAuditEntity();
-		// assertEquals("integrityAuditPU", iae.getPersistenceUnit());
-		assertEquals(A_SEQ_PU, iae.getPersistenceUnit());
-	}
-
-	/* Tests obtaining an IntegrityAuditEntity by ID */
-	@Test
-	public void testGetIntegrityAuditEntity() throws Exception {
-		Properties properties = makeProperties();
-
-		// Obtain an entry from the database based on ID
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-
-		// Find the proper database entry
-		Query iaequery = em
-				.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
-		iaequery.setParameter("rn", DbDAOTest.resourceName);
-		iaequery.setParameter("pu", DbDAOTest.A_SEQ_PU);
-
-		@SuppressWarnings("rawtypes")
-		List iaeList = iaequery.getResultList();
-		IntegrityAuditEntity iae = null;
-		if (!iaeList.isEmpty()) {
-			// ignores multiple results
-			iae = (IntegrityAuditEntity) iaeList.get(0);
-
-			// refresh the object from DB in case cached data was returned
-			em.refresh(iae);
-
-			// Obtain ID for an IntegrityAuditEntity
-			PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
-			Object iaeId = util.getIdentifier(iae);
-
-			// Obtain the same IntegrityAuditEntity based on ID
-			IntegrityAuditEntity iaeDuplicate = d.getIntegrityAuditEntity((long) iaeId);
-			Object duplicateId = util.getIdentifier(iaeDuplicate);
-
-			// Assert that the proper entry was retrieved based on ID
-			assertEquals((long) iaeId, (long) duplicateId);
-		}
-	}
-
-	/* Tests setting an IntegrityAuditEntity as the designated node */
-	@Test
-	public void testSetDesignated() throws Exception {
-		Properties properties = makeProperties();
-
-		try(EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
-			// Create an entry and set it's designated field to true
-			d = new DbDAO(resourceName, A_SEQ_PU, properties);
-			d.setDesignated(resourceName, A_SEQ_PU, true);
-
-			// Find the proper entry in the database
-			Query iaequery = em
-					.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
-			iaequery.setParameter("rn", resourceName);
-			iaequery.setParameter("pu", A_SEQ_PU);
-
-			@SuppressWarnings("rawtypes")
-			List iaeList = iaequery.getResultList();
-			IntegrityAuditEntity iae = null;
-
-			if (!iaeList.isEmpty()) {
-				// ignores multiple results
-				iae = (IntegrityAuditEntity) iaeList.get(0);
-				em.refresh(iae);
-
-				// Check if the node is designated
-				boolean result = iae.isDesignated();
-
-				// Assert that it is designated
-				assertTrue(result);
-			}
-
-			// flush to the DB
-			em.flush();
-
-			// close the transaction
-			et.commit();
-		}
-	}
-
-	/* Tests that the lastUpdated column in the database is updated properly */
-	@Test
-	public void testSetLastUpdated() throws Exception {
-		Properties properties = makeProperties();
-
-		try(EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
-			// Create an entry
-			d = new DbDAO(resourceName, A_SEQ_PU, properties);
-
-			// Find the proper entry in the database
-			Query iaequery = em
-					.createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
-			iaequery.setParameter("rn", resourceName);
-			iaequery.setParameter("pu", A_SEQ_PU);
-
-			@SuppressWarnings("rawtypes")
-			List iaeList = iaequery.getResultList();
-			IntegrityAuditEntity iae = null;
-
-			if (!iaeList.isEmpty()) {
-				// ignores multiple results
-				iae = (IntegrityAuditEntity) iaeList.get(0);
-				// refresh the object from DB in case cached data was returned
-				em.refresh(iae);
-
-				// Obtain old update value and set new update value
-				Date oldDate = iae.getLastUpdated();
-
-				// ensure dates are different by sleeping for a bit
-				Thread.sleep(1);
-
-				iae.setSite("SiteB");
-				iae.setLastUpdated(new Date());
-				Date newDate = iae.getLastUpdated();
-
-				em.persist(iae);
-				// flush to the DB
-				em.flush();
-				// close the transaction
-				et.commit();
-
-				// Assert that the old and new update times are different
-				assertNotEquals(oldDate, newDate);
-			}
-		}
-	}
-
-	/* Tests that all the entries from a class can be retrieved */
-	@Test
-	public void testGetAllMyEntriesString() throws Exception {
-		Properties properties = makeProperties();
-
-		// create entries for the IntegrityAuditEntity table
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
-		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
-
-		// Obtain a hash with the persisted objects
-		Map<Object, Object> entries = d.getAllMyEntries("org.onap.policy.common.ia.jpa.IntegrityAuditEntity");
-
-		// Assert there were 3 entries for that class
-		assertEquals(3, entries.size());
-	}
-
-	/*
-	 * Tests retrieving all entities in a Persistence Unit using the class name
-	 * and a hashset of IDs
-	 */
-	@Test
-	public void testGetAllMyEntriesStringHashSet() throws Exception {
-		Properties properties = makeProperties();
-
-		// create entries for the IntegrityAuditEntity table
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
-		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
-
-		// Obtain all entity keys
-		CriteriaBuilder cb = em.getCriteriaBuilder();
-		CriteriaQuery<Object> cq = cb.createQuery();
-		Root<?> rootEntry = cq.from(Class.forName("org.onap.policy.common.ia.jpa.IntegrityAuditEntity"));
-		CriteriaQuery<Object> all = cq.select(rootEntry);
-		TypedQuery<Object> allQuery = em.createQuery(all);
-		List<Object> objectList = allQuery.getResultList();
-		HashSet<Object> resultSet = new HashSet<Object>();
-		PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
-		for (Object o : objectList) {
-			Object key = util.getIdentifier(o);
-			resultSet.add(key);
-		}
-
-		// Obtain a hash with the persisted objects
-		Map<Object, Object> entries = d.getAllMyEntries("org.onap.policy.common.ia.jpa.IntegrityAuditEntity",
-				resultSet);
-
-		// Assert there were 3 entries for that class
-		assertEquals(3, entries.size());
-	}
-
-	/*
-	 * Tests retrieving all entities in a Persistence Unit using the persistence
-	 * unit, properties, and class name
-	 */
-	@Test
-	public void testGetAllEntriesStringPropertiesString() throws Exception {
-		Properties properties = makeProperties();
-
-		// create entries for the IntegrityAuditEntity table
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
-		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
-
-		// Obtain a hash with the persisted objects
-		Map<Object, Object> entries = d.getAllEntries("integrityAuditPU", properties,
-				"org.onap.policy.common.ia.jpa.IntegrityAuditEntity");
-
-		// Assert there were 3 entries for that class
-		assertEquals(3, entries.size());
-	}
-
-	/*
-	 * Tests retrieving all entities in a Persistence Unit using the persistence
-	 * unit, properties, class name, and a hashset of IDs
-	 */
-	@Test
-	public void testGetAllEntriesStringPropertiesStringHashSet() throws Exception {
-		Properties properties = makeProperties();
-
-		// create entries for the IntegrityAuditEntity table
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
-		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
-
-		// Obtain all entity keys
-		CriteriaBuilder cb = em.getCriteriaBuilder();
-		CriteriaQuery<Object> cq = cb.createQuery();
-		Root<?> rootEntry = cq.from(Class.forName("org.onap.policy.common.ia.jpa.IntegrityAuditEntity"));
-		CriteriaQuery<Object> all = cq.select(rootEntry);
-		TypedQuery<Object> allQuery = em.createQuery(all);
-		List<Object> objectList = allQuery.getResultList();
-		HashSet<Object> resultSet = new HashSet<Object>();
-		PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
-		for (Object o : objectList) {
-			Object key = util.getIdentifier(o);
-			resultSet.add(key);
-		}
-
-		// Obtain a hash with the persisted objects
-		Map<Object, Object> entries = d.getAllEntries("integrityAuditPU", properties,
-				"org.onap.policy.common.ia.jpa.IntegrityAuditEntity", resultSet);
-
-		// Assert there were 3 entries for that class
-		assertEquals(3, entries.size());
-	}
-
-	/*
-	 * Tests getting all the entries from a class based on persistenceUnit,
-	 * properties, and className
-	 */
-	@Test
-	public void testGetAllEntries() throws Exception {
-		Properties properties = makeProperties();
-
-		// create entries for the IntegrityAuditEntity table
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-		new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
-		new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
-
-		// Obtain a hash with the persisted objects
-		Map<Object, Object> entries = d.getAllEntries(A_SEQ_PU, properties,
-				"org.onap.policy.common.ia.jpa.IntegrityAuditEntity");
-
-		// Assert there were 3 entries for that class
-		assertEquals(3, entries.size());
-	}
-
-	/* Tests obtaining all class names of persisted classes */
-	public void testGetPersistenceClassNames() throws Exception {
-		Properties properties = makeProperties();
-
-		d = new DbDAO(resourceName, A_SEQ_PU, properties);
-
-		// Retrieve persistence class names
-		Set<String> result = d.getPersistenceClassNames();
-		assertEquals(1, result.size());
-	}
+    private static String resourceName = "pdp0";
+
+    private DbDAO dbDao;
+
+    @BeforeClass
+    public static void setUpBeforeClass() throws Exception {
+        IntegrityAuditTestBase.setUpBeforeClass(DEFAULT_DB_URL_PREFIX + DbDAOTest.class.getSimpleName());
+    }
+
+    @AfterClass
+    public static void tearDownAfterClass() {
+        IntegrityAuditTestBase.tearDownAfterClass();
+    }
+
+    @Override
+    @Before
+    public void setUp() {
+        super.setUp();
+        dbDao = null;
+    }
+
+    /**
+     * Tear down after test cases.
+     */
+    @Override
+    @After
+    public void tearDown() {
+        if (dbDao != null) {
+            dbDao.destroy();
+        }
+
+        super.tearDown();
+    }
+
+    /* Tests registering a new IntegrityAuditEntity object in the DB */
+    @Test
+    public void testNewRegistration() throws Exception {
+        Properties properties = makeProperties();
+
+        try (EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
+            dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+            // Find the proper entry in the database
+            Query iaequery = em.createQuery(
+                    "Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+            iaequery.setParameter("rn", DbDAOTest.resourceName);
+            iaequery.setParameter("pu", DbDAOTest.A_SEQ_PU);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+
+            // Assert that the IntegrityAuditEntity object was found
+            assertNotNull(iaeList);
+
+            // flush to the DB
+            em.flush();
+            et.commit();
+        }
+    }
+
+    /*
+     * Tests updating an IntegrityAuditEntity if it has already been registered
+     */
+    @Test
+    public void testUpdateRegistration() throws Exception {
+        Properties properties = makeProperties();
+
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+        // Change site_name in properties to test that an update was made to
+        // an existing entry in the table
+        properties.put(IntegrityAuditProperties.SITE_NAME, "SiteB");
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+        try (EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
+            // Find the proper entry in the database
+            Query iaequery = em.createQuery(
+                    "Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+            iaequery.setParameter("rn", DbDAOTest.resourceName);
+            iaequery.setParameter("pu", DbDAOTest.A_SEQ_PU);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae = null;
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+
+                em.refresh(iae);
+                em.persist(iae);
+
+                // flush to the DB
+                em.flush();
+
+                // commit transaction
+                et.commit();
+
+                // Assert that the site_name for the existing entry was updated
+                assertEquals("SiteB", iae.getSite());
+            }
+        }
+    }
+
+    /* Tests obtaining all Integrity Audit Entities from a table */
+    @Test
+    public void testGetIntegrityAuditEntities() throws Exception {
+        Properties properties = makeProperties();
+
+        // Add some entries to the DB
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+        properties.put(IntegrityAuditProperties.NODE_TYPE, "pdp_drools");
+        new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+        List<IntegrityAuditEntity> entities;
+        // Obtain entries based on persistenceUnit and nodeType
+        entities = dbDao.getIntegrityAuditEntities(A_SEQ_PU, "pdp_xacml");
+        assertEquals(2, entities.size());
+    }
+
+    /* Tests retrieving a DbDAO instance's IntegrityAuditEntity */
+    @Test
+    public void testGetMyIntegrityAuditEntity() throws Exception {
+        Properties properties = makeProperties();
+
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        IntegrityAuditEntity iae = dbDao.getMyIntegrityAuditEntity();
+        // assertEquals("integrityAuditPU", iae.getPersistenceUnit());
+        assertEquals(A_SEQ_PU, iae.getPersistenceUnit());
+    }
+
+    /* Tests obtaining an IntegrityAuditEntity by ID */
+    @Test
+    public void testGetIntegrityAuditEntity() throws Exception {
+        Properties properties = makeProperties();
+
+        // Obtain an entry from the database based on ID
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+        // Find the proper database entry
+        Query iaequery = em
+                .createQuery("Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+        iaequery.setParameter("rn", DbDAOTest.resourceName);
+        iaequery.setParameter("pu", DbDAOTest.A_SEQ_PU);
+
+        @SuppressWarnings("rawtypes")
+        List iaeList = iaequery.getResultList();
+        IntegrityAuditEntity iae = null;
+        if (!iaeList.isEmpty()) {
+            // ignores multiple results
+            iae = (IntegrityAuditEntity) iaeList.get(0);
+
+            // refresh the object from DB in case cached data was returned
+            em.refresh(iae);
+
+            // Obtain ID for an IntegrityAuditEntity
+            PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
+            Object iaeId = util.getIdentifier(iae);
+
+            // Obtain the same IntegrityAuditEntity based on ID
+            IntegrityAuditEntity iaeDuplicate = dbDao.getIntegrityAuditEntity((long) iaeId);
+            Object duplicateId = util.getIdentifier(iaeDuplicate);
+
+            // Assert that the proper entry was retrieved based on ID
+            assertEquals((long) iaeId, (long) duplicateId);
+        }
+    }
+
+    /* Tests setting an IntegrityAuditEntity as the designated node */
+    @Test
+    public void testSetDesignated() throws Exception {
+        Properties properties = makeProperties();
+
+        try (EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
+            // Create an entry and set it's designated field to true
+            dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+            dbDao.setDesignated(resourceName, A_SEQ_PU, true);
+
+            // Find the proper entry in the database
+            Query iaequery = em.createQuery(
+                    "Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+            iaequery.setParameter("rn", resourceName);
+            iaequery.setParameter("pu", A_SEQ_PU);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae = null;
+
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+                em.refresh(iae);
+
+                // Check if the node is designated
+                boolean result = iae.isDesignated();
+
+                // Assert that it is designated
+                assertTrue(result);
+            }
+
+            // flush to the DB
+            em.flush();
+
+            // close the transaction
+            et.commit();
+        }
+    }
+
+    /* Tests that the lastUpdated column in the database is updated properly */
+    @Test
+    public void testSetLastUpdated() throws Exception {
+        Properties properties = makeProperties();
+
+        try (EntityTransCloser et = new EntityTransCloser(em.getTransaction())) {
+            // Create an entry
+            dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+            // Find the proper entry in the database
+            Query iaequery = em.createQuery(
+                    "Select i from IntegrityAuditEntity i where i.resourceName=:rn and i.persistenceUnit=:pu");
+            iaequery.setParameter("rn", resourceName);
+            iaequery.setParameter("pu", A_SEQ_PU);
+
+            @SuppressWarnings("rawtypes")
+            List iaeList = iaequery.getResultList();
+            IntegrityAuditEntity iae = null;
+
+            if (!iaeList.isEmpty()) {
+                // ignores multiple results
+                iae = (IntegrityAuditEntity) iaeList.get(0);
+                // refresh the object from DB in case cached data was returned
+                em.refresh(iae);
+
+                // Obtain old update value and set new update value
+                final Date oldDate = iae.getLastUpdated();
+
+                // ensure dates are different by sleeping for a bit
+                Thread.sleep(1);
+
+                iae.setSite("SiteB");
+                iae.setLastUpdated(new Date());
+                final Date newDate = iae.getLastUpdated();
+
+                em.persist(iae);
+                // flush to the DB
+                em.flush();
+                // close the transaction
+                et.commit();
+
+                // Assert that the old and new update times are different
+                assertNotEquals(oldDate, newDate);
+            }
+        }
+    }
+
+    /* Tests that all the entries from a class can be retrieved */
+    @Test
+    public void testGetAllMyEntriesString() throws Exception {
+        Properties properties = makeProperties();
+
+        // create entries for the IntegrityAuditEntity table
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+        new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+        // Obtain a hash with the persisted objects
+        Map<Object, Object> entries = dbDao.getAllMyEntries("org.onap.policy.common.ia.jpa.IntegrityAuditEntity");
+
+        // Assert there were 3 entries for that class
+        assertEquals(3, entries.size());
+    }
+
+    /*
+     * Tests retrieving all entities in a Persistence Unit using the class name and a hashset of IDs
+     */
+    @Test
+    public void testGetAllMyEntriesStringHashSet() throws Exception {
+        Properties properties = makeProperties();
+
+        // create entries for the IntegrityAuditEntity table
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+        new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+        // Obtain all entity keys
+        CriteriaBuilder cb = em.getCriteriaBuilder();
+        CriteriaQuery<Object> cq = cb.createQuery();
+        Root<?> rootEntry = cq.from(Class.forName("org.onap.policy.common.ia.jpa.IntegrityAuditEntity"));
+        CriteriaQuery<Object> all = cq.select(rootEntry);
+        TypedQuery<Object> allQuery = em.createQuery(all);
+        List<Object> objectList = allQuery.getResultList();
+        HashSet<Object> resultSet = new HashSet<Object>();
+        PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
+        for (Object o : objectList) {
+            Object key = util.getIdentifier(o);
+            resultSet.add(key);
+        }
+
+        // Obtain a hash with the persisted objects
+        Map<Object, Object> entries =
+                dbDao.getAllMyEntries("org.onap.policy.common.ia.jpa.IntegrityAuditEntity", resultSet);
+
+        // Assert there were 3 entries for that class
+        assertEquals(3, entries.size());
+    }
+
+    /*
+     * Tests retrieving all entities in a Persistence Unit using the persistence unit, properties,
+     * and class name
+     */
+    @Test
+    public void testGetAllEntriesStringPropertiesString() throws Exception {
+        Properties properties = makeProperties();
+
+        // create entries for the IntegrityAuditEntity table
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+        new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+        // Obtain a hash with the persisted objects
+        Map<Object, Object> entries = dbDao.getAllEntries("integrityAuditPU", properties,
+                "org.onap.policy.common.ia.jpa.IntegrityAuditEntity");
+
+        // Assert there were 3 entries for that class
+        assertEquals(3, entries.size());
+    }
+
+    /*
+     * Tests retrieving all entities in a Persistence Unit using the persistence unit, properties,
+     * class name, and a hashset of IDs
+     */
+    @Test
+    public void testGetAllEntriesStringPropertiesStringHashSet() throws Exception {
+        Properties properties = makeProperties();
+
+        // create entries for the IntegrityAuditEntity table
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+        new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+        // Obtain all entity keys
+        CriteriaBuilder cb = em.getCriteriaBuilder();
+        CriteriaQuery<Object> cq = cb.createQuery();
+        Root<?> rootEntry = cq.from(Class.forName("org.onap.policy.common.ia.jpa.IntegrityAuditEntity"));
+        CriteriaQuery<Object> all = cq.select(rootEntry);
+        TypedQuery<Object> allQuery = em.createQuery(all);
+        List<Object> objectList = allQuery.getResultList();
+        HashSet<Object> resultSet = new HashSet<Object>();
+        PersistenceUnitUtil util = emf.getPersistenceUnitUtil();
+        for (Object o : objectList) {
+            Object key = util.getIdentifier(o);
+            resultSet.add(key);
+        }
+
+        // Obtain a hash with the persisted objects
+        Map<Object, Object> entries = dbDao.getAllEntries("integrityAuditPU", properties,
+                "org.onap.policy.common.ia.jpa.IntegrityAuditEntity", resultSet);
+
+        // Assert there were 3 entries for that class
+        assertEquals(3, entries.size());
+    }
+
+    /*
+     * Tests getting all the entries from a class based on persistenceUnit, properties, and
+     * className
+     */
+    @Test
+    public void testGetAllEntries() throws Exception {
+        Properties properties = makeProperties();
+
+        // create entries for the IntegrityAuditEntity table
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+        new DbDAO("pdp1", A_SEQ_PU, properties).destroy();
+        new DbDAO("pdp2", A_SEQ_PU, properties).destroy();
+
+        // Obtain a hash with the persisted objects
+        Map<Object, Object> entries =
+                dbDao.getAllEntries(A_SEQ_PU, properties, "org.onap.policy.common.ia.jpa.IntegrityAuditEntity");
+
+        // Assert there were 3 entries for that class
+        assertEquals(3, entries.size());
+    }
+
+    /**
+     * Tests obtaining all class names of persisted classes.
+     */
+    public void testGetPersistenceClassNames() throws Exception {
+        Properties properties = makeProperties();
+
+        dbDao = new DbDAO(resourceName, A_SEQ_PU, properties);
+
+        // Retrieve persistence class names
+        Set<String> result = dbDao.getPersistenceClassNames();
+        assertEquals(1, result.size());
+    }
 }
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/ExceptionsTest.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/ExceptionsTest.java
index b02b0c7f..3c8ce528 100644
--- a/integrity-audit/src/test/java/org/onap/policy/common/ia/ExceptionsTest.java
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/ExceptionsTest.java
@@ -23,10 +23,6 @@ package org.onap.policy.common.ia;
 import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
-import org.onap.policy.common.ia.DbAuditException;
-import org.onap.policy.common.ia.DbDaoTransactionException;
-import org.onap.policy.common.ia.IntegrityAuditException;
-import org.onap.policy.common.ia.IntegrityAuditPropertiesException;
 import org.onap.policy.common.utils.test.ExceptionsTester;
 
 /**
@@ -34,23 +30,23 @@ import org.onap.policy.common.utils.test.ExceptionsTester;
  */
 public class ExceptionsTest extends ExceptionsTester {
 
-	@Test
-	public void testDbAuditException() throws Exception {
-		assertEquals(4, test(DbAuditException.class));
-	}
-
-	@Test
-	public void testDbDaoTransactionException() throws Exception {
-		assertEquals(4, test(DbDaoTransactionException.class));
-	}
-
-	@Test
-	public void testIntegrityAuditException() throws Exception {
-		assertEquals(4, test(IntegrityAuditException.class));
-	}
-
-	@Test
-	public void testIntegrityAuditPropertiesException() throws Exception {
-		assertEquals(4, test(IntegrityAuditPropertiesException.class));
-	}
+    @Test
+    public void testDbAuditException() throws Exception {
+        assertEquals(4, test(DbAuditException.class));
+    }
+
+    @Test
+    public void testDbDaoTransactionException() throws Exception {
+        assertEquals(4, test(DbDaoTransactionException.class));
+    }
+
+    @Test
+    public void testIntegrityAuditException() throws Exception {
+        assertEquals(4, test(IntegrityAuditException.class));
+    }
+
+    @Test
+    public void testIntegrityAuditPropertiesException() throws Exception {
+        assertEquals(4, test(IntegrityAuditPropertiesException.class));
+    }
 }
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditDesignationTest.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditDesignationTest.java
index 1861787a..69f37da5 100644
--- a/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditDesignationTest.java
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditDesignationTest.java
@@ -30,590 +30,573 @@ import org.onap.policy.common.logging.flexlogger.Logger;
 import org.onap.policy.common.utils.test.log.logback.ExtractAppender;
 
 /**
- * All JUnits are designed to run in the local development environment where
- * they have write privileges and can execute time-sensitive tasks.
- * <p/>
- * Many of the test verification steps are performed by scanning for items
- * written to the log file. Rather than actually scan the log file, an
- * {@link ExtractAppender} is used to monitor events that are logged and extract
- * relevant items. In order to attach the appender to the debug log, it assumes
- * that the debug log is a <i>logback</i> Logger configured per EELF.
- * <p/>
- * These tests use a temporary, in-memory DB, which is dropped once the tests
- * complete.
+ * All JUnits are designed to run in the local development environment where they have write
+ * privileges and can execute time-sensitive tasks.
+ * 
+ * <p>Many of the test verification steps are performed by scanning for items written to the log
+ * file. Rather than actually scan the log file, an {@link ExtractAppender} is used to monitor
+ * events that are logged and extract relevant items. In order to attach the appender to the debug
+ * log, it assumes that the debug log is a <i>logback</i> Logger configured per EELF.
+ * 
+ * <p>These tests use a temporary, in-memory DB, which is dropped once the tests complete.
  */
 public class IntegrityAuditDesignationTest extends IntegrityAuditTestBase {
 
-	private static Logger logger = FlexLogger.getLogger(IntegrityAuditDesignationTest.class);
-
-	/**
-	 * Matches specified PDPs in the debug log. A regular expression matching
-	 * the desired PDPs should be appended, followed by a right parenthesis. For
-	 * example:
-	 * 
-	 * <pre>
-	 * <code>new ExtractAppender(START_AUDIT_RE_PREFIX + "pdp[124])")
-	 * </code>
-	 * </pre>
-	 */
-	private static final String START_AUDIT_RE_PREFIX = "Starting audit simulation for resourceName=(";
-
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		IntegrityAuditTestBase
-				.setUpBeforeClass(DEFAULT_DB_URL_PREFIX + IntegrityAuditDesignationTest.class.getSimpleName());
-	}
-
-	@AfterClass
-	public static void tearDownAfterClass() {
-		IntegrityAuditTestBase.tearDownAfterClass();
-	}
-
-	@Before
-	public void setUp() {
-		logger.info("setUp: Entering");
-
-		super.setUp();
-
-		logger.info("setUp: Exiting");
-	}
-
-	@After
-	public void tearDown() {
-		logger.info("tearDown: Entering");
-
-		super.tearDown();
-
-		logger.info("tearDown: Exiting");
-
-	}
-
-	/*
-	 * Tests designation logic when only one functioning resource is in play.
-	 * Designation should stay with single resource.
-	 * 
-	 * Note: console.log must be examined to ascertain whether or not this test
-	 * was successful.
-	 */
-	@Test
-	public void testOneResource() throws Exception {
-
-		logger.info("testOneResource: Entering");
-
-		ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
-
-		MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
-
-		/*
-		 * Wait for
-		 * 
-		 * 1) pdp1 to run audit
-		 * 
-		 * 2) Logic to detect that no other node is available for designation
-		 * 
-		 * 3) pdp1 to run audit again
-		 */
-		runAudit(integrityAudit);
-		waitStaleAndRun(integrityAudit);
-
-		logger.info("testOneResource: Stopping audit thread");
-		integrityAudit.stopAuditThread();
-
-		verifyItemsInLog(logA, "pdp1");
-
-		/*
-		 * Test fix for ONAPD2TD-783: Audit fails to run when application is
-		 * restarted.
-		 */
-		integrityAudit.startAuditThread();
-
-		/*
-		 * Sleep long enough to allow
-		 * 
-		 * 1) pdp1 to run audit
-		 * 
-		 * 2) Logic to detect that no other node is available for designation
-		 * 
-		 * 3) pdp1 to run audit again
-		 */
-		runAudit(integrityAudit);
-		waitStaleAndRun(integrityAudit);
-
-		verifyItemsInLog(logA, "pdp1");
-
-		logger.info("testOneResource: Exiting");
-
-	}
-
-	/*
-	 * Tests designation logic when two functioning resources are in play.
-	 * Designation should alternate between resources.
-	 * 
-	 * Note: console.log must be examined to ascertain whether or not this test
-	 * was successful. A quick way of examining the log is to search for the
-	 * string "audit simulation":
-	 * 
-	 * As you can see from the "dbAuditSimulate" method, when it executes, it
-	 * logs the "Starting audit simulation..." message and when it finishes, it
-	 * logs the "Finished audit simulation..." message. By looking for these
-	 * messages, you can verify that the audits are run by the proper resource.
-	 * For example, when testFourResourcesOneDead is run, you should see a
-	 * Starting.../Finished... sequence for "pdp1", followed by a
-	 * Starting.../Finished... sequence for pdp2, followed by a
-	 * Starting.../Finished... sequence for pdp4 (pdp3 is skipped as it's
-	 * dead/hung), followed by a Starting.../Finished... sequence for "pdp1",
-	 * etc.
-	 */
-	@Test
-	public void testTwoResources() throws Exception {
-
-		logger.info("testTwoResources: Entering");
-
-		ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
-
-		/*
-		 * Start audit for pdp1.
-		 */
-		MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
-
-		/*
-		 * Start audit for pdp2.
-		 */
-		MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", A_SEQ_PU);
-
-		/*
-		 * Sleep long enough to allow
-		 * 
-		 * 1) pdp1 to run audit
-		 * 
-		 * 2) Logic to detect that pdp1 is stale and designate pdp2
-		 * 
-		 * 3) pdp2 to run audit
-		 * 
-		 * 4) Logic to detect that pdp2 is stale and designate pdp1
-		 * 
-		 * 5) pdp1 to run audit
-		 */
-		runAudit(integrityAudit);
-		waitStaleAndRun(integrityAudit2);
-		waitStaleAndRun(integrityAudit);
-
-		verifyItemsInLog(logA, "pdp1", "pdp2", "pdp1");
-
-		logger.info("testTwoResources: Exiting");
-
-	}
-
-	/*
-	 * Tests designation logic when two functioning resources are in play, each
-	 * with different PUs. Audits for persistenceUnit and PU_B should run
-	 * simultaneously. Designation should not alternate.
-	 * 
-	 * Note: console.log must be examined to ascertain whether or not this test
-	 * was successful.
-	 */
-	@Test
-	public void testTwoResourcesDifferentPus() throws Exception {
-
-		logger.info("testTwoResourcesDifferentPus: Entering");
-
-		ExtractAppender logA = watch(debugLogger, START_AUDIT_RE_PREFIX + "pdp1)");
-		ExtractAppender logB = watch(debugLogger, START_AUDIT_RE_PREFIX + "pdp2)");
-
-		/*
-		 * Start audit for pdp1.
-		 */
-		MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
-
-		/*
-		 * Start audit for pdp2.
-		 */
-		MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", B_SEQ_PU);
-
-		/*
-		 * Sleep long enough to allow
-		 * 
-		 * 1) pdp1 and pdp2 to run audit simultaneously
-		 * 
-		 * 2) Logic to detect that no other node is available for designation
-		 * for either pdp1 or pdp2
-		 * 
-		 * 3) pdp1 and pdp2 to again run audit simultaneously
-		 */
-		runAudit(integrityAudit, integrityAudit2);
-		waitStaleAndRun(integrityAudit, integrityAudit2);
-
-		verifyItemsInLog(logA, "pdp1", "pdp1");
-		verifyItemsInLog(logB, "pdp2", "pdp2");
-
-		logger.info("testTwoResourcesDifferentPus: Exiting");
-
-	}
-
-	/*
-	 * Tests designation logic when two resources are in play but one of them is
-	 * dead/hung. Designation should move to second resource but then get
-	 * restored back to original resource when it's discovered that second
-	 * resource is dead.
-	 * 
-	 * Note: console.log must be examined to ascertain whether or not this test
-	 * was successful.
-	 */
-	@Test
-	public void testTwoResourcesOneDead() throws Exception {
-
-		logger.info("testTwoResourcesOneDead: Entering");
-
-		ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
-
-		/*
-		 * Start audit for pdp1.
-		 */
-		MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
-
-		/*
-		 * Populate DB for pdp2, which will simulate it having registered but
-		 * then having died.
-		 */
-		new DbDAO("pdp2", A_SEQ_PU, makeProperties()).destroy();
-
-		/*
-		 * Sleep long enough to allow
-		 * 
-		 * 1) pdp1 to run audit
-		 * 
-		 * 2) Logic to detect that other node, pdp2, is not available for
-		 * designation
-		 * 
-		 * 3) pdp1 to run audit again
-		 */
-		runAudit(integrityAudit);
-		waitStaleAndRun(integrityAudit);
-
-		verifyItemsInLog(logA, "pdp1", "pdp1");
-
-		logger.info("testTwoResourcesOneDead: Exiting");
-
-	}
-
-	/*
-	 * Tests designation logic when three functioning resources are in play.
-	 * Designation should round robin among resources.
-	 * 
-	 * Note: console.log must be examined to ascertain whether or not this test
-	 * was successful.
-	 */
-	@Test
-	public void testThreeResources() throws Exception {
-
-		logger.info("testThreeResources: Entering");
-
-		ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
-
-		/*
-		 * Start audit for pdp1.
-		 */
-		MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
-
-		/*
-		 * Start audit for pdp2.
-		 */
-		MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", A_SEQ_PU);
-
-		/*
-		 * Start audit for pdp3.
-		 */
-		MyIntegrityAudit integrityAudit3 = makeAuditor("pdp3", A_SEQ_PU);
-
-		/*
-		 * Sleep long enough to allow
-		 * 
-		 * 1) pdp1 to run audit
-		 * 
-		 * 2) Logic to detect that pdp1 is stale and designate pdp2
-		 * 
-		 * 3) pdp2 to run audit
-		 * 
-		 * 4) Logic to detect that pdp2 is stale and designate pdp3
-		 * 
-		 * 5) pdp3 to run audit
-		 * 
-		 * 6) Logic to detect that pdp3 is stale and designate pdp1
-		 * 
-		 * 7) pdp1 to run audit
-		 */
-		runAudit(integrityAudit);
-		waitStaleAndRun(integrityAudit2);
-		waitStaleAndRun(integrityAudit3);
-		waitStaleAndRun(integrityAudit);
-
-		verifyItemsInLog(logA, "pdp1", "pdp2", "pdp3", "pdp1");
-
-		logger.info("testThreeResources: Exiting");
-
-	}
-
-	/*
-	 * Tests designation logic when four functioning resources are in play, two
-	 * with one PU, two with another. Audits for persistenceUnit and PU_B should
-	 * run simultaneously. Designation should alternate between resources for
-	 * each of the two persistence units.
-	 * 
-	 * Note: console.log must be examined to ascertain whether or not this test
-	 * was successful.
-	 */
-	@Test
-	public void testFourResourcesDifferentPus() throws Exception {
-
-		logger.info("testFourResourcesDifferentPus: Entering");
-
-		ExtractAppender logA = watch(debugLogger, START_AUDIT_RE_PREFIX + "pdp1|pdp3)");
-		ExtractAppender logB = watch(debugLogger, START_AUDIT_RE_PREFIX + "pdp2|pdp4)");
-
-		/*
-		 * Start audit for "pdp1", testPU.
-		 */
-		MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
-
-		/*
-		 * Start audit for pdp2, integrityAuditPU.
-		 */
-		MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", B_SEQ_PU);
-
-		/*
-		 * Start audit for pdp3, testPU.
-		 */
-		MyIntegrityAudit integrityAudit3 = makeAuditor("pdp3", A_SEQ_PU);
-
-		/*
-		 * Start audit for pdp4, integrityAuditPU.
-		 */
-		MyIntegrityAudit integrityAudit4 = makeAuditor("pdp4", B_SEQ_PU);
-
-		/*
-		 * Sleep long enough to allow
-		 * 
-		 * 1) pdp1 and pdp2 to run audit simultaneously
-		 * 
-		 * 2) Logic to detect that pdp1 and pdp2 are stale and designate pdp3
-		 * (one's counterpart) and pdp4 (two's counterpart)
-		 * 
-		 * 3) pdp3 and pdp4 to run audit simultaneously
-		 * 
-		 * 4) Logic to detect that pdp3 and pdp4 are stale and designate pdp1
-		 * (three's counterpart) and pdp2 (four's counterpart)
-		 * 
-		 * 5) pdp1 and pdp2 to run audit simultaneously
-		 */
-		runAudit(integrityAudit, integrityAudit2);
-		waitStaleAndRun(integrityAudit3, integrityAudit4);
-		waitStaleAndRun(integrityAudit, integrityAudit2);
-
-		/*
-		 * These sequences may be intermingled, so we extract and compare one
-		 * sequence at a time.
-		 */
-
-		// only care about pdp1 & pdp3 in this sequence
-		verifyItemsInLog(logA, "pdp1", "pdp3", "pdp1");
-
-		// only care about pdp2 & pdp4 in this sequence
-		verifyItemsInLog(logB, "pdp2", "pdp4", "pdp2");
-
-		logger.info("testFourResourcesDifferentPus: Exiting");
-
-	}
-
-	/*
-	 * Tests designation logic when four resources are in play but one is not
-	 * functioning. Designation should round robin among functioning resources
-	 * only.
-	 * 
-	 * Note: console.log must be examined to ascertain whether or not this test
-	 * was successful.
-	 */
-	@Test
-	public void testFourResourcesOneDead() throws Exception {
-
-		logger.info("testFourResourcesOneDead: Entering");
-
-		ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
-
-		/*
-		 * Start audit for pdp1.
-		 */
-		MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
-
-		/*
-		 * Start audit for pdp2.
-		 */
-		MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", A_SEQ_PU);
-
-		/*
-		 * Populate DB for pdp3, which will simulate it having registered but
-		 * then having died.
-		 */
-		new DbDAO("pdp3", A_SEQ_PU, makeProperties()).destroy();
-
-		/*
-		 * Start audit for pdp4.
-		 */
-		MyIntegrityAudit integrityAudit4 = makeAuditor("pdp4", A_SEQ_PU);
-
-		/*
-		 * Sleep long enough to allow
-		 * 
-		 * 1) pdp1 to run audit
-		 * 
-		 * 2) Logic to detect that pdp1 is stale and designate pdp2
-		 * 
-		 * 3) pdp2 to run audit
-		 * 
-		 * 4) Logic to detect that pdp2 is stale and designate pdp4
-		 * 
-		 * 5) pdp4 to run audit
-		 * 
-		 * 6) Logic to detect that pdp4 is stale and designate pdp1
-		 * 
-		 * 7) pdp1 to run audit
-		 * 
-		 * 8) Logic to detect that pdp1 is stale and designate pdp2
-		 * 
-		 * 7) pdp2 to run audit
-		 */
-		runAudit(integrityAudit);
-		waitStaleAndRun(integrityAudit2);
-		waitStaleAndRun(integrityAudit4);
-		waitStaleAndRun(integrityAudit);
-		waitStaleAndRun(integrityAudit2);
-		waitStaleAndRun(integrityAudit4);
-
-		verifyItemsInLog(logA, "pdp1", "pdp2", "pdp4", "pdp1", "pdp2", "pdp4");
-
-		logger.info("testFourResourcesOneDead: Exiting");
-
-	}
-
-	/*
-	 * Tests designation logic when four resources are in play but only one is
-	 * functioning. Designation should remain with sole functioning resource.
-	 * 
-	 * Note: console.log must be examined to ascertain whether or not this test
-	 * was successful.
-	 */
-	@Test
-	public void testFourResourcesThreeDead() throws Exception {
-
-		logger.info("testFourResourcesThreeDead: Entering");
-
-		ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
-
-		/*
-		 * Populate DB for "pdp1", which will simulate it having registered but
-		 * then having died.
-		 */
-		new DbDAO("pdp1", A_SEQ_PU, makeProperties()).destroy();
-
-		/*
-		 * Populate DB for pdp2, which will simulate it having registered but
-		 * then having died.
-		 */
-		new DbDAO("pdp2", A_SEQ_PU, makeProperties()).destroy();
-
-		/*
-		 * Start audit for pdp3.
-		 */
-		MyIntegrityAudit integrityAudit3 = makeAuditor("pdp3", A_SEQ_PU);
-
-		/*
-		 * Populate DB for pdp4, which will simulate it having registered but
-		 * then having died.
-		 */
-		new DbDAO("pdp4", A_SEQ_PU, makeProperties()).destroy();
-
-		/*
-		 * Sleep long enough to allow
-		 * 
-		 * 1) pdp3 to discover that all other designation candidates are stale
-		 * 
-		 * 1) pdp3 to run audit
-		 * 
-		 * 2) Logic to detect that no other nodes are available for designation
-		 * 
-		 * 3) pdp3 to run audit again
-		 */
-		runAudit(integrityAudit3);
-		waitStaleAndRun(integrityAudit3);
-
-		verifyItemsInLog(logA, "pdp3", "pdp3");
-
-		logger.info("testFourResourcesThreeDead: Exiting");
-
-	}
-
-	/*
-	 * Tests designation logic when the designated node dies and is no longer
-	 * current
-	 * 
-	 * Note: console.log must be examined to ascertain whether or not this test
-	 * was successful.
-	 */
-	@Test
-	public void testDesignatedNodeDead() throws Exception {
-		logger.info("testDesignatedNodeDead: Entering");
-
-		ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
-
-		/*
-		 * Instantiate audit object for pdp1.
-		 */
-		MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
-
-		/*
-		 * Start audit for pdp2.
-		 */
-		MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", A_SEQ_PU);
-
-		/*
-		 * Instantiate audit object for pdp3.
-		 */
-		MyIntegrityAudit integrityAudit3 = makeAuditor("pdp3", A_SEQ_PU);
-
-		// Start audit on pdp1
-		logger.info("testDesignatedNodeDead: Start audit on pdp1");
-		runAudit(integrityAudit);
-
-		// Start the auditing threads on other nodes.
-		logger.info("testDesignatedNodeDead: Start audit on pdp2");
-		runAudit(integrityAudit2);
-
-		// Kill audit on pdp1
-		logger.info("testDesignatedNodeDead: Kill audit on pdp1");
-		integrityAudit.stopAuditThread();
-
-		// Wait long enough for pdp1 to get stale and pdp2 to take over
-		waitStaleAndRun(integrityAudit2);
-
-		// Start audit thread on pdp1 again.
-		logger.info("testDesignatedNodeDead: Start audit thread on pdp1 again.");
-		integrityAudit.startAuditThread();
-
-		// Wait long enough for pdp2 to complete its audit and get stale, at
-		// which point pdp3 should take over
-		logger.info(
-				"testDesignatedNodeDead: Wait long enough for pdp2 to complete its audit and get stale, at which point pdp3 should take over");
-		waitStaleAndRun(integrityAudit3);
-
-		// Kill audit on pdp3
-		logger.info("testDesignatedNodeDead: Killing audit on pdp3");
-		integrityAudit3.stopAuditThread();
-
-		// Wait long enough for pdp3 to get stale and pdp1 to take over
-		logger.info("testDesignatedNodeDead: Wait long enough for pdp3 to get stale and pdp1 to take over");
-		waitStaleAndRun(integrityAudit);
-
-		verifyItemsInLog(logA, "pdp1", "pdp2", "pdp3", "pdp1");
-
-		logger.info("testDesignatedNodeDead: Exiting");
-	}
+    private static Logger logger = FlexLogger.getLogger(IntegrityAuditDesignationTest.class);
+
+    /**
+     * Matches specified PDPs in the debug log. A regular expression matching the desired PDPs
+     * should be appended, followed by a right parenthesis. For example:
+     * 
+     * <pre>
+     * <code>new ExtractAppender(START_AUDIT_RE_PREFIX + "pdp[124])")
+     * </code>
+     * </pre>
+     */
+    private static final String START_AUDIT_RE_PREFIX = "Starting audit simulation for resourceName=(";
+
+    @BeforeClass
+    public static void setUpBeforeClass() throws Exception {
+        IntegrityAuditTestBase
+                .setUpBeforeClass(DEFAULT_DB_URL_PREFIX + IntegrityAuditDesignationTest.class.getSimpleName());
+    }
+
+    @AfterClass
+    public static void tearDownAfterClass() {
+        IntegrityAuditTestBase.tearDownAfterClass();
+    }
+
+    /**
+     * Set up before test cases.
+     */
+    @Override
+    @Before
+    public void setUp() {
+        logger.info("setUp: Entering");
+
+        super.setUp();
+
+        logger.info("setUp: Exiting");
+    }
+
+    /**
+     * Tear down after test cases.
+     */
+    @Override
+    @After
+    public void tearDown() {
+        logger.info("tearDown: Entering");
+
+        super.tearDown();
+
+        logger.info("tearDown: Exiting");
+
+    }
+
+    /*
+     * Tests designation logic when only one functioning resource is in play. Designation should
+     * stay with single resource.
+     * 
+     * Note: console.log must be examined to ascertain whether or not this test was successful.
+     */
+    @Test
+    public void testOneResource() throws Exception {
+
+        logger.info("testOneResource: Entering");
+
+        final ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
+
+        MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
+
+        /*
+         * Wait for
+         * 
+         * 1) pdp1 to run audit
+         * 
+         * 2) Logic to detect that no other node is available for designation
+         * 
+         * 3) pdp1 to run audit again
+         */
+        runAudit(integrityAudit);
+        waitStaleAndRun(integrityAudit);
+
+        logger.info("testOneResource: Stopping audit thread");
+        integrityAudit.stopAuditThread();
+
+        verifyItemsInLog(logA, "pdp1");
+
+        /*
+         * Test fix for ONAPD2TD-783: Audit fails to run when application is restarted.
+         */
+        integrityAudit.startAuditThread();
+
+        /*
+         * Sleep long enough to allow
+         * 
+         * 1) pdp1 to run audit
+         * 
+         * 2) Logic to detect that no other node is available for designation
+         * 
+         * 3) pdp1 to run audit again
+         */
+        runAudit(integrityAudit);
+        waitStaleAndRun(integrityAudit);
+
+        verifyItemsInLog(logA, "pdp1");
+
+        logger.info("testOneResource: Exiting");
+
+    }
+
+    /*
+     * Tests designation logic when two functioning resources are in play. Designation should
+     * alternate between resources.
+     * 
+     * Note: console.log must be examined to ascertain whether or not this test was successful. A
+     * quick way of examining the log is to search for the string "audit simulation":
+     * 
+     * As you can see from the "dbAuditSimulate" method, when it executes, it logs the
+     * "Starting audit simulation..." message and when it finishes, it logs the
+     * "Finished audit simulation..." message. By looking for these messages, you can verify that
+     * the audits are run by the proper resource. For example, when testFourResourcesOneDead is run,
+     * you should see a Starting.../Finished... sequence for "pdp1", followed by a
+     * Starting.../Finished... sequence for pdp2, followed by a Starting.../Finished... sequence for
+     * pdp4 (pdp3 is skipped as it's dead/hung), followed by a Starting.../Finished... sequence for
+     * "pdp1", etc.
+     */
+    @Test
+    public void testTwoResources() throws Exception {
+
+        logger.info("testTwoResources: Entering");
+
+        final ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
+
+        /*
+         * Start audit for pdp1.
+         */
+        MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
+
+        /*
+         * Start audit for pdp2.
+         */
+        MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", A_SEQ_PU);
+
+        /*
+         * Sleep long enough to allow
+         * 
+         * 1) pdp1 to run audit
+         * 
+         * 2) Logic to detect that pdp1 is stale and designate pdp2
+         * 
+         * 3) pdp2 to run audit
+         * 
+         * 4) Logic to detect that pdp2 is stale and designate pdp1
+         * 
+         * 5) pdp1 to run audit
+         */
+        runAudit(integrityAudit);
+        waitStaleAndRun(integrityAudit2);
+        waitStaleAndRun(integrityAudit);
+
+        verifyItemsInLog(logA, "pdp1", "pdp2", "pdp1");
+
+        logger.info("testTwoResources: Exiting");
+
+    }
+
+    /*
+     * Tests designation logic when two functioning resources are in play, each with different PUs.
+     * Audits for persistenceUnit and PU_B should run simultaneously. Designation should not
+     * alternate.
+     * 
+     * Note: console.log must be examined to ascertain whether or not this test was successful.
+     */
+    @Test
+    public void testTwoResourcesDifferentPus() throws Exception {
+
+        logger.info("testTwoResourcesDifferentPus: Entering");
+
+        final ExtractAppender logA = watch(debugLogger, START_AUDIT_RE_PREFIX + "pdp1)");
+        final ExtractAppender logB = watch(debugLogger, START_AUDIT_RE_PREFIX + "pdp2)");
+
+        /*
+         * Start audit for pdp1.
+         */
+        MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
+
+        /*
+         * Start audit for pdp2.
+         */
+        MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", B_SEQ_PU);
+
+        /*
+         * Sleep long enough to allow
+         * 
+         * 1) pdp1 and pdp2 to run audit simultaneously
+         * 
+         * 2) Logic to detect that no other node is available for designation for either pdp1 or
+         * pdp2
+         * 
+         * 3) pdp1 and pdp2 to again run audit simultaneously
+         */
+        runAudit(integrityAudit, integrityAudit2);
+        waitStaleAndRun(integrityAudit, integrityAudit2);
+
+        verifyItemsInLog(logA, "pdp1", "pdp1");
+        verifyItemsInLog(logB, "pdp2", "pdp2");
+
+        logger.info("testTwoResourcesDifferentPus: Exiting");
+
+    }
+
+    /*
+     * Tests designation logic when two resources are in play but one of them is dead/hung.
+     * Designation should move to second resource but then get restored back to original resource
+     * when it's discovered that second resource is dead.
+     * 
+     * Note: console.log must be examined to ascertain whether or not this test was successful.
+     */
+    @Test
+    public void testTwoResourcesOneDead() throws Exception {
+
+        logger.info("testTwoResourcesOneDead: Entering");
+
+        final ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
+
+        /*
+         * Start audit for pdp1.
+         */
+        MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
+
+        /*
+         * Populate DB for pdp2, which will simulate it having registered but then having died.
+         */
+        new DbDAO("pdp2", A_SEQ_PU, makeProperties()).destroy();
+
+        /*
+         * Sleep long enough to allow
+         * 
+         * 1) pdp1 to run audit
+         * 
+         * 2) Logic to detect that other node, pdp2, is not available for designation
+         * 
+         * 3) pdp1 to run audit again
+         */
+        runAudit(integrityAudit);
+        waitStaleAndRun(integrityAudit);
+
+        verifyItemsInLog(logA, "pdp1", "pdp1");
+
+        logger.info("testTwoResourcesOneDead: Exiting");
+
+    }
+
+    /*
+     * Tests designation logic when three functioning resources are in play. Designation should
+     * round robin among resources.
+     * 
+     * Note: console.log must be examined to ascertain whether or not this test was successful.
+     */
+    @Test
+    public void testThreeResources() throws Exception {
+
+        logger.info("testThreeResources: Entering");
+
+        final ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
+
+        /*
+         * Start audit for pdp1.
+         */
+        MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
+
+        /*
+         * Start audit for pdp2.
+         */
+        MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", A_SEQ_PU);
+
+        /*
+         * Start audit for pdp3.
+         */
+        MyIntegrityAudit integrityAudit3 = makeAuditor("pdp3", A_SEQ_PU);
+
+        /*
+         * Sleep long enough to allow
+         * 
+         * 1) pdp1 to run audit
+         * 
+         * 2) Logic to detect that pdp1 is stale and designate pdp2
+         * 
+         * 3) pdp2 to run audit
+         * 
+         * 4) Logic to detect that pdp2 is stale and designate pdp3
+         * 
+         * 5) pdp3 to run audit
+         * 
+         * 6) Logic to detect that pdp3 is stale and designate pdp1
+         * 
+         * 7) pdp1 to run audit
+         */
+        runAudit(integrityAudit);
+        waitStaleAndRun(integrityAudit2);
+        waitStaleAndRun(integrityAudit3);
+        waitStaleAndRun(integrityAudit);
+
+        verifyItemsInLog(logA, "pdp1", "pdp2", "pdp3", "pdp1");
+
+        logger.info("testThreeResources: Exiting");
+
+    }
+
+    /*
+     * Tests designation logic when four functioning resources are in play, two with one PU, two
+     * with another. Audits for persistenceUnit and PU_B should run simultaneously. Designation
+     * should alternate between resources for each of the two persistence units.
+     * 
+     * Note: console.log must be examined to ascertain whether or not this test was successful.
+     */
+    @Test
+    public void testFourResourcesDifferentPus() throws Exception {
+
+        logger.info("testFourResourcesDifferentPus: Entering");
+
+        final ExtractAppender logA = watch(debugLogger, START_AUDIT_RE_PREFIX + "pdp1|pdp3)");
+        final ExtractAppender logB = watch(debugLogger, START_AUDIT_RE_PREFIX + "pdp2|pdp4)");
+
+        /*
+         * Start audit for "pdp1", testPU.
+         */
+        MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
+
+        /*
+         * Start audit for pdp2, integrityAuditPU.
+         */
+        MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", B_SEQ_PU);
+
+        /*
+         * Start audit for pdp3, testPU.
+         */
+        MyIntegrityAudit integrityAudit3 = makeAuditor("pdp3", A_SEQ_PU);
+
+        /*
+         * Start audit for pdp4, integrityAuditPU.
+         */
+        MyIntegrityAudit integrityAudit4 = makeAuditor("pdp4", B_SEQ_PU);
+
+        /*
+         * Sleep long enough to allow
+         * 
+         * 1) pdp1 and pdp2 to run audit simultaneously
+         * 
+         * 2) Logic to detect that pdp1 and pdp2 are stale and designate pdp3 (one's counterpart)
+         * and pdp4 (two's counterpart)
+         * 
+         * 3) pdp3 and pdp4 to run audit simultaneously
+         * 
+         * 4) Logic to detect that pdp3 and pdp4 are stale and designate pdp1 (three's counterpart)
+         * and pdp2 (four's counterpart)
+         * 
+         * 5) pdp1 and pdp2 to run audit simultaneously
+         */
+        runAudit(integrityAudit, integrityAudit2);
+        waitStaleAndRun(integrityAudit3, integrityAudit4);
+        waitStaleAndRun(integrityAudit, integrityAudit2);
+
+        /*
+         * These sequences may be intermingled, so we extract and compare one sequence at a time.
+         */
+
+        // only care about pdp1 & pdp3 in this sequence
+        verifyItemsInLog(logA, "pdp1", "pdp3", "pdp1");
+
+        // only care about pdp2 & pdp4 in this sequence
+        verifyItemsInLog(logB, "pdp2", "pdp4", "pdp2");
+
+        logger.info("testFourResourcesDifferentPus: Exiting");
+
+    }
+
+    /*
+     * Tests designation logic when four resources are in play but one is not functioning.
+     * Designation should round robin among functioning resources only.
+     * 
+     * Note: console.log must be examined to ascertain whether or not this test was successful.
+     */
+    @Test
+    public void testFourResourcesOneDead() throws Exception {
+
+        logger.info("testFourResourcesOneDead: Entering");
+
+        final ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
+
+        /*
+         * Start audit for pdp1.
+         */
+        MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
+
+        /*
+         * Start audit for pdp2.
+         */
+        MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", A_SEQ_PU);
+
+        /*
+         * Populate DB for pdp3, which will simulate it having registered but then having died.
+         */
+        new DbDAO("pdp3", A_SEQ_PU, makeProperties()).destroy();
+
+        /*
+         * Start audit for pdp4.
+         */
+        MyIntegrityAudit integrityAudit4 = makeAuditor("pdp4", A_SEQ_PU);
+
+        /*
+         * Sleep long enough to allow
+         * 
+         * 1) pdp1 to run audit
+         * 
+         * 2) Logic to detect that pdp1 is stale and designate pdp2
+         * 
+         * 3) pdp2 to run audit
+         * 
+         * 4) Logic to detect that pdp2 is stale and designate pdp4
+         * 
+         * 5) pdp4 to run audit
+         * 
+         * 6) Logic to detect that pdp4 is stale and designate pdp1
+         * 
+         * 7) pdp1 to run audit
+         * 
+         * 8) Logic to detect that pdp1 is stale and designate pdp2
+         * 
+         * 7) pdp2 to run audit
+         */
+        runAudit(integrityAudit);
+        waitStaleAndRun(integrityAudit2);
+        waitStaleAndRun(integrityAudit4);
+        waitStaleAndRun(integrityAudit);
+        waitStaleAndRun(integrityAudit2);
+        waitStaleAndRun(integrityAudit4);
+
+        verifyItemsInLog(logA, "pdp1", "pdp2", "pdp4", "pdp1", "pdp2", "pdp4");
+
+        logger.info("testFourResourcesOneDead: Exiting");
+
+    }
+
+    /*
+     * Tests designation logic when four resources are in play but only one is functioning.
+     * Designation should remain with sole functioning resource.
+     * 
+     * Note: console.log must be examined to ascertain whether or not this test was successful.
+     */
+    @Test
+    public void testFourResourcesThreeDead() throws Exception {
+
+        logger.info("testFourResourcesThreeDead: Entering");
+
+        final ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
+
+        /*
+         * Populate DB for "pdp1", which will simulate it having registered but then having died.
+         */
+        new DbDAO("pdp1", A_SEQ_PU, makeProperties()).destroy();
+
+        /*
+         * Populate DB for pdp2, which will simulate it having registered but then having died.
+         */
+        new DbDAO("pdp2", A_SEQ_PU, makeProperties()).destroy();
+
+        /*
+         * Start audit for pdp3.
+         */
+        MyIntegrityAudit integrityAudit3 = makeAuditor("pdp3", A_SEQ_PU);
+
+        /*
+         * Populate DB for pdp4, which will simulate it having registered but then having died.
+         */
+        new DbDAO("pdp4", A_SEQ_PU, makeProperties()).destroy();
+
+        /*
+         * Sleep long enough to allow
+         * 
+         * 1) pdp3 to discover that all other designation candidates are stale
+         * 
+         * 1) pdp3 to run audit
+         * 
+         * 2) Logic to detect that no other nodes are available for designation
+         * 
+         * 3) pdp3 to run audit again
+         */
+        runAudit(integrityAudit3);
+        waitStaleAndRun(integrityAudit3);
+
+        verifyItemsInLog(logA, "pdp3", "pdp3");
+
+        logger.info("testFourResourcesThreeDead: Exiting");
+
+    }
+
+    /*
+     * Tests designation logic when the designated node dies and is no longer current
+     * 
+     * Note: console.log must be examined to ascertain whether or not this test was successful.
+     */
+    @Test
+    public void testDesignatedNodeDead() throws Exception {
+        logger.info("testDesignatedNodeDead: Entering");
+
+        final ExtractAppender logA = watch(debugLogger, START_AUDIT_RE);
+
+        /*
+         * Instantiate audit object for pdp1.
+         */
+        final MyIntegrityAudit integrityAudit = makeAuditor("pdp1", A_SEQ_PU);
+
+        /*
+         * Start audit for pdp2.
+         */
+        final MyIntegrityAudit integrityAudit2 = makeAuditor("pdp2", A_SEQ_PU);
+
+        /*
+         * Instantiate audit object for pdp3.
+         */
+        final MyIntegrityAudit integrityAudit3 = makeAuditor("pdp3", A_SEQ_PU);
+
+        // Start audit on pdp1
+        logger.info("testDesignatedNodeDead: Start audit on pdp1");
+        runAudit(integrityAudit);
+
+        // Start the auditing threads on other nodes.
+        logger.info("testDesignatedNodeDead: Start audit on pdp2");
+        runAudit(integrityAudit2);
+
+        // Kill audit on pdp1
+        logger.info("testDesignatedNodeDead: Kill audit on pdp1");
+        integrityAudit.stopAuditThread();
+
+        // Wait long enough for pdp1 to get stale and pdp2 to take over
+        waitStaleAndRun(integrityAudit2);
+
+        // Start audit thread on pdp1 again.
+        logger.info("testDesignatedNodeDead: Start audit thread on pdp1 again.");
+        integrityAudit.startAuditThread();
+
+        // Wait long enough for pdp2 to complete its audit and get stale, at
+        // which point pdp3 should take over
+        logger.info(
+                "testDesignatedNodeDead: Wait long enough for pdp2 to complete its audit and get stale, at which point"
+                        + " pdp3 should take over");
+        waitStaleAndRun(integrityAudit3);
+
+        // Kill audit on pdp3
+        logger.info("testDesignatedNodeDead: Killing audit on pdp3");
+        integrityAudit3.stopAuditThread();
+
+        // Wait long enough for pdp3 to get stale and pdp1 to take over
+        logger.info("testDesignatedNodeDead: Wait long enough for pdp3 to get stale and pdp1 to take over");
+        waitStaleAndRun(integrityAudit);
+
+        verifyItemsInLog(logA, "pdp1", "pdp2", "pdp3", "pdp1");
+
+        logger.info("testDesignatedNodeDead: Exiting");
+    }
 }
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditTest.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditTest.java
index 344ac34e..5adbb561 100644
--- a/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditTest.java
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditTest.java
@@ -20,53 +20,52 @@
 
 package org.onap.policy.common.ia;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 import java.util.Properties;
 
 import org.junit.Test;
-import org.onap.policy.common.ia.IntegrityAudit;
-import org.onap.policy.common.ia.IntegrityAuditProperties;
 
 public class IntegrityAuditTest {
 
-	@Test
-	/**
-	 * Test if we can access the updated bad params outside of the parmsAreBad method
-	 */
-	public void parmsAreBadTest() {
-		// Try with 2 null params
-		StringBuilder badParams = new StringBuilder();
-		IntegrityAudit.parmsAreBad(null, "something", null, badParams);
-		
-		assertFalse("".equals(badParams.toString()));
-		assertTrue(badParams.toString().contains("resourceName"));
-		assertTrue(badParams.toString().contains("properties"));
-		
-		// Try with 1 null params
-		badParams = new StringBuilder();
-		Properties props = new Properties();
-		props.put(IntegrityAuditProperties.DB_DRIVER, "test_db_driver");
-		IntegrityAudit.parmsAreBad(null, "something", props, badParams);
-		
-		assertFalse("".equals(badParams.toString()));
-		assertTrue(badParams.toString().contains("resourceName"));
-		assertFalse(badParams.toString().contains("properties"));
-		
-		// Try with 0 null params
-		badParams = new StringBuilder();
-		IntegrityAudit.parmsAreBad("someting", "something", props, badParams);
-		assertFalse("".equals(badParams.toString()));
-		assertFalse(badParams.toString().contains("resourceName"));
-		assertFalse(badParams.toString().contains("properties"));
-		
-		// Try with invalid node type
-		props.put(IntegrityAuditProperties.NODE_TYPE, "bogus");
-		badParams = new StringBuilder();
-		IntegrityAudit.parmsAreBad("someting", "something", props, badParams);
-		assertFalse("".equals(badParams.toString()));
-		assertTrue(badParams.toString().contains("nodeType"));
+    @Test
+    /**
+     * Test if we can access the updated bad params outside of the parmsAreBad method.
+     */
+    public void parmsAreBadTest() {
+        // Try with 2 null params
+        StringBuilder badParams = new StringBuilder();
+        IntegrityAudit.parmsAreBad(null, "something", null, badParams);
 
-	}
+        assertFalse("".equals(badParams.toString()));
+        assertTrue(badParams.toString().contains("resourceName"));
+        assertTrue(badParams.toString().contains("properties"));
+
+        // Try with 1 null params
+        badParams = new StringBuilder();
+        Properties props = new Properties();
+        props.put(IntegrityAuditProperties.DB_DRIVER, "test_db_driver");
+        IntegrityAudit.parmsAreBad(null, "something", props, badParams);
+
+        assertFalse("".equals(badParams.toString()));
+        assertTrue(badParams.toString().contains("resourceName"));
+        assertFalse(badParams.toString().contains("properties"));
+
+        // Try with 0 null params
+        badParams = new StringBuilder();
+        IntegrityAudit.parmsAreBad("someting", "something", props, badParams);
+        assertFalse("".equals(badParams.toString()));
+        assertFalse(badParams.toString().contains("resourceName"));
+        assertFalse(badParams.toString().contains("properties"));
+
+        // Try with invalid node type
+        props.put(IntegrityAuditProperties.NODE_TYPE, "bogus");
+        badParams = new StringBuilder();
+        IntegrityAudit.parmsAreBad("someting", "something", props, badParams);
+        assertFalse("".equals(badParams.toString()));
+        assertTrue(badParams.toString().contains("nodeType"));
+
+    }
 
 }
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditTestBase.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditTestBase.java
index e30c5631..afbcc452 100644
--- a/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditTestBase.java
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/IntegrityAuditTestBase.java
@@ -23,6 +23,9 @@ package org.onap.policy.common.ia;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -47,587 +50,560 @@ import org.onap.policy.common.utils.jpa.EntityTransCloser;
 import org.onap.policy.common.utils.test.log.logback.ExtractAppender;
 import org.slf4j.LoggerFactory;
 
-import ch.qos.logback.classic.Level;
-import ch.qos.logback.classic.Logger;
-
 /**
- * All JUnits are designed to run in the local development environment where
- * they have write privileges and can execute time-sensitive tasks.
- * <p/>
- * Many of the test verification steps are performed by scanning for items
- * written to the log file. Rather than actually scan the log file, an
- * {@link ExtractAppender} is used to monitor events that are logged and extract
- * relevant items. In order to attach the appender to the debug log, it assumes
- * that the debug log is a <i>logback</i> Logger configured per EELF.
- * <p/>
- * These tests use a temporary, in-memory DB, which is dropped once the tests
- * complete.
+ * All JUnits are designed to run in the local development environment where they have write
+ * privileges and can execute time-sensitive tasks.
+ * 
+ * <p>Many of the test verification steps are performed by scanning for items written to the log
+ * file. Rather than actually scan the log file, an {@link ExtractAppender} is used to monitor
+ * events that are logged and extract relevant items. In order to attach the appender to the debug
+ * log, it assumes that the debug log is a <i>logback</i> Logger configured per EELF.
+ * 
+ * <p>These tests use a temporary, in-memory DB, which is dropped once the tests complete.
  */
 public class IntegrityAuditTestBase {
 
-	/**
-	 * Root of the debug logger, as defined in the logback-test.xml.
-	 */
-	protected static final Logger debugLogger = (Logger) LoggerFactory.getLogger("com.att.eelf.debug");
-
-	/**
-	 * Root of the error logger, as defined in the logback-test.xml.
-	 */
-	protected static final Logger errorLogger = (Logger) LoggerFactory.getLogger("com.att.eelf.error");
-
-	/**
-	 * Directory containing the log files.
-	 */
-	private static final String LOG_DIR = "testingLogs/common-modules/integrity-audit";
-
-	/**
-	 * Max time, in milliseconds, to wait for a latch to be triggered.
-	 */
-	protected static final long WAIT_MS = 5000l;
-
-	/**
-	 * Milliseconds that auditor should sleep between audit steps.
-	 */
-	protected static final long SLEEP_INTERVAL_MS = 2l;
-
-	/**
-	 * Milliseconds that auditor should sleep when an audit completes.
-	 */
-	protected static final long COMPLETION_INTERVAL_MS = 5l;
-
-	/**
-	 * Milliseconds that an entire audit-simulation cycles takes.
-	 */
-	protected static final long AUDIT_SIMULATION_MS = SLEEP_INTERVAL_MS * AuditThread.AUDIT_SIMULATION_ITERATIONS;
-
-	/**
-	 * Milliseconds that it takes for an auditor's last update to become stale.
-	 * Includes a 1ms fudge factor.
-	 */
-	protected static final long STALE_MS = 1 + 2 * Math.max(COMPLETION_INTERVAL_MS, AUDIT_SIMULATION_MS);
-
-	/**
-	 * Milliseconds that the db-audit should wait between makings updates.
-	 */
-	private static final long DB_AUDIT_UPDATE_MS = 10l;
-
-	/**
-	 * Milliseconds that the db-audit should sleep between cycles.
-	 */
-	private static final long DB_AUDIT_SLEEP_MS = 3l;
-
-	public static final String DEFAULT_DB_URL_PREFIX = "jdbc:h2:mem:";
-
-	protected static final String dbDriver = "org.h2.Driver";
-	protected static final String dbUser = "testu";
-	protected static final String dbPwd = "testp";
-	protected static final String siteName = "SiteA";
-	protected static final String nodeType = "pdp_xacml";
-
-	// will be defined by the test *Classes*
-	protected static String dbUrl;
-
-	/**
-	 * Persistence unit for PDP sequence A.
-	 */
-	protected static final String A_SEQ_PU = "testPU";
-
-	/**
-	 * Persistence unit for PDP sequence B.
-	 */
-	protected static final String B_SEQ_PU = "integrityAuditPU";
-
-	/**
-	 * Matches the start of an audit for arbitrary PDPs in the debug log.
-	 */
-	protected static final String START_AUDIT_RE = "Starting audit simulation for resourceName=([^,]*)";
-
-	/**
-	 * Properties to be used in all tests.
-	 */
-	protected static Properties properties;
-
-	/**
-	 * Entity manager factory pointing to the in-memory DB for A_SEQ_PU.
-	 */
-	protected static EntityManagerFactory emf;
-
-	/**
-	 * Entity manager factory pointing to the in-memory DB associated with emf.
-	 */
-	protected static EntityManager em;
-
-	/**
-	 * Saved debug logger level, to be restored once all tests complete.
-	 */
-	private static Level savedDebugLevel;
-
-	/**
-	 * Saved error logger level, to be restored once all tests complete.
-	 */
-	private static Level savedErrorLevel;
-
-	/**
-	 * Saved audit sleep interval, to be restored once all tests complete.
-	 */
-	private static long savedSleepIntervalMs;
-
-	/**
-	 * Saved audit completion interval, to be restored once all tests complete.
-	 */
-	private static long savedCompletionIntervalMs;
-
-	/**
-	 * Saved db audit update time, to be restored once all tests complete.
-	 */
-	private static long savedDbAuditUpdateMs;
-
-	/**
-	 * Saved db audit sleep time, to be restored once all tests complete.
-	 */
-	private static long savedDbAuditSleepMs;
-
-	/**
-	 * List of auditors whose threads must be stopped when a given test case
-	 * ends.
-	 */
-	private List<MyIntegrityAudit> auditors;
-
-	/**
-	 * List of appenders that must be removed from loggers when a given test
-	 * case ends.
-	 */
-	private List<LogApp> appenders;
-
-	/**
-	 * Saves current configuration information and then sets new values.
-	 * 
-	 * @param dbDriver
-	 *            the name of the DB Driver class
-	 * @param dbUrl
-	 *            the URL to the DB
-	 * @throws IOException
-	 * @throws Exception
-	 */
-	protected static void setUpBeforeClass(String dbUrl) throws IOException {
-
-		// truncate the logs
-		new FileOutputStream(LOG_DIR + "/audit.log").close();
-		new FileOutputStream(LOG_DIR + "/debug.log").close();
-		new FileOutputStream(LOG_DIR + "/error.log").close();
-		new FileOutputStream(LOG_DIR + "/metrics.log").close();
-
-		IntegrityAuditTestBase.dbUrl = dbUrl;
-
-		// save data that we have to restore at the end of the test
-		savedDebugLevel = debugLogger.getLevel();
-		savedErrorLevel = errorLogger.getLevel();
-		savedSleepIntervalMs = AuditThread.getAuditThreadSleepIntervalMillis();
-		savedCompletionIntervalMs = AuditThread.getAuditCompletionIntervalMillis();
-		savedDbAuditUpdateMs = DbAudit.getDbAuditUpdateMillis();
-		savedDbAuditSleepMs = DbAudit.getDbAuditSleepMillis();
-
-		AuditThread.setAuditThreadSleepIntervalMillis(SLEEP_INTERVAL_MS);
-		AuditThread.setAuditCompletionIntervalMillis(COMPLETION_INTERVAL_MS);
-
-		DbAudit.setDbAuditUpdateMillis(DB_AUDIT_UPDATE_MS);
-		DbAudit.setDbAuditSleepMillis(DB_AUDIT_SLEEP_MS);
-
-		IntegrityAudit.setUnitTesting(true);
-
-		properties = new Properties();
-		properties.put(IntegrityAuditProperties.DB_DRIVER, dbDriver);
-		properties.put(IntegrityAuditProperties.DB_URL, dbUrl);
-		properties.put(IntegrityAuditProperties.DB_USER, dbUser);
-		properties.put(IntegrityAuditProperties.DB_PWD, dbPwd);
-		properties.put(IntegrityAuditProperties.SITE_NAME, siteName);
-		properties.put(IntegrityAuditProperties.NODE_TYPE, nodeType);
-
-		emf = Persistence.createEntityManagerFactory(A_SEQ_PU, makeProperties());
-
-		// keep this open so the in-memory DB stays around until all tests are
-		// done
-		em = emf.createEntityManager();
-
-		debugLogger.setLevel(Level.DEBUG);
-		errorLogger.setLevel(Level.ERROR);
-	}
-
-	/**
-	 * Restores the configuration to what it was before the test.
-	 */
-	protected static void tearDownAfterClass() {
-		AuditThread.setAuditThreadSleepIntervalMillis(savedSleepIntervalMs);
-		AuditThread.setAuditCompletionIntervalMillis(savedCompletionIntervalMs);
-
-		DbAudit.setDbAuditUpdateMillis(savedDbAuditUpdateMs);
-		DbAudit.setDbAuditSleepMillis(savedDbAuditSleepMs);
-
-		IntegrityAudit.setUnitTesting(false);
-
-		debugLogger.setLevel(savedDebugLevel);
-		errorLogger.setLevel(savedErrorLevel);
-
-		// this should result in the in-memory DB being deleted
-		em.close();
-		emf.close();
-	}
-
-	/**
-	 * Sets up for a test, which includes deleting all records from the
-	 * IntegrityAuditEntity table.
-	 */
-	protected void setUp() {
-		auditors = new LinkedList<>();
-		appenders = new LinkedList<>();
-
-		properties.put(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS, String.valueOf(SLEEP_INTERVAL_MS));
-
-		// Clean up the DB
-		try (EntityTransCloser etc = new EntityTransCloser(em.getTransaction())) {
-			EntityTransaction et = etc.getTransation();
-
-			em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
-
-			// commit transaction
-			et.commit();
-		}
-	}
-
-	/**
-	 * Cleans up after a test, removing any ExtractAppenders from the logger and
-	 * stopping any AuditThreads.
-	 */
-	protected void tearDown() {
-		for (LogApp p : appenders) {
-			p.detach();
-		}
-
-		for (MyIntegrityAudit p : auditors) {
-			p.stopAuditThread();
-		}
-	}
-
-	/**
-	 * 
-	 * @param properties
-	 * @param persistenceUnit
-	 * @param tableName
-	 */
-	public void truncateTable(Properties properties, String persistenceUnit, String tableName) {
-
-		try (EntityMgrFactoryCloser emfc = new EntityMgrFactoryCloser(
-				Persistence.createEntityManagerFactory(persistenceUnit, properties));
-				EntityMgrCloser emc = new EntityMgrCloser(emfc.getFactory().createEntityManager());
-				EntityTransCloser etc = new EntityTransCloser(emc.getManager().getTransaction())) {
-
-			EntityManager em = emc.getManager();
-			EntityTransaction et = etc.getTransation();
-
-			// Clean up the DB
-			em.createQuery("Delete from " + tableName).executeUpdate();
-
-			// commit transaction
-			et.commit();
-		}
-	}
-
-	/**
-	 * Verifies that items appear within the log, in order. A given item may
-	 * appear more than once. In addition, the log may contain extra items;
-	 * those are ignored.
-	 * 
-	 * @param textre
-	 *            regular expression used to extract an item from a line in the
-	 *            log. The first "capture" group of the regular expression is
-	 *            assumed to contain the extracted item
-	 * @param items
-	 *            items that should be matched by the items extracted from the
-	 *            log, in order
-	 * @throws IOException
-	 * @throws AssertionError
-	 *             if the desired items were not all found
-	 */
-	protected void verifyItemsInLog(ExtractAppender app, String... items) throws IOException {
-
-		Iterator<String> it = new ArrayList<>(Arrays.asList(items)).iterator();
-		if (!it.hasNext()) {
-			return;
-		}
-
-		String expected = it.next();
-		String last = null;
-
-		for (String rName : app.getExtracted()) {
-			if (rName.equals(expected)) {
-				if (!it.hasNext()) {
-					// matched all of the items
-					return;
-				}
-
-				last = expected;
-				expected = it.next();
-
-			} else if (!rName.equals(last)) {
-				List<String> remaining = getRemaining(expected, it);
-				fail("missing items " + remaining + ", but was: " + rName);
-			}
-		}
-
-		List<String> remaining = getRemaining(expected, it);
-		assertTrue("missing items " + remaining, remaining.isEmpty());
-	}
-
-	/**
-	 * Gets the remaining items from an iterator
-	 * 
-	 * @param current
-	 *            the current item, to be included within the list
-	 * @param it
-	 *            iterator from which to get the remaining items
-	 * @return a list of the remaining items
-	 */
-	private LinkedList<String> getRemaining(String current, Iterator<String> it) {
-		LinkedList<String> remaining = new LinkedList<>();
-		remaining.add(current);
-
-		while (it.hasNext()) {
-			remaining.add(it.next());
-		}
-		return remaining;
-	}
-
-	/**
-	 * Waits for a thread to stop. If the thread doesn't complete in the
-	 * allotted time, then it interrupts it and waits again.
-	 * 
-	 * @param auditor
-	 *            the thread for which to wait
-	 * @return {@code true} if the thread stopped, {@code false} otherwise
-	 */
-	public boolean waitThread(MyIntegrityAudit auditor) {
-		if (auditor != null) {
-			try {
-				auditor.interrupt();
-
-				if (!auditor.joinAuditThread(WAIT_MS)) {
-					System.out.println("failed to stop audit thread");
-					return false;
-				}
-
-			} catch (InterruptedException e) {
-				Thread.currentThread().interrupt();
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * Makes a new auditor.
-	 * 
-	 * @param resourceName2
-	 * @param persistenceUnit2
-	 * @return a new auditor
-	 * @throws Exception
-	 */
-	protected MyIntegrityAudit makeAuditor(String resourceName2, String persistenceUnit2) throws Exception {
-		return new MyIntegrityAudit(resourceName2, persistenceUnit2, makeProperties());
-	}
-
-	/**
-	 * Watches for patterns in a logger by attaching a ExtractAppender to it.
-	 * 
-	 * @param logger
-	 *            the logger to watch
-	 * @param regex
-	 *            regular expression used to extract relevant text
-	 * @return a new appender
-	 */
-	protected ExtractAppender watch(Logger logger, String regex) {
-		ExtractAppender app = new ExtractAppender(regex);
-		appenders.add(new LogApp(logger, app));
-
-		return app;
-	}
-
-	/**
-	 * Makes a new Property set that's a clone of {@link #properties}.
-	 * 
-	 * @return a new Property set containing all of a copy of all of the
-	 *         {@link #properties}
-	 */
-	protected static Properties makeProperties() {
-		Properties props = new Properties();
-		props.putAll(properties);
-		return props;
-	}
-
-	/**
-	 * Waits for data to become stale and then runs an audit on several auditors
-	 * in parallel.
-	 * 
-	 * @param auditors
-	 * @throws InterruptedException
-	 */
-	protected void waitStaleAndRun(MyIntegrityAudit... auditors) throws InterruptedException {
-		waitStale();
-		runAudit(auditors);
-	}
-
-	/**
-	 * Runs an audit on several auditors in parallel.
-	 * 
-	 * @param auditors
-	 * @throws InterruptedException
-	 */
-	protected void runAudit(MyIntegrityAudit... auditors) throws InterruptedException {
-
-		// start an audit cycle on each auditor
-		List<CountDownLatch> latches = new ArrayList<>(auditors.length);
-		for (MyIntegrityAudit p : auditors) {
-			latches.add(p.startAudit());
-		}
-
-		// wait for each auditor to complete its cycle
-		for (CountDownLatch latch : latches) {
-			waitLatch(latch);
-		}
-	}
-
-	/**
-	 * Waits for a latch to reach zero.
-	 * 
-	 * @param latch
-	 * @throws InterruptedException
-	 * @throws AssertionError
-	 *             if the latch did not reach zero in the allotted time
-	 */
-	protected void waitLatch(CountDownLatch latch) throws InterruptedException {
-		assertTrue(latch.await(WAIT_MS, TimeUnit.SECONDS));
-	}
-
-	/**
-	 * Sleep a bit so that the currently designated pdp becomes stale.
-	 * 
-	 * @throws InterruptedException
-	 */
-	protected void waitStale() throws InterruptedException {
-		Thread.sleep(STALE_MS);
-	}
-
-	/**
-	 * Tracks which appender has been added to a logger.
-	 */
-	private static class LogApp {
-		private final Logger logger;
-		private final ExtractAppender appender;
-
-		public LogApp(Logger logger, ExtractAppender appender) {
-			this.logger = logger;
-			this.appender = appender;
-
-			logger.addAppender(appender);
-
-			appender.start();
-		}
-
-		public void detach() {
-			logger.detachAppender(appender);
-		}
-	}
-
-	/**
-	 * Manages audits by inserting latches into a queue for the AuditThread to
-	 * count.
-	 */
-	protected class MyIntegrityAudit extends IntegrityAudit {
-
-		/**
-		 * Queue from which the AuditThread will take latches.
-		 */
-		private BlockingQueue<CountDownLatch> queue = null;
-
-		/**
-		 * Constructs an auditor and starts the AuditThread.
-		 * 
-		 * @param resourceName
-		 * @param persistenceUnit
-		 * @param properties
-		 * @throws Exception
-		 */
-		public MyIntegrityAudit(String resourceName, String persistenceUnit, Properties properties) throws Exception {
-			super(resourceName, persistenceUnit, properties);
-
-			auditors.add(this);
-
-			startAuditThread();
-		}
-
-		/**
-		 * Interrupts the AuditThread.
-		 */
-		public void interrupt() {
-			super.stopAuditThread();
-		}
-
-		/**
-		 * Triggers an audit by adding a latch to the queue.
-		 * 
-		 * @return the latch that was added
-		 * @throws InterruptedException
-		 */
-		public CountDownLatch startAudit() throws InterruptedException {
-			CountDownLatch latch = new CountDownLatch(1);
-			queue.add(latch);
-
-			return latch;
-		}
-
-		/**
-		 * Starts a new AuditThread. Creates a new latch queue and associates it
-		 * with the thread.
-		 */
-		@Override
-		public final void startAuditThread() throws IntegrityAuditException {
-			if (queue != null) {
-				// queue up a bogus latch, in case a thread is still running
-				queue.add(new CountDownLatch(1) {
-					@Override
-					public void countDown() {
-						throw new RuntimeException("auditor has multiple threads");
-					}
-				});
-			}
-
-			queue = new LinkedBlockingQueue<>();
-
-			if (super.startAuditThread(queue)) {
-				// wait for the thread to start
-				CountDownLatch latch = new CountDownLatch(1);
-				queue.add(latch);
-				
-				try {
-					waitLatch(latch);
-					
-				} catch (InterruptedException e) {
-					Thread.currentThread().interrupt();
-					throw new IntegrityAuditException(e);
-				}
-			}
-		}
-
-		/**
-		 * Stops the AuditThread and waits for it to stop.
-		 * 
-		 * @throws AssertionError
-		 *             if the thread is still running
-		 */
-		@Override
-		public void stopAuditThread() {
-			super.stopAuditThread();
-
-			assertTrue(waitThread(this));
-		}
-	}
+    /**
+     * Root of the debug logger, as defined in the logback-test.xml.
+     */
+    protected static final Logger debugLogger = (Logger) LoggerFactory.getLogger("com.att.eelf.debug");
+
+    /**
+     * Root of the error logger, as defined in the logback-test.xml.
+     */
+    protected static final Logger errorLogger = (Logger) LoggerFactory.getLogger("com.att.eelf.error");
+
+    /**
+     * Directory containing the log files.
+     */
+    private static final String LOG_DIR = "testingLogs/common-modules/integrity-audit";
+
+    /**
+     * Max time, in milliseconds, to wait for a latch to be triggered.
+     */
+    protected static final long WAIT_MS = 5000L;
+
+    /**
+     * Milliseconds that auditor should sleep between audit steps.
+     */
+    protected static final long SLEEP_INTERVAL_MS = 2L;
+
+    /**
+     * Milliseconds that auditor should sleep when an audit completes.
+     */
+    protected static final long COMPLETION_INTERVAL_MS = 5L;
+
+    /**
+     * Milliseconds that an entire audit-simulation cycles takes.
+     */
+    protected static final long AUDIT_SIMULATION_MS = SLEEP_INTERVAL_MS * AuditThread.AUDIT_SIMULATION_ITERATIONS;
+
+    /**
+     * Milliseconds that it takes for an auditor's last update to become stale. Includes a 1ms fudge
+     * factor.
+     */
+    protected static final long STALE_MS = 1 + 2 * Math.max(COMPLETION_INTERVAL_MS, AUDIT_SIMULATION_MS);
+
+    /**
+     * Milliseconds that the db-audit should wait between makings updates.
+     */
+    private static final long DB_AUDIT_UPDATE_MS = 10L;
+
+    /**
+     * Milliseconds that the db-audit should sleep between cycles.
+     */
+    private static final long DB_AUDIT_SLEEP_MS = 3L;
+
+    public static final String DEFAULT_DB_URL_PREFIX = "jdbc:h2:mem:";
+
+    protected static final String dbDriver = "org.h2.Driver";
+    protected static final String dbUser = "testu";
+    protected static final String dbPwd = "testp";
+    protected static final String siteName = "SiteA";
+    protected static final String nodeType = "pdp_xacml";
+
+    // will be defined by the test *Classes*
+    protected static String dbUrl;
+
+    /**
+     * Persistence unit for PDP sequence A.
+     */
+    protected static final String A_SEQ_PU = "testPU";
+
+    /**
+     * Persistence unit for PDP sequence B.
+     */
+    protected static final String B_SEQ_PU = "integrityAuditPU";
+
+    /**
+     * Matches the start of an audit for arbitrary PDPs in the debug log.
+     */
+    protected static final String START_AUDIT_RE = "Starting audit simulation for resourceName=([^,]*)";
+
+    /**
+     * Properties to be used in all tests.
+     */
+    protected static Properties properties;
+
+    /**
+     * Entity manager factory pointing to the in-memory DB for A_SEQ_PU.
+     */
+    protected static EntityManagerFactory emf;
+
+    /**
+     * Entity manager factory pointing to the in-memory DB associated with emf.
+     */
+    protected static EntityManager em;
+
+    /**
+     * Saved debug logger level, to be restored once all tests complete.
+     */
+    private static Level savedDebugLevel;
+
+    /**
+     * Saved error logger level, to be restored once all tests complete.
+     */
+    private static Level savedErrorLevel;
+
+    /**
+     * Saved audit sleep interval, to be restored once all tests complete.
+     */
+    private static long savedSleepIntervalMs;
+
+    /**
+     * Saved audit completion interval, to be restored once all tests complete.
+     */
+    private static long savedCompletionIntervalMs;
+
+    /**
+     * Saved db audit update time, to be restored once all tests complete.
+     */
+    private static long savedDbAuditUpdateMs;
+
+    /**
+     * Saved db audit sleep time, to be restored once all tests complete.
+     */
+    private static long savedDbAuditSleepMs;
+
+    /**
+     * List of auditors whose threads must be stopped when a given test case ends.
+     */
+    private List<MyIntegrityAudit> auditors;
+
+    /**
+     * List of appenders that must be removed from loggers when a given test case ends.
+     */
+    private List<LogApp> appenders;
+
+    /**
+     * Saves current configuration information and then sets new values.
+     * 
+     * @param dbDriver the name of the DB Driver class
+     * @param dbUrl the URL to the DB
+     * @throws IOException if an IO error occurs
+     */
+    protected static void setUpBeforeClass(String dbUrl) throws IOException {
+
+        // truncate the logs
+        new FileOutputStream(LOG_DIR + "/audit.log").close();
+        new FileOutputStream(LOG_DIR + "/debug.log").close();
+        new FileOutputStream(LOG_DIR + "/error.log").close();
+        new FileOutputStream(LOG_DIR + "/metrics.log").close();
+
+        IntegrityAuditTestBase.dbUrl = dbUrl;
+
+        // save data that we have to restore at the end of the test
+        savedDebugLevel = debugLogger.getLevel();
+        savedErrorLevel = errorLogger.getLevel();
+        savedSleepIntervalMs = AuditThread.getAuditThreadSleepIntervalMillis();
+        savedCompletionIntervalMs = AuditThread.getAuditCompletionIntervalMillis();
+        savedDbAuditUpdateMs = DbAudit.getDbAuditUpdateMillis();
+        savedDbAuditSleepMs = DbAudit.getDbAuditSleepMillis();
+
+        AuditThread.setAuditThreadSleepIntervalMillis(SLEEP_INTERVAL_MS);
+        AuditThread.setAuditCompletionIntervalMillis(COMPLETION_INTERVAL_MS);
+
+        DbAudit.setDbAuditUpdateMillis(DB_AUDIT_UPDATE_MS);
+        DbAudit.setDbAuditSleepMillis(DB_AUDIT_SLEEP_MS);
+
+        IntegrityAudit.setUnitTesting(true);
+
+        properties = new Properties();
+        properties.put(IntegrityAuditProperties.DB_DRIVER, dbDriver);
+        properties.put(IntegrityAuditProperties.DB_URL, dbUrl);
+        properties.put(IntegrityAuditProperties.DB_USER, dbUser);
+        properties.put(IntegrityAuditProperties.DB_PWD, dbPwd);
+        properties.put(IntegrityAuditProperties.SITE_NAME, siteName);
+        properties.put(IntegrityAuditProperties.NODE_TYPE, nodeType);
+
+        emf = Persistence.createEntityManagerFactory(A_SEQ_PU, makeProperties());
+
+        // keep this open so the in-memory DB stays around until all tests are
+        // done
+        em = emf.createEntityManager();
+
+        debugLogger.setLevel(Level.DEBUG);
+        errorLogger.setLevel(Level.ERROR);
+    }
+
+    /**
+     * Restores the configuration to what it was before the test.
+     */
+    protected static void tearDownAfterClass() {
+        AuditThread.setAuditThreadSleepIntervalMillis(savedSleepIntervalMs);
+        AuditThread.setAuditCompletionIntervalMillis(savedCompletionIntervalMs);
+
+        DbAudit.setDbAuditUpdateMillis(savedDbAuditUpdateMs);
+        DbAudit.setDbAuditSleepMillis(savedDbAuditSleepMs);
+
+        IntegrityAudit.setUnitTesting(false);
+
+        debugLogger.setLevel(savedDebugLevel);
+        errorLogger.setLevel(savedErrorLevel);
+
+        // this should result in the in-memory DB being deleted
+        em.close();
+        emf.close();
+    }
+
+    /**
+     * Sets up for a test, which includes deleting all records from the IntegrityAuditEntity table.
+     */
+    protected void setUp() {
+        auditors = new LinkedList<>();
+        appenders = new LinkedList<>();
+
+        properties.put(IntegrityAuditProperties.AUDIT_PERIOD_MILLISECONDS, String.valueOf(SLEEP_INTERVAL_MS));
+
+        // Clean up the DB
+        try (EntityTransCloser etc = new EntityTransCloser(em.getTransaction())) {
+            EntityTransaction et = etc.getTransation();
+
+            em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
+
+            // commit transaction
+            et.commit();
+        }
+    }
+
+    /**
+     * Cleans up after a test, removing any ExtractAppenders from the logger and stopping any
+     * AuditThreads.
+     */
+    protected void tearDown() {
+        for (LogApp p : appenders) {
+            p.detach();
+        }
+
+        for (MyIntegrityAudit p : auditors) {
+            p.stopAuditThread();
+        }
+    }
+
+    /**
+     * Truncate the table.
+     * 
+     * @param properties the properties
+     * @param persistenceUnit the persistence unit
+     * @param tableName the name of the table
+     */
+    public void truncateTable(Properties properties, String persistenceUnit, String tableName) {
+
+        try (EntityMgrFactoryCloser emfc =
+                new EntityMgrFactoryCloser(Persistence.createEntityManagerFactory(persistenceUnit, properties));
+                EntityMgrCloser emc = new EntityMgrCloser(emfc.getFactory().createEntityManager());
+                EntityTransCloser etc = new EntityTransCloser(emc.getManager().getTransaction())) {
+
+            EntityManager em = emc.getManager();
+            EntityTransaction et = etc.getTransation();
+
+            // Clean up the DB
+            em.createQuery("Delete from " + tableName).executeUpdate();
+
+            // commit transaction
+            et.commit();
+        }
+    }
+
+    /**
+     * Verifies that items appear within the log, in order. A given item may appear more than once.
+     * In addition, the log may contain extra items; those are ignored.
+     * 
+     * @param textre regular expression used to extract an item from a line in the log. The first
+     *        "capture" group of the regular expression is assumed to contain the extracted item
+     * @param items items that should be matched by the items extracted from the log, in order
+     * @throws IOException if an IO error occurs
+     * @throws AssertionError if the desired items were not all found
+     */
+    protected void verifyItemsInLog(ExtractAppender app, String... items) throws IOException {
+
+        Iterator<String> it = new ArrayList<>(Arrays.asList(items)).iterator();
+        if (!it.hasNext()) {
+            return;
+        }
+
+        String expected = it.next();
+        String last = null;
+
+        for (String extractedText : app.getExtracted()) {
+            if (extractedText.equals(expected)) {
+                if (!it.hasNext()) {
+                    // matched all of the items
+                    return;
+                }
+
+                last = expected;
+                expected = it.next();
+
+            } else if (!extractedText.equals(last)) {
+                List<String> remaining = getRemaining(expected, it);
+                fail("missing items " + remaining + ", but was: " + extractedText);
+            }
+        }
+
+        List<String> remaining = getRemaining(expected, it);
+        assertTrue("missing items " + remaining, remaining.isEmpty());
+    }
+
+    /**
+     * Gets the remaining items from an iterator.
+     * 
+     * @param current the current item, to be included within the list
+     * @param it iterator from which to get the remaining items
+     * @return a list of the remaining items
+     */
+    private LinkedList<String> getRemaining(String current, Iterator<String> it) {
+        LinkedList<String> remaining = new LinkedList<>();
+        remaining.add(current);
+
+        while (it.hasNext()) {
+            remaining.add(it.next());
+        }
+        return remaining;
+    }
+
+    /**
+     * Waits for a thread to stop. If the thread doesn't complete in the allotted time, then it
+     * interrupts it and waits again.
+     * 
+     * @param auditor the thread for which to wait
+     * @return {@code true} if the thread stopped, {@code false} otherwise
+     */
+    public boolean waitThread(MyIntegrityAudit auditor) {
+        if (auditor != null) {
+            try {
+                auditor.interrupt();
+
+                if (!auditor.joinAuditThread(WAIT_MS)) {
+                    System.out.println("failed to stop audit thread");
+                    return false;
+                }
+
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Makes a new auditor.
+     * 
+     * @param resourceName2 the name of the resource
+     * @param persistenceUnit2 the persistence unit
+     * @return a new auditor
+     * @throws Exception if an error occurs
+     */
+    protected MyIntegrityAudit makeAuditor(String resourceName2, String persistenceUnit2) throws Exception {
+        return new MyIntegrityAudit(resourceName2, persistenceUnit2, makeProperties());
+    }
+
+    /**
+     * Watches for patterns in a logger by attaching a ExtractAppender to it.
+     * 
+     * @param logger the logger to watch
+     * @param regex regular expression used to extract relevant text
+     * @return a new appender
+     */
+    protected ExtractAppender watch(Logger logger, String regex) {
+        ExtractAppender app = new ExtractAppender(regex);
+        appenders.add(new LogApp(logger, app));
+
+        return app;
+    }
+
+    /**
+     * Makes a new Property set that's a clone of {@link #properties}.
+     * 
+     * @return a new Property set containing all of a copy of all of the {@link #properties}
+     */
+    protected static Properties makeProperties() {
+        Properties props = new Properties();
+        props.putAll(properties);
+        return props;
+    }
+
+    /**
+     * Waits for data to become stale and then runs an audit on several auditors in parallel.
+     * 
+     * @param auditors the auditors
+     * @throws InterruptedException if a thread is interrupted
+     */
+    protected void waitStaleAndRun(MyIntegrityAudit... auditors) throws InterruptedException {
+        waitStale();
+        runAudit(auditors);
+    }
+
+    /**
+     * Runs an audit on several auditors in parallel.
+     * 
+     * @param auditors the auditors
+     * @throws InterruptedException if a thread is interrupted
+     */
+    protected void runAudit(MyIntegrityAudit... auditors) throws InterruptedException {
+
+        // start an audit cycle on each auditor
+        List<CountDownLatch> latches = new ArrayList<>(auditors.length);
+        for (MyIntegrityAudit p : auditors) {
+            latches.add(p.startAudit());
+        }
+
+        // wait for each auditor to complete its cycle
+        for (CountDownLatch latch : latches) {
+            waitLatch(latch);
+        }
+    }
+
+    /**
+     * Waits for a latch to reach zero.
+     * 
+     * @param latch the latch to wait for
+     * @throws InterruptedException if the thread is interrupted
+     * @throws AssertionError if the latch did not reach zero in the allotted time
+     */
+    protected void waitLatch(CountDownLatch latch) throws InterruptedException {
+        assertTrue(latch.await(WAIT_MS, TimeUnit.SECONDS));
+    }
+
+    /**
+     * Sleep a bit so that the currently designated pdp becomes stale.
+     * 
+     * @throws InterruptedException if the thread is interrupted
+     */
+    protected void waitStale() throws InterruptedException {
+        Thread.sleep(STALE_MS);
+    }
+
+    /**
+     * Tracks which appender has been added to a logger.
+     */
+    private static class LogApp {
+        private final Logger logger;
+        private final ExtractAppender appender;
+
+        public LogApp(Logger logger, ExtractAppender appender) {
+            this.logger = logger;
+            this.appender = appender;
+
+            logger.addAppender(appender);
+
+            appender.start();
+        }
+
+        public void detach() {
+            logger.detachAppender(appender);
+        }
+    }
+
+    /**
+     * Manages audits by inserting latches into a queue for the AuditThread to count.
+     */
+    protected class MyIntegrityAudit extends IntegrityAudit {
+
+        /**
+         * Queue from which the AuditThread will take latches.
+         */
+        private BlockingQueue<CountDownLatch> queue = null;
+
+        /**
+         * Constructs an auditor and starts the AuditThread.
+         * 
+         * @param resourceName the resource name
+         * @param persistenceUnit the persistence unit
+         * @param properties the properties
+         * @throws Exception if an error occurs
+         */
+        public MyIntegrityAudit(String resourceName, String persistenceUnit, Properties properties) throws Exception {
+            super(resourceName, persistenceUnit, properties);
+
+            auditors.add(this);
+
+            startAuditThread();
+        }
+
+        /**
+         * Interrupts the AuditThread.
+         */
+        public void interrupt() {
+            super.stopAuditThread();
+        }
+
+        /**
+         * Triggers an audit by adding a latch to the queue.
+         * 
+         * @return the latch that was added
+         * @throws InterruptedException if the thread is interrupted
+         */
+        public CountDownLatch startAudit() throws InterruptedException {
+            CountDownLatch latch = new CountDownLatch(1);
+            queue.add(latch);
+
+            return latch;
+        }
+
+        /**
+         * Starts a new AuditThread. Creates a new latch queue and associates it with the thread.
+         */
+        @Override
+        public final void startAuditThread() throws IntegrityAuditException {
+            if (queue != null) {
+                // queue up a bogus latch, in case a thread is still running
+                queue.add(new CountDownLatch(1) {
+                    @Override
+                    public void countDown() {
+                        throw new RuntimeException("auditor has multiple threads");
+                    }
+                });
+            }
+
+            queue = new LinkedBlockingQueue<>();
+
+            if (super.startAuditThread(queue)) {
+                // wait for the thread to start
+                CountDownLatch latch = new CountDownLatch(1);
+                queue.add(latch);
+
+                try {
+                    waitLatch(latch);
+
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    throw new IntegrityAuditException(e);
+                }
+            }
+        }
+
+        /**
+         * Stops the AuditThread and waits for it to stop.
+         * 
+         * @throws AssertionError if the thread is still running
+         */
+        @Override
+        public void stopAuditThread() {
+            super.stopAuditThread();
+
+            assertTrue(waitThread(this));
+        }
+    }
 }
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/jpa/IaTestEntity.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/jpa/IaTestEntity.java
index 43277a71..36b9ef66 100644
--- a/integrity-audit/src/test/java/org/onap/policy/common/ia/jpa/IaTestEntity.java
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/jpa/IaTestEntity.java
@@ -37,119 +37,139 @@ import javax.persistence.Temporal;
 import javax.persistence.TemporalType;
 
 @Entity
-@Table(name="IaTestEntity")
-@NamedQueries({
-	@NamedQuery(name=" IaTestEntity.findAll", query="SELECT e FROM IaTestEntity e "),
-	@NamedQuery(name="IaTestEntity.deleteAll", query="DELETE FROM IaTestEntity WHERE 1=1")
-})
+@Table(name = "IaTestEntity")
+@NamedQueries({@NamedQuery(name = " IaTestEntity.findAll", query = "SELECT e FROM IaTestEntity e "),
+        @NamedQuery(name = "IaTestEntity.deleteAll", query = "DELETE FROM IaTestEntity WHERE 1=1")})
 
 public class IaTestEntity implements Serializable {
-	private static final long serialVersionUID = 1L;
-
-	@Id
-	@GeneratedValue(strategy = GenerationType.AUTO)
-	@Column(name="ImTestId")
-	private long imTestId;
-	
-	@Column(name="created_by", nullable=false, length=255)
-	private String createdBy = "guest";
-	
-	@Column(name="person", nullable=false, length=255)
-	private PersonSample person;
-
-	@Temporal(TemporalType.TIMESTAMP)
-	@Column(name="created_date", updatable=false)
-	private Date createdDate;
-
-	@Column(name="modified_by", nullable=false, length=255)
-	private String modifiedBy = "guest";
-
-	@Temporal(TemporalType.TIMESTAMP)
-	@Column(name="modified_date", nullable=false)
-	private Date modifiedDate;
-
-	public IaTestEntity() {
-	}
-
-	@PrePersist
-	public void	prePersist() {
-		Date date = new Date();
-		this.createdDate = date;
-		this.modifiedDate = date;
-	}
-
-	@PreUpdate
-	public void preUpdate() {
-		this.modifiedDate = new Date();
-	}
-	
-	/**
-	 * @return the Id
-	 */
-	public long getImTestId() {
-		return imTestId;
-	}
-	
-	/**
-	 * @return the createdBy
-	 */
-	public String getCreatedBy() {
-		return createdBy;
-	}
-
-	/**
-	 * @param createdBy the createdBy to set
-	 */
-	public void setCreatedBy(String createdBy) {
-		this.createdBy = createdBy;
-	}
-	
-	/**
-	 * @return the modifiedBy
-	 */
-	public String getModifiedBy() {
-		return modifiedBy;
-	}
-	
-	/**
-	 * @param modifiedBy the modifiedBy to set
-	 */
-	public void setModifiedBy(String modifiedBy) {
-		this.modifiedBy = modifiedBy;
-	}
-	
-	/**
-	 * @return the modifiedDate
-	 */
-	public Date getModifiedDate() {
-		return modifiedDate;
-	}
-
-	/**
-	 * @param modifiedDate the modifiedDate to set
-	 */
-	public void setModifiedDate(Date modifiedDate) {
-		this.modifiedDate = modifiedDate;
-	}
-
-	/**
-	 * @return the createdDate
-	 */
-	public Date getCreatedDate() {
-		return createdDate;
-	}
-	
-	/**
-	 * @param the person to set
-	 */
-	public void setPersonTest(PersonSample p) {
-		this.person = p;
-	}
-	
-	/**
-	 * @return the person
-	 */
-	public PersonSample getPersonTest() {
-		return person;
-	}
+    private static final long serialVersionUID = 1L;
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(name = "ImTestId")
+    private long imTestId;
+
+    @Column(name = "created_by", nullable = false, length = 255)
+    private String createdBy = "guest";
+
+    @Column(name = "person", nullable = false, length = 255)
+    private PersonSample person;
+
+    @Temporal(TemporalType.TIMESTAMP)
+    @Column(name = "created_date", updatable = false)
+    private Date createdDate;
+
+    @Column(name = "modified_by", nullable = false, length = 255)
+    private String modifiedBy = "guest";
+
+    @Temporal(TemporalType.TIMESTAMP)
+    @Column(name = "modified_date", nullable = false)
+    private Date modifiedDate;
+
+    public IaTestEntity() {}
+
+    /**
+     * PrePersist call back method.
+     */
+    @PrePersist
+    public void prePersist() {
+        Date date = new Date();
+        this.createdDate = date;
+        this.modifiedDate = date;
+    }
+
+    @PreUpdate
+    public void preUpdate() {
+        this.modifiedDate = new Date();
+    }
+
+    /**
+     * The the Im test Id.
+     * 
+     * @return the Id
+     */
+    public long getImTestId() {
+        return imTestId;
+    }
+
+    /**
+     * Get the createdBy.
+     * 
+     * @return the createdBy
+     */
+    public String getCreatedBy() {
+        return createdBy;
+    }
+
+    /**
+     * Set the createdBy.
+     * 
+     * @param createdBy the createdBy to set
+     */
+    public void setCreatedBy(String createdBy) {
+        this.createdBy = createdBy;
+    }
+
+    /**
+     * Get the modifiedBy.
+     * 
+     * @return the modifiedBy
+     */
+    public String getModifiedBy() {
+        return modifiedBy;
+    }
+
+    /**
+     * Set the ModifiedBy.
+     * 
+     * @param modifiedBy the modifiedBy to set
+     */
+    public void setModifiedBy(String modifiedBy) {
+        this.modifiedBy = modifiedBy;
+    }
+
+    /**
+     * Get the ModifiedDate.
+     * 
+     * @return the modifiedDate
+     */
+    public Date getModifiedDate() {
+        return modifiedDate;
+    }
+
+    /**
+     * Set the ModifiedDate.
+     * 
+     * @param modifiedDate the modifiedDate to set
+     */
+    public void setModifiedDate(Date modifiedDate) {
+        this.modifiedDate = modifiedDate;
+    }
+
+    /**
+     * Get the CreatedDate.
+     * 
+     * @return the createdDate
+     */
+    public Date getCreatedDate() {
+        return createdDate;
+    }
+
+    /**
+     * Set the person.
+     * 
+     * @param person the person to set
+     */
+    public void setPersonTest(PersonSample person) {
+        this.person = person;
+    }
+
+    /**
+     * Get the person.
+     * 
+     * @return the person
+     */
+    public PersonSample getPersonTest() {
+        return person;
+    }
 }
diff --git a/integrity-audit/src/test/java/org/onap/policy/common/ia/jpa/PersonSample.java b/integrity-audit/src/test/java/org/onap/policy/common/ia/jpa/PersonSample.java
index d7fcf330..47fa843b 100644
--- a/integrity-audit/src/test/java/org/onap/policy/common/ia/jpa/PersonSample.java
+++ b/integrity-audit/src/test/java/org/onap/policy/common/ia/jpa/PersonSample.java
@@ -23,42 +23,47 @@ package org.onap.policy.common.ia.jpa;
 import java.io.Serializable;
 
 public class PersonSample implements Serializable {
-	/**
-	 * 
-	 */
-	private static final long serialVersionUID = 1L;
-	private String firstName;
-	private String lastName;
-	private int age;
-	
-	public PersonSample(String first, String last, int age) {
-		this.firstName = first;
-		this.lastName = last;
-		this.age = age;
-	}
-	
-	public String getFirstName() {
-		return this.firstName;
-	}
-	
-	public void setFirstName(String name) {
-		this.firstName = name;
-	}
-	
-	public String getLasttName() {
-		return this.lastName;
-	}
-	
-	public void setLastName(String name) {
-		this.lastName = name;
-	}
-	
-	public int getAge() {
-		return this.age;
-	}
-	
-	public void setAge(int age) {
-		this.age = age;
-	}
-	
+
+    private static final long serialVersionUID = 1L;
+    private String firstName;
+    private String lastName;
+    private int age;
+
+    /**
+     * Create an instance.
+     * 
+     * @param first first name
+     * @param last last name
+     * @param age age
+     */
+    public PersonSample(String first, String last, int age) {
+        this.firstName = first;
+        this.lastName = last;
+        this.age = age;
+    }
+
+    public String getFirstName() {
+        return this.firstName;
+    }
+
+    public void setFirstName(String name) {
+        this.firstName = name;
+    }
+
+    public String getLasttName() {
+        return this.lastName;
+    }
+
+    public void setLastName(String name) {
+        this.lastName = name;
+    }
+
+    public int getAge() {
+        return this.age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
 }