diff options
Diffstat (limited to 'utils-test')
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> |