Removed checkstyle warnings

Removed checkstyle warnings in policy/common/utils-test

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

5 files changed, 742 insertions, 754 deletions

diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/test/ConstructionErrorTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/test/ConstructionErrorTest.java
index 27387bfd..710926d3 100644
--- a/utils-test/src/test/java/org/onap/policy/common/utils/test/ConstructionErrorTest.java
+++ b/utils-test/src/test/java/org/onap/policy/common/utils/test/ConstructionErrorTest.java
@@ -20,18 +20,15 @@
 
 package org.onap.policy.common.utils.test;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
 
-/**
- * 
- */
 public class ConstructionErrorTest extends ErrorsTester {
 
-	@Test
-	public void test() throws Exception {
-		assertEquals(4, testAllError(ConstructionError.class));
-	}
+    @Test
+    public void test() throws Exception {
+        assertEquals(4, testAllError(ConstructionError.class));
+    }
 
 }
diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/test/ErrorsTesterTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/test/ErrorsTesterTest.java
index 60aed22d..2009e297 100644
--- a/utils-test/src/test/java/org/onap/policy/common/utils/test/ErrorsTesterTest.java
+++ b/utils-test/src/test/java/org/onap/policy/common/utils/test/ErrorsTesterTest.java
@@ -26,52 +26,52 @@ import org.junit.Test;
 
 public class ErrorsTesterTest {
 
-	@Test
-	public void test() {
-		assertEquals(2, new ErrorsTester().testAllError(SimpleError.class));
-		assertEquals(5, new ErrorsTester().testAllError(StaticError.class));
-	}
+    @Test
+    public void test() {
+        assertEquals(2, new ErrorsTester().testAllError(SimpleError.class));
+        assertEquals(5, new ErrorsTester().testAllError(StaticError.class));
+    }
 
-	/**
-	 * Used to test a simple success case.
-	 */
-	public static class SimpleError extends Error {
-		private static final long serialVersionUID = 1L;
+    /**
+     * Used to test a simple success case.
+     */
+    public static class SimpleError extends Error {
+        private static final long serialVersionUID = 1L;
 
-		public SimpleError() {
-			super();
-		}
+        public SimpleError() {
+            super();
+        }
 
-		public SimpleError(String message) {
-			super(message);
-		}
-	}
+        public SimpleError(String message) {
+            super(message);
+        }
+    }
 
-	/**
-	 * Used to test the exhaustive success case.
-	 */
-	public static class StaticError extends Error {
-		private static final long serialVersionUID = 1L;
+    /**
+     * Used to test the exhaustive success case.
+     */
+    public static class StaticError extends Error {
+        private static final long serialVersionUID = 1L;
 
-		public StaticError() {
-			super();
-		}
+        public StaticError() {
+            super();
+        }
 
-		public StaticError(String message) {
-			super(message);
-		}
+        public StaticError(String message) {
+            super(message);
+        }
 
-		public StaticError(Throwable cause) {
-			super(cause);
-		}
+        public StaticError(Throwable cause) {
+            super(cause);
+        }
 
-		public StaticError(String message, Throwable cause) {
-			super(message, cause);
-		}
+        public StaticError(String message, Throwable cause) {
+            super(message, cause);
+        }
 
-		public StaticError(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
-			super(message, cause, enableSuppression, writableStackTrace);
-		}
-	}
+        public StaticError(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+            super(message, cause, enableSuppression, writableStackTrace);
+        }
+    }
 
 }
diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/test/ExceptionsTesterTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/test/ExceptionsTesterTest.java
index b9975227..89ff3ba1 100644
--- a/utils-test/src/test/java/org/onap/policy/common/utils/test/ExceptionsTesterTest.java
+++ b/utils-test/src/test/java/org/onap/policy/common/utils/test/ExceptionsTesterTest.java
@@ -26,84 +26,83 @@ import org.junit.Test;
 
 public class ExceptionsTesterTest {
 
-	@Test
-	public void test() {
-		assertEquals(2, new ExceptionsTester().test(SimpleException.class));
-		assertEquals(8, new ExceptionsTester().test(StaticException.class));
-	}
-
-	@Test(expected = AssertionError.class)
-	public void testNoConstructorsException() {
-		new ExceptionsTester().test(NoConstructorsException.class);
-	}
-
-	/**
-	 * Used to test a failure case - this has no standard constructors. The only
-	 * constructor it has takes an "int", thus it is not one of the standard
-	 * constructors.
-	 */
-	public static class NoConstructorsException extends Exception {
-		private static final long serialVersionUID = 1L;
-
-		public NoConstructorsException(int value) {
-			super();
-		}
-	}
-
-	/**
-	 * Used to test a simple success case.
-	 */
-	public static class SimpleException extends Exception {
-		private static final long serialVersionUID = 1L;
-
-		public SimpleException() {
-			super();
-		}
-
-		public SimpleException(String message) {
-			super(message);
-		}
-	}
-
-	/**
-	 * Used to test the exhaustive success case.
-	 */
-	public static class StaticException extends Exception {
-		private static final long serialVersionUID = 1L;
-
-		public StaticException() {
-			super();
-		}
-
-		public StaticException(String message) {
-			super(message);
-		}
-
-		public StaticException(Throwable cause) {
-			super(cause);
-		}
-
-		public StaticException(String message, Throwable cause) {
-			super(message, cause);
-		}
-
-		public StaticException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
-			super(message, cause, enableSuppression, writableStackTrace);
-		}
-
-		// same as above, but with Exceptions substituted for Throwables
-
-		public StaticException(Exception cause) {
-			super(cause);
-		}
-
-		public StaticException(String message, Exception cause) {
-			super(message, cause);
-		}
-
-		public StaticException(String message, Exception cause, boolean enableSuppression, boolean writableStackTrace) {
-			super(message, cause, enableSuppression, writableStackTrace);
-		}
-	}
+    @Test
+    public void test() {
+        assertEquals(2, new ExceptionsTester().test(SimpleException.class));
+        assertEquals(8, new ExceptionsTester().test(StaticException.class));
+    }
+
+    @Test(expected = AssertionError.class)
+    public void testNoConstructorsException() {
+        new ExceptionsTester().test(NoConstructorsException.class);
+    }
+
+    /**
+     * Used to test a failure case - this has no standard constructors. The only constructor it has
+     * takes an "int", thus it is not one of the standard constructors.
+     */
+    public static class NoConstructorsException extends Exception {
+        private static final long serialVersionUID = 1L;
+
+        public NoConstructorsException(int value) {
+            super();
+        }
+    }
+
+    /**
+     * Used to test a simple success case.
+     */
+    public static class SimpleException extends Exception {
+        private static final long serialVersionUID = 1L;
+
+        public SimpleException() {
+            super();
+        }
+
+        public SimpleException(String message) {
+            super(message);
+        }
+    }
+
+    /**
+     * Used to test the exhaustive success case.
+     */
+    public static class StaticException extends Exception {
+        private static final long serialVersionUID = 1L;
+
+        public StaticException() {
+            super();
+        }
+
+        public StaticException(String message) {
+            super(message);
+        }
+
+        public StaticException(Throwable cause) {
+            super(cause);
+        }
+
+        public StaticException(String message, Throwable cause) {
+            super(message, cause);
+        }
+
+        public StaticException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+            super(message, cause, enableSuppression, writableStackTrace);
+        }
+
+        // same as above, but with Exceptions substituted for Throwables
+
+        public StaticException(Exception cause) {
+            super(cause);
+        }
+
+        public StaticException(String message, Exception cause) {
+            super(message, cause);
+        }
+
+        public StaticException(String message, Exception cause, boolean enableSuppression, boolean writableStackTrace) {
+            super(message, cause, enableSuppression, writableStackTrace);
+        }
+    }
 
 }
diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/test/ThrowablesTesterTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/test/ThrowablesTesterTest.java
index cb8c0ef6..4d289c6a 100644
--- a/utils-test/src/test/java/org/onap/policy/common/utils/test/ThrowablesTesterTest.java
+++ b/utils-test/src/test/java/org/onap/policy/common/utils/test/ThrowablesTesterTest.java
@@ -26,191 +26,189 @@ import org.junit.Test;
 
 public class ThrowablesTesterTest {
 
-	@Test
-	public void test() {
-		assertEquals(2, new ThrowablesTester().testAllThrowable(SimpleThrowable.class));
-		assertEquals(5, new ThrowablesTester().testAllThrowable(StaticThrowable.class));
-	}
-
-	@Test
-	public void testNoConstructorsThrowable() {
-		// this will not throw an error, but it should return 0, as there are
-		// no matching constructors
-		assertEquals(0, new ThrowablesTester().testAllThrowable(NoConstructorsThrowable.class));
-	}
-
-	@Test(expected = AssertionError.class)
-	public void testIgnoreMessageThrowable() {
-		new ThrowablesTester().testAllThrowable(IgnoreMessageThrowable.class);
-	}
-
-	@Test(expected = AssertionError.class)
-	public void testIgnoreCauseThrowable() {
-		new ThrowablesTester().testAllThrowable(IgnoreCauseThrowable.class);
-	}
-
-	@Test(expected = AssertionError.class)
-	public void testAlwaysSuppressThrowable() {
-		new ThrowablesTester().testAllThrowable(AlwaysSuppressThrowable.class);
-	}
-
-	@Test(expected = AssertionError.class)
-	public void testNeverSuppressThrowable() {
-		new ThrowablesTester().testAllThrowable(NeverSuppressThrowable.class);
-	}
-
-	@Test(expected = AssertionError.class)
-	public void testAlwaysWritableThrowable() {
-		new ThrowablesTester().testAllThrowable(AlwaysWritableThrowable.class);
-	}
-
-	@Test(expected = AssertionError.class)
-	public void testNeverWritableThrowable() {
-		new ThrowablesTester().testAllThrowable(NeverWritableThrowable.class);
-	}
-
-	@Test(expected = ConstructionError.class)
-	public void testThrowInstantiationException() {
-		new ThrowablesTester().testAllThrowable(ThrowInstantiationException.class);
-	}
-
-	/**
-	 * Used to test a failure case - message text is ignored.
-	 */
-	public static class IgnoreMessageThrowable extends Throwable {
-		private static final long serialVersionUID = 1L;
-
-		public IgnoreMessageThrowable(String message) {
-			super("bogus");
-		}
-	}
-
-	/**
-	 * Used to test a failure case - cause is ignored.
-	 */
-	public static class IgnoreCauseThrowable extends Throwable {
-		private static final long serialVersionUID = 1L;
-
-		public IgnoreCauseThrowable(Throwable cause) {
-			super(new Throwable("another cause"));
-		}
-	}
-
-	/**
-	 * Used to test a failure case - this has no standard constructors. The only
-	 * constructor it has takes an "int", thus it is not one of the standard
-	 * constructors.
-	 */
-	public static class NoConstructorsThrowable extends Throwable {
-		private static final long serialVersionUID = 1L;
-
-		public NoConstructorsThrowable(int value) {
-			super();
-		}
-	}
-
-	/**
-	 * Used to test a failure case - always suppresses.
-	 */
-	public static class AlwaysSuppressThrowable extends Throwable {
-		private static final long serialVersionUID = 1L;
-
-		public AlwaysSuppressThrowable(String message, Throwable cause, boolean enableSuppression,
-				boolean writableStackTrace) {
-			super(message, cause, true, writableStackTrace);
-		}
-	}
-
-	/**
-	 * Used to test a failure case - never suppresses.
-	 */
-	public static class NeverSuppressThrowable extends Throwable {
-		private static final long serialVersionUID = 1L;
-
-		public NeverSuppressThrowable(String message, Throwable cause, boolean enableSuppression,
-				boolean writableStackTrace) {
-			super(message, cause, false, writableStackTrace);
-		}
-	}
-
-	/**
-	 * Used to test a failure case - always allows stack writes.
-	 */
-	public static class AlwaysWritableThrowable extends Throwable {
-		private static final long serialVersionUID = 1L;
-
-		public AlwaysWritableThrowable(String message, Throwable cause, boolean enableSuppression,
-				boolean writableStackTrace) {
-			super(message, cause, enableSuppression, true);
-		}
-	}
-
-	/**
-	 * Used to test a failure case - never allows stack writes.
-	 */
-	public static class NeverWritableThrowable extends Throwable {
-		private static final long serialVersionUID = 1L;
-
-		public NeverWritableThrowable(String message, Throwable cause, boolean enableSuppression,
-				boolean writableStackTrace) {
-			super(message, cause, enableSuppression, false);
-		}
-	}
-
-	/**
-	 * Used to test a failure case - throws InstantiationException when
-	 * constructed.
-	 */
-	public static class ThrowInstantiationException extends Throwable {
-		private static final long serialVersionUID = 1L;
-
-		public ThrowInstantiationException(String message, Throwable cause, boolean enableSuppression,
-				boolean writableStackTrace) throws InstantiationException {
-
-			throw new InstantiationException(ThrowablesTester.EXPECTED_EXCEPTION_MSG);
-		}
-	}
-
-	/**
-	 * Used to test a simple success case.
-	 */
-	public static class SimpleThrowable extends Throwable {
-		private static final long serialVersionUID = 1L;
-
-		public SimpleThrowable() {
-			super();
-		}
-
-		public SimpleThrowable(String message) {
-			super(message);
-		}
-	}
-
-	/**
-	 * Used to test the exhaustive success case.
-	 */
-	public static class StaticThrowable extends Throwable {
-		private static final long serialVersionUID = 1L;
-
-		public StaticThrowable() {
-			super();
-		}
-
-		public StaticThrowable(String message) {
-			super(message);
-		}
-
-		public StaticThrowable(Throwable cause) {
-			super(cause);
-		}
-
-		public StaticThrowable(String message, Throwable cause) {
-			super(message, cause);
-		}
-
-		public StaticThrowable(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
-			super(message, cause, enableSuppression, writableStackTrace);
-		}
-	}
+    @Test
+    public void test() {
+        assertEquals(2, new ThrowablesTester().testAllThrowable(SimpleThrowable.class));
+        assertEquals(5, new ThrowablesTester().testAllThrowable(StaticThrowable.class));
+    }
+
+    @Test
+    public void testNoConstructorsThrowable() {
+        // this will not throw an error, but it should return 0, as there are
+        // no matching constructors
+        assertEquals(0, new ThrowablesTester().testAllThrowable(NoConstructorsThrowable.class));
+    }
+
+    @Test(expected = AssertionError.class)
+    public void testIgnoreMessageThrowable() {
+        new ThrowablesTester().testAllThrowable(IgnoreMessageThrowable.class);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void testIgnoreCauseThrowable() {
+        new ThrowablesTester().testAllThrowable(IgnoreCauseThrowable.class);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void testAlwaysSuppressThrowable() {
+        new ThrowablesTester().testAllThrowable(AlwaysSuppressThrowable.class);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void testNeverSuppressThrowable() {
+        new ThrowablesTester().testAllThrowable(NeverSuppressThrowable.class);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void testAlwaysWritableThrowable() {
+        new ThrowablesTester().testAllThrowable(AlwaysWritableThrowable.class);
+    }
+
+    @Test(expected = AssertionError.class)
+    public void testNeverWritableThrowable() {
+        new ThrowablesTester().testAllThrowable(NeverWritableThrowable.class);
+    }
+
+    @Test(expected = ConstructionError.class)
+    public void testThrowInstantiationException() {
+        new ThrowablesTester().testAllThrowable(ThrowInstantiationException.class);
+    }
+
+    /**
+     * Used to test a failure case - message text is ignored.
+     */
+    public static class IgnoreMessageThrowable extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        public IgnoreMessageThrowable(String message) {
+            super("bogus");
+        }
+    }
+
+    /**
+     * Used to test a failure case - cause is ignored.
+     */
+    public static class IgnoreCauseThrowable extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        public IgnoreCauseThrowable(Throwable cause) {
+            super(new Throwable("another cause"));
+        }
+    }
+
+    /**
+     * Used to test a failure case - this has no standard constructors. The only constructor it has
+     * takes an "int", thus it is not one of the standard constructors.
+     */
+    public static class NoConstructorsThrowable extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        public NoConstructorsThrowable(int value) {
+            super();
+        }
+    }
+
+    /**
+     * Used to test a failure case - always suppresses.
+     */
+    public static class AlwaysSuppressThrowable extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        public AlwaysSuppressThrowable(String message, Throwable cause, boolean enableSuppression,
+                boolean writableStackTrace) {
+            super(message, cause, true, writableStackTrace);
+        }
+    }
+
+    /**
+     * Used to test a failure case - never suppresses.
+     */
+    public static class NeverSuppressThrowable extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        public NeverSuppressThrowable(String message, Throwable cause, boolean enableSuppression,
+                boolean writableStackTrace) {
+            super(message, cause, false, writableStackTrace);
+        }
+    }
+
+    /**
+     * Used to test a failure case - always allows stack writes.
+     */
+    public static class AlwaysWritableThrowable extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        public AlwaysWritableThrowable(String message, Throwable cause, boolean enableSuppression,
+                boolean writableStackTrace) {
+            super(message, cause, enableSuppression, true);
+        }
+    }
+
+    /**
+     * Used to test a failure case - never allows stack writes.
+     */
+    public static class NeverWritableThrowable extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        public NeverWritableThrowable(String message, Throwable cause, boolean enableSuppression,
+                boolean writableStackTrace) {
+            super(message, cause, enableSuppression, false);
+        }
+    }
+
+    /**
+     * Used to test a failure case - throws InstantiationException when constructed.
+     */
+    public static class ThrowInstantiationException extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        public ThrowInstantiationException(String message, Throwable cause, boolean enableSuppression,
+                boolean writableStackTrace) throws InstantiationException {
+
+            throw new InstantiationException(ThrowablesTester.EXPECTED_EXCEPTION_MSG);
+        }
+    }
+
+    /**
+     * Used to test a simple success case.
+     */
+    public static class SimpleThrowable extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        public SimpleThrowable() {
+            super();
+        }
+
+        public SimpleThrowable(String message) {
+            super(message);
+        }
+    }
+
+    /**
+     * Used to test the exhaustive success case.
+     */
+    public static class StaticThrowable extends Throwable {
+        private static final long serialVersionUID = 1L;
+
+        public StaticThrowable() {
+            super();
+        }
+
+        public StaticThrowable(String message) {
+            super(message);
+        }
+
+        public StaticThrowable(Throwable cause) {
+            super(cause);
+        }
+
+        public StaticThrowable(String message, Throwable cause) {
+            super(message, cause);
+        }
+
+        public StaticThrowable(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+            super(message, cause, enableSuppression, writableStackTrace);
+        }
+    }
 
 }
diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/test/log/logback/ExtractAppenderTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/test/log/logback/ExtractAppenderTest.java
index 6ef36822..eee60c38 100644
--- a/utils-test/src/test/java/org/onap/policy/common/utils/test/log/logback/ExtractAppenderTest.java
+++ b/utils-test/src/test/java/org/onap/policy/common/utils/test/log/logback/ExtractAppenderTest.java
@@ -23,6 +23,10 @@ package org.onap.policy.common.utils.test.log.logback;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
@@ -35,450 +39,440 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 import org.slf4j.LoggerFactory;
 
-import ch.qos.logback.classic.Level;
-import ch.qos.logback.classic.Logger;
-import ch.qos.logback.classic.spi.ILoggingEvent;
-
 public class ExtractAppenderTest {
 
-	/**
-	 * Milliseconds to wait for a thread to terminate.
-	 */
-	private static final long THREAD_WAIT_MS = 5000l;
+    /**
+     * Milliseconds to wait for a thread to terminate.
+     */
+    private static final long THREAD_WAIT_MS = 5000L;
+
+    private static Logger logger;
+
+    private List<Thread> threads;
+
+    @BeforeClass
+    public static void setUpBeforeClass() throws Exception {
+        logger = (Logger) LoggerFactory.getLogger(ExtractAppenderTest.class);
+        logger.setLevel(Level.INFO);
+    }
+
+    @Before
+    public void setUp() throws Exception {
+        threads = new LinkedList<>();
+    }
+
+    /**
+     * Tear down all appenders and threads.
+     */
+    @After
+    public void tearDown() throws Exception {
+        logger.detachAndStopAllAppenders();
+
+        for (Thread p : threads) {
+            p.interrupt();
+            p.join(THREAD_WAIT_MS);
+        }
+    }
+
+    @Test
+    public void testExtractAppender() {
+        AtomicInteger count = new AtomicInteger(0);
+
+        ExtractAppender appender = new ExtractAppender() {
+            @Override
+            protected void append(ILoggingEvent event) {
+                count.incrementAndGet();
+                super.append(event);
+            }
+        };
+
+        addAppender(appender);
+
+        logger.info("hello");
+        logger.info("world");
+
+        // "append" should always be called
+        assertEquals(2, count.get());
+
+        // appender with no patterns - everything should match
+        assertEquals(strList("hello", "world"), appender.getExtracted());
+
+        // add a pattern and verify match
+        appender.setPattern("abc[0-9]");
+        logger.info("hello abc1");
+
+        // this should not match
+        logger.info("hello def2");
+
+        assertEquals(4, count.get());
+        assertEquals(strList("hello", "world", "abc1"), appender.getExtracted());
+    }
+
+    @Test
+    public void testExtractAppenderStringArray() {
+        AtomicInteger count = new AtomicInteger(0);
+
+        ExtractAppender appender = new ExtractAppender("abc[0-9]", "def[0-9]") {
+            @Override
+            protected void append(ILoggingEvent event) {
+                count.incrementAndGet();
+                super.append(event);
+            }
+        };
+
+        addAppender(appender);
+
+        logger.info("hello abc1 world");
+        logger.info("world ghi2 world"); // no match
+        logger.info("world def3 world");
+        logger.info("hello abc4");
+        logger.info("abc5 world");
+        logger.info("hello def6");
+        logger.info("ghi7 world"); // no match
+        logger.info("def8 world");
+
+        // "append" should always be called
+        assertEquals(8, count.get());
+
+        assertEquals(strList("abc1", "def3", "abc4", "abc5", "def6", "def8"), appender.getExtracted());
+
+        appender.setPattern("ghi[0-9]");
+        logger.info("hello abc9");
+        logger.info("hello ghi9");
+
+        // this should not match
+        logger.info("hello xyz");
+
+        assertEquals(11, count.get());
+        assertEquals(strList("abc1", "def3", "abc4", "abc5", "def6", "def8", "abc9", "ghi9"), appender.getExtracted());
+    }
+
+    @Test
+    public void testExtractAppenderQueueStringArray() {
+        // no. of matches allowed in the list
+        int nallowed = 3;
+
+        AtomicInteger count = new AtomicInteger(0);
+
+        LinkedList<String> queue = new LinkedList<String>() {
+            private static final long serialVersionUID = 1L;
+
+            @Override
+            public boolean offer(String element) {
+                if (count.incrementAndGet() <= nallowed) {
+                    return super.offer(element);
+
+                } else {
+                    return false;
+                }
+            }
+        };
+
+        ExtractAppender appender = new ExtractAppender(queue, "abc[0-9]");
+        addAppender(appender);
+
+        // these shouldn't match
+        for (int x = 0; x < 10; ++x) {
+            logger.info("xyz");
+        }
+
+        int nmatches = 10;
+
+        LinkedList<String> expected = new LinkedList<>();
+
+        for (int x = 0; x < nmatches; ++x) {
+            String msg = "abc" + x;
+            logger.info(msg + " world");
+
+            if (x < nallowed) {
+                expected.add(msg);
+            }
+        }
+
+        // "offer" should always be called for a match
+        assertEquals(nmatches, count.get());
+
+        assertEquals(expected, appender.getExtracted());
+    }
+
+    @Test
+    public void testAppendILoggingEvent_NoPatterns() {
+        ExtractAppender appender = makeAppender();
+
+        logger.info("hello");
+        logger.info("world");
+
+        assertEquals(strList("hello", "world"), appender.getExtracted());
+    }
+
+    @Test
+    public void testAppendILoggingEvent_MatchFirstPattern() {
+        ExtractAppender appender = makeAppender("abc[0-9]", "def[0-9]");
+
+        logger.info("hello abc1");
+        logger.info("world xyz2");
+
+        assertEquals(strList("abc1"), appender.getExtracted());
+    }
+
+    @Test
+    public void testAppendILoggingEvent_MatchLastPattern() {
+        ExtractAppender appender = makeAppender("abc[0-9]", "def[0-9]");
+
+        logger.info("hello def1");
+        logger.info("world xyz2");
+
+        assertEquals(strList("def1"), appender.getExtracted());
+    }
+
+    @Test
+    public void testAppendILoggingEvent_Group1() {
+        ExtractAppender appender = makeAppender("hello (abc)|(xyz)", "def[0-9]");
+
+        logger.info("hello abc, world!");
+        logger.info("world abc");
+
+        assertEquals(strList("abc"), appender.getExtracted());
+    }
+
+    @Test
+    public void testAppendILoggingEvent_Group3() {
+        ExtractAppender appender = makeAppender("hello (abc)|(pdq)|(xyz)", "def[0-9]");
+
+        logger.info("say hello xyz, world!");
+        logger.info("world abc");
+
+        assertEquals(strList("xyz"), appender.getExtracted());
+    }
+
+    @Test
+    public void testAppendILoggingEvent_NoGroup() {
+        ExtractAppender appender = makeAppender("hello abc");
+
+        logger.info("say hello abc, world!");
+        logger.info("world abc");
+
+        assertEquals(strList("hello abc"), appender.getExtracted());
+    }
+
+    @Test
+    public void testGetExtracted() {
+        ExtractAppender appender = makeAppender("abc[1-9]");
+
+        logger.info("hello abc1 world");
+        logger.info("world ghi2 world"); // no match
+        logger.info("hello abc3");
+
+        List<String> oldlst = appender.getExtracted();
+        assertEquals(strList("abc1", "abc3"), oldlst);
+        assertEquals(oldlst, appender.getExtracted());
+
+        logger.info("abc9");
+        assertEquals(strList("abc1", "abc3", "abc9"), appender.getExtracted());
+    }
+
+    @Test
+    public void testClearExtractions() {
+        final ExtractAppender appender = makeAppender("abc[1-9]");
+
+        logger.info("hello abc1 world");
+        logger.info("world ghi2 world");
+        logger.info("hello abc3");
+
+        assertEquals(strList("abc1", "abc3"), appender.getExtracted());
+
+        appender.clearExtractions();
+
+        // list should be empty now
+        assertEquals(strList(), appender.getExtracted());
+
+        logger.info("hello abc4 world");
+        logger.info("world ghi5 world");
+        logger.info("hello abc6");
+
+        // list should only contain the new items
+        assertEquals(strList("abc4", "abc6"), appender.getExtracted());
+    }
+
+    @Test
+    public void testSetPattern() {
+        final ExtractAppender appender = makeAppender("abc[1-9]");
+
+        logger.info("hello abc1 world");
+        logger.info("world ghi2 world"); // no match
+        logger.info("hello abc3");
+
+        assertEquals(strList("abc1", "abc3"), appender.getExtracted());
 
-	private static Logger logger;
-
-	private List<Thread> threads;
-
-	@BeforeClass
-	public static void setUpBeforeClass() throws Exception {
-		logger = (Logger) LoggerFactory.getLogger(ExtractAppenderTest.class);
-		logger.setLevel(Level.INFO);
-	}
-
-	@Before
-	public void setUp() throws Exception {
-		threads = new LinkedList<>();
-	}
-
-	@After
-	public void tearDown() throws Exception {
-		logger.detachAndStopAllAppenders();
-
-		for (Thread p : threads) {
-			p.interrupt();
-			p.join(THREAD_WAIT_MS);
-		}
-	}
-
-	@Test
-	public void testExtractAppender() {
-		AtomicInteger count = new AtomicInteger(0);
-
-		ExtractAppender p = new ExtractAppender() {
-			@Override
-			protected void append(ILoggingEvent event) {
-				count.incrementAndGet();
-				super.append(event);
-			}
-		};
-
-		addAppender(p);
-
-		logger.info("hello");
-		logger.info("world");
-
-		// "append" should always be called
-		assertEquals(2, count.get());
-
-		// appender with no patterns - everything should match
-		assertEquals(strList("hello", "world"), p.getExtracted());
-
-		// add a pattern and verify match
-		p.setPattern("abc[0-9]");
-		logger.info("hello abc1");
-
-		// this should not match
-		logger.info("hello def2");
-
-		assertEquals(4, count.get());
-		assertEquals(strList("hello", "world", "abc1"), p.getExtracted());
-	}
-
-	@Test
-	public void testExtractAppenderStringArray() {
-		AtomicInteger count = new AtomicInteger(0);
-
-		ExtractAppender p = new ExtractAppender("abc[0-9]", "def[0-9]") {
-			@Override
-			protected void append(ILoggingEvent event) {
-				count.incrementAndGet();
-				super.append(event);
-			}
-		};
-
-		addAppender(p);
-
-		logger.info("hello abc1 world");
-		logger.info("world ghi2 world"); // no match
-		logger.info("world def3 world");
-		logger.info("hello abc4");
-		logger.info("abc5 world");
-		logger.info("hello def6");
-		logger.info("ghi7 world"); // no match
-		logger.info("def8 world");
-
-		// "append" should always be called
-		assertEquals(8, count.get());
-
-		assertEquals(strList("abc1", "def3", "abc4", "abc5", "def6", "def8"), p.getExtracted());
-
-		p.setPattern("ghi[0-9]");
-		logger.info("hello abc9");
-		logger.info("hello ghi9");
-
-		// this should not match
-		logger.info("hello xyz");
-
-		assertEquals(11, count.get());
-		assertEquals(strList("abc1", "def3", "abc4", "abc5", "def6", "def8", "abc9", "ghi9"), p.getExtracted());
-	}
-
-	@Test
-	public void testExtractAppenderQueueStringArray() {
-		// no. of matches allowed in the list
-		int nallowed = 3;
-		
-		AtomicInteger count = new AtomicInteger(0);
-		
-		LinkedList<String> queue = new LinkedList<String>() {
-			private static final long serialVersionUID = 1L;
-
-			@Override
-			public boolean offer(String e) {
-				if(count.incrementAndGet() <= nallowed) {
-					return super.offer(e);
-					
-				} else {
-					return false;
-				}
-			}
-		};
-
-		ExtractAppender p = new ExtractAppender(queue, "abc[0-9]");
-		addAppender(p);
-
-		// these shouldn't match
-		for(int x = 0;  x < 10;  ++x) {
-			logger.info("xyz");
-		}
-		
-		int nmatches = 10;
-
-		LinkedList<String> expected = new LinkedList<>();
-		
-		for(int x = 0;  x < nmatches;  ++x) {
-			String msg = "abc" + x;
-			logger.info(msg + " world");
-			
-			if(x < nallowed) {
-				expected.add(msg);
-			}
-		}
-
-		// "offer" should always be called for a match
-		assertEquals(nmatches, count.get());
-		
-		assertEquals(expected, p.getExtracted());
-	}
-
-	@Test
-	public void testAppendILoggingEvent_NoPatterns() {
-		ExtractAppender p = makeAppender();
-		
-		logger.info("hello");
-		logger.info("world");
-		
-		assertEquals(strList("hello", "world"), p.getExtracted());
-	}
-
-	@Test
-	public void testAppendILoggingEvent_MatchFirstPattern() {
-		ExtractAppender p = makeAppender("abc[0-9]", "def[0-9]");
-		
-		logger.info("hello abc1");
-		logger.info("world xyz2");
-		
-		assertEquals(strList("abc1"), p.getExtracted());
-	}
-
-	@Test
-	public void testAppendILoggingEvent_MatchLastPattern() {
-		ExtractAppender p = makeAppender("abc[0-9]", "def[0-9]");
-		
-		logger.info("hello def1");
-		logger.info("world xyz2");
-		
-		assertEquals(strList("def1"), p.getExtracted());
-	}
-
-	@Test
-	public void testAppendILoggingEvent_Group1() {
-		ExtractAppender p = makeAppender("hello (abc)|(xyz)", "def[0-9]");
-		
-		logger.info("hello abc, world!");
-		logger.info("world abc");
-		
-		assertEquals(strList("abc"), p.getExtracted());
-	}
-
-	@Test
-	public void testAppendILoggingEvent_Group3() {
-		ExtractAppender p = makeAppender("hello (abc)|(pdq)|(xyz)", "def[0-9]");
-		
-		logger.info("say hello xyz, world!");
-		logger.info("world abc");
-		
-		assertEquals(strList("xyz"), p.getExtracted());
-	}
-
-	@Test
-	public void testAppendILoggingEvent_NoGroup() {
-		ExtractAppender p = makeAppender("hello abc");
-		
-		logger.info("say hello abc, world!");
-		logger.info("world abc");
-		
-		assertEquals(strList("hello abc"), p.getExtracted());
-	}
-
-	@Test
-	public void testGetExtracted() {
-		ExtractAppender p = makeAppender("abc[1-9]");
-
-		logger.info("hello abc1 world");
-		logger.info("world ghi2 world"); // no match
-		logger.info("hello abc3");
-
-		List<String> oldlst = p.getExtracted();
-		assertEquals(strList("abc1", "abc3"), oldlst);
-		assertEquals(oldlst, p.getExtracted());
-
-		logger.info("abc9");
-		assertEquals(strList("abc1", "abc3", "abc9"), p.getExtracted());
-	}
-
-	@Test
-	public void testClearExtractions() {
-		ExtractAppender p = makeAppender("abc[1-9]");
-
-		logger.info("hello abc1 world");
-		logger.info("world ghi2 world");
-		logger.info("hello abc3");
-
-		assertEquals(strList("abc1", "abc3"), p.getExtracted());
-
-		p.clearExtractions();
-
-		// list should be empty now
-		assertEquals(strList(), p.getExtracted());
-
-		logger.info("hello abc4 world");
-		logger.info("world ghi5 world");
-		logger.info("hello abc6");
-
-		// list should only contain the new items
-		assertEquals(strList("abc4", "abc6"), p.getExtracted());
-	}
-
-	@Test
-	public void testSetPattern() {
-		ExtractAppender p = makeAppender("abc[1-9]");
-
-		logger.info("hello abc1 world");
-		logger.info("world ghi2 world"); // no match
-		logger.info("hello abc3");
-
-		assertEquals(strList("abc1", "abc3"), p.getExtracted());
-
-		p.setPattern("ghi[0-9]");
-
-		logger.info("world ghi4 world"); // this should match now
-		logger.info("hello abc5"); // this should still match
-		logger.info("hello xyz5"); // no match
-
-		assertEquals(strList("abc1", "abc3", "ghi4", "abc5"), p.getExtracted());
-	}
-
-	/**
-	 * Launches threads doing everything in parallel to ensure nothing crashes.
-	 * 
-	 * @throws Exception
-	 */
-	@Test
-	public void test_MultiThreaded() throws Exception {
-		// when to stop
-		long tend = System.currentTimeMillis() + 250;
-
-		// maximum number of items allowed in the extraction list
-		int maxItems = 10;
-
-		// this will be set if one of the threads generates an error
-		AtomicBoolean err = new AtomicBoolean(false);
-
-		// extracted messages go here - this is a finite-length queue since
-		// we don't know how many messages may actually be logged
-		LinkedList<String> queue = new LinkedList<String>() {
-			private static final long serialVersionUID = 1L;
-
-			@Override
-			public boolean offer(String e) {
-				if (size() < maxItems) {
-					return super.offer(e);
-				} else {
-					return false;
-				}
-			}
-		};
-
-		ExtractAppender app = new ExtractAppender(queue, "abc[1-9]");
-		addAppender(app);
-
-		// create some threads to add another pattern
-		addThread(tend, err, xtxt -> {
-			app.setPattern("def[0-9]");
-		});
-
-		// create some threads to log "abc" messages
-		addThread(tend, err, xtxt -> {
-			logger.info("hello abc" + xtxt + "world!");
-		});
-
-		// create some threads to log "def" messages
-		addThread(tend, err, xtxt -> {
-			logger.info("hello def" + xtxt + "world!");
-		});
-
-		// create some threads to get extractions
-		addThread(tend, err, xtxt -> {
-			app.getExtracted();
-		});
-
-		// create some threads to clear extractions
-		addThread(tend, err, xtxt -> {
-			app.clearExtractions();
-
-			// don't want to clear the list too frequently
-			// so sleep a bit in between
-			try {
-				Thread.sleep(10 + Integer.valueOf(xtxt));
-
-			} catch (InterruptedException e) {
-				Thread.currentThread().interrupt();
-				throw e;
-			}
-		});
-
-		/*
-		 * Finally ready to start.
-		 */
-
-		// start all of the threads
-		for (Thread t : threads) {
-			t.setDaemon(true);
-			t.start();
-		}
-
-		// wait for each thread to stop
-		for (Thread t : threads) {
-			t.join(THREAD_WAIT_MS);
-			assertFalse(t.isAlive());
-		}
-		
-		// ensure none of the threads threw an exception
-		assertFalse(err.get());
-	}
-
-	/**
-	 * Adds multiple threads to perform some function repeatedly until the given
-	 * time is reached.
-	 * 
-	 * @param tend
-	 *            time, in milliseconds, when the test should terminate
-	 * @param haderr
-	 *            this will be set to {@code true} if the function throws an
-	 *            exception other than an InterruptedException
-	 * @param func
-	 *            function to be repeatedly invoked
-	 */
-	private void addThread(long tend, AtomicBoolean haderr, VoidFunction func) {
-		// number of threads of each type to create
-		int neach = 3;
-
-		for (int x = 0; x < neach; ++x) {
-			String xtxt = String.valueOf(x);
-
-			threads.add(new Thread() {
-				@Override
-				public void run() {
-					try {
-						while (System.currentTimeMillis() < tend) {
-							func.apply(xtxt);
-						}
-
-					} catch (InterruptedException ex) {
-						Thread.currentThread().interrupt();
-
-					} catch (Exception ex) {
-						haderr.set(true);
-					}
-				}
-			});
-
-		}
-	}
-
-	/**
-	 * Makes an appender that recognizes the given set of strings.
-	 * 
-	 * @param strings
-	 *            regular expressions to be matched
-	 * @return a new appender
-	 */
-	private ExtractAppender makeAppender(String... strings) {
-		ExtractAppender p = new ExtractAppender(strings);
-
-		addAppender(p);
-
-		return p;
-	}
-
-	/**
-	 * Adds an appender to the logger.
-	 * 
-	 * @param app
-	 *            appender to be added
-	 */
-	private void addAppender(ExtractAppender app) {
-		app.setContext(logger.getLoggerContext());
-		app.start();
-
-		logger.addAppender(app);
-	}
-
-	/**
-	 * Converts an array of strings into a list of strings.
-	 * 
-	 * @param strings
-	 *            array of strings
-	 * @return a list of the strings
-	 */
-	private List<String> strList(String... strings) {
-		return Arrays.asList(strings);
-	}
-
-	@FunctionalInterface
-	public interface VoidFunction {
-		public void apply(String text) throws InterruptedException;
-	}
+        appender.setPattern("ghi[0-9]");
+
+        logger.info("world ghi4 world"); // this should match now
+        logger.info("hello abc5"); // this should still match
+        logger.info("hello xyz5"); // no match
+
+        assertEquals(strList("abc1", "abc3", "ghi4", "abc5"), appender.getExtracted());
+    }
+
+    /**
+     * Launches threads doing everything in parallel to ensure nothing crashes.
+     */
+    @Test
+    public void test_MultiThreaded() throws Exception {
+        // when to stop
+        long tend = System.currentTimeMillis() + 250;
+
+        // maximum number of items allowed in the extraction list
+        int maxItems = 10;
+
+        // this will be set if one of the threads generates an error
+        AtomicBoolean err = new AtomicBoolean(false);
+
+        // extracted messages go here - this is a finite-length queue since
+        // we don't know how many messages may actually be logged
+        LinkedList<String> queue = new LinkedList<String>() {
+            private static final long serialVersionUID = 1L;
+
+            @Override
+            public boolean offer(String element) {
+                if (size() < maxItems) {
+                    return super.offer(element);
+                } else {
+                    return false;
+                }
+            }
+        };
+
+        ExtractAppender app = new ExtractAppender(queue, "abc[1-9]");
+        addAppender(app);
+
+        // create some threads to add another pattern
+        addThread(tend, err, xtxt -> {
+            app.setPattern("def[0-9]");
+        });
+
+        // create some threads to log "abc" messages
+        addThread(tend, err, xtxt -> {
+            logger.info("hello abc" + xtxt + "world!");
+        });
+
+        // create some threads to log "def" messages
+        addThread(tend, err, xtxt -> {
+            logger.info("hello def" + xtxt + "world!");
+        });
+
+        // create some threads to get extractions
+        addThread(tend, err, xtxt -> {
+            app.getExtracted();
+        });
+
+        // create some threads to clear extractions
+        addThread(tend, err, xtxt -> {
+            app.clearExtractions();
+
+            // don't want to clear the list too frequently
+            // so sleep a bit in between
+            try {
+                Thread.sleep(10 + Integer.valueOf(xtxt));
+
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw e;
+            }
+        });
+
+        /*
+         * Finally ready to start.
+         */
+
+        // start all of the threads
+        for (Thread t : threads) {
+            t.setDaemon(true);
+            t.start();
+        }
+
+        // wait for each thread to stop
+        for (Thread t : threads) {
+            t.join(THREAD_WAIT_MS);
+            assertFalse(t.isAlive());
+        }
+
+        // ensure none of the threads threw an exception
+        assertFalse(err.get());
+    }
+
+    /**
+     * Adds multiple threads to perform some function repeatedly until the given time is reached.
+     * 
+     * @param tend time, in milliseconds, when the test should terminate
+     * @param haderr this will be set to {@code true} if the function throws an exception other than
+     *        an InterruptedException
+     * @param func function to be repeatedly invoked
+     */
+    private void addThread(long tend, AtomicBoolean haderr, VoidFunction func) {
+        // number of threads of each type to create
+        int neach = 3;
+
+        for (int x = 0; x < neach; ++x) {
+            String xtxt = String.valueOf(x);
+
+            threads.add(new Thread() {
+                @Override
+                public void run() {
+                    try {
+                        while (System.currentTimeMillis() < tend) {
+                            func.apply(xtxt);
+                        }
+
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+
+                    } catch (Exception ex) {
+                        haderr.set(true);
+                    }
+                }
+            });
+
+        }
+    }
+
+    /**
+     * Makes an appender that recognizes the given set of strings.
+     * 
+     * @param strings regular expressions to be matched
+     * @return a new appender
+     */
+    private ExtractAppender makeAppender(String... strings) {
+        ExtractAppender appender = new ExtractAppender(strings);
+
+        addAppender(appender);
+
+        return appender;
+    }
+
+    /**
+     * Adds an appender to the logger.
+     * 
+     * @param app appender to be added
+     */
+    private void addAppender(ExtractAppender app) {
+        app.setContext(logger.getLoggerContext());
+        app.start();
+
+        logger.addAppender(app);
+    }
+
+    /**
+     * Converts an array of strings into a list of strings.
+     * 
+     * @param strings array of strings
+     * @return a list of the strings
+     */
+    private List<String> strList(String... strings) {
+        return Arrays.asList(strings);
+    }
+
+    @FunctionalInterface
+    public interface VoidFunction {
+        public void apply(String text) throws InterruptedException;
+    }
 }