--- /dev/null
+package jalview.workers;
+
+import static org.testng.Assert.*;
+
+import java.util.ArrayList;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import jalview.api.AlignCalcManagerI2;
+import jalview.api.AlignCalcWorkerI;
+import jalview.datamodel.Alignment;
+import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.AlignmentI;
+import jalview.datamodel.Annotation;
+import jalview.datamodel.Sequence;
+import jalview.datamodel.SequenceI;
+import jalview.gui.AlignFrame;
+import jalview.gui.JvOptionPane;
+
+@Test(singleThreaded = true)
+public class AlignCaclManager2Test
+{
+ AlignFrame alignFrame;
+
+ AlignCalcManagerI2 calcManager;
+
+ @BeforeClass(alwaysRun = true)
+ public void setUpClass()
+ {
+ JvOptionPane.setInteractiveMode(false);
+ JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
+ }
+
+ @BeforeMethod(alwaysRun = true)
+ public void setUp()
+ {
+ AlignmentI al = new Alignment(
+ new SequenceI[] { new Sequence("Seq1", "ABC") });
+ al.setDataset(null);
+ alignFrame = new AlignFrame(al, 3, 1);
+ calcManager = alignFrame.getViewport().getCalcManager();
+ }
+
+ @AfterMethod(alwaysRun = true)
+ public void tearDown()
+ {
+ calcManager.shutdown();
+ }
+
+ // Running workers
+
+ @Test(groups = "Functional")
+ public void testStartRegisteredWorker() throws InterruptedException
+ {
+ var sentinel = new Object();
+ var job = CompletableFuture.completedFuture(sentinel);
+ var worker = new AlignCalcWorkerMock(job);
+ calcManager.registerWorker(worker);
+ Thread.sleep(10);
+ assertSame(worker.getLastResult(), sentinel);
+ }
+
+ @Test(groups = "Functional")
+ public void testIsWorking() throws InterruptedException
+ {
+ var job = new CompletableFuture<Object>();
+ var worker = new AlignCalcWorkerMock(job);
+ calcManager.registerWorker(worker);
+ assertTrue(calcManager.isWorking(worker));
+ assertTrue(calcManager.isWorking());
+ job.complete(null);
+ Thread.sleep(10);
+ assertFalse(calcManager.isWorking(worker));
+ assertFalse(calcManager.isWorking());
+ }
+
+ @Test(groups = "Functional")
+ public void testIsWorkingWithAnnotation() throws InterruptedException
+ {
+ var job = new CompletableFuture<Void>();
+ var worker1 = new AlignCalcWorkerMock(job);
+ var annot = worker1.annotation = newAlignmentAnnotation();
+ var otherAnnot = newAlignmentAnnotation();
+ calcManager.registerWorker(worker1);
+ assertTrue(calcManager.isWorkingWithAnnotation(annot));
+ assertFalse(calcManager.isWorkingWithAnnotation(otherAnnot));
+ job.complete(null);
+ Thread.sleep(10);
+ assertFalse(calcManager.isWorkingWithAnnotation(annot));
+ }
+
+ @Test(groups = "Functional")
+ public void testRestartCompletedWorkers() throws Throwable
+ {
+ var sentinel1 = new Object();
+ var sentinel2 = new Object();
+ var job = CompletableFuture.completedFuture(sentinel1);
+ var worker = new AlignCalcWorkerMock(job);
+ calcManager.registerWorker(worker);
+ Thread.sleep(10);
+ assertSame(worker.getLastResult(), sentinel1);
+ job.obtrudeValue(sentinel2);
+ calcManager.restartWorkers();
+ Thread.sleep(10);
+ assertSame(worker.getLastResult(), sentinel2);
+ }
+
+ @Test(groups = "Functional")
+ public void testRestartCancelsWorkers() throws Throwable
+ {
+ var job = new CompletableFuture<Object>();
+ var worker = new AlignCalcWorkerMock(job);
+ var sentinel = new Object();
+ calcManager.registerWorker(worker);
+ Thread.sleep(10);
+ calcManager.restartWorkers();
+ Thread.sleep(10);
+ assertTrue(worker.wasCancelled());
+ job.obtrudeValue(sentinel);
+ Thread.sleep(10);
+ assertSame(worker.getLastResult(), sentinel);
+ }
+
+ // Disabling workers
+
+ @Test(groups = "Functional")
+ public void testDisableWorker()
+ {
+ var worker = new AlignCalcWorkerMock(null);
+ calcManager.registerWorker(worker);
+ calcManager.disableWorker(worker);
+ assertTrue(calcManager.isDisabled(worker));
+ calcManager.enableWorker(worker);
+ assertFalse(calcManager.isDisabled(worker));
+ }
+
+ @Test(groups = "Functional")
+ public void testRestartDisabledWorker() throws InterruptedException
+ {
+ var worker = new AlignCalcWorkerMock(null);
+ calcManager.registerWorker(worker);
+ Thread.sleep(10);
+ assertEquals(worker.getCallCount(), 1);
+ calcManager.disableWorker(worker);
+ calcManager.restartWorkers();
+ Thread.sleep(10);
+ assertEquals(worker.getCallCount(), 1);
+ calcManager.enableWorker(worker);
+ calcManager.restartWorkers();
+ Thread.sleep(10);
+ assertEquals(worker.getCallCount(), 2);
+ }
+
+ // Canceling workers
+
+ @Test(groups = "Functional")
+ public void testCancelWorker() throws InterruptedException
+ {
+ var worker = new AlignCalcWorkerMock(new CompletableFuture<>());
+ calcManager.registerWorker(worker);
+ Thread.sleep(10);
+ calcManager.cancelWorker(worker);
+ Thread.sleep(10);
+ assertTrue(worker.wasCancelled());
+ }
+
+ // One-shot workers
+
+ @Test(groups = "Functional")
+ public void testStartOneShotWorker() throws InterruptedException
+ {
+ var job = CompletableFuture.completedFuture("result");
+ var worker = new AlignCalcWorkerMock(job);
+ calcManager.startWorker(worker);
+ Thread.sleep(10);
+ assertEquals(worker.getLastResult(), "result");
+ }
+
+ @Test(groups = "Functional")
+ public void testCancelOneShotWorker() throws InterruptedException
+ {
+ var worker = new AlignCalcWorkerMock(new CompletableFuture<>());
+ calcManager.startWorker(worker);
+ Thread.sleep(10);
+ calcManager.cancelWorker(worker);
+ Thread.sleep(10);
+ assertTrue(worker.wasCancelled());
+ }
+
+ @Test(groups = "Functional")
+ public void restartOneShotWorker() throws InterruptedException
+ {
+ var job = CompletableFuture.completedFuture("result1");
+ var worker = new AlignCalcWorkerMock(job);
+ calcManager.startWorker(worker);
+ Thread.sleep(10);
+ job.obtrudeValue("result2");
+ calcManager.restartWorkers();
+ Thread.sleep(10);
+
+ }
+
+
+ // Retrieving workers
+
+ @Test(groups = "Functional")
+ public void testGetWorkersOfClass() throws InterruptedException
+ {
+ var worker1 = new AlignCalcWorkerMock(null);
+ var worker2 = new AlignCalcWorkerMock(null);
+ var worker3 = new AlignCalcWorkerMock(null) {};
+ calcManager.registerWorker(worker1);
+ calcManager.registerWorker(worker2);
+ calcManager.registerWorker(worker3);
+ final var workers = calcManager
+ .getWorkersOfClass(AlignCalcWorkerMock.class);
+ assertTrue(workers.contains(worker1) && workers.contains(worker2));
+ assertFalse(workers.contains(worker3));
+ }
+
+ // Removing workers
+
+ @Test(groups = "Functional")
+ public void testRemoveWorker()
+ {
+ var worker = new AlignCalcWorkerMock(null);
+ calcManager.registerWorker(worker);
+ calcManager.removeWorker(worker);
+ assertFalse(calcManager.getWorkers().contains(worker));
+ }
+
+ @Test(groups = "Functional")
+ public void testRemoveWorkersOfClass()
+ {
+ var worker1 = new AlignCalcWorkerMock(null);
+ var worker2 = new AlignCalcWorkerMock(null);
+ var worker3 = new AlignCalcWorkerMock(null) {};
+ calcManager.registerWorker(worker1);
+ calcManager.registerWorker(worker2);
+ calcManager.registerWorker(worker3);
+ calcManager.removeWorkersOfClass(worker1.getClass());
+ assertFalse(calcManager.getWorkers().contains(worker1)
+ || calcManager.getWorkers().contains(worker2));
+ assertTrue(calcManager.getWorkers().contains(worker3));
+ }
+
+ @Test(groups = "Functional")
+ public void testRemoveWorkersForAnnotation()
+ {
+ var worker1 = new AlignCalcWorkerMock(null);
+ var worker2 = new AlignCalcWorkerMock(null);
+ var annot = worker1.annotation = newAlignmentAnnotation();
+ calcManager.registerWorker(worker1);
+ calcManager.registerWorker(worker2);
+ calcManager.removeWorkerForAnnotation(annot);
+ var workers = calcManager.getWorkers();
+ assertFalse(workers.contains(worker1));
+ assertTrue(workers.contains(worker2));
+ }
+
+ @Test(groups = "Functional")
+ public void testRemoveNonRemovableWorker()
+ {
+ var worker = new AlignCalcWorkerMock(null);
+ worker.deletable = false;
+ calcManager.registerWorker(worker);
+ calcManager.removeWorker(worker);
+ assertTrue(calcManager.getWorkers().contains(worker));
+ }
+
+ @Test(groups = "Functional")
+ public void testRemoveNonRemovableWorkersOfClass()
+ {
+ var worker1 = new AlignCalcWorkerMock(null);
+ var worker2 = new AlignCalcWorkerMock(null);
+ worker2.deletable = false;
+ calcManager.registerWorker(worker1);
+ calcManager.registerWorker(worker2);
+ calcManager.removeWorkersOfClass(worker1.getClass());
+ var workers = calcManager.getWorkers();
+ assertFalse(workers.contains(worker1));
+ assertTrue(workers.contains(worker2));
+ }
+
+ private int annotationCount = 0;
+
+ private AlignmentAnnotation newAlignmentAnnotation()
+ {
+ return new AlignmentAnnotation("Ann" + annotationCount++, "description",
+ new Annotation[] {});
+ }
+}
+
+class AlignCalcWorkerMock implements AlignCalcWorkerI
+{
+ AlignmentAnnotation annotation = null;
+ Future<?> job;
+ ArrayList<Object> values = new ArrayList<>();
+ int callCount = 0;
+ boolean deletable = true;
+
+ AlignCalcWorkerMock(Future<?> job)
+ {
+ this.job = job;
+ }
+
+ public Object getLastResult()
+ {
+ return values.isEmpty() ? null : values.get(values.size() - 1);
+ }
+
+ public Throwable getException()
+ {
+ var result = getLastResult();
+ return (result instanceof Throwable) ? (Throwable) result : null;
+ }
+
+ public int getCallCount() {
+ return callCount;
+ }
+
+ public boolean wasCancelled()
+ {
+ return getException() instanceof InterruptedException;
+ }
+
+ @Override
+ public boolean involves(AlignmentAnnotation annot)
+ {
+ if (annotation == null)
+ return false;
+ else
+ return annot == annotation;
+ }
+
+ @Override
+ public void updateAnnotation()
+ {
+ }
+
+ @Override
+ public void removeAnnotation()
+ {
+ }
+
+ @Override
+ public void run() throws Throwable
+ {
+ callCount++;
+ if (job != null)
+ {
+ try
+ {
+ values.add(job.get());
+ }
+ catch (InterruptedException e) { values.add(e); }
+ catch (CancellationException e) {
+ values.add(new InterruptedException());
+ } catch (ExecutionException e)
+ {
+ values.add(e.getCause());
+ }
+ }
+ }
+
+ @Override
+ public boolean isDeletable()
+ {
+ return deletable;
+ }
+}
git://source.jalview.org / jalview.git / blobdiff