JAL-2727 add SelectionGroup, Tree and PCA to test

diff --git a/test/jalview/gui/FreeUpMemoryTest.java b/test/jalview/gui/FreeUpMemoryTest.java
index 9fc0678..fede008 100644 (file)
--- a/test/jalview/gui/FreeUpMemoryTest.java
+++ b/test/jalview/gui/FreeUpMemoryTest.java
@@ -1,10 +1,13 @@
 package jalview.gui;
 
+import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertTrue;
 
 import jalview.analysis.AlignmentGenerator;
 import jalview.bin.Cache;
 import jalview.bin.Jalview;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.SequenceGroup;
 import jalview.io.DataSourceType;
 import jalview.io.FileLoader;
 
@@ -50,12 +53,12 @@ public class FreeUpMemoryTest
    * </li>
    * </ul>
    * If the test fails, this suggests that a reference to some large object
-   * (perhaps the alignment data, or consensus profile) has failed to be garbage
-   * collected. If this is the case, the heap will need to be inspected manually
-   * (suggest using jvisualvm) in order to track down where large objects are
-   * still referenced. The code (for example AlignmentViewport.dispose()) should
-   * then be updated to ensure references to large objects are set to null when
-   * they are no longer required.
+   * (perhaps the alignment data, or some annotation / Tree / PCA data) has
+   * failed to be garbage collected. If this is the case, the heap will need to
+   * be inspected manually (suggest using jvisualvm) in order to track down
+   * where large objects are still referenced. The code (for example
+   * AlignmentViewport.dispose()) should then be updated to ensure references to
+   * large objects are set to null when they are no longer required.
    * 
    * @throws IOException
    */
@@ -65,35 +68,34 @@ public class FreeUpMemoryTest
     File f = generateAlignment();
     f.deleteOnExit();
 
-    /*
-     * load alignment, wait for consensus and other threads to complete
-     */
-    AlignFrame af = new FileLoader().LoadFileWaitTillLoaded(f.getPath(),
-            DataSourceType.FILE);
-    waitForThreads(af.getViewport());
+    doStuffInJalview(f);
+
+    Desktop.instance.closeAll_actionPerformed(null);
 
-    af.closeMenuItem_actionPerformed(true);
+    checkUsedMemory(35L);
+  }
 
+  /**
+   * Requests garbage collection and then checks whether remaining memory in use
+   * is less than the expected value (in Megabytes)
+   * 
+   * @param expectedMax
+   */
+  protected void checkUsedMemory(long expectedMax)
+  {
     /*
      * request garbage collection and wait briefly for it to run;
      * NB there is no guarantee when, or whether, it will do so
      */
     System.gc();
-    synchronized (this)
-    {
-      try
-      {
-        wait(10);
-      } catch (InterruptedException e)
-      {
-      }
-    }
+    waitFor(100);
 
     /*
      * a second gc() call should not be necessary - but it is!
      * the test passes with it, and fails without it
      */
     System.gc();
+    waitFor(100);
 
     /*
      * check used memory is 'reasonably low'
@@ -101,8 +103,12 @@ public class FreeUpMemoryTest
     long availableMemory = Runtime.getRuntime().totalMemory() / ONE_MB;
     long freeMemory = Runtime.getRuntime().freeMemory() / ONE_MB;
     long usedMemory = availableMemory - freeMemory;
-    System.out.println("Memory in use after close all windows: "
-            + usedMemory + "MB");
+
+    /*
+     * sanity check - fails if any frame was added after
+     * closeAll_actionPerformed
+     */
+    assertEquals(Desktop.instance.getAllFrames().length, 0);
 
     /*
      * if this assertion fails
@@ -111,27 +117,78 @@ public class FreeUpMemoryTest
      * - identify large objects in the heap and their referers
      * - fix code as necessary to null the references on close
      */
-    long expectedMax = 30L; // typically reports around 25
+    System.out.println("Used memory after gc = " + usedMemory + "MB");
     assertTrue(usedMemory < expectedMax, String.format(
             "Used memory %d should be less than %d", usedMemory,
             expectedMax));
   }
 
   /**
-   * wait for consensus etc thread to complete
+   * Loads an alignment from file and exercises various operations in Jalview
+   * 
+   * @param f
+   */
+  protected void doStuffInJalview(File f)
+  {
+    /*
+     * load alignment, wait for consensus and other threads to complete
+     */
+    AlignFrame af = new FileLoader().LoadFileWaitTillLoaded(f.getPath(),
+            DataSourceType.FILE);
+    while (af.getViewport().isCalcInProgress())
+    {
+      waitFor(200);
+    }
+
+    /*
+     * set a selection group - potential memory leak if it retains
+     * a reference to the alignment
+     */
+    SequenceGroup sg = new SequenceGroup();
+    sg.setStartRes(0);
+    sg.setEndRes(100);
+    AlignmentI al = af.viewport.getAlignment();
+    for (int i = 0; i < al.getHeight(); i++)
+    {
+      sg.addSequence(al.getSequenceAt(i), false);
+    }
+    af.viewport.setSelectionGroup(sg);
+
+    /*
+     * compute Tree and PCA (on all sequences, 100 columns)
+     */
+    af.openTreePcaDialog();
+    CalculationChooser dialog = af.alignPanel.getCalculationDialog();
+    dialog.openPcaPanel("BLOSUM62", dialog.getSimilarityParameters(true));
+    dialog.openTreePanel("BLOSUM62", dialog.getSimilarityParameters(false));
+
+    /*
+     * wait until Tree and PCA have been computed
+     */
+    while (af.viewport.getCurrentTree() == null
+            && dialog.getPcaPanel().isWorking())
+    {
+      waitFor(10);
+    }
+
+    /*
+     * give Swing time to add the PCA panel (?!?)
+     */
+    waitFor(100);
+  }
+
+  /**
+   * Wait for waitMs miliseconds
    * 
-   * @param av
+   * @param waitMs
    */
-  protected void waitForThreads(AlignViewport av)
+  protected void waitFor(int waitMs)
   {
-    while (av.isCalcInProgress())
+    try
+    {
+      Thread.sleep(waitMs);
+    } catch (InterruptedException e)
     {
-      try
-      {
-        Thread.sleep(200);
-      } catch (Exception x)
-      {
-      }
     }
   }