diff --git a/test/dorkbox/util/messagebus/ConcurrentSetTest.java b/test/dorkbox/util/messagebus/ConcurrentSetTest.java index 2af8239..43abdc8 100644 --- a/test/dorkbox/util/messagebus/ConcurrentSetTest.java +++ b/test/dorkbox/util/messagebus/ConcurrentSetTest.java @@ -1,23 +1,13 @@ package dorkbox.util.messagebus; -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedList; -import java.util.List; -import java.util.Random; -import java.util.Set; -import java.util.concurrent.CopyOnWriteArraySet; -import java.util.concurrent.atomic.AtomicInteger; - -import junit.framework.Assert; - -import org.junit.Before; -import org.junit.Test; - import dorkbox.util.messagebus.common.AssertSupport; import dorkbox.util.messagebus.common.ConcurrentExecutor; +import org.junit.Before; +import org.junit.Test; + +import java.util.*; +import java.util.concurrent.CopyOnWriteArraySet; +import java.util.concurrent.atomic.AtomicInteger; /** * This test ensures the correct behaviour of the set implementation that is the building @@ -171,7 +161,7 @@ public abstract class ConcurrentSetTest extends AssertSupport { // ensure that the test set does not contain any of the elements that have been removed from it for (Object tar : testSet) { - Assert.assertTrue(!toRemove.contains(tar)); + assertTrue(!toRemove.contains(tar)); } // ensure that the test set still contains all objects from the source set that have not been marked // for removal @@ -214,7 +204,7 @@ public abstract class ConcurrentSetTest extends AssertSupport { // ensure that the test set does not contain any of the elements that have been removed from it for (Object tar : testSet) { - Assert.assertTrue(!toRemove.contains(tar)); + assertTrue(!toRemove.contains(tar)); } // ensure that the test set still contains all objects from the source set that have not been marked // for removal diff --git a/test/dorkbox/util/messagebus/PerformanceTest.java b/test/dorkbox/util/messagebus/PerformanceTest.java index f55e1a5..4c8b07c 100644 --- a/test/dorkbox/util/messagebus/PerformanceTest.java +++ b/test/dorkbox/util/messagebus/PerformanceTest.java @@ -7,12 +7,14 @@ import dorkbox.util.messagebus.annotations.Handler; import dorkbox.util.messagebus.common.ConcurrentExecutor; import dorkbox.util.messagebus.error.IPublicationErrorHandler; import dorkbox.util.messagebus.error.PublicationError; -import junit.framework.Assert; + +import static org.junit.Assert.*; /** * @author dorkbox, llc Date: 2/2/15 */ -public class PerformanceTest { +public +class PerformanceTest { // 15 == 32 * 1024 public static final int REPETITIONS = Integer.getInteger("reps", 50) * 1000 * 1000; @@ -22,21 +24,29 @@ public class PerformanceTest { protected static final IPublicationErrorHandler TestFailingHandler = new IPublicationErrorHandler() { @Override - public void handleError(PublicationError error) { - error.getCause().printStackTrace(); - Assert.fail(); + public + void handleError(PublicationError error) { + error.getCause() + .printStackTrace(); + fail(); } @Override - public void handleError(final String error, final Class listenerClass) { + public + void handleError(final String error, final Class listenerClass) { // Printout the error itself - System.out.println(new StringBuilder().append(error).append(": ").append(listenerClass.getSimpleName()).toString()); + System.out.println(new StringBuilder().append(error) + .append(": ") + .append(listenerClass.getSimpleName()) + .toString()); } }; - public static void main(String[] args) throws Exception { + public static + void main(String[] args) throws Exception { final MessageBus bus = new MessageBus(CONCURRENCY_LEVEL); - bus.getErrorHandler().addErrorHandler(TestFailingHandler); + bus.getErrorHandler() + .addErrorHandler(TestFailingHandler); Listener listener1 = new Listener(); @@ -45,7 +55,8 @@ public class PerformanceTest { ConcurrentExecutor.runConcurrent(new Runnable() { @Override - public void run() { + public + void run() { Long num = Long.valueOf(7L); while (true) { bus.publish(num); @@ -57,13 +68,16 @@ public class PerformanceTest { bus.shutdown(); } - public PerformanceTest() { + public + PerformanceTest() { } @SuppressWarnings("unused") - public static class Listener { + public static + class Listener { @Handler - public void handleSync(Long o1) { + public + void handleSync(Long o1) { // System.err.println(Long.toString(o1)); } } diff --git a/test/dorkbox/util/messagebus/common/AssertSupport.java b/test/dorkbox/util/messagebus/common/AssertSupport.java index c674d6b..993f119 100644 --- a/test/dorkbox/util/messagebus/common/AssertSupport.java +++ b/test/dorkbox/util/messagebus/common/AssertSupport.java @@ -63,7 +63,8 @@ public class AssertSupport { Assert.fail(message); } - public void fail() { + public static + void fail() { Assert.fail(); } diff --git a/test/dorkbox/util/messagebus/common/ListenerFactory.java b/test/dorkbox/util/messagebus/common/ListenerFactory.java index 2a27dde..ea7c446 100644 --- a/test/dorkbox/util/messagebus/common/ListenerFactory.java +++ b/test/dorkbox/util/messagebus/common/ListenerFactory.java @@ -1,10 +1,10 @@ package dorkbox.util.messagebus.common; -import junit.framework.Assert; - import java.util.*; import java.util.concurrent.atomic.AtomicInteger; +import static org.junit.Assert.fail; + /** * The factory can be used to declaratively specify how many instances of some given classes * should be created. It will create those instances using reflection and provide a list containing those instances. @@ -14,87 +14,103 @@ import java.util.concurrent.atomic.AtomicInteger; * @author bennidi * Date: 11/22/12 */ -public class ListenerFactory { +public +class ListenerFactory { private Map requiredBeans = new HashMap(); private volatile List generatedListeners; private int requiredSize = 0; - public int getNumberOfListeners(Class listener){ + public + int getNumberOfListeners(Class listener) { return requiredBeans.containsKey(listener) ? requiredBeans.get(listener) : 0; } - public ListenerFactory create(int numberOfInstances, Class clazz){ + public + ListenerFactory create(int numberOfInstances, Class clazz) { requiredBeans.put(clazz, numberOfInstances); - requiredSize +=numberOfInstances; + requiredSize += numberOfInstances; return this; } - public ListenerFactory create(int numberOfInstances, Class ...classes){ - for(Class clazz : classes) - create(numberOfInstances,clazz); + public + ListenerFactory create(int numberOfInstances, Class... classes) { + for (Class clazz : classes) { + create(numberOfInstances, clazz); + } return this; } - public ListenerFactory create(int numberOfInstances, Collection classes){ - for(Class clazz : classes) - create(numberOfInstances,clazz); + public + ListenerFactory create(int numberOfInstances, Collection classes) { + for (Class clazz : classes) { + create(numberOfInstances, clazz); + } return this; } - public synchronized List getAll(){ - if(generatedListeners != null) + @SuppressWarnings("unchecked") + public synchronized + List getAll() { + if (generatedListeners != null) { return generatedListeners; + } List listeners = new ArrayList(requiredSize); try { - for(Class clazz : requiredBeans.keySet()){ + for (Class clazz : requiredBeans.keySet()) { int numberOfRequiredBeans = requiredBeans.get(clazz); - for(int i = 0; i < numberOfRequiredBeans; i++){ + for (int i = 0; i < numberOfRequiredBeans; i++) { listeners.add(clazz.newInstance()); } } } catch (Exception e) { // if instantiation fails, counts will be incorrect // -> fail early here - Assert.fail("There was a problem instantiating a listener " + e); + fail("There was a problem instantiating a listener " + e); } Collections.shuffle(listeners); - generatedListeners = Collections.unmodifiableList(listeners); + generatedListeners = Collections.unmodifiableList(listeners); return generatedListeners; } // not thread-safe but not yet used concurrently - public synchronized void clear(){ + public synchronized + void clear() { generatedListeners = null; requiredBeans.clear(); } /** * Create a thread-safe read-only iterator - * + *

* NOTE: Iterator is not perfectly synchronized with mutator methods of the list of generated listeners * In theory, it is possible that the list is changed while iterators are still running which should be avoided. + * * @return */ - public Iterator iterator(){ + public + Iterator iterator() { getAll(); final AtomicInteger current = new AtomicInteger(0); return new Iterator() { @Override - public boolean hasNext() { + public + boolean hasNext() { return current.get() < generatedListeners.size(); } @Override - public Object next() { - int index = current.getAndIncrement(); + public + Object next() { + int index = current.getAndIncrement(); return index < generatedListeners.size() ? generatedListeners.get(index) : null; } @Override - public void remove() { + public + void remove() { throw new UnsupportedOperationException("Iterator is read only"); } }; diff --git a/test/dorkbox/util/messagebus/common/MessageBusTest.java b/test/dorkbox/util/messagebus/common/MessageBusTest.java index a2a9477..9a01b6b 100644 --- a/test/dorkbox/util/messagebus/common/MessageBusTest.java +++ b/test/dorkbox/util/messagebus/common/MessageBusTest.java @@ -4,7 +4,6 @@ import dorkbox.util.messagebus.MessageBus; import dorkbox.util.messagebus.error.IPublicationErrorHandler; import dorkbox.util.messagebus.error.PublicationError; import dorkbox.util.messagebus.messages.MessageTypes; -import junit.framework.Assert; import org.junit.Before; /** @@ -14,7 +13,8 @@ import org.junit.Before; * @author bennidi * Date: 3/2/13 */ -public abstract class MessageBusTest extends AssertSupport { +public abstract +class MessageBusTest extends AssertSupport { // this value probably needs to be adjusted depending on the performance of the underlying plattform // otherwise the tests will fail since asynchronous processing might not have finished when @@ -25,35 +25,43 @@ public abstract class MessageBusTest extends AssertSupport { protected static final IPublicationErrorHandler TestFailingHandler = new IPublicationErrorHandler() { @Override - public void handleError(PublicationError error) { - error.getCause().printStackTrace(); - Assert.fail(); + public + void handleError(PublicationError error) { + error.getCause() + .printStackTrace(); + fail(); } @Override - public void handleError(final String error, final Class listenerClass) { + public + void handleError(final String error, final Class listenerClass) { System.err.println(error + " " + listenerClass); } }; @Before - public void setUp() { + public + void setUp() { for (MessageTypes mes : MessageTypes.values()) { mes.reset(); } } - public MessageBus createBus() { + public + MessageBus createBus() { MessageBus bus = new MessageBus(); - bus.getErrorHandler().addErrorHandler(TestFailingHandler); + bus.getErrorHandler() + .addErrorHandler(TestFailingHandler); bus.start(); return bus; } - public MessageBus createBus(ListenerFactory listeners) { + public + MessageBus createBus(ListenerFactory listeners) { MessageBus bus = new MessageBus(); - bus.getErrorHandler().addErrorHandler(TestFailingHandler); + bus.getErrorHandler() + .addErrorHandler(TestFailingHandler); ConcurrentExecutor.runConcurrent(TestUtil.subscriber(bus, listeners), ConcurrentUnits); bus.start(); return bus; diff --git a/test/dorkbox/util/messagebus/queuePerf/PerfTest_LinkedBlockingQueue_Block.java b/test/dorkbox/util/messagebus/queuePerf/PerfTest_LinkedBlockingQueue_Block.java index 7946384..45a4f2d 100644 --- a/test/dorkbox/util/messagebus/queuePerf/PerfTest_LinkedBlockingQueue_Block.java +++ b/test/dorkbox/util/messagebus/queuePerf/PerfTest_LinkedBlockingQueue_Block.java @@ -2,13 +2,15 @@ package dorkbox.util.messagebus.queuePerf; import java.util.concurrent.LinkedBlockingQueue; -public class PerfTest_LinkedBlockingQueue_Block { +public +class PerfTest_LinkedBlockingQueue_Block { public static final int REPETITIONS = 50 * 1000 * 100; public static final Integer TEST_VALUE = Integer.valueOf(777); private static final int concurrency = 4; - public static void main(final String[] args) throws Exception { + public static + void main(final String[] args) throws Exception { System.out.println("reps:" + REPETITIONS + " Concurrency " + concurrency); final int warmupRuns = 4; @@ -17,10 +19,15 @@ public class PerfTest_LinkedBlockingQueue_Block { final LinkedBlockingQueue queue = new LinkedBlockingQueue(concurrency); long average = averageRun(warmupRuns, runs, queue, true, concurrency, REPETITIONS); - System.out.format("summary,QueuePerfTest,%s %,d\n", queue.getClass().getSimpleName(), average); + System.out.format("summary,QueuePerfTest,%s %,d\n", + queue.getClass() + .getSimpleName(), + average); } - public static long averageRun(int warmUpRuns, int sumCount, LinkedBlockingQueue queue, boolean showStats, int concurrency, int repetitions) throws Exception { + public static + long averageRun(int warmUpRuns, int sumCount, LinkedBlockingQueue queue, boolean showStats, int concurrency, int repetitions) + throws Exception { int runs = warmUpRuns + sumCount; final long[] results = new long[runs]; for (int i = 0; i < runs; i++) { @@ -33,39 +40,41 @@ public class PerfTest_LinkedBlockingQueue_Block { sum += results[i]; } - return sum/sumCount; + return sum / sumCount; } - private static long performanceRun(int runNumber, LinkedBlockingQueue queue, boolean showStats, int concurrency, int repetitions) throws Exception { + private static + long performanceRun(int runNumber, LinkedBlockingQueue queue, boolean showStats, int concurrency, int repetitions) + throws Exception { Producer[] producers = new Producer[concurrency]; Consumer[] consumers = new Consumer[concurrency]; - Thread[] threads = new Thread[concurrency*2]; + Thread[] threads = new Thread[concurrency * 2]; - for (int i=0;i queue; volatile long start; private int repetitions; - public Producer(LinkedBlockingQueue queue, int repetitions) { + public + Producer(LinkedBlockingQueue queue, int repetitions) { this.queue = queue; this.repetitions = repetitions; } @Override - public void run() { - LinkedBlockingQueue producer = this.queue; + public + void run() { + LinkedBlockingQueue producer = this.queue; int i = this.repetitions; this.start = System.nanoTime(); @@ -112,20 +125,24 @@ public class PerfTest_LinkedBlockingQueue_Block { } } - public static class Consumer implements Runnable { - private final LinkedBlockingQueue queue; + + public static + class Consumer implements Runnable { + private final LinkedBlockingQueue queue; Object result; volatile long end; private int repetitions; - public Consumer(LinkedBlockingQueue queue, int repetitions) { + public + Consumer(LinkedBlockingQueue queue, int repetitions) { this.queue = queue; this.repetitions = repetitions; } @Override - public void run() { - LinkedBlockingQueue consumer = this.queue; + public + void run() { + LinkedBlockingQueue consumer = this.queue; Object result = null; int i = this.repetitions; diff --git a/test/dorkbox/util/messagebus/queuePerf/PerfTest_LinkedBlockingQueue_NonBlock.java b/test/dorkbox/util/messagebus/queuePerf/PerfTest_LinkedBlockingQueue_NonBlock.java index 9729b10..3c66094 100644 --- a/test/dorkbox/util/messagebus/queuePerf/PerfTest_LinkedBlockingQueue_NonBlock.java +++ b/test/dorkbox/util/messagebus/queuePerf/PerfTest_LinkedBlockingQueue_NonBlock.java @@ -18,13 +18,13 @@ public class PerfTest_LinkedBlockingQueue_NonBlock { long average = 0; - final LinkedBlockingQueue queue = new LinkedBlockingQueue(Integer.MAX_VALUE); + final LinkedBlockingQueue queue = new LinkedBlockingQueue(Integer.MAX_VALUE); average = averageRun(warmupRuns, runs, queue, true, concurrency, REPETITIONS); System.out.format("summary,QueuePerfTest,%s %,d\n", queue.getClass().getSimpleName(), average); } - public static long averageRun(int warmUpRuns, int sumCount, LinkedBlockingQueue queue, boolean showStats, int concurrency, int repetitions) throws Exception { + public static long averageRun(int warmUpRuns, int sumCount, LinkedBlockingQueue queue, boolean showStats, int concurrency, int repetitions) throws Exception { int runs = warmUpRuns + sumCount; final long[] results = new long[runs]; for (int i = 0; i < runs; i++) { @@ -40,7 +40,7 @@ public class PerfTest_LinkedBlockingQueue_NonBlock { return sum/sumCount; } - private static long performanceRun(int runNumber, LinkedBlockingQueue queue, boolean showStats, int concurrency, int repetitions) throws Exception { + private static long performanceRun(int runNumber, LinkedBlockingQueue queue, boolean showStats, int concurrency, int repetitions) throws Exception { Producer[] producers = new Producer[concurrency]; Consumer[] consumers = new Consumer[concurrency]; @@ -91,18 +91,18 @@ public class PerfTest_LinkedBlockingQueue_NonBlock { } public static class Producer implements Runnable { - private final LinkedBlockingQueue queue; + private final LinkedBlockingQueue queue; volatile long start; private int repetitions; - public Producer(LinkedBlockingQueue queue, int repetitions) { + public Producer(LinkedBlockingQueue queue, int repetitions) { this.queue = queue; this.repetitions = repetitions; } @Override public void run() { - LinkedBlockingQueue producer = this.queue; + LinkedBlockingQueue producer = this.queue; int i = this.repetitions; this.start = System.nanoTime(); @@ -115,19 +115,19 @@ public class PerfTest_LinkedBlockingQueue_NonBlock { } public static class Consumer implements Runnable { - private final LinkedBlockingQueue queue; + private final LinkedBlockingQueue queue; Object result; volatile long end; private int repetitions; - public Consumer(LinkedBlockingQueue queue, int repetitions) { + public Consumer(LinkedBlockingQueue queue, int repetitions) { this.queue = queue; this.repetitions = repetitions; } @Override public void run() { - LinkedBlockingQueue consumer = this.queue; + LinkedBlockingQueue consumer = this.queue; Object result = null; int i = this.repetitions;