{@link ITrace2D} the chart.
* * * @author Achim Westermann * */ public class TestMultithreading extends TestCase { /** * Thread that invokes paint operations with a mock graphics context (thus * consumes pending unscaled points) interrupted by a sleep between 0 and a * configurable amount of milliseconds. *
*
* @author Achim Westermann
*
*/
class Consumer extends Thread {
/** The maximum sleep time between two paint operations. */
private long m_sleepRange;
/** Flag to allow termination from outside. */
private boolean m_stop = false;
/**
* Creates an instance that mock-paints the chart every
* 0 .. sleeprange ms.
*
* * @param sleepRange * the maximum sleep range between two rendering operations. */ Consumer(final long sleepRange) { this.m_sleepRange = sleepRange; } /** * Do the job. *
*/ @Override public void run() { MockGraphics2D mockGraphics = new MockGraphics2D(); while (!(this.m_stop || TestMultithreading.this.isAllProducersFinished())) { try { Thread.sleep((long) (Math.random() * this.m_sleepRange)); } catch (InterruptedException e) { e.printStackTrace(); this.m_stop = true; } System.out.println('[' + this.getClass().getName() + "] painting..."); TestMultithreading.this.m_chart.paint(mockGraphics); } } } /** * Thread implementation that adds random points to the trace of the outer * classes's chart and takes a random sleep time between 0 and a constructor * given value between two add operations. *
* * @author Achim Westermann * */ class Producer extends Thread { /** The amount of points to add before termination. */ private long m_toAdd; /** The maximum sleep time between two add operations. */ private long m_sleepRange; /** Flag to allow stopping this Thread from outside. */ private boolean m_stop = false; /** *
* Constructs a producer that will add toAdd points with random
* breaks of milliseconds between maxSleep and zero.
*
*/ @Override public void run() { ITracePoint2D point; while (this.m_toAdd > 0 && !this.m_stop) { try { Thread.sleep((long) (Math.random() * this.m_sleepRange)); } catch (InterruptedException e) { e.printStackTrace(); this.m_stop = true; } if (this.m_toAdd % 10 == 0) { System.out.println('[' + this.getName() + "] adding point... " + this.m_toAdd + " to go..."); } point = new TracePoint2D(this.m_toAdd, this.m_toAdd); TestMultithreading.this.m_weakMap.put(point, point.toString()); TestMultithreading.this.m_trace.addPoint(point); this.m_toAdd--; } } } /** * Test suite for this test class. *
*
* @return the test suite
*/
public static Test suite() {
TestSuite suite = new TestSuite();
suite.setName(TestMultithreading.class.getName());
suite.addTest(new TestMultithreading("testTrace2DLtd"));
return suite;
}
/** The chart used for testing. */
protected Chart2D m_chart;
/** The trace used for testing. */
protected ITrace2D m_trace;
/** Weak storage of points to render. */
protected WeakHashMap
*/
public TestMultithreading() {
super();
}
/**
* Constructor with test name.
*
*
* @param testName
*/
public TestMultithreading(final String testName) {
super(testName);
}
// ////////////////////////////
// Test methods
// ////////////////////////////
// ////////////////////////////
// Helper methods
// ////////////////////////////
/**
* Returns true if all producer threads have finished their work.
*
*
* @return true if all producer threads have finished their work.
*/
protected boolean isAllProducersFinished() {
boolean ret = true;
Iterator
*/
void report() {
long keys = this.m_weakMap.size();
System.out.println("Points remaining in the weakMap: " + keys);
System.out.println("System.runFinalization()... ");
System.runFinalization();
System.out.println("System.gc()... ");
System.gc();
System.out.println("Points remaining in the weakMap: " + keys);
keys = 0;
for (ITracePoint2D point : this.m_weakMap.keySet()) {
keys++;
System.out.println("Point " + point.toString() + " was not dropped.");
}
System.out.println("Points remaining in the weakMap: " + keys);
Assert.assertFalse("There are " + keys
+ " TracePoint2D instances not deleted from the WeakHashMap.", keys > this.m_trace
.getMaxSize());
}
/**
* Creates producers, consumers and initializes further members.
*
*
* @see junit.framework.TestCase#setUp()
*
* @throws Exception
* if something goes wrong.
*/
@Override
public void setUp() throws Exception {
super.setUp();
this.m_chart = new Chart2D();
this.m_weakMap = new WeakHashMap
*
*/
protected void startThreads() {
for (Thread producer : this.m_producers) {
producer.start();
}
Consumer consumer = new Consumer(TestMultithreading.CONSUMER_SLEEPRANGE);
consumer.start();
while (!this.isAllProducersFinished() || consumer.isAlive()) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.report();
}
// ////////////////////////////
// Worker classes
// ////////////////////////////
/**
* @see junit.framework.TestCase#tearDown()
*
* @throws Exception
* if something goes wrong.
*/
@Override
protected void tearDown() throws Exception {
super.tearDown();
this.m_weakMap = null;
this.m_chart = null;
this.m_producers = null;
}
/**
* Tests the producer / consumer scenario.
*
*/
public void testTrace2DLtd() {
this.startThreads();
}
}
{@link TracePoint2D}. */
protected static final int PRODUCER_AMOUNT = 10;
/**
* Range of milliseconds to pick a random sleep time out between producing two
* {@link TracePoint2D} instances.
*/
protected static final int PRODUCER_SLEEPRANGE = 100;
/** Amount of {@link TracePoint2D} to create per producer. */
protected static final int PRODUCER_ADD_POINT_AMOUNT = 500;
/**
* Range of milliseconds to pick a random sleep time out between consuming two
* {@link TracePoint2D}.
*/
protected static final int CONSUMER_SLEEPRANGE = 1000;
/**
* The {@link ITrace2D} class to use an instance of for the test.
*/
private static final Class{@link System#out}.
*