test/jalview/viewmodel/ViewportRangesTest.java

   1 package jalview.viewmodel;
   2
   3 import static org.testng.Assert.assertEquals;
   4 import static org.testng.Assert.assertTrue;
   5
   6 import jalview.analysis.AlignmentGenerator;
   7 import jalview.datamodel.AlignmentI;
   8 import jalview.datamodel.ColumnSelection;
   9 import jalview.datamodel.HiddenColumns;
  10 import jalview.datamodel.HiddenSequences;
  11
  12 import java.beans.PropertyChangeEvent;
  13 import java.util.ArrayList;
  14 import java.util.Arrays;
  15 import java.util.List;
  16
  17 import org.testng.annotations.BeforeMethod;
  18 import org.testng.annotations.Test;
  19
  20 public class ViewportRangesTest {
  21
  22   AlignmentGenerator gen = new AlignmentGenerator(false);
  23
  24   AlignmentI al = gen.generate(20, 30, 1, 5, 5);
  25
  26   AlignmentI smallAl = gen.generate(7, 2, 2, 5, 5);
  27
  28   @BeforeMethod
  29   public void cleanUp()
  30   {
  31     ColumnSelection sel = new ColumnSelection();
  32     al.getHiddenColumns().revealAllHiddenColumns(sel);
  33     al.getHiddenSequences().showAll(null);
  34     smallAl.getHiddenColumns().revealAllHiddenColumns(sel);
  35     smallAl.getHiddenSequences().showAll(null);
  36   }
  37
  38   @Test(groups = { "Functional" })
  39   public void testViewportRanges()
  40   {
  41     ViewportRanges vr = new ViewportRanges(al);
  42
  43     assertEquals(vr.getStartRes(),0);
  44     assertEquals(vr.getEndRes(), al.getWidth()-1);
  45     assertEquals(vr.getStartSeq(), 0);
  46     assertEquals(vr.getEndSeq(), al.getHeight() - 1);
  47   }
  48
  49   @Test(groups = { "Functional" })
  50   public void testGetAbsoluteAlignmentHeight()
  51   {
  52     ViewportRanges vr = new ViewportRanges(al);
  53
  54     assertEquals(vr.getAbsoluteAlignmentHeight(), al.getHeight());
  55
  56     al.getHiddenSequences().hideSequence(al.getSequenceAt(3));
  57     assertEquals(vr.getAbsoluteAlignmentHeight(), al.getHeight() + 1);
  58   }
  59
  60   @Test(groups = { "Functional" })
  61   public void testGetAbsoluteAlignmentWidth()
  62   {
  63     ViewportRanges vr = new ViewportRanges(al);
  64     assertEquals(vr.getAbsoluteAlignmentWidth(), al.getWidth());
  65   }
  66
  67   @Test(groups = { "Functional" })
  68   public void testSetEndRes()
  69   {
  70     ViewportRanges vr = new ViewportRanges(al);
  71     vr.setEndRes(-1);
  72     assertEquals(vr.getEndRes(), 0);
  73
  74     vr.setEndRes(al.getWidth() - 1);
  75     assertEquals(vr.getEndRes(), al.getWidth() - 1);
  76   }
  77
  78   @Test(groups = { "Functional" })
  79   public void testSetEndSeq()
  80   {
  81     ViewportRanges vr = new ViewportRanges(al);
  82     vr.setEndSeq(-1);
  83     assertEquals(vr.getEndSeq(), 0);
  84
  85     vr.setEndSeq(al.getHeight());
  86     assertEquals(vr.getEndSeq(), al.getHeight() - 1);
  87
  88     vr.setEndRes(al.getHeight() - 1);
  89     assertEquals(vr.getEndSeq(), al.getHeight() - 1);
  90   }
  91
  92   @Test(groups = { "Functional" })
  93   public void testSetStartRes()
  94   {
  95     ViewportRanges vr = new ViewportRanges(al);
  96     vr.setStartRes(-1);
  97     assertEquals(vr.getStartRes(), 0);
  98
  99     vr.setStartRes(al.getWidth());
 100     assertEquals(vr.getStartRes(), al.getWidth() - 1);
 101
 102     vr.setStartRes(al.getWidth() - 1);
 103     assertEquals(vr.getStartRes(), al.getWidth() - 1);
 104   }
 105
 106   @Test(groups = { "Functional" })
 107   public void testSetStartSeq()
 108   {
 109     ViewportRanges vr = new ViewportRanges(al);
 110     vr.setStartSeq(-1);
 111     assertEquals(vr.getStartSeq(), 0);
 112
 113     vr.setStartSeq(al.getHeight() - vr.getViewportHeight() + 1);
 114     assertEquals(vr.getStartSeq(), al.getHeight() - vr.getViewportHeight());
 115
 116     vr.setStartSeq(al.getHeight() - vr.getViewportHeight());
 117     assertEquals(vr.getStartSeq(), al.getHeight() - vr.getViewportHeight());
 118   }
 119
 120   @Test(groups = { "Functional" })
 121   public void testSetStartEndRes()
 122   {
 123     ViewportRanges vr = new ViewportRanges(al);
 124     vr.setStartEndRes(-1, -1);
 125     assertEquals(vr.getStartRes(), 0);
 126     assertEquals(vr.getEndRes(), 0);
 127
 128     vr.setStartEndRes(5, 19);
 129     assertEquals(vr.getStartRes(), 5);
 130     assertEquals(vr.getEndRes(), 19);
 131
 132     vr.setStartEndRes(al.getWidth(), al.getWidth());
 133     assertEquals(vr.getEndRes(), al.getWidth() - 1);
 134
 135     ViewportRanges vrsmall = new ViewportRanges(smallAl);
 136     vrsmall.setStartEndRes(al.getWidth(), al.getWidth());
 137     assertEquals(vrsmall.getEndRes(), 6);
 138
 139     // make visible alignment width = 0
 140     smallAl.getHiddenColumns().hideColumns(0, 6);
 141     vrsmall.setStartEndRes(0, 4);
 142     assertEquals(vrsmall.getStartRes(), 0);
 143     assertEquals(vrsmall.getEndRes(), 0);
 144   }
 145
 146   @Test(groups = { "Functional" })
 147   public void testSetStartEndSeq()
 148   {
 149     ViewportRanges vr = new ViewportRanges(al);
 150     vr.setStartEndSeq(-1, -1);
 151     assertEquals(vr.getStartSeq(), 0);
 152     assertEquals(vr.getEndSeq(), 0);
 153
 154     vr.setStartEndSeq(5, 19);
 155     assertEquals(vr.getStartSeq(), 5);
 156     assertEquals(vr.getEndSeq(), 19);
 157
 158     vr.setStartEndSeq(al.getHeight(), al.getHeight());
 159     assertEquals(vr.getEndSeq(), al.getHeight() - 1);
 160
 161     // make visible alignment height = 0
 162     smallAl.getHiddenSequences().hideSequence(smallAl.getSequenceAt(0));
 163     smallAl.getHiddenSequences().hideSequence(smallAl.getSequenceAt(0));
 164     ViewportRanges vrsmall = new ViewportRanges(smallAl);
 165     vrsmall.setStartEndSeq(0, 3);
 166     assertEquals(vrsmall.getStartSeq(), 0);
 167     assertEquals(vrsmall.getEndSeq(), 0);
 168   }
 169
 170   @Test(groups = { "Functional" })
 171   public void testSetViewportHeight()
 172   {
 173     ViewportRanges vr = new ViewportRanges(al);
 174     vr.setViewportHeight(13);
 175     assertEquals(vr.getViewportHeight(), 13);
 176   }
 177
 178   @Test(groups = { "Functional" })
 179   public void testSetViewportWidth()
 180   {
 181     ViewportRanges vr = new ViewportRanges(al);
 182     vr.setViewportWidth(13);
 183     assertEquals(vr.getViewportWidth(), 13);
 184   }
 185
 186   @Test(groups = { "Functional" })
 187   public void testSetViewportStartAndHeight()
 188   {
 189     ViewportRanges vr = new ViewportRanges(al);
 190     vr.setViewportStartAndHeight(2, 6);
 191     assertEquals(vr.getViewportHeight(), 6);
 192     assertEquals(vr.getStartSeq(), 2);
 193
 194     // reset -ve values of start to 0
 195     vr.setViewportStartAndHeight(-1, 7);
 196     assertEquals(vr.getViewportHeight(), 7);
 197     assertEquals(vr.getStartSeq(), 0);
 198
 199     // reset out of bounds start values to within bounds
 200     vr.setViewportStartAndHeight(35, 5);
 201     assertEquals(vr.getViewportHeight(), 5);
 202     assertEquals(vr.getStartSeq(), 24);
 203   }
 204
 205   @Test(groups = { "Functional" })
 206   public void testSetViewportStartAndWidth()
 207   {
 208     ViewportRanges vr = new ViewportRanges(al);
 209     vr.setViewportStartAndWidth(2, 6);
 210     assertEquals(vr.getViewportWidth(), 6);
 211     assertEquals(vr.getStartRes(), 2);
 212
 213     // reset -ve values of start to 0
 214     vr.setViewportStartAndWidth(-1, 7);
 215     assertEquals(vr.getViewportWidth(), 7);
 216     assertEquals(vr.getStartRes(), 0);
 217
 218     // reset out of bounds start values to within bounds
 219     vr.setViewportStartAndWidth(35, 5);
 220     assertEquals(vr.getViewportWidth(), 5);
 221     assertEquals(vr.getStartRes(), 16);
 222
 223     // small alignment doesn't get bounds reset
 224     ViewportRanges vrsmall = new ViewportRanges(smallAl);
 225     vrsmall.setViewportStartAndWidth(0, 63);
 226     assertEquals(vrsmall.getViewportWidth(), 7);
 227     assertEquals(vrsmall.getStartRes(), 0);
 228   }
 229
 230   @Test(groups = { "Functional" })
 231   public void testPageUpDown()
 232   {
 233     ViewportRanges vr = new ViewportRanges(al);
 234     vr.setViewportStartAndHeight(8, 6);
 235     vr.pageDown();
 236     assertEquals(vr.getStartSeq(), 13);
 237
 238     vr.pageUp();
 239     assertEquals(vr.getStartSeq(), 8);
 240
 241     vr.pageUp();
 242     assertEquals(vr.getStartSeq(), 3);
 243
 244     vr.pageUp();
 245     // pageup does not go beyond 0, viewport height stays the same
 246     assertEquals(vr.getStartSeq(), 0);
 247     assertEquals(vr.getViewportHeight(), 6);
 248
 249     vr.pageDown();
 250     vr.pageDown();
 251     vr.pageDown();
 252     vr.pageDown();
 253     vr.pageDown();
 254
 255     // pagedown to bottom does not go beyond end, and height stays same
 256     assertEquals(vr.getStartSeq(), 24);
 257     assertEquals(vr.getViewportHeight(), 6);
 258   }
 259
 260   @Test(groups = { "Functional" })
 261   public void testScrollUp()
 262   {
 263     ViewportRanges vr = new ViewportRanges(al);
 264     vr.setViewportStartAndHeight(1, 5);
 265     vr.scrollUp(true);
 266     assertEquals(vr.getStartSeq(), 0);
 267     // can't scroll above top
 268     vr.scrollUp(true);
 269     assertEquals(vr.getStartSeq(), 0);
 270
 271     vr.setViewportStartAndHeight(24, 5);
 272     vr.scrollUp(false);
 273     assertEquals(vr.getStartSeq(), 25);
 274     // can't scroll beyond bottom
 275     vr.scrollUp(false);
 276     assertEquals(vr.getStartSeq(), 25);
 277   }
 278
 279   @Test(groups = { "Functional" })
 280   public void testScrollUpWithHidden()
 281   {
 282     ViewportRanges vr = new ViewportRanges(al);
 283
 284     // hide last sequence
 285     HiddenSequences hidden = new HiddenSequences(al);
 286     hidden.hideSequence(al.getSequenceAt(29));
 287
 288     vr.setViewportStartAndHeight(1, 5);
 289     vr.scrollUp(true);
 290     assertEquals(vr.getStartSeq(), 0);
 291     // can't scroll above top
 292     vr.scrollUp(true);
 293     assertEquals(vr.getStartSeq(), 0);
 294
 295     vr.setViewportStartAndHeight(23, 5);
 296     vr.scrollUp(false);
 297     assertEquals(vr.getStartSeq(), 24);
 298     // can't scroll beyond bottom
 299     vr.scrollUp(false);
 300     assertEquals(vr.getStartSeq(), 24);
 301   }
 302
 303   @Test(groups = { "Functional" })
 304   public void testScrollRight()
 305   {
 306     ViewportRanges vr = new ViewportRanges(al);
 307     vr.setViewportStartAndWidth(1, 5);
 308     vr.scrollRight(false);
 309     assertEquals(vr.getStartRes(), 0);
 310     // can't scroll left past start
 311     vr.scrollRight(false);
 312     assertEquals(vr.getStartRes(), 0);
 313
 314     vr.setViewportStartAndWidth(15, 5);
 315     vr.scrollRight(true);
 316     assertEquals(vr.getStartRes(), 16);
 317     // can't scroll right past end
 318     vr.scrollRight(true);
 319     assertEquals(vr.getStartRes(), 16);
 320   }
 321
 322   @Test(groups = { "Functional" })
 323   public void testScrollRightWithHidden()
 324   {
 325     ViewportRanges vr = new ViewportRanges(al);
 326
 327     // hide last 2 columns
 328     HiddenColumns cols = new HiddenColumns();
 329     cols.hideColumns(19, 20);
 330     al.setHiddenColumns(cols);
 331
 332     vr.setViewportStartAndWidth(1, 5);
 333     vr.scrollRight(false);
 334     assertEquals(vr.getStartRes(), 0);
 335     // can't scroll left past start
 336     vr.scrollRight(false);
 337     assertEquals(vr.getStartRes(), 0);
 338
 339     vr.setViewportStartAndWidth(13, 5);
 340     vr.scrollRight(true);
 341     assertEquals(vr.getStartRes(), 14);
 342     // can't scroll right past last visible col
 343     vr.scrollRight(true);
 344     assertEquals(vr.getStartRes(), 14);
 345   }
 346
 347   @Test(groups = { "Functional" })
 348   public void testScrollToWrappedVisible()
 349   {
 350     ViewportRanges vr = new ViewportRanges(al);
 351     vr.setViewportStartAndWidth(5, 10);
 352
 353     vr.scrollToWrappedVisible(0);
 354     assertEquals(vr.getStartRes(), 0);
 355
 356     vr.scrollToWrappedVisible(10);
 357     assertEquals(vr.getStartRes(), 10);
 358
 359     vr.scrollToWrappedVisible(15);
 360     assertEquals(vr.getStartRes(), 10);
 361   }
 362
 363   // leave until JAL-2388 is merged and we can do without viewport
 364   /*@Test(groups = { "Functional" })
 365   public void testScrollToVisible()
 366   {
 367     ViewportRanges vr = new ViewportRanges(al);
 368     vr.setViewportStartAndWidth(12,5);
 369     vr.setViewportStartAndHeight(10,6);
 370     vr.scrollToVisible(13,14)
 371
 372     // no change
 373     assertEquals(vr.getStartRes(), 12);
 374     assertEquals(vr.getStartSeq(), 10);
 375
 376     vr.scrollToVisible(5,6);
 377     assertEquals(vr.getStartRes(), 5);
 378     assertEquals(vr.getStartSeq(), 6);
 379
 380     // test for hidden columns too
 381   }*/
 382
 383   @Test(groups = { "Functional" })
 384   public void testEventFiring()
 385   {
 386     ViewportRanges vr = new ViewportRanges(al);
 387     MockPropChangeListener l = new MockPropChangeListener(vr);
 388     List<String> emptylist = new ArrayList<>();
 389
 390     vr.setViewportWidth(5);
 391     vr.setViewportHeight(5);
 392     l.reset();
 393
 394     // one event fired when startRes is called with new value
 395     vr.setStartRes(4);
 396     assertTrue(l.verify(1, Arrays.asList("startres")));
 397     l.reset();
 398
 399     // no event fired for same value
 400     vr.setStartRes(4);
 401     assertTrue(l.verify(0, emptylist));
 402     l.reset();
 403
 404     vr.setEndRes(10);
 405     assertTrue(l.verify(1, Arrays.asList("startres")));
 406     l.reset();
 407
 408     // no event fired for same value
 409     vr.setEndRes(10);
 410     assertTrue(l.verify(0, emptylist));
 411     l.reset();
 412
 413     vr.setStartSeq(4);
 414     assertTrue(l.verify(1, Arrays.asList("startseq")));
 415     l.reset();
 416
 417     vr.setStartSeq(4);
 418     assertTrue(l.verify(0, emptylist));
 419     l.reset();
 420
 421     vr.setEndSeq(10);
 422     assertTrue(l.verify(1, Arrays.asList("startseq")));
 423     l.reset();
 424
 425     vr.setEndSeq(10);
 426     assertTrue(l.verify(0, emptylist));
 427     l.reset();
 428
 429     vr.setStartEndRes(2, 15);
 430     assertTrue(l.verify(1, Arrays.asList("startres")));
 431     l.reset();
 432
 433     vr.setStartEndRes(2, 15);
 434     assertTrue(l.verify(0, emptylist));
 435     l.reset();
 436
 437     // check new value fired by event is corrected startres
 438     vr.setStartEndRes(-1, 5);
 439     assertTrue(l.verify(1, Arrays.asList("startres"), Arrays.asList(0)));
 440     l.reset();
 441
 442     // check new value fired by event is corrected endres
 443     vr.setStartEndRes(0, -1);
 444     assertTrue(l.verify(1, Arrays.asList("endres"), Arrays.asList(0)));
 445     l.reset();
 446
 447     vr.setStartEndSeq(2, 15);
 448     assertTrue(l.verify(1, Arrays.asList("startseq")));
 449     l.reset();
 450
 451     vr.setStartEndSeq(2, 15);
 452     assertTrue(l.verify(0, emptylist));
 453     l.reset();
 454
 455     vr.setStartEndRes(2, 2); // so seq and res values should be different, in
 456                              // case of transposing in code
 457     l.reset();
 458
 459     // check new value fired by event is corrected startseq
 460     vr.setStartEndSeq(-1, 5);
 461     assertTrue(l.verify(1, Arrays.asList("startseq"), Arrays.asList(0)));
 462     l.reset();
 463
 464     // check new value fired by event is corrected endseq
 465     vr.setStartEndSeq(0, -1);
 466     assertTrue(l.verify(1, Arrays.asList("endseq"), Arrays.asList(0)));
 467     l.reset();
 468
 469     // reset for later tests
 470     vr.setStartEndSeq(2, 15);
 471     l.reset();
 472
 473     // test viewport height and width setting triggers event
 474     vr.setViewportHeight(10);
 475     assertTrue(l.verify(1, Arrays.asList("endseq")));
 476     l.reset();
 477
 478     vr.setViewportWidth(18);
 479     assertTrue(l.verify(1, Arrays.asList("endres")));
 480     l.reset();
 481
 482     // already has seq start set to 2, so triggers endseq
 483     vr.setViewportStartAndHeight(2, 16);
 484     assertTrue(l.verify(1, Arrays.asList("endseq")));
 485     l.reset();
 486
 487     vr.setViewportStartAndWidth(1, 14);
 488     assertTrue(l.verify(1, Arrays.asList("startres")));
 489     l.reset();
 490
 491     // test page up/down triggers event
 492     vr.pageUp();
 493     assertTrue(l.verify(1, Arrays.asList("startseq")));
 494     l.reset();
 495
 496     vr.pageDown();
 497     assertTrue(l.verify(1, Arrays.asList("startseq")));
 498     l.reset();
 499
 500     // test scrolling triggers event
 501     vr.scrollUp(true);
 502     assertTrue(l.verify(1, Arrays.asList("startseq")));
 503     l.reset();
 504
 505     vr.scrollUp(false);
 506     assertTrue(l.verify(1, Arrays.asList("startseq")));
 507     l.reset();
 508
 509     vr.scrollRight(true);
 510     assertTrue(l.verify(1, Arrays.asList("startres")));
 511     l.reset();
 512
 513     vr.scrollRight(false);
 514     assertTrue(l.verify(1, Arrays.asList("startres")));
 515     l.reset();
 516
 517     vr.scrollToVisible(10, 10);
 518     assertTrue(l.verify(4,
 519             Arrays.asList("startseq", "startseq", "startseq", "startseq")));
 520     l.reset();
 521
 522     vr.scrollToWrappedVisible(5);
 523     assertTrue(l.verify(1, Arrays.asList("startres")));
 524     l.reset();
 525   }
 526 }
 527
 528 // mock listener for property change events
 529 class MockPropChangeListener implements ViewportListenerI
 530 {
 531   private int firecount = 0;
 532
 533   private List<String> events = new ArrayList<>();
 534
 535   private List<Integer> newvalues = new ArrayList<>();
 536
 537   public MockPropChangeListener(ViewportRanges vr)
 538   {
 539     vr.addPropertyChangeListener(this);
 540   }
 541
 542   @Override
 543   public void propertyChange(PropertyChangeEvent evt)
 544   {
 545     firecount++;
 546     events.add(evt.getPropertyName());
 547     newvalues.add((Integer) evt.getNewValue());
 548   }
 549
 550   public boolean verify(int count, List<String> eventslist,
 551           List<Integer> valueslist)
 552   {
 553     return (count == firecount) && events.equals(eventslist)
 554             && newvalues.equals(valueslist);
 555   }
 556
 557   public boolean verify(int count, List<String> eventslist)
 558   {
 559     return (count == firecount) && events.equals(eventslist);
 560   }
 561
 562   public void reset()
 563   {
 564     firecount = 0;
 565     events.clear();
 566     newvalues.clear();
 567   }
 568 }