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", new Annotation[] {});
  39     final AlignmentAnnotation ann2 = new AlignmentAnnotation("Ann2",
  40             "desc", new Annotation[] {});
  41
  42     /*
  43      * make two workers for ann1, one deletable, one not
  44      * and no worker for ann2
  45      */
  46     AlignCalcWorkerI worker1 = makeWorker(ann1, true);
  47     AlignCalcWorkerI worker2 = makeWorker(ann1, false);
  48
  49     /*
  50      * The new workers will get run each in their own thread.
  51      * We can't tell here whether they have finished, or not yet started.
  52      * They have to finish to be 'seen' by getRegisteredWorkersOfClass()
  53      *   registerWorker adds to the 'restartable' list but
  54      *   getRegisteredWorkers reads from the 'canUpdate' list
  55      *   (which is only updated after a worker has run) - why?
  56      * So just give workers time to start and finish
  57      */
  58     synchronized (this)
  59     {
  60       try
  61       {
  62         wait(100);
  63       } catch (InterruptedException e)
  64       {
  65         //
  66       }
  67     }
  68
  69     List<AlignCalcWorkerI> workers = acm
  70             .getRegisteredWorkersOfClass(worker1.getClass());
  71     assertEquals(2, workers.size());
  72     assertTrue(workers.contains(worker1));
  73     assertTrue(workers.contains(worker2));
  74     assertFalse(acm.isDisabled(worker1));
  75     assertFalse(acm.isDisabled(worker2));
  76
  77     /*
  78      * remove workers for ann2 (there aren't any)
  79      */
  80     acm.removeWorkerForAnnotation(ann2);
  81     assertTrue(acm.getRegisteredWorkersOfClass(worker1.getClass())
  82             .contains(worker1));
  83     assertTrue(acm.getRegisteredWorkersOfClass(worker1.getClass())
  84             .contains(worker2));
  85     assertFalse(acm.isDisabled(worker1));
  86     assertFalse(acm.isDisabled(worker2));
  87
  88     /*
  89      * remove worker2 for ann1
  90      * - should delete worker1 but not worker2
  91      */
  92     acm.removeWorkerForAnnotation(ann1);
  93     assertEquals(1, acm.getRegisteredWorkersOfClass(worker1.getClass())
  94             .size());
  95     assertTrue(acm.getRegisteredWorkersOfClass(worker1.getClass())
  96             .contains(worker2));
  97     assertFalse(acm.isDisabled(worker1));
  98     assertFalse(acm.isDisabled(worker2));
  99   }
 100
 101   /**
 102    * Make a worker linked to the given annotation
 103    *
 104    * @param ann
 105    * @param deletable
 106    * @return
 107    */
 108   AnnotationWorker makeWorker(final AlignmentAnnotation ann,
 109           final boolean deletable)
 110   {
 111     AnnotationProviderI annotationProvider = new AnnotationProviderI()
 112     {
 113       @Override
 114       public List<AlignmentAnnotation> calculateAnnotation(AlignmentI al,
 115               FeatureRenderer fr)
 116       {
 117         return Collections.singletonList(ann);
 118       }
 119     };
 120     return new AnnotationWorker(alignFrame.getViewport(),
 121             alignFrame.alignPanel, annotationProvider)
 122     {
 123       @Override
 124       public boolean isDeletable()
 125       {
 126         return deletable;
 127       }
 128
 129       @Override
 130       public boolean involves(AlignmentAnnotation ann1)
 131       {
 132         return ann == ann1;
 133       }
 134     };
 135   }
 136
 137   @BeforeMethod(alwaysRun = true)
 138   public void setUp()
 139   {
 140     AlignmentI al = new Alignment(new SequenceI[] { new Sequence("Seq1",
 141             "ABC") });
 142     al.setDataset(null);
 143     alignFrame = new AlignFrame(al, 3, 1);
 144   }
 145 }