Fix checkstyle in utils

Cleared all the checkstyle in these 2 submodules.

Issue-ID: POLICY-881
Change-Id: I248e1894aebf549d5a4f8669a6466ec227d40b55
Signed-off-by: Pamela Dragosh <pdragosh@research.att.com>

7 files changed, 904 insertions, 895 deletions

diff --git a/utils-test/src/main/java/org/onap/policy/common/utils/test/ConstructionError.java b/utils-test/src/main/java/org/onap/policy/common/utils/test/ConstructionError.java
index 0ae4fb97..d3438577 100644
--- a/utils-test/src/main/java/org/onap/policy/common/utils/test/ConstructionError.java
+++ b/utils-test/src/main/java/org/onap/policy/common/utils/test/ConstructionError.java
@@ -24,35 +24,41 @@ package org.onap.policy.common.utils.test;
  * An error that occurred while trying to construct an object for a junit test.
  */
 public class ConstructionError extends AssertionError {
-	private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;
 
-	/**
-	 *
-	 */
-	public ConstructionError() {
-		super();
-	}
+    /**
+     * Constructor.
+     */
+    public ConstructionError() {
+        super();
+    }
 
-	/**
-	 * @param message denotes the error message
-	 */
-	public ConstructionError(final String message) {
-		super(message);
-	}
+    /**
+     * Constructor.
+     * 
+     * @param message denotes the error message
+     */
+    public ConstructionError(final String message) {
+        super(message);
+    }
 
-	/**
-	 * @param cause denotes the cause of the error
-	 */
-	public ConstructionError(final Throwable cause) {
-		super(cause);
-	}
+    /**
+     * Constructor.
+     * 
+     * @param cause denotes the cause of the error
+     */
+    public ConstructionError(final Throwable cause) {
+        super(cause);
+    }
 
-	/**
-	 * @param message denotes the error message
-	 * @param cause denotes the cause of the error
-	 */
-	public ConstructionError(final String message, final Throwable cause) {
-		super(message, cause);
-	}
+    /**
+     * Constructor.
+     * 
+     * @param message denotes the error message
+     * @param cause denotes the cause of the error
+     */
+    public ConstructionError(final String message, final Throwable cause) {
+        super(message, cause);
+    }
 
 }
diff --git a/utils-test/src/main/java/org/onap/policy/common/utils/test/ErrorsTester.java b/utils-test/src/main/java/org/onap/policy/common/utils/test/ErrorsTester.java
index e63b073e..ab876b6e 100644
--- a/utils-test/src/main/java/org/onap/policy/common/utils/test/ErrorsTester.java
+++ b/utils-test/src/main/java/org/onap/policy/common/utils/test/ErrorsTester.java
@@ -26,23 +26,23 @@ package org.onap.policy.common.utils.test;
  */
 public class ErrorsTester extends ThrowablesTester {
 
-	/**
-	 * Runs tests, on an Error subclass, for all of the standard
-	 * constructors.If the Error subclass does not support a given
-	 * type of constructor, then it skips that test.
-	 * Does <i>not</i> throw an exception if no standard constructors
-	 * are found.
-	 *
-	 * @param claz subclass to be tested
-	 * @param <T> this needs to be declared
-	 *
-	 * @return the number of constructors that were found/tested
-	 * @throws ConstructionError
-	 *             if the Error subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public <T extends Error> int testAllError(final Class<T> claz) {
-		return testAllThrowable(claz);
-	}
+    /**
+     * Runs tests, on an Error subclass, for all of the standard
+     * constructors.If the Error subclass does not support a given
+     * type of constructor, then it skips that test.
+     * Does <i>not</i> throw an exception if no standard constructors
+     * are found.
+     *
+     * @param claz subclass to be tested
+     * @param <T> this needs to be declared
+     *
+     * @return the number of constructors that were found/tested
+     * @throws ConstructionError
+     *             if the Error subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public <T extends Error> int testAllError(final Class<T> claz) {
+        return testAllThrowable(claz);
+    }
 }
diff --git a/utils-test/src/main/java/org/onap/policy/common/utils/test/ExceptionsTester.java b/utils-test/src/main/java/org/onap/policy/common/utils/test/ExceptionsTester.java
index 7208748a..f457dd21 100644
--- a/utils-test/src/main/java/org/onap/policy/common/utils/test/ExceptionsTester.java
+++ b/utils-test/src/main/java/org/onap/policy/common/utils/test/ExceptionsTester.java
@@ -32,176 +32,176 @@ import java.lang.reflect.Constructor;
  */
 public class ExceptionsTester extends ThrowablesTester {
 
-	/**
-	 * Runs tests, on an Exception subclass, for all of the standard
-	 * constructors. If the Exception subclass does not support a given
-	 * type of constructor, then it skips that test.
-	 *
-	 * @param claz subclass to be tested
-	 * @param <T> Type of the class
-	 *
-	 * @return the number of constructors that were found/tested
-	 * @throws ConstructionError
-	 *             if the Exception subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public <T extends Exception> int test(final Class<T> claz) {
-		int ncons = testAllException(claz);
-
-		assertTrue(ncons > 0);
-
-		return ncons;
-	}
-
-	/**
-	 * Runs tests, on an Exception subclass, for all of the standard
-	 * constructors. If the Exception subclass does not support a given
-	 * type of constructor, then it skips that test. Does <i>not</i> throw
-	 * an exception if no standard constructors are found.
-	 *
-	 * @param claz subclass to be tested
-	 * @param <T> type of the class
-	 *
-	 * @return the number of constructors that were found/tested
-	 * @throws ConstructionError
-	 *             if the Exception subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public <T extends Exception> int testAllException(final Class<T> claz) {
-		int ncons = 0;
-
-		ncons += testAllThrowable(claz);
-		ncons += testException(claz);
-		ncons += testStringException(claz);
-		ncons += testStringExceptionBooleanBoolean(claz);
-
-		return ncons;
-	}
-
-	/**
-	 * Tests exceptions created via the constructor that takes just an
-	 * Exception. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the cause's message</li>
-	 * <li><i>getCause()</i> returns the original cause passed to the
-	 * constructor</li>
-	 * </ul>
-	 *
-	 * If the Exception subclass does not support this type of constructor,
-	 * then this method simply returns.
-	 *
-	 * @param claz subclass to be tested
-	 * @param <T> Type of the class
-	 *
-	 * @return {@code 1}, if the subclass supports this type of constructor,
-	 *         {@code 0} otherwise
-	 * @throws ConstructionError
-	 *             if the Exception subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public <T extends Exception> int testException(final Class<T> claz) {
-		Constructor<T> cons = getConstructor(claz, "exception",
-				Exception.class);
-
-		if (cons == null) {
-			return 0;
-		}
-
-		Exception cause = new Exception(EXPECTED_EXCEPTION_MSG);
-		T ex = newInstance(cons, cause);
-
-		assertNotNull(ex.toString());
-		assertEquals(ex.getMessage(), ex.getMessage());
-		assertEquals(cause, ex.getCause());
-
-		return 1;
-	}
-
-	/**
-	 * Tests exceptions created via the constructor that takes a String
-	 * and an Exception. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the original message passed to
-	 * the constructor</li>
-	 * <li><i>getCause()</i> returns the original cause passed to the
-	 * constructor</li>
-	 * </ul>
-	 *
-	 * If the Exception subclass does not support this type of
-	 * constructor, then this method simply returns.
-	 *
-	 * @param claz subclass to be tested
-	 * @param <T> Type of the class
-	 *
-	 * @return {@code 1}, if the subclass supports this type of constructor,
-	 *         {@code 0} otherwise
-	 * @throws ConstructionError
-	 *             if the Exception subclass cannot be constructed
-	 */
-	public <T extends Exception> int testStringException(
-                                                final Class<T> claz) {
-		Constructor<T> cons = getConstructor(claz, "string-exception",
-				String.class, Exception.class);
-		if (cons == null) {
-			return 0;
-		}
-
-		Exception cause = new Exception(EXPECTED_EXCEPTION_MSG);
-		T ex = newInstance(cons, "world", cause);
-
-		assertNotNull(ex.toString());
-		assertEquals("world", ex.getMessage());
-		assertEquals(cause, ex.getCause());
-
-		return 1;
-	}
-
-	/**
-	 * Tests exceptions created via the constructor that takes a String, an
-	 * Exception, and two booleans. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the original message passed to the
-	 * constructor</li>
-	 * <li><i>getCause()</i> returns the original cause passed to the
-	 * constructor</li>
-	 * <li>suppressed exceptions can be added, if enabled</li>
-	 * <li>the stack trace can be added, if enabled</li>
-	 * </ul>
-	 *
-	 * If the Exception subclass does not support this type of constructor,
-	 * then this method simply returns.
-	 *
-	 * @param claz subclass to be tested
-	 * @param <T> Type of the class
-	 *
-	 * @return {@code 1}, if the subclass supports this type of constructor,
-	 *         {@code 0} otherwise
-	 * @throws ConstructionError
-	 *             if the Exception subclass cannot be constructed
-	 */
-	public <T extends Exception> int testStringExceptionBooleanBoolean(
-                                                 final Class<T> claz) {
-
-		Constructor<T> cons = getConstructor(claz,
-                "string-exception-flags", String.class, Exception.class,
-                                            Boolean.TYPE, Boolean.TYPE);
-
-		if (cons == null) {
-			return 0;
-		}
-
-		// test each combination of "message" and "cause"
-		testMessageCauseCombos(cons);
-
-		// test each combination of the boolean flags
-		testFlagCombos(cons);
-
-		return 1;
-	}
+    /**
+     * Runs tests, on an Exception subclass, for all of the standard
+     * constructors. If the Exception subclass does not support a given
+     * type of constructor, then it skips that test.
+     *
+     * @param claz subclass to be tested
+     * @param <T> Type of the class
+     *
+     * @return the number of constructors that were found/tested
+     * @throws ConstructionError
+     *             if the Exception subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public <T extends Exception> int test(final Class<T> claz) {
+        int ncons = testAllException(claz);
+
+        assertTrue(ncons > 0);
+
+        return ncons;
+    }
+
+    /**
+     * Runs tests, on an Exception subclass, for all of the standard
+     * constructors. If the Exception subclass does not support a given
+     * type of constructor, then it skips that test. Does <i>not</i> throw
+     * an exception if no standard constructors are found.
+     *
+     * @param claz subclass to be tested
+     * @param <T> type of the class
+     *
+     * @return the number of constructors that were found/tested
+     * @throws ConstructionError
+     *             if the Exception subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public <T extends Exception> int testAllException(final Class<T> claz) {
+        int ncons = 0;
+
+        ncons += testAllThrowable(claz);
+        ncons += testException(claz);
+        ncons += testStringException(claz);
+        ncons += testStringExceptionBooleanBoolean(claz);
+
+        return ncons;
+    }
+
+    /**
+     * Tests exceptions created via the constructor that takes just an
+     * Exception. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the cause's message</li>
+     * <li><i>getCause()</i> returns the original cause passed to the
+     * constructor</li>
+     * </ul>
+     *
+     * <p>If the Exception subclass does not support this type of constructor,
+     * then this method simply returns.
+     *
+     * @param claz subclass to be tested
+     * @param <T> Type of the class
+     *
+     * @return {@code 1}, if the subclass supports this type of constructor,
+     *         {@code 0} otherwise
+     * @throws ConstructionError
+     *             if the Exception subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public <T extends Exception> int testException(final Class<T> claz) {
+        Constructor<T> cons = getConstructor(claz, "exception",
+                        Exception.class);
+
+        if (cons == null) {
+            return 0;
+        }
+
+        Exception cause = new Exception(EXPECTED_EXCEPTION_MSG);
+        T ex = newInstance(cons, cause);
+
+        assertNotNull(ex.toString());
+        assertEquals(ex.getMessage(), ex.getMessage());
+        assertEquals(cause, ex.getCause());
+
+        return 1;
+    }
+
+    /**
+     * Tests exceptions created via the constructor that takes a String
+     * and an Exception. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the original message passed to
+     * the constructor</li>
+     * <li><i>getCause()</i> returns the original cause passed to the
+     * constructor</li>
+     * </ul>
+     *
+     * <p>If the Exception subclass does not support this type of
+     * constructor, then this method simply returns.
+     *
+     * @param claz subclass to be tested
+     * @param <T> Type of the class
+     *
+     * @return {@code 1}, if the subclass supports this type of constructor,
+     *         {@code 0} otherwise
+     * @throws ConstructionError
+     *             if the Exception subclass cannot be constructed
+     */
+    public <T extends Exception> int testStringException(
+                    final Class<T> claz) {
+        Constructor<T> cons = getConstructor(claz, "string-exception",
+                        String.class, Exception.class);
+        if (cons == null) {
+            return 0;
+        }
+
+        Exception cause = new Exception(EXPECTED_EXCEPTION_MSG);
+        T ex = newInstance(cons, "world", cause);
+
+        assertNotNull(ex.toString());
+        assertEquals("world", ex.getMessage());
+        assertEquals(cause, ex.getCause());
+
+        return 1;
+    }
+
+    /**
+     * Tests exceptions created via the constructor that takes a String, an
+     * Exception, and two booleans. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the original message passed to the
+     * constructor</li>
+     * <li><i>getCause()</i> returns the original cause passed to the
+     * constructor</li>
+     * <li>suppressed exceptions can be added, if enabled</li>
+     * <li>the stack trace can be added, if enabled</li>
+     * </ul>
+     *
+     * <p>If the Exception subclass does not support this type of constructor,
+     * then this method simply returns.
+     *
+     * @param claz subclass to be tested
+     * @param <T> Type of the class
+     *
+     * @return {@code 1}, if the subclass supports this type of constructor,
+     *         {@code 0} otherwise
+     * @throws ConstructionError
+     *             if the Exception subclass cannot be constructed
+     */
+    public <T extends Exception> int testStringExceptionBooleanBoolean(
+                    final Class<T> claz) {
+
+        Constructor<T> cons = getConstructor(claz,
+                        "string-exception-flags", String.class, Exception.class,
+                        Boolean.TYPE, Boolean.TYPE);
+
+        if (cons == null) {
+            return 0;
+        }
+
+        // test each combination of "message" and "cause"
+        testMessageCauseCombos(cons);
+
+        // test each combination of the boolean flags
+        testFlagCombos(cons);
+
+        return 1;
+    }
 }
diff --git a/utils-test/src/main/java/org/onap/policy/common/utils/test/ThrowablesTester.java b/utils-test/src/main/java/org/onap/policy/common/utils/test/ThrowablesTester.java
index c77b7813..0fba944e 100644
--- a/utils-test/src/main/java/org/onap/policy/common/utils/test/ThrowablesTester.java
+++ b/utils-test/src/main/java/org/onap/policy/common/utils/test/ThrowablesTester.java
@@ -37,529 +37,529 @@ import org.slf4j.LoggerFactory;
  */
 public class ThrowablesTester {
 
-	private static Logger logger =
-                          LoggerFactory.getLogger(ThrowablesTester.class);
-
-	public static final String EXPECTED_EXCEPTION_MSG = 
-                                           "expected exception";
-	private static final String EXPECTED_SUPPRESSED_EXCEPTION_MSG =
-                                           "expected suppressed exception";
-
-	/**
-	 * Passed as a "cause" to constructors.
-	 */
-	public static final Exception CAUSE =
-                                      new Exception(EXPECTED_EXCEPTION_MSG);
-
-	/**
-	 * Passed to new objects via the <i>addSuppressed()</i> method..
-	 */
-	public static final Throwable SUPPRESSED =
-                            new Throwable(EXPECTED_SUPPRESSED_EXCEPTION_MSG);
-
-	/**
-	 * Runs tests, on an Throwable subclass, for all of the
-	 * standard constructors. If the Throwable subclass does
-	 * not support a given type of constructor, then it skips
-	 * that test. Does <i>not</i> throw an exception if no
-	 * standard constructors are found.
-	 *
-	 * @param claz subclass to be tested
-	 * @param <T> To be defined
-	 * @return the number of constructors that were found/tested
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> int testAllThrowable(
-                                                  final Class<T> claz) {
-		int ncons = 0;
-
-		ncons += testDefault(claz);
-		ncons += testString(claz);
-		ncons += testThrowable(claz);
-		ncons += testStringThrowable(claz);
-		ncons += testStringThrowableBooleanBoolean(claz);
-
-		return ncons;
-	}
-
-	/**
-	 * Tests Throwable objects created via the default constructor. Verifies
-	 * that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns null</li>
-	 * <li><i>getCause()</i> returns null</li>
-	 * </ul>
-	 *
-	 * If the Throwable subclass does not support this type of
-	 * constructor, then this method simply returns.
-	 *
-	 * @param claz subclass to be tested
-	 * @param <T> to be defined
-	 * @return {@code 1}, if the subclass supports this type of constructor,
-	 *         {@code 0} otherwise
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> int testDefault(
-                                                  final Class<T> claz) {
-		Constructor<T> cons = getConstructor(claz, "default");
-		if (cons == null) {
-			return 0;
-		}
-
-		T ex = newInstance(cons);
-
-		assertNotNull(ex.toString());
-		assertNull(ex.getMessage());
-		assertNull(ex.getCause());
-
-		return 1;
-	}
-
-	/**
-	 * Tests Throwable objects created via the constructor that takes just a
-	 * String. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the original message passed to the
-	 * constructor</li>
-	 * <li><i>getCause()</i> returns null</li>
-	 * </ul>
-	 *
-	 * If the Throwable subclass does not support this type of constructor,
-	 * then this method simply returns.
-	 *
-	 * @param claz
-	 *            subclass to be tested
-	 * @param <T> to be defined
-	 * @return {@code 1}, if the subclass supports this type of constructor,
-	 *         {@code 0} otherwise
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> int testString(final Class<T> claz) {
-		Constructor<T> cons = getConstructor(claz, "string",
-                                                        String.class);
-		if (cons == null) {
-			return 0;
-		}
-
-		T ex = newInstance(cons, "hello");
-
-		assertNotNull(ex.toString());
-		assertEquals("hello", ex.getMessage());
-		assertNull(ex.getCause());
-
-		return 1;
-	}
-
-	/**
-	 * Tests Throwable objects created via the constructor that takes just a
-	 * Throwable. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the cause's message</li>
-	 * <li><i>getCause()</i> returns the original cause passed to the
-	 * constructor</li>
-	 * </ul>
-	 *
-	 * If the Throwable subclass does not support this type of constructor,
-	 * then this method simply returns.
-	 *
-	 * @param claz
-	 *            subclass to be tested
-	 * @param <T> to be defined
-	 * @return {@code 1}, if the subclass supports this type of constructor,
-	 *         {@code 0} otherwise
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> int testThrowable(
-                                                   final Class<T> claz) {
-		Constructor<T> cons = getConstructor(claz, "throwable",
-                                                        Throwable.class);
-		if (cons == null) {
-			return 0;
-		}
-
-		T ex = newInstance(cons, CAUSE);
-
-		assertEquals(ex.getMessage(), ex.getMessage());
-		assertNotNull(ex.toString());
-		assertEquals(CAUSE, ex.getCause());
-
-		return 1;
-	}
-
-	/**
-	 * Tests Throwable objects created via the constructor that takes
-	 * a String and a Throwable. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the original message passed to the
-	 * constructor</li>
-	 * <li><i>getCause()</i> returns the original cause passed to the
-	 * constructor</li>
-	 * </ul>
-	 *
-	 * If the Throwable subclass does not support this type of constructor,
-	 * then this method simply returns.
-	 *
-	 * @param claz subclass to be tested
-	 * @param <T> to be defined
-	 * @return {@code 1}, if the subclass supports this type of constructor,
-	 *         {@code 0} otherwise
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> int testStringThrowable(
-                                                  final Class<T> claz) {
-		Constructor<T> cons = getConstructor(claz, "string-throwable",
-                                          String.class, Throwable.class);
-		if (cons == null) {
-			return 0;
-		}
-
-		T ex = newInstance(cons, "world", CAUSE);
-
-		assertNotNull(ex.toString());
-		assertEquals("world", ex.getMessage());
-		assertEquals(CAUSE, ex.getCause());
-
-		return 1;
-	}
-
-	/**
-	 * Tests Throwable objects created via the constructor that takes
-	 * a String, a Throwable, and two booleans. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the original message passed to the
-	 * constructor</li>
-	 * <li><i>getCause()</i> returns the original cause passed to the
-	 * constructor</li>
-	 * <li>suppressed exceptions can be added, if enabled</li>
-	 * <li>the stack trace can be added, if enabled</li>
-	 * </ul>
-	 *
-	 * If the Throwable subclass does not support this type of constructor,
-	 * then this method simply returns.
-	 *
-	 * @param claz
-	 *            subclass to be tested
-	 * @param <T> to be defined
-	 * @return {@code 1}, if the subclass supports this type of constructor,
-	 *         {@code 0} otherwise
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> int
-	                      testStringThrowableBooleanBoolean(
-                                                  final Class<T> claz) {
-		Constructor<T> cons = getConstructor(claz,
-				              "string-throwable-flags",
-				               String.class, Throwable.class,
-				               Boolean.TYPE, Boolean.TYPE);
-		if (cons == null) {
-			return 0;
-		}
-
-		// test each combination of "message" and "cause"
-		testMessageCauseCombos(cons);
-
-		// test each combination of the boolean flags
-		testSuppressStack(cons);
-		testSuppressNoStack(cons);
-		testNoSuppressStack(cons);
-		testNoSuppressNoStack(cons);
-
-		return 1;
-	}
-
-	/**
-	 * Tests each combination of values for the "message" and the "cause"
-	 * when using the constructor that takes a String,
-	 * a Throwable/Exception, and two booleans. Verifies that expected
-	 * values are returned
-	 * <ul>
-	 * <i>toString()</i>,
-	 * <i>getMessage()</i>, and <i>getCause()</i>.
-	 * </ul>
-	 *
-	 * @param cons
-	 *            constructor to be invoked
-	 * @param <T> to be defined
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> void testMessageCauseCombos(
-                                             final Constructor<T> cons) {
-		T ex;
-
-		ex = newInstance(cons, null, null, true, true);
-		assertNotNull(ex.toString());
-		assertNull(ex.getMessage());
-		assertNull(ex.getCause());
-
-		ex = newInstance(cons, "abc", null, true, true);
-		assertNotNull(ex.toString());
-		assertEquals("abc", ex.getMessage());
-		assertNull(ex.getCause());
-
-		ex = newInstance(cons, null, CAUSE, true, true);
-		assertNotNull(ex.toString());
-		assertNull(ex.getMessage());
-		assertEquals(CAUSE, ex.getCause());
-
-		ex = newInstance(cons, "xyz", CAUSE, true, true);
-		assertNotNull(ex.toString());
-		assertEquals("xyz", ex.getMessage());
-		assertEquals(CAUSE, ex.getCause());
-	}
-
-	/**
-	 * Tests each combination of values for the "message" and the
-	 * "cause" when using the constructor that takes a String,
-	 * a Throwable/Exception, and two booleans. Verifies that
-	 * expected values are returned by
-	 * <ul>
-	 * <i>toString()</i>,
-	 * <i>getMessage()</i>, and <i>getCause()</i>.
-	 * </ul>
-	 *
-	 * @param cons
-	 *            constructor to be invoked
-	 * @param <T> to be defined
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> void testFlagCombos(
-                                       final Constructor<T> cons) {
-		testSuppressStack(cons);
-		testSuppressNoStack(cons);
-		testNoSuppressStack(cons);
-		testNoSuppressNoStack(cons);
-	}
-
-	/**
-	 * Tests Throwable objects constructed with
-	 * {@code enableSuppression=true} and
-	 * {@code writableStackTrace=true}. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the original message passed to the
-	 * constructor</li>
-	 * <li><i>getCause()</i> returns the original cause passed to the
-	 * constructor</li>
-	 * <li>suppressed exceptions are added</li>
-	 * <li>the stack trace is added</li>
-	 * </ul>
-	 *
-	 * @param cons
-	 *            the throwable's class constructor
-	 * @param <T> to be defined
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> void testSuppressStack(
-                                             final Constructor<T> cons) {
-		T ex = newInstance(cons, "yes,yes", CAUSE, true, true);
-
-		ex.addSuppressed(SUPPRESSED);
-
-		assertNotNull(ex.toString());
-		assertEquals("yes,yes", ex.getMessage());
-		assertEquals(CAUSE, ex.getCause());
-
-		assertEquals(1, ex.getSuppressed().length);
-		assertEquals(SUPPRESSED, ex.getSuppressed()[0]);
-
-		assertTrue(ex.getStackTrace().length > 0);
-	}
-
-	/**
-	 * Tests Throwable objects constructed with
-	 * {@code enableSuppression=true} and
-	 * {@code writableStackTrace=false}. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the original message passed to the
-	 * constructor</li>
-	 * <li><i>getCause()</i> returns the original cause passed to the
-	 * constructor</li>
-	 * <li>suppressed exceptions are added</li>
-	 * <li>the stack trace is <i>not</i> added</li>
-	 * </ul>
-	 *
-	 * @param cons
-	 *            the throwable's class constructor
-	 * @param <T> to be defined
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> void testSuppressNoStack(
-                                            final Constructor<T> cons) {
-		T ex = newInstance(cons, "yes,no", CAUSE, true, false);
-
-		ex.addSuppressed(SUPPRESSED);
-
-		assertNotNull(ex.toString());
-		assertEquals("yes,no", ex.getMessage());
-		assertEquals(CAUSE, ex.getCause());
-
-		assertEquals(1, ex.getSuppressed().length);
-		assertEquals(SUPPRESSED, ex.getSuppressed()[0]);
-
-		assertEquals(0, ex.getStackTrace().length);
-	}
-
-	/**
-	 * Tests Throwable objects constructed with
-	 * {@code enableSuppression=false} and
-	 * {@code writableStackTrace=true}. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the original message passed to the
-	 * constructor</li>
-	 * <li><i>getCause()</i> returns the original cause passed to the
-	 * constructor</li>
-	 * <li>suppressed exceptions are <i>not</i> added</li>
-	 * <li>the stack trace is added</li>
-	 * </ul>
-	 *
-	 * @param cons
-	 *            the throwable's class constructor
-	 * @param <T> to be defined
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> void testNoSuppressStack(
-                                            final Constructor<T> cons) {
-		T ex = newInstance(cons, "no,yes", CAUSE, false, true);
-
-		ex.addSuppressed(SUPPRESSED);
-
-		assertNotNull(ex.toString());
-		assertEquals("no,yes", ex.getMessage());
-		assertEquals(CAUSE, ex.getCause());
-
-		assertEquals(0, ex.getSuppressed().length);
-
-		assertTrue(ex.getStackTrace().length > 0);
-	}
-
-	/**
-	 * Tests Throwable objects constructed with
-	 * {@code enableSuppression=false} and
-	 * {@code writableStackTrace=false}. Verifies that:
-	 * <ul>
-	 * <li><i>toString()</i> returns a non-null value</li>
-	 * <li><i>getMessage()</i> returns the original message passed to the
-	 * constructor</li>
-	 * <li><i>getCause()</i> returns the original cause passed to the
-	 * constructor</li>
-	 * <li>suppressed exceptions are <i>not</i> added</li>
-	 * <li>the stack trace is <i>not</i> added</li>
-	 * </ul>
-	 * @param cons
-	 *            the throwable's class constructor
-	 * @param <T> to be defined
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 * @throws AssertionError
-	 *             if the constructed objects fail to pass various tests
-	 */
-	public final <T extends Throwable> void testNoSuppressNoStack(
-                                            final Constructor<T> cons) {
-		T ex = newInstance(cons, "no,no", CAUSE, false, false);
-
-		ex.addSuppressed(SUPPRESSED);
-
-		assertNotNull(ex.toString());
-		assertEquals("no,no", ex.getMessage());
-		assertEquals(CAUSE, ex.getCause());
-
-		assertEquals(0, ex.getSuppressed().length);
-		assertEquals(0, ex.getStackTrace().length);
-	}
-
-	/**
-	 * Attempts to get a constructor for objects of a given type.
-	 *
-	 * @param claz
-	 *            class of objects whose constructor is to be gotten
-	 * @param <T> to be defined
-	 * @param testType
-	 *            type of test being run
-	 * @param argTypes
-	 *            argument types to be passed to the constructor
-	 * @return the desired constructor, or {@code null} if the desired
-	 *         constructor is not available
-	 */
-	protected <T extends Throwable> Constructor<T> getConstructor(
-                              final Class<T> claz,
-                                  final String testType,
-			                         final Class<?>... argTypes) {
-
-		try {
-			return claz.getConstructor(argTypes);
-
-		} catch (NoSuchMethodException | SecurityException e) {
-			// this constructor is not defined so nothing to test
-			logger.debug("skipped test, no constructor for: "
-                                          + claz + " due to: " + e);
-			return null;
-		}
-	}
-
-	/**
-	 * Creates a new instance of an Throwable subclass.
-	 *
-	 * @param cons
-	 *            subclass constructor
-	 * @param <T> to be defined
-	 * @param args
-	 *            arguments to be passed to the constructor
-	 * @return a new instance of the Throwable subclass
-	 * @throws ConstructionError
-	 *             if the Throwable subclass cannot be constructed
-	 */
-	protected <T extends Throwable> T newInstance(
-                                         final Constructor<T> cons,
-                                            final Object... args) {
-		try {
-			return cons.newInstance(args);
-
-		} catch (InstantiationException | IllegalAccessException
-				| IllegalArgumentException
-				| InvocationTargetException e) {
-
-			throw new ConstructionError(e);
-		}
-
-	}
+    private static Logger logger =
+                    LoggerFactory.getLogger(ThrowablesTester.class);
+
+    public static final String EXPECTED_EXCEPTION_MSG = 
+                    "expected exception";
+    private static final String EXPECTED_SUPPRESSED_EXCEPTION_MSG =
+                    "expected suppressed exception";
+
+    /**
+     * Passed as a "cause" to constructors.
+     */
+    public static final Exception CAUSE =
+                    new Exception(EXPECTED_EXCEPTION_MSG);
+
+    /**
+     * Passed to new objects via the <i>addSuppressed()</i> method..
+     */
+    public static final Throwable SUPPRESSED =
+                    new Throwable(EXPECTED_SUPPRESSED_EXCEPTION_MSG);
+
+    /**
+     * Runs tests, on an Throwable subclass, for all of the
+     * standard constructors. If the Throwable subclass does
+     * not support a given type of constructor, then it skips
+     * that test. Does <i>not</i> throw an exception if no
+     * standard constructors are found.
+     *
+     * @param claz subclass to be tested
+     * @param <T> To be defined
+     * @return the number of constructors that were found/tested
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> int testAllThrowable(
+                    final Class<T> claz) {
+        int ncons = 0;
+
+        ncons += testDefault(claz);
+        ncons += testString(claz);
+        ncons += testThrowable(claz);
+        ncons += testStringThrowable(claz);
+        ncons += testStringThrowableBooleanBoolean(claz);
+
+        return ncons;
+    }
+
+    /**
+     * Tests Throwable objects created via the default constructor. Verifies
+     * that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns null</li>
+     * <li><i>getCause()</i> returns null</li>
+     * </ul>
+     *
+     * <p>If the Throwable subclass does not support this type of
+     * constructor, then this method simply returns.
+     *
+     * @param claz subclass to be tested
+     * @param <T> to be defined
+     * @return {@code 1}, if the subclass supports this type of constructor,
+     *         {@code 0} otherwise
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> int testDefault(
+                    final Class<T> claz) {
+        Constructor<T> cons = getConstructor(claz, "default");
+        if (cons == null) {
+            return 0;
+        }
+
+        T ex = newInstance(cons);
+
+        assertNotNull(ex.toString());
+        assertNull(ex.getMessage());
+        assertNull(ex.getCause());
+
+        return 1;
+    }
+
+    /**
+     * Tests Throwable objects created via the constructor that takes just a
+     * String. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the original message passed to the
+     * constructor</li>
+     * <li><i>getCause()</i> returns null</li>
+     * </ul>
+     *
+     * <p>If the Throwable subclass does not support this type of constructor,
+     * then this method simply returns.
+     *
+     * @param claz
+     *            subclass to be tested
+     * @param <T> to be defined
+     * @return {@code 1}, if the subclass supports this type of constructor,
+     *         {@code 0} otherwise
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> int testString(final Class<T> claz) {
+        Constructor<T> cons = getConstructor(claz, "string",
+                        String.class);
+        if (cons == null) {
+            return 0;
+        }
+
+        T ex = newInstance(cons, "hello");
+
+        assertNotNull(ex.toString());
+        assertEquals("hello", ex.getMessage());
+        assertNull(ex.getCause());
+
+        return 1;
+    }
+
+    /**
+     * Tests Throwable objects created via the constructor that takes just a
+     * Throwable. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the cause's message</li>
+     * <li><i>getCause()</i> returns the original cause passed to the
+     * constructor</li>
+     * </ul>
+     *
+     * <p>If the Throwable subclass does not support this type of constructor,
+     * then this method simply returns.
+     *
+     * @param claz
+     *            subclass to be tested
+     * @param <T> to be defined
+     * @return {@code 1}, if the subclass supports this type of constructor,
+     *         {@code 0} otherwise
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> int testThrowable(
+                    final Class<T> claz) {
+        Constructor<T> cons = getConstructor(claz, "throwable",
+                        Throwable.class);
+        if (cons == null) {
+            return 0;
+        }
+
+        T ex = newInstance(cons, CAUSE);
+
+        assertEquals(ex.getMessage(), ex.getMessage());
+        assertNotNull(ex.toString());
+        assertEquals(CAUSE, ex.getCause());
+
+        return 1;
+    }
+
+    /**
+     * Tests Throwable objects created via the constructor that takes
+     * a String and a Throwable. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the original message passed to the
+     * constructor</li>
+     * <li><i>getCause()</i> returns the original cause passed to the
+     * constructor</li>
+     * </ul>
+     *
+     * <p>If the Throwable subclass does not support this type of constructor,
+     * then this method simply returns.
+     *
+     * @param claz subclass to be tested
+     * @param <T> to be defined
+     * @return {@code 1}, if the subclass supports this type of constructor,
+     *         {@code 0} otherwise
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> int testStringThrowable(
+                    final Class<T> claz) {
+        Constructor<T> cons = getConstructor(claz, "string-throwable",
+                        String.class, Throwable.class);
+        if (cons == null) {
+            return 0;
+        }
+
+        T ex = newInstance(cons, "world", CAUSE);
+
+        assertNotNull(ex.toString());
+        assertEquals("world", ex.getMessage());
+        assertEquals(CAUSE, ex.getCause());
+
+        return 1;
+    }
+
+    /**
+     * Tests Throwable objects created via the constructor that takes
+     * a String, a Throwable, and two booleans. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the original message passed to the
+     * constructor</li>
+     * <li><i>getCause()</i> returns the original cause passed to the
+     * constructor</li>
+     * <li>suppressed exceptions can be added, if enabled</li>
+     * <li>the stack trace can be added, if enabled</li>
+     * </ul>
+     *
+     * <p>If the Throwable subclass does not support this type of constructor,
+     * then this method simply returns.
+     *
+     * @param claz
+     *            subclass to be tested
+     * @param <T> to be defined
+     * @return {@code 1}, if the subclass supports this type of constructor,
+     *         {@code 0} otherwise
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> int
+        testStringThrowableBooleanBoolean(
+                    final Class<T> claz) {
+        Constructor<T> cons = getConstructor(claz,
+                        "string-throwable-flags",
+                        String.class, Throwable.class,
+                        Boolean.TYPE, Boolean.TYPE);
+        if (cons == null) {
+            return 0;
+        }
+
+        // test each combination of "message" and "cause"
+        testMessageCauseCombos(cons);
+
+        // test each combination of the boolean flags
+        testSuppressStack(cons);
+        testSuppressNoStack(cons);
+        testNoSuppressStack(cons);
+        testNoSuppressNoStack(cons);
+
+        return 1;
+    }
+
+    /**
+     * Tests each combination of values for the "message" and the "cause"
+     * when using the constructor that takes a String,
+     * a Throwable/Exception, and two booleans. Verifies that expected
+     * values are returned
+     * <ul>
+     * <i>toString()</i>,
+     * <i>getMessage()</i>, and <i>getCause()</i>.
+     * </ul>
+     *
+     * @param cons
+     *            constructor to be invoked
+     * @param <T> to be defined
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> void testMessageCauseCombos(
+                    final Constructor<T> cons) {
+        T ex;
+
+        ex = newInstance(cons, null, null, true, true);
+        assertNotNull(ex.toString());
+        assertNull(ex.getMessage());
+        assertNull(ex.getCause());
+
+        ex = newInstance(cons, "abc", null, true, true);
+        assertNotNull(ex.toString());
+        assertEquals("abc", ex.getMessage());
+        assertNull(ex.getCause());
+
+        ex = newInstance(cons, null, CAUSE, true, true);
+        assertNotNull(ex.toString());
+        assertNull(ex.getMessage());
+        assertEquals(CAUSE, ex.getCause());
+
+        ex = newInstance(cons, "xyz", CAUSE, true, true);
+        assertNotNull(ex.toString());
+        assertEquals("xyz", ex.getMessage());
+        assertEquals(CAUSE, ex.getCause());
+    }
+
+    /**
+     * Tests each combination of values for the "message" and the
+     * "cause" when using the constructor that takes a String,
+     * a Throwable/Exception, and two booleans. Verifies that
+     * expected values are returned by
+     * <ul>
+     * <i>toString()</i>,
+     * <i>getMessage()</i>, and <i>getCause()</i>.
+     * </ul>
+     *
+     * @param cons
+     *            constructor to be invoked
+     * @param <T> to be defined
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> void testFlagCombos(
+                    final Constructor<T> cons) {
+        testSuppressStack(cons);
+        testSuppressNoStack(cons);
+        testNoSuppressStack(cons);
+        testNoSuppressNoStack(cons);
+    }
+
+    /**
+     * Tests Throwable objects constructed with
+     * {@code enableSuppression=true} and
+     * {@code writableStackTrace=true}. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the original message passed to the
+     * constructor</li>
+     * <li><i>getCause()</i> returns the original cause passed to the
+     * constructor</li>
+     * <li>suppressed exceptions are added</li>
+     * <li>the stack trace is added</li>
+     * </ul>
+     *
+     * @param cons
+     *            the throwable's class constructor
+     * @param <T> to be defined
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> void testSuppressStack(
+                    final Constructor<T> cons) {
+        T ex = newInstance(cons, "yes,yes", CAUSE, true, true);
+
+        ex.addSuppressed(SUPPRESSED);
+
+        assertNotNull(ex.toString());
+        assertEquals("yes,yes", ex.getMessage());
+        assertEquals(CAUSE, ex.getCause());
+
+        assertEquals(1, ex.getSuppressed().length);
+        assertEquals(SUPPRESSED, ex.getSuppressed()[0]);
+
+        assertTrue(ex.getStackTrace().length > 0);
+    }
+
+    /**
+     * Tests Throwable objects constructed with
+     * {@code enableSuppression=true} and
+     * {@code writableStackTrace=false}. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the original message passed to the
+     * constructor</li>
+     * <li><i>getCause()</i> returns the original cause passed to the
+     * constructor</li>
+     * <li>suppressed exceptions are added</li>
+     * <li>the stack trace is <i>not</i> added</li>
+     * </ul>
+     *
+     * @param cons
+     *            the throwable's class constructor
+     * @param <T> to be defined
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> void testSuppressNoStack(
+                    final Constructor<T> cons) {
+        T ex = newInstance(cons, "yes,no", CAUSE, true, false);
+
+        ex.addSuppressed(SUPPRESSED);
+
+        assertNotNull(ex.toString());
+        assertEquals("yes,no", ex.getMessage());
+        assertEquals(CAUSE, ex.getCause());
+
+        assertEquals(1, ex.getSuppressed().length);
+        assertEquals(SUPPRESSED, ex.getSuppressed()[0]);
+
+        assertEquals(0, ex.getStackTrace().length);
+    }
+
+    /**
+     * Tests Throwable objects constructed with
+     * {@code enableSuppression=false} and
+     * {@code writableStackTrace=true}. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the original message passed to the
+     * constructor</li>
+     * <li><i>getCause()</i> returns the original cause passed to the
+     * constructor</li>
+     * <li>suppressed exceptions are <i>not</i> added</li>
+     * <li>the stack trace is added</li>
+     * </ul>
+     *
+     * @param cons
+     *            the throwable's class constructor
+     * @param <T> to be defined
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> void testNoSuppressStack(
+                    final Constructor<T> cons) {
+        T ex = newInstance(cons, "no,yes", CAUSE, false, true);
+
+        ex.addSuppressed(SUPPRESSED);
+
+        assertNotNull(ex.toString());
+        assertEquals("no,yes", ex.getMessage());
+        assertEquals(CAUSE, ex.getCause());
+
+        assertEquals(0, ex.getSuppressed().length);
+
+        assertTrue(ex.getStackTrace().length > 0);
+    }
+
+    /**
+     * Tests Throwable objects constructed with
+     * {@code enableSuppression=false} and
+     * {@code writableStackTrace=false}. Verifies that:
+     * <ul>
+     * <li><i>toString()</i> returns a non-null value</li>
+     * <li><i>getMessage()</i> returns the original message passed to the
+     * constructor</li>
+     * <li><i>getCause()</i> returns the original cause passed to the
+     * constructor</li>
+     * <li>suppressed exceptions are <i>not</i> added</li>
+     * <li>the stack trace is <i>not</i> added</li>
+     * </ul>
+     * @param cons
+     *            the throwable's class constructor
+     * @param <T> to be defined
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     * @throws AssertionError
+     *             if the constructed objects fail to pass various tests
+     */
+    public final <T extends Throwable> void testNoSuppressNoStack(
+                    final Constructor<T> cons) {
+        T ex = newInstance(cons, "no,no", CAUSE, false, false);
+
+        ex.addSuppressed(SUPPRESSED);
+
+        assertNotNull(ex.toString());
+        assertEquals("no,no", ex.getMessage());
+        assertEquals(CAUSE, ex.getCause());
+
+        assertEquals(0, ex.getSuppressed().length);
+        assertEquals(0, ex.getStackTrace().length);
+    }
+
+    /**
+     * Attempts to get a constructor for objects of a given type.
+     *
+     * @param claz
+     *            class of objects whose constructor is to be gotten
+     * @param <T> to be defined
+     * @param testType
+     *            type of test being run
+     * @param argTypes
+     *            argument types to be passed to the constructor
+     * @return the desired constructor, or {@code null} if the desired
+     *         constructor is not available
+     */
+    protected <T extends Throwable> Constructor<T> getConstructor(
+                    final Class<T> claz,
+                    final String testType,
+                    final Class<?>... argTypes) {
+
+        try {
+            return claz.getConstructor(argTypes);
+
+        } catch (NoSuchMethodException | SecurityException e) {
+            // this constructor is not defined so nothing to test
+            logger.debug("skipped test, no constructor for: "
+                            + claz + " due to: " + e);
+            return null;
+        }
+    }
+
+    /**
+     * Creates a new instance of an Throwable subclass.
+     *
+     * @param cons
+     *            subclass constructor
+     * @param <T> to be defined
+     * @param args
+     *            arguments to be passed to the constructor
+     * @return a new instance of the Throwable subclass
+     * @throws ConstructionError
+     *             if the Throwable subclass cannot be constructed
+     */
+    protected <T extends Throwable> T newInstance(
+                    final Constructor<T> cons,
+                    final Object... args) {
+        try {
+            return cons.newInstance(args);
+
+        } catch (InstantiationException | IllegalAccessException
+                        | IllegalArgumentException
+                        | InvocationTargetException e) {
+
+            throw new ConstructionError(e);
+        }
+
+    }
 }
diff --git a/utils-test/src/main/java/org/onap/policy/common/utils/test/log/logback/ExtractAppender.java b/utils-test/src/main/java/org/onap/policy/common/utils/test/log/logback/ExtractAppender.java
index 14bceb4c..5ccb13ee 100644
--- a/utils-test/src/main/java/org/onap/policy/common/utils/test/log/logback/ExtractAppender.java
+++ b/utils-test/src/main/java/org/onap/policy/common/utils/test/log/logback/ExtractAppender.java
@@ -20,6 +20,8 @@
 
 package org.onap.policy.common.utils.test.log.logback;
 
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.AppenderBase;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.LinkedList;
@@ -28,9 +30,6 @@ import java.util.Queue;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import ch.qos.logback.classic.spi.ILoggingEvent;
-import ch.qos.logback.core.AppenderBase;
-
 /**
  * This is an appender that is intended for use by JUnit tests that wish to
  * capture logged messages. The appender takes an optional list of regular
@@ -46,147 +45,147 @@ import ch.qos.logback.core.AppenderBase;
  */
 public class ExtractAppender extends AppenderBase<ILoggingEvent> {
 
-	/**
-	 * Extracted text is placed here.
-	 */
-	private final Queue<String> extracted;
-
-	/**
-	 * Regular expressions/Patterns to be used to extract text. Uses a
-	 * LinkedHashMap so that order is preserved.
-	 */
-	private final LinkedHashMap<String, Pattern> patterns;
-
-	/**
-	 * Records every message that is logged.
-	 */
-	public ExtractAppender() {
-		this(new LinkedList<>());
-	}
-
-	/**
-	 * Records portions of messages that match one of the regular
-	 * expressions.
-	 *
-	 * @param regex
-	 *            regular expression (i.e., {@link Pattern}) to match
-	 */
-	public ExtractAppender(final String... regex) {
-		this(new LinkedList<>(), regex);
-	}
-
-	/**
-	 * Rather than allocating an internal queue to store matched messages,
-	 * messages are recorded in the specified target queue using the
-	 * {@link Queue#offer(Object)} method. Note: whenever the queue is used,
-	 * it will be synchronized to prevent simultaneous accesses.
-	 *
-	 * @param target - queue into which the matched text should be placed
-	 * @param regex regular expression (i.e., {@link Pattern}) to match
-	 */
-	public ExtractAppender(final Queue<String> target,
-							final String... regex) {
-		extracted = target;
-		patterns = new LinkedHashMap<>(regex.length);
-
-		for (String re : regex) {
-			patterns.put(re, Pattern.compile(re));
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 *
-	 * @see ch.qos.logback.core.AppenderBase#append(Object)
-	 */
-	@Override
-	protected void append(final ILoggingEvent event) {
-
-		String msg = event.getMessage();
-
-		synchronized (patterns) {
-			if (patterns.isEmpty()) {
-				addExtraction(msg);
-				return;
-			}
-
-			for (Pattern p : patterns.values()) {
-				Matcher m = p.matcher(msg);
-
-				if (m.find()) {
-					addGroupMatch(m);
-					break;
-				}
-			}
-		}
-	}
-
-	/**
-	 * Adds the first match group to {@link #extracted}.
-	 *
-	 * @param mat the matcher containing the groups
-	 *
-	 */
-	private void addGroupMatch(final Matcher mat) {
-		int ngroups = mat.groupCount();
-
-		for (int x = 1; x <= ngroups; ++x) {
-			String txt = mat.group(x);
-
-			if (txt != null) {
-				addExtraction(txt);
-				return;
-			}
-		}
-
-		addExtraction(mat.group());
-	}
-
-	/**
-	 * Adds an item to {@link #extracted}, in a thread-safe manner.
-	 * It uses the queue's <i>offer()</i> method so that the queue
-	 * can discard the item if it so chooses, without generating
-	 * an exception.
-	 *
-	 * @param txt
-	 *            text to be added
-	 */
-	private void addExtraction(final String txt) {
-		synchronized (extracted) {
-			extracted.offer(txt);
-		}
-	}
-
-	/**
-	 * Gets the text that has been extracted.
-	 *
-	 * @return a copy of the text that has been extracted
-	 */
-	public List<String> getExtracted() {
-		synchronized (extracted) {
-			return new ArrayList<>(extracted);
-		}
-	}
-
-	/**
-	 * Clears the list of extracted text.
-	 */
-	public void clearExtractions() {
-		synchronized (extracted) {
-			extracted.clear();
-		}
-	}
-
-	/**
-	 * Adds a pattern to be matched by this appender.
-	 *
-	 * @param regex
-	 *            regular expression (i.e., {@link Pattern}) to match
-	 */
-	public void setPattern(final String regex) {
-		synchronized (patterns) {
-			patterns.put(regex, Pattern.compile(regex));
-		}
-	}
+    /**
+     * Extracted text is placed here.
+     */
+    private final Queue<String> extracted;
+
+    /**
+     * Regular expressions/Patterns to be used to extract text. Uses a
+     * LinkedHashMap so that order is preserved.
+     */
+    private final LinkedHashMap<String, Pattern> patterns;
+
+    /**
+     * Records every message that is logged.
+     */
+    public ExtractAppender() {
+        this(new LinkedList<>());
+    }
+
+    /**
+     * Records portions of messages that match one of the regular
+     * expressions.
+     *
+     * @param regex
+     *            regular expression (i.e., {@link Pattern}) to match
+     */
+    public ExtractAppender(final String... regex) {
+        this(new LinkedList<>(), regex);
+    }
+
+    /**
+     * Rather than allocating an internal queue to store matched messages,
+     * messages are recorded in the specified target queue using the
+     * {@link Queue#offer(Object)} method. Note: whenever the queue is used,
+     * it will be synchronized to prevent simultaneous accesses.
+     *
+     * @param target - queue into which the matched text should be placed
+     * @param regex regular expression (i.e., {@link Pattern}) to match
+     */
+    public ExtractAppender(final Queue<String> target,
+                    final String... regex) {
+        extracted = target;
+        patterns = new LinkedHashMap<>(regex.length);
+
+        for (String re : regex) {
+            patterns.put(re, Pattern.compile(re));
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     *
+     * @see ch.qos.logback.core.AppenderBase#append(Object)
+     */
+    @Override
+    protected void append(final ILoggingEvent event) {
+
+        String msg = event.getMessage();
+
+        synchronized (patterns) {
+            if (patterns.isEmpty()) {
+                addExtraction(msg);
+                return;
+            }
+
+            for (Pattern p : patterns.values()) {
+                Matcher matcher = p.matcher(msg);
+
+                if (matcher.find()) {
+                    addGroupMatch(matcher);
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Adds the first match group to {@link #extracted}.
+     *
+     * @param mat the matcher containing the groups
+     *
+     */
+    private void addGroupMatch(final Matcher mat) {
+        int ngroups = mat.groupCount();
+
+        for (int x = 1; x <= ngroups; ++x) {
+            String txt = mat.group(x);
+
+            if (txt != null) {
+                addExtraction(txt);
+                return;
+            }
+        }
+
+        addExtraction(mat.group());
+    }
+
+    /**
+     * Adds an item to {@link #extracted}, in a thread-safe manner.
+     * It uses the queue's <i>offer()</i> method so that the queue
+     * can discard the item if it so chooses, without generating
+     * an exception.
+     *
+     * @param txt
+     *            text to be added
+     */
+    private void addExtraction(final String txt) {
+        synchronized (extracted) {
+            extracted.offer(txt);
+        }
+    }
+
+    /**
+     * Gets the text that has been extracted.
+     *
+     * @return a copy of the text that has been extracted
+     */
+    public List<String> getExtracted() {
+        synchronized (extracted) {
+            return new ArrayList<>(extracted);
+        }
+    }
+
+    /**
+     * Clears the list of extracted text.
+     */
+    public void clearExtractions() {
+        synchronized (extracted) {
+            extracted.clear();
+        }
+    }
+
+    /**
+     * Adds a pattern to be matched by this appender.
+     *
+     * @param regex
+     *            regular expression (i.e., {@link Pattern}) to match
+     */
+    public void setPattern(final String regex) {
+        synchronized (patterns) {
+            patterns.put(regex, Pattern.compile(regex));
+        }
+    }
 
 }
diff --git a/utils-test/src/main/java/org/onap/policy/common/utils/time/TestTime.java b/utils-test/src/main/java/org/onap/policy/common/utils/time/TestTime.java
index 3dfed4bd..414c18bb 100644
--- a/utils-test/src/main/java/org/onap/policy/common/utils/time/TestTime.java
+++ b/utils-test/src/main/java/org/onap/policy/common/utils/time/TestTime.java
@@ -36,7 +36,8 @@ public class TestTime extends CurrentTime {
     private AtomicLong tcur = new AtomicLong(System.currentTimeMillis());
 
     /**
-     * 
+     *  Constructor.
+     *  
      */
     public TestTime() {
         super();
diff --git a/utils-test/src/main/java/org/onap/policy/common/utils/time/TestTimeMulti.java b/utils-test/src/main/java/org/onap/policy/common/utils/time/TestTimeMulti.java
index 7a8277c7..2782eb72 100644
--- a/utils-test/src/main/java/org/onap/policy/common/utils/time/TestTimeMulti.java
+++ b/utils-test/src/main/java/org/onap/policy/common/utils/time/TestTimeMulti.java
@@ -56,6 +56,7 @@ public class TestTimeMulti extends CurrentTime {
     private final Object locker = new Object();
 
     /**
+     * Constructor.
      * 
      * @param nthreads number of threads that will be sleeping simultaneously
      */
@@ -122,7 +123,7 @@ public class TestTimeMulti extends CurrentTime {
      */
     private void wakeThreads() {
         Info info = queue.poll();
-        if(info == null) {
+        if (info == null) {
             return;
         }
 
@@ -157,6 +158,8 @@ public class TestTimeMulti extends CurrentTime {
         private final CountDownLatch latch = new CountDownLatch(1);
 
         /**
+         * Constructor.
+         * 
          * @param awakenAtMs time, in milliseconds, at which the associated thread should
          *        awaken
          */
@@ -179,20 +182,20 @@ public class TestTimeMulti extends CurrentTime {
          * Blocks the current thread until awakened (i.e., until its latch is
          * decremented).
          * 
-         * @throws InterruptedException
+         * @throws InterruptedException can be interrupted
          */
         public void await() throws InterruptedException {
             latch.await();
         }
 
         @Override
-        public int compareTo(Info o) {
-            int diff = Long.compare(awakenAtMs, o.awakenAtMs);
+        public int compareTo(Info object) {
+            int diff = Long.compare(awakenAtMs, object.awakenAtMs);
 
             // this assumes that Object.toString() is unique for each Info object
-            if (diff == 0)
-                diff = this.toString().compareTo(o.toString());
-
+            if (diff == 0) {
+                diff = this.toString().compareTo(object.toString());
+            }
             return diff;
         }