Clover icon

jalviewX

  1. Project Clover database Wed Oct 31 2018 15:13:58 GMT
  2. Package jalview.viewmodel

File ViewportRangesTest.java

 

Code metrics

10
517
35
2
983
706
41
0.08
14.77
17.5
1.17

Classes

Class Line # Actions
ViewportRangesTest 23 505 35 0
1.0100%
MockPropChangeListener 936 12 6 0
1.0100%
 

Contributing tests

This file is covered by 28 tests. .

Source view

1    package jalview.viewmodel;
2   
3    import static org.testng.Assert.assertEquals;
4    import static org.testng.Assert.assertFalse;
5    import static org.testng.Assert.assertTrue;
6   
7    import jalview.analysis.AlignmentGenerator;
8    import jalview.datamodel.AlignmentI;
9    import jalview.datamodel.ColumnSelection;
10    import jalview.datamodel.HiddenColumns;
11    import jalview.datamodel.HiddenSequences;
12   
13    import java.beans.PropertyChangeEvent;
14    import java.util.ArrayList;
15    import java.util.Arrays;
16    import java.util.Collections;
17    import java.util.List;
18   
19    import org.testng.annotations.BeforeClass;
20    import org.testng.annotations.BeforeMethod;
21    import org.testng.annotations.Test;
22   
 
23    public class ViewportRangesTest {
24   
25    AlignmentGenerator gen = new AlignmentGenerator(false);
26   
27    AlignmentI al = gen.generate(20, 30, 1, 5, 5);
28   
29    AlignmentI smallAl = gen.generate(7, 2, 2, 5, 5);
30   
 
31  1 toggle @BeforeClass(alwaysRun = true)
32    public void setUp()
33    {
34  1 gen = new AlignmentGenerator(false);
35  1 al = gen.generate(20, 30, 1, 5, 5);
36  1 smallAl = gen.generate(7, 2, 2, 5, 5);
37    }
38   
 
39  28 toggle @BeforeMethod(alwaysRun = true)
40    public void cleanUp()
41    {
42  28 ColumnSelection sel = new ColumnSelection();
43  28 al.getHiddenColumns().revealAllHiddenColumns(sel);
44  28 al.getHiddenSequences().showAll(null);
45  28 smallAl.getHiddenColumns().revealAllHiddenColumns(sel);
46  28 smallAl.getHiddenSequences().showAll(null);
47    }
48   
 
49  1 toggle @Test(groups = { "Functional" })
50    public void testViewportRanges()
51    {
52  1 ViewportRanges vr = new ViewportRanges(al);
53   
54  1 assertEquals(vr.getStartRes(),0);
55  1 assertEquals(vr.getEndRes(), al.getWidth()-1);
56  1 assertEquals(vr.getStartSeq(), 0);
57  1 assertEquals(vr.getEndSeq(), al.getHeight() - 1);
58    }
59   
 
60  1 toggle @Test(groups = { "Functional" })
61    public void testGetAbsoluteAlignmentHeight()
62    {
63  1 ViewportRanges vr = new ViewportRanges(al);
64   
65  1 assertEquals(vr.getAbsoluteAlignmentHeight(), al.getHeight());
66   
67  1 al.getHiddenSequences().hideSequence(al.getSequenceAt(3));
68  1 assertEquals(vr.getAbsoluteAlignmentHeight(), al.getHeight() + 1);
69    }
70   
 
71  1 toggle @Test(groups = { "Functional" })
72    public void testGetAbsoluteAlignmentWidth()
73    {
74  1 ViewportRanges vr = new ViewportRanges(al);
75  1 assertEquals(vr.getAbsoluteAlignmentWidth(), al.getWidth());
76    }
77   
 
78  1 toggle @Test(groups = { "Functional" })
79    public void testSetEndSeq()
80    {
81  1 ViewportRanges vr = new ViewportRanges(al);
82  1 vr.setEndSeq(-1);
83  1 assertEquals(vr.getEndSeq(), 0);
84   
85  1 vr.setEndSeq(al.getHeight());
86  1 assertEquals(vr.getEndSeq(), al.getHeight() - 1);
87   
88  1 vr.setEndSeq(al.getHeight() - 1);
89  1 assertEquals(vr.getEndSeq(), al.getHeight() - 1);
90    }
91   
 
92  1 toggle @Test(groups = { "Functional" })
93    public void testSetStartRes()
94    {
95  1 ViewportRanges vr = new ViewportRanges(al);
96  1 vr.setStartRes(-1);
97  1 assertEquals(vr.getStartRes(), 0);
98   
99  1 vr.setStartRes(al.getWidth());
100  1 assertEquals(vr.getStartRes(), al.getWidth() - 1);
101   
102  1 vr.setStartRes(al.getWidth() - 1);
103  1 assertEquals(vr.getStartRes(), al.getWidth() - 1);
104    }
105   
 
106  1 toggle @Test(groups = { "Functional" })
107    public void testSetStartSeq()
108    {
109  1 ViewportRanges vr = new ViewportRanges(al);
110  1 vr.setStartSeq(-1);
111  1 assertEquals(vr.getStartSeq(), 0);
112   
113  1 vr.setStartSeq(al.getHeight() - vr.getViewportHeight() + 1);
114  1 assertEquals(vr.getStartSeq(), al.getHeight() - vr.getViewportHeight());
115   
116  1 vr.setStartSeq(al.getHeight() - vr.getViewportHeight());
117  1 assertEquals(vr.getStartSeq(), al.getHeight() - vr.getViewportHeight());
118    }
119   
 
120  1 toggle @Test(groups = { "Functional" })
121    public void testSetStartEndRes()
122    {
123  1 ViewportRanges vr = new ViewportRanges(al);
124  1 vr.setStartEndRes(-1, -1);
125  1 assertEquals(vr.getStartRes(), 0);
126  1 assertEquals(vr.getEndRes(), 0);
127   
128  1 vr.setStartEndRes(5, 19);
129  1 assertEquals(vr.getStartRes(), 5);
130  1 assertEquals(vr.getEndRes(), 19);
131   
132  1 vr.setStartEndRes(al.getWidth(), al.getWidth());
133  1 assertEquals(vr.getEndRes(), al.getWidth() - 1);
134   
135  1 ViewportRanges vrsmall = new ViewportRanges(smallAl);
136  1 vrsmall.setStartEndRes(al.getWidth(), al.getWidth());
137  1 assertEquals(vrsmall.getEndRes(), 6);
138   
139    // make visible alignment width = 0
140  1 smallAl.getHiddenColumns().hideColumns(0, 6);
141  1 vrsmall.setStartEndRes(0, 4);
142  1 assertEquals(vrsmall.getStartRes(), 0);
143  1 assertEquals(vrsmall.getEndRes(), 0);
144    }
145   
 
146  1 toggle @Test(groups = { "Functional" })
147    public void testSetStartEndSeq()
148    {
149  1 ViewportRanges vr = new ViewportRanges(al);
150  1 vr.setStartEndSeq(-1, -1);
151  1 assertEquals(vr.getStartSeq(), 0);
152  1 assertEquals(vr.getEndSeq(), 0);
153   
154  1 vr.setStartEndSeq(5, 19);
155  1 assertEquals(vr.getStartSeq(), 5);
156  1 assertEquals(vr.getEndSeq(), 19);
157   
158  1 vr.setStartEndSeq(al.getHeight(), al.getHeight());
159  1 assertEquals(vr.getEndSeq(), al.getHeight() - 1);
160   
161    // make visible alignment height = 0
162  1 smallAl.getHiddenSequences().hideSequence(smallAl.getSequenceAt(0));
163  1 smallAl.getHiddenSequences().hideSequence(smallAl.getSequenceAt(0));
164  1 ViewportRanges vrsmall = new ViewportRanges(smallAl);
165  1 vrsmall.setStartEndSeq(0, 3);
166  1 assertEquals(vrsmall.getStartSeq(), 0);
167  1 assertEquals(vrsmall.getEndSeq(), 0);
168    }
169   
 
170  1 toggle @Test(groups = { "Functional" })
171    public void testSetStartResAndSeq()
172    {
173  1 ViewportRanges vr = new ViewportRanges(al);
174  1 vr.setViewportHeight(10);
175  1 vr.setStartResAndSeq(3, 6);
176  1 assertEquals(vr.getStartRes(), 3);
177  1 assertEquals(vr.getStartSeq(), 6);
178  1 assertEquals(vr.getEndRes(), 3 + vr.getViewportWidth() - 1);
179  1 assertEquals(vr.getEndSeq(), 6 + vr.getViewportHeight() - 1);
180   
181  1 vr.setStartResAndSeq(10, 25);
182  1 assertEquals(vr.getStartRes(), 10);
183  1 assertEquals(vr.getStartSeq(), 19);
184  1 assertEquals(vr.getEndRes(), 10 + vr.getViewportWidth() - 1);
185  1 assertEquals(vr.getEndSeq(), 19 + vr.getViewportHeight() - 1);
186    }
187   
 
188  1 toggle @Test(groups = { "Functional" })
189    public void testSetViewportHeight()
190    {
191  1 ViewportRanges vr = new ViewportRanges(al);
192  1 vr.setViewportHeight(13);
193  1 assertEquals(vr.getViewportHeight(), 13);
194    }
195   
 
196  1 toggle @Test(groups = { "Functional" })
197    public void testSetViewportWidth()
198    {
199  1 ViewportRanges vr = new ViewportRanges(al);
200  1 vr.setViewportWidth(13);
201  1 assertEquals(vr.getViewportWidth(), 13);
202    }
203   
 
204  1 toggle @Test(groups = { "Functional" })
205    public void testSetViewportStartAndHeight()
206    {
207  1 ViewportRanges vr = new ViewportRanges(al);
208  1 vr.setViewportStartAndHeight(2, 6);
209  1 assertEquals(vr.getViewportHeight(), 6);
210  1 assertEquals(vr.getStartSeq(), 2);
211   
212    // reset -ve values of start to 0
213  1 vr.setViewportStartAndHeight(-1, 7);
214  1 assertEquals(vr.getViewportHeight(), 7);
215  1 assertEquals(vr.getStartSeq(), 0);
216   
217    // reset out of bounds start values to within bounds
218  1 vr.setViewportStartAndHeight(35, 5);
219  1 assertEquals(vr.getViewportHeight(), 5);
220  1 assertEquals(vr.getStartSeq(), 24);
221    }
222   
 
223  1 toggle @Test(groups = { "Functional" })
224    public void testSetViewportStartAndWidth()
225    {
226  1 ViewportRanges vr = new ViewportRanges(al);
227  1 vr.setViewportStartAndWidth(2, 6);
228  1 assertEquals(vr.getViewportWidth(), 6);
229  1 assertEquals(vr.getStartRes(), 2);
230   
231    // reset -ve values of start to 0
232  1 vr.setViewportStartAndWidth(-1, 7);
233  1 assertEquals(vr.getViewportWidth(), 7);
234  1 assertEquals(vr.getStartRes(), 0);
235   
236    // reset out of bounds start values to within bounds
237  1 vr.setViewportStartAndWidth(35, 5);
238  1 assertEquals(vr.getViewportWidth(), 5);
239  1 assertEquals(vr.getStartRes(), 16);
240   
241    // small alignment doesn't get bounds reset
242  1 ViewportRanges vrsmall = new ViewportRanges(smallAl);
243  1 vrsmall.setViewportStartAndWidth(0, 63);
244  1 assertEquals(vrsmall.getViewportWidth(), 7);
245  1 assertEquals(vrsmall.getStartRes(), 0);
246    }
247   
 
248  1 toggle @Test(groups = { "Functional" })
249    public void testPageUpDown()
250    {
251  1 ViewportRanges vr = new ViewportRanges(al);
252  1 vr.setViewportStartAndHeight(8, 6);
253  1 vr.pageDown();
254  1 assertEquals(vr.getStartSeq(), 13);
255   
256  1 vr.pageUp();
257  1 assertEquals(vr.getStartSeq(), 8);
258   
259  1 vr.pageUp();
260  1 assertEquals(vr.getStartSeq(), 3);
261   
262  1 vr.pageUp();
263    // pageup does not go beyond 0, viewport height stays the same
264  1 assertEquals(vr.getStartSeq(), 0);
265  1 assertEquals(vr.getViewportHeight(), 6);
266   
267  1 vr.pageDown();
268  1 vr.pageDown();
269  1 vr.pageDown();
270  1 vr.pageDown();
271  1 vr.pageDown();
272   
273    // pagedown to bottom does not go beyond end, and height stays same
274  1 assertEquals(vr.getStartSeq(), 24);
275  1 assertEquals(vr.getViewportHeight(), 6);
276    }
277   
 
278  1 toggle @Test(groups = { "Functional" })
279    public void testScrollUp()
280    {
281  1 ViewportRanges vr = new ViewportRanges(al);
282  1 vr.setViewportStartAndHeight(1, 5);
283  1 vr.scrollUp(true);
284  1 assertEquals(vr.getStartSeq(), 0);
285    // can't scroll above top
286  1 vr.scrollUp(true);
287  1 assertEquals(vr.getStartSeq(), 0);
288   
289  1 vr.setViewportStartAndHeight(24, 5);
290  1 vr.scrollUp(false);
291  1 assertEquals(vr.getStartSeq(), 25);
292    // can't scroll beyond bottom
293  1 vr.scrollUp(false);
294  1 assertEquals(vr.getStartSeq(), 25);
295    }
296   
 
297  1 toggle @Test(groups = { "Functional" })
298    public void testScrollUpWithHidden()
299    {
300  1 ViewportRanges vr = new ViewportRanges(al);
301   
302    // hide last sequence
303  1 HiddenSequences hidden = new HiddenSequences(al);
304  1 hidden.hideSequence(al.getSequenceAt(29));
305   
306  1 vr.setViewportStartAndHeight(1, 5);
307  1 vr.scrollUp(true);
308  1 assertEquals(vr.getStartSeq(), 0);
309    // can't scroll above top
310  1 vr.scrollUp(true);
311  1 assertEquals(vr.getStartSeq(), 0);
312   
313  1 vr.setViewportStartAndHeight(23, 5);
314  1 vr.scrollUp(false);
315  1 assertEquals(vr.getStartSeq(), 24);
316    // can't scroll beyond bottom
317  1 vr.scrollUp(false);
318  1 assertEquals(vr.getStartSeq(), 24);
319    }
320   
 
321  1 toggle @Test(groups = { "Functional" })
322    public void testScrollRight()
323    {
324  1 ViewportRanges vr = new ViewportRanges(al);
325  1 vr.setViewportStartAndWidth(1, 5);
326  1 vr.scrollRight(false);
327  1 assertEquals(vr.getStartRes(), 0);
328    // can't scroll left past start
329  1 vr.scrollRight(false);
330  1 assertEquals(vr.getStartRes(), 0);
331   
332  1 vr.setViewportStartAndWidth(15, 5);
333  1 vr.scrollRight(true);
334  1 assertEquals(vr.getStartRes(), 16);
335    // can't scroll right past end
336  1 vr.scrollRight(true);
337  1 assertEquals(vr.getStartRes(), 16);
338    }
339   
 
340  1 toggle @Test(groups = { "Functional" })
341    public void testScrollRightWithHidden()
342    {
343  1 ViewportRanges vr = new ViewportRanges(al);
344   
345    // hide last 2 columns
346  1 HiddenColumns cols = new HiddenColumns();
347  1 cols.hideColumns(19, 20);
348  1 al.setHiddenColumns(cols);
349   
350  1 vr.setViewportStartAndWidth(1, 5);
351  1 vr.scrollRight(false);
352  1 assertEquals(vr.getStartRes(), 0);
353    // can't scroll left past start
354  1 vr.scrollRight(false);
355  1 assertEquals(vr.getStartRes(), 0);
356   
357  1 vr.setViewportStartAndWidth(13, 5);
358  1 vr.scrollRight(true);
359  1 assertEquals(vr.getStartRes(), 14);
360    // can't scroll right past last visible col
361  1 vr.scrollRight(true);
362  1 assertEquals(vr.getStartRes(), 14);
363    }
364   
 
365  1 toggle @Test(groups = { "Functional" })
366    public void testScrollToWrappedVisible()
367    {
368  1 AlignmentI al2 = gen.generate(60, 30, 1, 5, 5);
369   
370  1 ViewportRanges vr = new ViewportRanges(al2);
371   
372    // start with viewport on 5-14
373  1 vr.setViewportStartAndWidth(5, 10);
374  1 assertEquals(vr.getStartRes(), 5);
375  1 assertEquals(vr.getEndRes(), 14);
376   
377    // scroll to 12 - no change
378  1 assertFalse(vr.scrollToWrappedVisible(12));
379  1 assertEquals(vr.getStartRes(), 5);
380   
381    // scroll to 2 - back to 0-9
382  1 assertTrue(vr.scrollToWrappedVisible(2));
383  1 assertEquals(vr.getStartRes(), 0);
384  1 assertEquals(vr.getEndRes(), 9);
385   
386    // scroll to 9 - no change
387  1 assertFalse(vr.scrollToWrappedVisible(9));
388  1 assertEquals(vr.getStartRes(), 0);
389   
390    // scroll to 12 - moves to 10-19
391  1 assertTrue(vr.scrollToWrappedVisible(12));
392  1 assertEquals(vr.getStartRes(), 10);
393  1 assertEquals(vr.getEndRes(), 19);
394   
395  1 vr.setStartRes(13);
396  1 assertEquals(vr.getStartRes(), 13);
397  1 assertEquals(vr.getEndRes(), 22);
398   
399    // scroll to 45 - jumps to 43-52
400  1 assertTrue(vr.scrollToWrappedVisible(45));
401  1 assertEquals(vr.getStartRes(), 43);
402  1 assertEquals(vr.getEndRes(), 52);
403    }
404   
 
405  1 toggle @Test(groups = { "Functional" })
406    public void testScrollToVisible()
407    {
408  1 ViewportRanges vr = new ViewportRanges(al);
409  1 vr.setViewportStartAndWidth(12,5);
410  1 vr.setViewportStartAndHeight(10,6);
411  1 vr.scrollToVisible(13, 14);
412   
413    // no change
414  1 assertEquals(vr.getStartRes(), 12);
415  1 assertEquals(vr.getStartSeq(), 10);
416   
417  1 vr.scrollToVisible(5,6);
418  1 assertEquals(vr.getStartRes(), 5);
419  1 assertEquals(vr.getStartSeq(), 6);
420   
421    // test for hidden columns too
422  1 al.getHiddenColumns().hideColumns(1, 3);
423  1 vr.scrollToVisible(13, 3);
424  1 assertEquals(vr.getStartRes(), 6);
425  1 assertEquals(vr.getStartSeq(), 3);
426   
427  1 vr.scrollToVisible(2, 9);
428  1 assertEquals(vr.getStartRes(), 0);
429  1 assertEquals(vr.getStartSeq(), 4);
430    }
431   
 
432  1 toggle @Test(groups = { "Functional" })
433    public void testEventFiring()
434    {
435  1 ViewportRanges vr = new ViewportRanges(al);
436  1 MockPropChangeListener l = new MockPropChangeListener(vr);
437  1 List<String> emptylist = new ArrayList<>();
438   
439  1 vr.setViewportWidth(5);
440  1 vr.setViewportHeight(5);
441  1 l.reset();
442   
443    // one event fired when startRes is called with new value
444  1 vr.setStartRes(4);
445  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTRES)));
446  1 l.reset();
447   
448    // no event fired for same value
449  1 vr.setStartRes(4);
450  1 assertTrue(l.verify(0, emptylist));
451  1 l.reset();
452   
453  1 vr.setStartSeq(4);
454  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTSEQ)));
455  1 l.reset();
456   
457  1 vr.setStartSeq(4);
458  1 assertTrue(l.verify(0, emptylist));
459  1 l.reset();
460   
461  1 vr.setEndSeq(10);
462  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTSEQ)));
463  1 l.reset();
464   
465  1 vr.setEndSeq(10);
466  1 assertTrue(l.verify(0, emptylist));
467  1 l.reset();
468   
469  1 vr.setStartEndRes(2, 15);
470  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTRES)));
471  1 l.reset();
472   
473  1 vr.setStartEndRes(2, 15);
474  1 assertTrue(l.verify(0, emptylist));
475  1 l.reset();
476   
477    // check new value fired by event is corrected startres
478  1 vr.setStartEndRes(-1, 5);
479  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTRES),
480    Arrays.asList(0)));
481  1 l.reset();
482   
483    // check new value fired by event is corrected endres
484  1 vr.setStartEndRes(0, -1);
485  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.ENDRES),
486    Arrays.asList(0)));
487  1 l.reset();
488   
489  1 vr.setStartEndSeq(2, 15);
490  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTSEQ)));
491  1 l.reset();
492   
493  1 vr.setStartEndSeq(2, 15);
494  1 assertTrue(l.verify(0, emptylist));
495  1 l.reset();
496   
497  1 vr.setStartEndRes(2, 2); // so seq and res values should be different, in
498    // case of transposing in code
499  1 l.reset();
500   
501    // check new value fired by event is corrected startseq
502  1 vr.setStartEndSeq(-1, 5);
503  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTSEQ),
504    Arrays.asList(0)));
505  1 l.reset();
506   
507    // check new value fired by event is corrected endseq
508  1 vr.setStartEndSeq(0, -1);
509  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.ENDSEQ),
510    Arrays.asList(0)));
511  1 l.reset();
512   
513    // reset for later tests
514  1 vr.setStartEndSeq(2, 15);
515  1 l.reset();
516   
517    // test viewport height and width setting triggers event
518  1 vr.setViewportHeight(10);
519  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.ENDSEQ)));
520  1 l.reset();
521   
522  1 vr.setViewportWidth(18);
523  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.ENDRES)));
524  1 l.reset();
525   
526    // already has seq start set to 2, so triggers endseq
527  1 vr.setViewportStartAndHeight(2, 16);
528  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.ENDSEQ)));
529  1 l.reset();
530   
531  1 vr.setViewportStartAndWidth(1, 14);
532  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTRES)));
533  1 l.reset();
534   
535    // test page up/down triggers event
536  1 vr.pageUp();
537  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTSEQ)));
538  1 l.reset();
539   
540  1 vr.pageDown();
541  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTSEQ)));
542  1 l.reset();
543   
544    // test scrolling triggers event
545  1 vr.scrollUp(true);
546  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTSEQ)));
547  1 l.reset();
548   
549  1 vr.scrollUp(false);
550  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTSEQ)));
551  1 l.reset();
552   
553  1 vr.scrollRight(true);
554  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTRES)));
555  1 l.reset();
556   
557  1 vr.scrollRight(false);
558  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTRES)));
559  1 l.reset();
560   
561  1 vr.scrollToVisible(10, 10);
562  1 assertTrue(l.verify(4,
563    Arrays.asList(ViewportRanges.STARTSEQ, ViewportRanges.STARTSEQ,
564    ViewportRanges.STARTSEQ, ViewportRanges.STARTSEQ)));
565  1 l.reset();
566   
567    /*
568    * scrollToWrappedVisible does nothing if the target position is
569    * within the current startRes-endRes range
570    */
571  1 assertFalse(vr.scrollToWrappedVisible(5));
572  1 assertTrue(l.verify(0, Collections.<String> emptyList()));
573  1 l.reset();
574   
575  1 vr.scrollToWrappedVisible(25);
576  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTRES)));
577  1 l.reset();
578   
579    // test setStartResAndSeq triggers one event
580  1 vr.setStartResAndSeq(5, 7);
581  1 assertTrue(l.verify(1, Arrays.asList(ViewportRanges.STARTRESANDSEQ),
582    Arrays.asList(5, 7)));
583   
584  1 l.reset();
585    }
586   
 
587  1 toggle @Test(groups = { "Functional" })
588    public void testGetWrappedScrollPosition()
589    {
590  1 AlignmentI al2 = gen.generate(157, 15, 1, 5, 5);
591  1 ViewportRanges vr = new ViewportRanges(al2);
592  1 vr.setStartEndRes(0, 39);
593  1 int width = vr.getViewportWidth(); // 40
594   
595    /*
596    * scroll is 0 at column 0 (only)
597    */
598  1 assertEquals(vr.getWrappedScrollPosition(0), 0);
599   
600    /*
601    * scroll is 1 at columns 1-40
602    */
603  1 int i = 1;
604  1 int j = width;
605  41 for (; i <= j; i++)
606    {
607  40 assertEquals(1, vr.getWrappedScrollPosition(i));
608    }
609   
610    /*
611    * scroll is 2 at columns 41-80, etc
612    */
613  1 j += width;
614  41 for (; i <= j; i++)
615    {
616  40 assertEquals(2, vr.getWrappedScrollPosition(i), "For " + i);
617    }
618    }
619   
 
620  1 toggle @Test(groups = { "Functional" })
621    public void testPageUpDownWrapped()
622    {
623    /*
624    * 15 sequences, 110 residues wide (+gaps)
625    */
626  1 AlignmentI al2 = gen.generate(110, 15, 1, 5, 5);
627   
628  1 ViewportRanges vr = new ViewportRanges(al2);
629  1 vr.setWrappedMode(true);
630   
631    // first row
632  1 vr.setViewportStartAndWidth(0, 40);
633  1 int width = vr.getViewportWidth();
634  1 assertEquals(width, 40);
635  1 assertEquals(vr.getStartRes(), 0);
636  1 assertEquals(vr.getEndRes(), 39);
637  1 assertEquals(vr.getStartSeq(), 0);
638  1 assertEquals(vr.getEndSeq(), 14);
639   
640    // second row
641  1 vr.pageDown();
642  1 assertEquals(vr.getStartRes(), 40);
643  1 assertEquals(vr.getEndRes(), 79);
644  1 assertEquals(vr.getStartSeq(), 0);
645  1 assertEquals(vr.getEndSeq(), 14);
646   
647    // third and last row
648    // note endRes is nominal (>width) to preserve viewport width
649  1 vr.pageDown();
650  1 assertEquals(vr.getStartRes(), 80);
651  1 assertEquals(vr.getEndRes(), 119);
652  1 assertEquals(vr.getStartSeq(), 0);
653  1 assertEquals(vr.getEndSeq(), 14);
654   
655    // another pageDown should do nothing
656  1 vr.pageDown();
657  1 assertEquals(vr.getStartRes(), 80);
658  1 assertEquals(vr.getEndRes(), 119);
659  1 assertEquals(vr.getStartSeq(), 0);
660  1 assertEquals(vr.getEndSeq(), 14);
661   
662    // back to second row
663  1 vr.pageUp();
664  1 assertEquals(vr.getStartRes(), 40);
665  1 assertEquals(vr.getEndRes(), 79);
666  1 assertEquals(vr.getStartSeq(), 0);
667  1 assertEquals(vr.getEndSeq(), 14);
668   
669    // back to first row
670  1 vr.pageUp();
671  1 assertEquals(vr.getStartRes(), 0);
672  1 assertEquals(vr.getEndRes(), 39);
673  1 assertEquals(vr.getStartSeq(), 0);
674  1 assertEquals(vr.getEndSeq(), 14);
675   
676    // another pageUp should do nothing
677  1 vr.pageUp();
678  1 assertEquals(vr.getStartRes(), 0);
679  1 assertEquals(vr.getEndRes(), 39);
680  1 assertEquals(vr.getStartSeq(), 0);
681  1 assertEquals(vr.getEndSeq(), 14);
682   
683    /*
684    * simulate scroll right a few positions
685    */
686  1 vr.setStartRes(5);
687  1 assertEquals(vr.getStartRes(), 5);
688  1 assertEquals(vr.getEndRes(), 5 + width - 1); // 44
689   
690  1 vr.pageDown(); // 5-44 shifts to 45-84
691  1 assertEquals(vr.getStartRes(), 45);
692  1 assertEquals(vr.getEndRes(), 84);
693   
694  1 vr.pageDown(); // 45-84 shifts to 85-124
695  1 assertEquals(vr.getStartRes(), 85);
696  1 assertEquals(vr.getEndRes(), 124);
697   
698  1 vr.pageDown(); // no change - at end already
699  1 assertEquals(vr.getStartRes(), 85);
700  1 assertEquals(vr.getEndRes(), 124);
701   
702  1 vr.pageUp(); // back we go
703  1 assertEquals(vr.getStartRes(), 45);
704  1 assertEquals(vr.getEndRes(), 84);
705   
706  1 vr.pageUp();
707  1 assertEquals(vr.getStartRes(), 5);
708  1 assertEquals(vr.getEndRes(), 44);
709   
710  1 vr.pageUp(); // back to the start
711  1 assertEquals(vr.getStartRes(), 0);
712  1 assertEquals(vr.getEndRes(), 39);
713    }
714   
 
715  1 toggle @Test(groups = { "Functional" })
716    public void testSetStartEndResWrapped()
717    {
718  1 ViewportRanges vr = new ViewportRanges(al);
719  1 vr.setWrappedMode(true);
720  1 vr.setStartEndRes(-1, -1);
721  1 assertEquals(vr.getStartRes(), 0);
722  1 assertEquals(vr.getEndRes(), 0);
723   
724  1 vr.setStartEndRes(5, 19);
725  1 assertEquals(vr.getStartRes(), 5);
726  1 assertEquals(vr.getEndRes(), 19);
727   
728    // bounds are not constrained to alignment width
729    // when in wrapped mode
730  1 vr.setStartEndRes(88, 888);
731  1 assertEquals(vr.getStartRes(), 88);
732  1 assertEquals(vr.getEndRes(), 888);
733   
734  1 ViewportRanges vrsmall = new ViewportRanges(smallAl);
735  1 vrsmall.setWrappedMode(true);
736  1 vrsmall.setStartEndRes(88, 888);
737  1 assertEquals(vrsmall.getStartRes(), 88);
738  1 assertEquals(vrsmall.getEndRes(), 888);
739   
740    // make visible alignment width = 0
741  1 smallAl.getHiddenColumns().hideColumns(0, 6);
742  1 vrsmall.setStartEndRes(0, 4);
743  1 assertEquals(vrsmall.getStartRes(), 0);
744  1 assertEquals(vrsmall.getEndRes(), 4);
745    }
746   
 
747  1 toggle @Test(groups = { "Functional" })
748    public void testSetViewportStartAndWidthWrapped()
749    {
750  1 ViewportRanges vr = new ViewportRanges(al);
751  1 vr.setWrappedMode(true);
752  1 vr.setViewportStartAndWidth(2, 6);
753  1 assertEquals(vr.getViewportWidth(), 6);
754  1 assertEquals(vr.getStartRes(), 2);
755   
756    // reset -ve values of start to 0
757  1 vr.setViewportStartAndWidth(-1, 7);
758  1 assertEquals(vr.getViewportWidth(), 7);
759  1 assertEquals(vr.getStartRes(), 0);
760   
761    // out of bounds values are not forced to within bounds
762  1 vr.setViewportStartAndWidth(35, 5);
763  1 assertEquals(vr.getViewportWidth(), 5);
764  1 assertEquals(vr.getStartRes(), 35);
765   
766    // small alignment doesn't get bounds reset
767  1 ViewportRanges vrsmall = new ViewportRanges(smallAl);
768  1 vrsmall.setViewportStartAndWidth(0, 63);
769  1 assertEquals(vrsmall.getViewportWidth(), 7);
770  1 assertEquals(vrsmall.getStartRes(), 0);
771    }
772   
 
773  1 toggle @Test(groups = { "Functional" })
774    public void testGetWrappedMaxScroll()
775    {
776    // generate an ungapped alignment of width 140
777  1 int alignmentWidth = 140;
778  1 AlignmentI al2 = gen.generate(alignmentWidth, 15, 1, 0, 5);
779  1 ViewportRanges vr = new ViewportRanges(al2);
780  1 vr.setStartEndRes(0, 39);
781  1 int width = vr.getViewportWidth(); // 40
782  1 int partWidth = alignmentWidth % width; // 20
783   
784    /*
785    * there are 3 * 40 remainder 20 residues
786    * number of widths depends on offset (scroll right)
787    * 4 widths (maxScroll = 3) if offset by 0 or more than 19 columns
788    * 5 widths (maxScroll = 4) if 1 <= offset <= 19
789    */
790  141 for (int col = 0; col < alignmentWidth; col++)
791    {
792  140 int offset = col % width;
793  140 if (offset > 0 && offset < partWidth)
794    {
795  76 assertEquals(vr.getWrappedMaxScroll(col), 4, "col " + col);
796    }
797    else
798    {
799  64 assertEquals(vr.getWrappedMaxScroll(col), 3, "col " + col);
800    }
801    }
802    }
803   
 
804  1 toggle @Test(groups = { "Functional" })
805    public void testScrollUp_wrapped()
806    {
807    /*
808    * alignment 30 tall and 45 wide
809    */
810  1 AlignmentI al2 = gen.generate(45, 30, 1, 0, 5);
811   
812    /*
813    * wrapped view, 5 sequences high, start at sequence offset 1
814    */
815  1 ViewportRanges vr = new ViewportRanges(al2);
816  1 vr.setWrappedMode(true);
817  1 vr.setViewportStartAndHeight(1, 5);
818   
819    /*
820    * offset wrapped view to column 3
821    */
822  1 vr.setStartEndRes(3, 22);
823   
824  1 int startRes = vr.getStartRes();
825  1 int width = vr.getViewportWidth();
826  1 assertEquals(startRes, 3);
827  1 assertEquals(width, 20);
828   
829    // in wrapped mode, we change startRes but not startSeq
830    // scroll down:
831  1 vr.scrollUp(false);
832  1 assertEquals(vr.getStartSeq(), 1);
833  1 assertEquals(vr.getStartRes(), 23);
834   
835    // scroll up returns to original position
836  1 vr.scrollUp(true);
837  1 assertEquals(vr.getStartSeq(), 1);
838  1 assertEquals(vr.getStartRes(), 3);
839   
840    // scroll up again returns to 'origin'
841  1 vr.scrollUp(true);
842  1 assertEquals(vr.getStartSeq(), 1);
843  1 assertEquals(vr.getStartRes(), 0);
844   
845    /*
846    * offset 3 columns once more and do some scroll downs
847    */
848  1 vr.setStartEndRes(3, 22);
849  1 vr.scrollUp(false);
850  1 assertEquals(vr.getStartSeq(), 1);
851  1 assertEquals(vr.getStartRes(), 23);
852  1 vr.scrollUp(false);
853  1 assertEquals(vr.getStartSeq(), 1);
854  1 assertEquals(vr.getStartRes(), 43);
855   
856    /*
857    * scroll down beyond end of alignment does nothing
858    */
859  1 vr.scrollUp(false);
860  1 assertEquals(vr.getStartSeq(), 1);
861  1 assertEquals(vr.getStartRes(), 43);
862    }
863   
 
864  1 toggle @Test(groups = { "Functional" })
865    public void testSetViewportLocation()
866    {
867  1 AlignmentI al2 = gen.generate(60, 80, 1, 0, 0);
868   
869  1 ViewportRanges vr = new ViewportRanges(al2);
870   
871    // start with viewport on 5-14
872  1 vr.setViewportStartAndWidth(5, 10);
873  1 assertEquals(vr.getStartRes(), 5);
874  1 assertEquals(vr.getEndRes(), 14);
875   
876  1 vr.setViewportStartAndHeight(3, 13);
877  1 assertEquals(vr.getStartSeq(), 3);
878  1 assertEquals(vr.getEndSeq(), 15);
879   
880    // set location to (8,5) - no change
881  1 vr.setViewportLocation(8, 5);
882  1 assertEquals(vr.getStartRes(), 5);
883  1 assertEquals(vr.getEndRes(), 14);
884  1 assertEquals(vr.getStartSeq(), 3);
885  1 assertEquals(vr.getEndSeq(), 15);
886   
887    // set location to (40,50) - change to top left (40,50)
888  1 vr.setViewportLocation(40, 50);
889  1 assertEquals(vr.getStartRes(), 40);
890  1 assertEquals(vr.getEndRes(), 49);
891  1 assertEquals(vr.getStartSeq(), 50);
892  1 assertEquals(vr.getEndSeq(), 62);
893   
894    // set location past end of alignment - resets to leftmost pos
895  1 vr.setViewportLocation(63, 85);
896  1 assertEquals(vr.getStartRes(), 50);
897  1 assertEquals(vr.getEndRes(), 59);
898  1 assertEquals(vr.getStartSeq(), 67);
899  1 assertEquals(vr.getEndSeq(), 79);
900   
901    // hide some columns
902  1 al2.getHiddenColumns().hideColumns(20, 50);
903  1 vr.setViewportLocation(55, 4);
904  1 assertEquals(vr.getStartRes(), 19);
905  1 assertEquals(vr.getEndRes(), 28);
906  1 assertEquals(vr.getStartSeq(), 4);
907  1 assertEquals(vr.getEndSeq(), 16);
908   
909    // hide some sequences
910  1 al2.getHiddenSequences().hideSequence(al2.getSequenceAt(3));
911  1 al2.getHiddenSequences().hideSequence(al2.getSequenceAt(4));
912  1 vr.setViewportLocation(17, 5);
913  1 assertEquals(vr.getStartRes(), 17);
914  1 assertEquals(vr.getEndRes(), 26);
915  1 assertEquals(vr.getStartSeq(), 3);
916  1 assertEquals(vr.getEndSeq(), 15);
917   
918    // set wrapped mode
919  1 vr.setWrappedMode(true);
920  1 vr.setViewportLocation(1, 8);
921  1 assertEquals(vr.getStartRes(), 0);
922  1 assertEquals(vr.getEndRes(), 9);
923  1 assertEquals(vr.getStartSeq(), 3);
924  1 assertEquals(vr.getEndSeq(), 15);
925   
926    // try further down the alignment
927  1 vr.setViewportLocation(57, 5);
928  1 assertEquals(vr.getStartRes(), 20);
929  1 assertEquals(vr.getEndRes(), 29);
930  1 assertEquals(vr.getStartSeq(), 3);
931  1 assertEquals(vr.getEndSeq(), 15);
932    }
933    }
934   
935    // mock listener for property change events
 
936    class MockPropChangeListener implements ViewportListenerI
937    {
938    private int firecount = 0;
939   
940    private List<String> events = new ArrayList<>();
941   
942    private List<Integer> newvalues = new ArrayList<>();
943   
 
944  1 toggle public MockPropChangeListener(ViewportRanges vr)
945    {
946  1 vr.addPropertyChangeListener(this);
947    }
948   
 
949  29 toggle @Override
950    public void propertyChange(PropertyChangeEvent evt)
951    {
952  29 firecount++;
953  29 events.add(evt.getPropertyName());
954  29 if (evt.getPropertyName().equals(ViewportRanges.STARTRESANDSEQ))
955    {
956  1 newvalues.add(((int[]) evt.getNewValue())[0]);
957  1 newvalues.add(((int[]) evt.getNewValue())[1]);
958    }
959    else
960    {
961  28 newvalues.add((Integer) evt.getNewValue());
962    }
963    }
964   
 
965  5 toggle public boolean verify(int count, List<String> eventslist,
966    List<Integer> valueslist)
967    {
968  5 return (count == firecount) && events.equals(eventslist)
969    && newvalues.equals(valueslist);
970    }
971   
 
972  23 toggle public boolean verify(int count, List<String> eventslist)
973    {
974  23 return (count == firecount) && events.equals(eventslist);
975    }
976   
 
977  31 toggle public void reset()
978    {
979  31 firecount = 0;
980  31 events.clear();
981  31 newvalues.clear();
982    }
983    }