From 82bc8f543e578f32201d07a23b42d8539b89a4f1 Mon Sep 17 00:00:00 2001 From: Jim Hahn Date: Mon, 5 Feb 2018 12:05:26 -0500 Subject: Add utils-test project Added utils-test project to policy/common. Modified integrity-audit and integrity-monitor to use the new utils-test project to test the Exception subclasses. Change-Id: If4a27cdb2351b7c49b084dbf287950172fa059cf Issue-ID: POLICY-582 Signed-off-by: Jim Hahn --- .../policy/common/utils/test/ExceptionsTester.java | 588 +++++++++++++++++++++ 1 file changed, 588 insertions(+) create mode 100644 utils-test/src/main/java/org/onap/policy/common/utils/test/ExceptionsTester.java (limited to 'utils-test/src/main') 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 new file mode 100644 index 00000000..8705c48c --- /dev/null +++ b/utils-test/src/main/java/org/onap/policy/common/utils/test/ExceptionsTester.java @@ -0,0 +1,588 @@ +/* + * ============LICENSE_START======================================================= + * Integrity Monitor + * ================================================================================ + * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.common.utils.test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +import java.lang.reflect.Constructor; + +/** + * Used to test various Exception subclasses. Uses reflection to identify the + * constructors that the subclass supports. + */ +public class ExceptionsTester { + + /** + * 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 + * @return the number of constructors that the test found/tested + * @throws Exception + * if the Exception cannot be constructed + */ + public int test(Class claz) throws Exception { + int ncons = 0; + + ncons += testDefault(claz); + ncons += testString(claz); + ncons += testThrowable(claz); + ncons += testException(claz); + ncons += testStringThrowable(claz); + ncons += testStringException(claz); + ncons += testStringThrowableBooleanBoolean(claz); + ncons += testStringExceptionBooleanBoolean(claz); + + assertTrue(ncons > 0); + + return ncons; + } + + /** + * Tests exceptions created via the default constructor. Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns null
    • + *
  • getCause() returns null
    • + *
+ * + * If the Exception subclass does not support this type of constructor, then + * this method simply returns. + * + * @param claz + * subclass to be tested + * @return {@code 1}, if the subclass supports this type of constructor, + * {@code 0} otherwise + * @throws Exception + * if the Exception cannot be constructed + */ + public int testDefault(Class claz) throws Exception { + Constructor cons; + + try { + cons = claz.getConstructor(); + + } catch (NoSuchMethodException | SecurityException e) { + // this constructor is not defined so nothing to test + return 0; + } + + T ex = cons.newInstance(); + + assertNotNull(ex.toString()); + assertNull(ex.getMessage()); + assertNull(ex.getCause()); + + return 1; + } + + /** + * Tests exceptions created via the constructor that takes just a String. + * Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the original message passed to the + * constructor
    • + *
  • getCause() returns null
    • + *
+ * + * If the Exception subclass does not support this type of constructor, then + * this method simply returns. + * + * @param claz + * subclass to be tested + * @return {@code 1}, if the subclass supports this type of constructor, + * {@code 0} otherwise + * @throws Exception + * if the Exception cannot be constructed + */ + public int testString(Class claz) throws Exception { + Constructor cons; + + try { + cons = claz.getConstructor(String.class); + + } catch (NoSuchMethodException | SecurityException e) { + // this constructor is not defined so nothing to test + return 0; + } + + T ex = cons.newInstance("hello"); + + assertNotNull(ex.toString()); + assertEquals("hello", ex.getMessage()); + assertNull(ex.getCause()); + + return 1; + } + + /** + * Tests exceptions created via the constructor that takes just a Throwable. + * Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the cause's message
    • + *
  • getCause() returns the original cause passed to the + * constructor
    • + *
+ * + * If the Exception subclass does not support this type of constructor, then + * this method simply returns. + * + * @param claz + * subclass to be tested + * @return {@code 1}, if the subclass supports this type of constructor, + * {@code 0} otherwise + * @throws Exception + * if the Exception cannot be constructed + */ + public int testThrowable(Class claz) throws Exception { + Constructor cons; + + try { + cons = claz.getConstructor(Throwable.class); + + } catch (NoSuchMethodException | SecurityException e) { + // this constructor is not defined so nothing to test + return 0; + } + + Throwable cause = new Throwable("expected exception"); + T ex = cons.newInstance(cause); + + assertEquals(ex.getMessage(), ex.getMessage()); + assertNotNull(ex.toString()); + assertEquals(cause, ex.getCause()); + + return 1; + } + + /** + * Tests exceptions created via the constructor that takes just an + * Exception. Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the cause's message
    • + *
  • getCause() returns the original cause passed to the + * constructor
    • + *
+ * + * If the Exception subclass does not support this type of constructor, then + * this method simply returns. + * + * @param claz + * subclass to be tested + * @return {@code 1}, if the subclass supports this type of constructor, + * {@code 0} otherwise + * @throws Exception + * if the Exception cannot be constructed + */ + public int testException(Class claz) throws Exception { + Constructor cons; + + try { + cons = claz.getConstructor(Exception.class); + + } catch (NoSuchMethodException | SecurityException e) { + // this constructor is not defined so nothing to test + return 0; + } + + Exception cause = new Exception("expected exception"); + T ex = cons.newInstance(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 a + * Throwable. Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the original message passed to the + * constructor
    • + *
  • getCause() returns the original cause passed to the + * constructor
    • + *
+ * + * If the Exception subclass does not support this type of constructor, then + * this method simply returns. + * + * @param claz + * subclass to be tested + * @return {@code 1}, if the subclass supports this type of constructor, + * {@code 0} otherwise + * @throws Exception + * if the Exception cannot be constructed + */ + public int testStringThrowable(Class claz) throws Exception { + Constructor cons; + + try { + cons = claz.getConstructor(String.class, Throwable.class); + + } catch (NoSuchMethodException | SecurityException e) { + // this constructor is not defined so nothing to test + return 0; + } + + Throwable cause = new Throwable("expected exception"); + T ex = cons.newInstance("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 and an + * Exception. Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the original message passed to the + * constructor
    • + *
  • getCause() returns the original cause passed to the + * constructor
    • + *
+ * + * If the Exception subclass does not support this type of constructor, then + * this method simply returns. + * + * @param claz + * subclass to be tested + * @return {@code 1}, if the subclass supports this type of constructor, + * {@code 0} otherwise + * @throws Exception + * if the Exception cannot be constructed + */ + public int testStringException(Class claz) throws Exception { + Constructor cons; + + try { + cons = claz.getConstructor(String.class, Exception.class); + + } catch (NoSuchMethodException | SecurityException e) { + // this constructor is not defined so nothing to test + return 0; + } + + Exception cause = new Exception("expected exception"); + T ex = cons.newInstance("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, a + * Throwable, and two booleans. Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the original message passed to the + * constructor
    • + *
  • getCause() returns the original cause passed to the + * constructor
    • + *
  • suppressed exceptions can be added, if enabled
    • + *
  • the stack trace can be added, if enabled
    • + *
+ * + * If the Exception subclass does not support this type of constructor, then + * this method simply returns. + * + * @param claz + * subclass to be tested + * @return {@code 1}, if the subclass supports this type of constructor, + * {@code 0} otherwise + * @throws Exception + * if the Exception cannot be constructed + */ + public int testStringThrowableBooleanBoolean(Class claz) throws Exception { + Constructor cons; + + try { + cons = claz.getConstructor(String.class, Throwable.class, Boolean.TYPE, Boolean.TYPE); + + } catch (NoSuchMethodException | SecurityException e) { + // this constructor is not defined so nothing to test + 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 exceptions created via the constructor that takes a String, an + * Exception, and two booleans. Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the original message passed to the + * constructor
    • + *
  • getCause() returns the original cause passed to the + * constructor
    • + *
  • suppressed exceptions can be added, if enabled
    • + *
  • the stack trace can be added, if enabled
    • + *
+ * + * If the Exception subclass does not support this type of constructor, then + * this method simply returns. + * + * @param claz + * subclass to be tested + * @return {@code 1}, if the subclass supports this type of constructor, + * {@code 0} otherwise + * @throws Exception + * if the Exception cannot be constructed + */ + public int testStringExceptionBooleanBoolean(Class claz) throws Exception { + Constructor cons; + + try { + cons = claz.getConstructor(String.class, Exception.class, Boolean.TYPE, Boolean.TYPE); + + } catch (NoSuchMethodException | SecurityException e) { + // this constructor is not defined so nothing to test + return 0; + } + + // test each combination of "message" and "cause" + testMessageCauseCombos(cons); + + // test each combination of the boolean flags + testFlagCombos(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 by toString()/i>, + * getMessage(), and getCause(). + * + * + * @param cons + * constructor to be invoked + * @throws Exception + * if the Exception cannot be constructed + */ + private void testMessageCauseCombos(Constructor cons) throws Exception { + T ex; + Exception cause = new Exception("expected throwable"); + + ex = cons.newInstance(null, null, true, true); + assertNotNull(ex.toString()); + assertNull(ex.getMessage()); + assertNull(ex.getCause()); + + ex = cons.newInstance("abc", null, true, true); + assertNotNull(ex.toString()); + assertEquals("abc", ex.getMessage()); + assertNull(ex.getCause()); + + ex = cons.newInstance(null, cause, true, true); + assertNotNull(ex.toString()); + assertNull(ex.getMessage()); + assertEquals(cause, ex.getCause()); + + ex = cons.newInstance("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 toString()/i>, + * getMessage(), and getCause(). + * + * + * @param cons + * constructor to be invoked + * @throws Exception + * if the Exception cannot be constructed + */ + public void testFlagCombos(Constructor cons) throws Exception { + testSuppressStack(cons); + testSuppressNoStack(cons); + testNoSuppressStack(cons); + testNoSuppressNoStack(cons); + } + + /** + * Tests exceptions constructed with {@code enableSuppression=true} and + * {@code writableStackTrace=true}. Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the original message passed to the + * constructor
    • + *
  • getCause() returns the original cause passed to the + * constructor
    • + *
  • suppressed exceptions are added
    • + *
  • the stack trace is added
    • + *
+ * + * @param cons + * the exception's class constructor + * @throws Exception + * if the Exception cannot be constructed + */ + public void testSuppressStack(Constructor cons) throws Exception { + Exception cause = new Exception("expected exception"); + Throwable supr = new Throwable("expected suppressed exception"); + T ex = cons.newInstance("yes,yes", cause, true, true); + + ex.addSuppressed(supr); + + assertNotNull(ex.toString()); + assertEquals("yes,yes", ex.getMessage()); + assertEquals(cause, ex.getCause()); + + assertEquals(1, ex.getSuppressed().length); + assertEquals(supr, ex.getSuppressed()[0]); + + assertTrue(ex.getStackTrace().length > 0); + } + + /** + * Tests exceptions constructed with {@code enableSuppression=true} and + * {@code writableStackTrace=false}. Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the original message passed to the + * constructor
    • + *
  • getCause() returns the original cause passed to the + * constructor
    • + *
  • suppressed exceptions are added
    • + *
  • the stack trace is not added
    • + *
+ * + * @param cons + * the exception's class constructor + * @throws Exception + * if the Exception cannot be constructed + */ + public void testSuppressNoStack(Constructor cons) throws Exception { + Exception cause = new Exception("expected exception"); + Throwable supr = new Throwable("expected suppressed exception"); + T ex = cons.newInstance("yes,no", cause, true, false); + + ex.addSuppressed(supr); + + assertNotNull(ex.toString()); + assertEquals("yes,no", ex.getMessage()); + assertEquals(cause, ex.getCause()); + + assertEquals(1, ex.getSuppressed().length); + assertEquals(supr, ex.getSuppressed()[0]); + + assertEquals(0, ex.getStackTrace().length); + } + + /** + * Tests exceptions constructed with {@code enableSuppression=false} and + * {@code writableStackTrace=true}. Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the original message passed to the + * constructor
    • + *
  • getCause() returns the original cause passed to the + * constructor
    • + *
  • suppressed exceptions are not added
    • + *
  • the stack trace is added
    • + *
+ * + * @param cons + * the exception's class constructor + * @throws Exception + * if the Exception cannot be constructed + */ + public void testNoSuppressStack(Constructor cons) throws Exception { + Exception cause = new Exception("expected exception"); + Throwable supr = new Throwable("expected suppressed exception"); + T ex = cons.newInstance("no,yes", cause, false, true); + + ex.addSuppressed(supr); + + assertNotNull(ex.toString()); + assertEquals("no,yes", ex.getMessage()); + assertEquals(cause, ex.getCause()); + + assertEquals(0, ex.getSuppressed().length); + + assertTrue(ex.getStackTrace().length > 0); + } + + /** + * Tests exceptions constructed with {@code enableSuppression=false} and + * {@code writableStackTrace=false}. Verifies that: + *
    + *
  • toString() returns a non-null value
    • + *
  • getMessage() returns the original message passed to the + * constructor
    • + *
  • getCause() returns the original cause passed to the + * constructor
    • + *
  • suppressed exceptions are not added
    • + *
  • the stack trace is not added
    • + * + * @param cons + * the exception's class constructor + * @throws Exception + * if the Exception cannot be constructed + */ + public void testNoSuppressNoStack(Constructor cons) throws Exception { + Exception cause = new Exception("expected exception"); + Throwable supr = new Throwable("expected suppressed exception"); + T ex = cons.newInstance("no,no", cause, false, false); + + ex.addSuppressed(supr); + + assertNotNull(ex.toString()); + assertEquals("no,no", ex.getMessage()); + assertEquals(cause, ex.getCause()); + + assertEquals(0, ex.getSuppressed().length); + assertEquals(0, ex.getStackTrace().length); + } +} -- cgit 1.2.3-korg