test/jalview/workers/AlignCalcManagerTest.java

   1 package jalview.workers;
   2
   3 import static org.testng.AssertJUnit.assertEquals;
   4 import static org.testng.AssertJUnit.assertFalse;
   5 import static org.testng.AssertJUnit.assertTrue;
   6
   7 import jalview.api.AlignCalcManagerI;
   8 import jalview.api.AlignCalcWorkerI;
   9 import jalview.api.FeatureRenderer;
  10 import jalview.datamodel.Alignment;
  11 import jalview.datamodel.AlignmentAnnotation;
  12 import jalview.datamodel.AlignmentI;
  13 import jalview.datamodel.Annotation;
  14 import jalview.datamodel.Sequence;
  15 import jalview.datamodel.SequenceI;
  16 import jalview.gui.AlignFrame;
  17
  18 import java.util.Collections;
  19 import java.util.List;
  20
  21 import org.testng.annotations.BeforeMethod;
  22 import org.testng.annotations.Test;
  23
  24 public class AlignCalcManagerTest
  25 {
  26   private AlignFrame alignFrame;
  27
  28   /**
  29    * Test the method that removes a worker associated with an annotation,
  30    * provided the worker is marked as 'deletable' (some workers should continue
  31    * to run even when their results are no longer displayed)
  32    */
  33   @Test(groups = "Functional")
  34   public void testRemoveWorkerForAnnotation()
  35   {
  36     AlignCalcManagerI acm = alignFrame.getViewport().getCalcManager();
  37     final AlignmentAnnotation ann1 = new AlignmentAnnotation("Ann1",
  38             "desc",
  39             new Annotation[] {});
  40     final AlignmentAnnotation ann2 = new AlignmentAnnotation("Ann2",
  41             "desc",
  42             new Annotation[] {});
  43
  44     /*
  45      * make two workers for ann1, one deletable, one not
  46      * and no worker for ann2
  47      */
  48     AlignCalcWorkerI worker1 = makeWorker(ann1, true);
  49     AlignCalcWorkerI worker2 = makeWorker(ann1, false);
  50
  51     /*
  52      * The new workers will get run each in their own thread.
  53      * We can't tell here whether they have finished, or not yet started.
  54      * They have to finish to be 'seen' by getRegisteredWorkersOfClass()
  55      *   registerWorker adds to the 'restartable' list but
  56      *   getRegisteredWorkers reads from the 'canUpdate' list
  57      *   (which is only updated after a worker has run) - why?
  58      * So just give workers time to start and finish
  59      */
  60     synchronized (this)
  61     {
  62       try
  63       {
  64         wait(100);
  65       } catch (InterruptedException e)
  66       {
  67         //
  68       }
  69     }
  70
  71     List<AlignCalcWorkerI> workers = acm.getRegisteredWorkersOfClass(worker1.getClass());
  72     assertEquals(2, workers.size());
  73     assertTrue(workers.contains(worker1));
  74     assertTrue(workers.contains(worker2));
  75     assertFalse(acm.isDisabled(worker1));
  76     assertFalse(acm.isDisabled(worker2));
  77
  78     /*
  79      * remove workers for ann2 (there aren't any)
  80      */
  81     acm.removeWorkerForAnnotation(ann2);
  82     assertTrue(acm.getRegisteredWorkersOfClass(worker1.getClass())
  83             .contains(worker1));
  84     assertTrue(acm.getRegisteredWorkersOfClass(worker1.getClass())
  85             .contains(worker2));
  86     assertFalse(acm.isDisabled(worker1));
  87     assertFalse(acm.isDisabled(worker2));
  88
  89     /*
  90      * remove worker2 for ann1
  91      * - should delete worker1 but not worker2
  92      */
  93     acm.removeWorkerForAnnotation(ann1);
  94     assertEquals(1, acm.getRegisteredWorkersOfClass(worker1.getClass())
  95             .size());
  96     assertTrue(acm.getRegisteredWorkersOfClass(worker1.getClass())
  97             .contains(worker2));
  98     assertFalse(acm.isDisabled(worker1));
  99     assertFalse(acm.isDisabled(worker2));
 100   }
 101
 102   /**
 103    * Make a worker linked to the given annotation
 104    *
 105    * @param ann
 106    * @param deletable
 107    * @return
 108    */
 109   AnnotationWorker makeWorker(final AlignmentAnnotation ann,
 110           final boolean deletable)
 111   {
 112     AnnotationProviderI annotationProvider = new AnnotationProviderI()
 113     {
 114       @Override
 115       public List<AlignmentAnnotation> calculateAnnotation(AlignmentI al,
 116               FeatureRenderer fr)
 117       {
 118         return Collections.singletonList(ann);
 119       }
 120     };
 121     return new AnnotationWorker(alignFrame.getViewport(),
 122             alignFrame.alignPanel,
 123             annotationProvider)
 124     {
 125       @Override
 126       public boolean isDeletable()
 127       {
 128         return deletable;
 129       }
 130
 131       @Override
 132       public boolean involves(AlignmentAnnotation ann1)
 133       {
 134         return ann == ann1;
 135       }
 136     };
 137   }
 138
 139   @BeforeMethod(alwaysRun = true)
 140   public void setUp()
 141   {
 142     AlignmentI al = new Alignment(new SequenceI[] { new Sequence("Seq1",
 143             "ABC") });
 144     al.setDataset(null);
 145     alignFrame = new AlignFrame(al, 3, 1);
 146   }
 147 }