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