Unit tests for ProgressMeterDaemon

public/java/src/org/broadinstitute/sting/utils/progressmeter/ProgressMeter.java

@@ -160,6 +160,13 @@ public class ProgressMeter {
     public ProgressMeter(final File performanceLogFile,
                          final String processingUnitName,
                          final GenomeLocSortedSet processingIntervals) {
+        this(performanceLogFile, processingUnitName, processingIntervals, ProgressMeterDaemon.DEFAULT_POLL_FREQUENCY_MILLISECONDS);
+    }
+
+    protected ProgressMeter(final File performanceLogFile,
+                            final String processingUnitName,
+                            final GenomeLocSortedSet processingIntervals,
+                            final long pollingFrequency) {
         if ( processingUnitName == null ) throw new IllegalArgumentException("processingUnitName cannot be null");
         if ( processingIntervals == null ) throw new IllegalArgumentException("Target intervals cannot be null");
 
@@ -184,10 +191,14 @@ public class ProgressMeter {
         targetSizeInBP = processingIntervals.coveredSize();
 
         // start up the timer
-        progressMeterDaemon = new ProgressMeterDaemon(this);
+        progressMeterDaemon = new ProgressMeterDaemon(this, pollingFrequency);
         start();
     }
 
+    public ProgressMeterDaemon getProgressMeterDaemon() {
+        return progressMeterDaemon;
+    }
+
     /**
      * Start up the progress meter, printing initialization message and starting up the
      * daemon thread for periodic printing.

public/java/src/org/broadinstitute/sting/utils/progressmeter/ProgressMeterDaemon.java

@@ -8,10 +8,20 @@ package org.broadinstitute.sting.utils.progressmeter;
  * Time: 9:16 PM
  */
 public final class ProgressMeterDaemon extends Thread {
+    public final static long DEFAULT_POLL_FREQUENCY_MILLISECONDS = 10 * 1000;
+
     /**
      * How frequently should we poll and print progress?
      */
-    private final static long POLL_FREQUENCY_MILLISECONDS = 10 * 1000;
+    private final long pollFrequencyMilliseconds;
+
+    /**
+     * How long are we waiting between print progress calls are issued?
+     * @return the time in milliseconds between progress meter calls
+     */
+    private long getPollFrequencyMilliseconds() {
+        return pollFrequencyMilliseconds;
+    }
 
     /**
      * Are we to continue periodically printing status, or should we shut down?
@@ -27,13 +37,20 @@ public final class ProgressMeterDaemon extends Thread {
      * Create a new ProgressMeterDaemon printing progress for meter
      * @param meter the progress meter to print progress of
      */
-    public ProgressMeterDaemon(final ProgressMeter meter) {
+    public ProgressMeterDaemon(final ProgressMeter meter, final long pollFrequencyMilliseconds) {
         if ( meter == null ) throw new IllegalArgumentException("meter cannot be null");
+        if ( pollFrequencyMilliseconds <= 0 ) throw new IllegalArgumentException("pollFrequencyMilliseconds must be greater than 0 but got " + pollFrequencyMilliseconds);
+
         this.meter = meter;
+        this.pollFrequencyMilliseconds = pollFrequencyMilliseconds;
         setDaemon(true);
         setName("ProgressMeterDaemon");
     }
 
+    public ProgressMeterDaemon(final ProgressMeter meter) {
+        this(meter, DEFAULT_POLL_FREQUENCY_MILLISECONDS);
+    }
+
     /**
      * Tells this daemon thread to shutdown at the next opportunity, as the progress
      * metering is complete.
@@ -42,6 +59,14 @@ public final class ProgressMeterDaemon extends Thread {
         this.done = true;
     }
 
+    /**
+     * Is this daemon thread done?
+     * @return true if done, false otherwise
+     */
+    public boolean isDone() {
+        return done;
+    }
+
     /**
      * Start up the ProgressMeterDaemon, polling every tens of seconds to print, if
      * necessary, the provided progress meter.  Never exits until the JVM is complete,
@@ -51,7 +76,7 @@ public final class ProgressMeterDaemon extends Thread {
         while (! done) {
             meter.printProgress(false);
             try {
-                Thread.sleep(POLL_FREQUENCY_MILLISECONDS);
+                Thread.sleep(getPollFrequencyMilliseconds());
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }

public/java/test/org/broadinstitute/sting/utils/progressmeter/ProgressMeterDaemonUnitTest.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2012 The Broad Institute
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package org.broadinstitute.sting.utils.progressmeter;
+
+import org.broadinstitute.sting.BaseTest;
+import org.broadinstitute.sting.utils.GenomeLocParser;
+import org.broadinstitute.sting.utils.GenomeLocSortedSet;
+import org.broadinstitute.sting.utils.fasta.CachingIndexedFastaSequenceFile;
+import org.testng.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * UnitTests for the ProgressMeterDaemon
+ *
+ * User: depristo
+ * Date: 8/24/12
+ * Time: 11:25 AM
+ * To change this template use File | Settings | File Templates.
+ */
+public class ProgressMeterDaemonUnitTest extends BaseTest {
+    private GenomeLocParser genomeLocParser;
+
+    @BeforeClass
+    public void init() throws FileNotFoundException {
+        genomeLocParser = new GenomeLocParser(new CachingIndexedFastaSequenceFile(new File(b37KGReference)));
+    }
+
+    // capture and count calls to progress
+    private class TestingProgressMeter extends ProgressMeter {
+        final List<Long> progressCalls = new LinkedList<Long>();
+
+        private TestingProgressMeter(final long poll) {
+            super(null, "test", new GenomeLocSortedSet(genomeLocParser), poll);
+        }
+
+        @Override
+        protected synchronized void printProgress(boolean mustPrint) {
+            progressCalls.add(System.currentTimeMillis());
+        }
+    }
+
+    @DataProvider(name = "PollingData")
+    public Object[][] makePollingData() {
+        List<Object[]> tests = new ArrayList<Object[]>();
+        for ( final int ticks : Arrays.asList(1, 5, 10) ) {
+            for ( final int poll : Arrays.asList(10, 100) ) {
+                tests.add(new Object[]{poll, ticks});
+            }
+        }
+
+        return tests.toArray(new Object[][]{});
+    }
+
+    @Test(dataProvider = "PollingData", invocationCount = 10, successPercentage = 90)
+    public void testMe(final long poll, final int ticks) throws InterruptedException {
+        final TestingProgressMeter meter = new TestingProgressMeter(poll);
+        final ProgressMeterDaemon daemon = meter.getProgressMeterDaemon();
+        Assert.assertTrue(daemon.isDaemon());
+
+        Assert.assertFalse(daemon.isDone());
+        Thread.sleep(ticks * poll);
+        Assert.assertFalse(daemon.isDone());
+
+        daemon.done();
+        Assert.assertTrue(daemon.isDone());
+
+        Assert.assertEquals(meter.progressCalls.size(), ticks,
+                "Expected " + ticks + " progress calls from daemon thread, but only got " + meter.progressCalls.size() + " with exact calls " + meter.progressCalls);
+    }
+}