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