aboutsummaryrefslogtreecommitdiffstats
path: root/utils-test
diff options
context:
space:
mode:
Diffstat (limited to 'utils-test')
-rw-r--r--utils-test/src/main/java/org/onap/policy/common/utils/test/ConstructionError.java58
-rw-r--r--utils-test/src/main/java/org/onap/policy/common/utils/test/ErrorsTester.java38
-rw-r--r--utils-test/src/main/java/org/onap/policy/common/utils/test/ExceptionsTester.java344
-rw-r--r--utils-test/src/main/java/org/onap/policy/common/utils/test/ThrowablesTester.java1050
-rw-r--r--utils-test/src/main/java/org/onap/policy/common/utils/test/log/logback/ExtractAppender.java289
-rw-r--r--utils-test/src/main/java/org/onap/policy/common/utils/time/TestTime.java3
-rw-r--r--utils-test/src/main/java/org/onap/policy/common/utils/time/TestTimeMulti.java17
-rw-r--r--utils-test/src/test/java/org/onap/policy/common/utils/time/TestTimeMultiTest.java5
-rw-r--r--utils-test/src/test/java/org/onap/policy/common/utils/time/TestTimeTest.java3
-rw-r--r--utils-test/src/test/resources/logback-test.xml22
10 files changed, 920 insertions, 909 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;
}
diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/time/TestTimeMultiTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/time/TestTimeMultiTest.java
index 206ab5f1..311e276d 100644
--- a/utils-test/src/test/java/org/onap/policy/common/utils/time/TestTimeMultiTest.java
+++ b/utils-test/src/test/java/org/onap/policy/common/utils/time/TestTimeMultiTest.java
@@ -22,6 +22,7 @@ package org.onap.policy.common.utils.time;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;
@@ -29,7 +30,7 @@ import java.util.concurrent.TimeUnit;
import org.junit.Test;
/**
- *
+ * Class to test TestTimeMulti.
*/
public class TestTimeMultiTest {
@@ -46,7 +47,7 @@ public class TestTimeMultiTest {
ttm = new TestTimeMulti(NTHREADS);
done = new Semaphore(0);
- long tbeg = ttm.getMillis();
+ final long tbeg = ttm.getMillis();
// create threads
List<MyThread> threads = new ArrayList<>(NTHREADS);
diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/time/TestTimeTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/time/TestTimeTest.java
index 12086657..3e7897e9 100644
--- a/utils-test/src/test/java/org/onap/policy/common/utils/time/TestTimeTest.java
+++ b/utils-test/src/test/java/org/onap/policy/common/utils/time/TestTimeTest.java
@@ -22,6 +22,7 @@ package org.onap.policy.common.utils.time;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+
import org.junit.Test;
public class TestTimeTest {
@@ -31,7 +32,7 @@ public class TestTimeTest {
TestTime tm = new TestTime();
TestTime tm2 = new TestTime();
- long treal = System.currentTimeMillis();
+ final long treal = System.currentTimeMillis();
long tcur = tm.getMillis();
assertEquals(tcur, tm.getDate().getTime());
diff --git a/utils-test/src/test/resources/logback-test.xml b/utils-test/src/test/resources/logback-test.xml
index c99cd4a6..a5d46f8a 100644
--- a/utils-test/src/test/resources/logback-test.xml
+++ b/utils-test/src/test/resources/logback-test.xml
@@ -22,16 +22,16 @@
<configuration>
- <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
- <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
- <Pattern>
- %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M\(%line\) - %msg%n
- </Pattern>
- </encoder>
- </appender>
-
- <root level="debug">
- <appender-ref ref="STDOUT" />
- </root>
+ <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+ <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
+ <Pattern>
+ %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36}.%M\(%line\) - %msg%n
+ </Pattern>
+ </encoder>
+ </appender>
+
+ <root level="debug">
+ <appender-ref ref="STDOUT" />
+ </root>
</configuration>