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     vr.setStartEndSeq(2, 15);
 345     assertTrue(l.verify(1, Arrays.asList("startseq")));
 346     l.reset();
 347
 348     vr.setStartEndSeq(2, 15);
 349     assertTrue(l.verify(0, emptylist));
 350     l.reset();
 351
 352     // test viewport height and width setting triggers event
 353     vr.setViewportHeight(10);
 354     assertTrue(l.verify(1, Arrays.asList("endseq")));
 355     l.reset();
 356
 357     vr.setViewportWidth(18);
 358     assertTrue(l.verify(1, Arrays.asList("endres")));
 359     l.reset();
 360
 361     // already has seq start set to 2, so triggers endseq
 362     vr.setViewportStartAndHeight(2, 16);
 363     assertTrue(l.verify(1, Arrays.asList("endseq")));
 364     l.reset();
 365
 366     vr.setViewportStartAndWidth(1, 14);
 367     assertTrue(l.verify(1, Arrays.asList("startres")));
 368     l.reset();
 369
 370     // test page up/down triggers event
 371     vr.pageUp();
 372     assertTrue(l.verify(1, Arrays.asList("startseq")));
 373     l.reset();
 374
 375     vr.pageDown();
 376     assertTrue(l.verify(1, Arrays.asList("startseq")));
 377     l.reset();
 378
 379     // test scrolling triggers event
 380     vr.scrollUp(true);
 381     assertTrue(l.verify(1, Arrays.asList("startseq")));
 382     l.reset();
 383
 384     vr.scrollUp(false);
 385     assertTrue(l.verify(1, Arrays.asList("startseq")));
 386     l.reset();
 387
 388     vr.scrollRight(true);
 389     assertTrue(l.verify(1, Arrays.asList("startres")));
 390     l.reset();
 391
 392     vr.scrollRight(false);
 393     assertTrue(l.verify(1, Arrays.asList("startres")));
 394     l.reset();
 395
 396     // TODO test scrollToVisibble once hidden columns JAL-2388 merged in
 397     // to avoid somersaults with align viewport
 398     /*vr.scrollToVisible(10, 10);
 399     assertTrue(l.verify(1, Arrays.asList("startres")));
 400     l.reset();*/
 401
 402     vr.scrollToWrappedVisible(5);
 403     assertTrue(l.verify(1, Arrays.asList("startres")));
 404     l.reset();
 405   }
 406 }
 407
 408 // mock listener for property change events
 409 class MockPropChangeListener implements ViewportListenerI
 410 {
 411   private int firecount = 0;
 412
 413   private List<String> events = new ArrayList<String>();
 414
 415   public MockPropChangeListener(ViewportRanges vr)
 416   {
 417     vr.addPropertyChangeListener(this);
 418   }
 419
 420   @Override
 421   public void propertyChange(PropertyChangeEvent evt)
 422   {
 423     firecount++;
 424     events.add(evt.getPropertyName());
 425   }
 426
 427   public boolean verify(int count, List<String> eventslist)
 428   {
 429     return (count == firecount) && events.equals(eventslist);
 430   }
 431
 432   public void reset()
 433   {
 434     firecount = 0;
 435     events.clear();
 436   }
 437 }