1 package jalview.viewmodel;
3 import static org.testng.Assert.assertEquals;
4 import static org.testng.Assert.assertFalse;
5 import static org.testng.Assert.assertTrue;
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;
13 import java.beans.PropertyChangeEvent;
14 import java.util.ArrayList;
15 import java.util.Arrays;
16 import java.util.List;
18 import org.testng.annotations.BeforeClass;
19 import org.testng.annotations.BeforeMethod;
20 import org.testng.annotations.Test;
22 public class ViewportRangesTest {
24 AlignmentGenerator gen = new AlignmentGenerator(false);
26 AlignmentI al = gen.generate(20, 30, 1, 5, 5);
28 AlignmentI smallAl = gen.generate(7, 2, 2, 5, 5);
30 @BeforeClass(alwaysRun = true)
33 gen = new AlignmentGenerator(false);
34 al = gen.generate(20, 30, 1, 5, 5);
35 smallAl = gen.generate(7, 2, 2, 5, 5);
38 @BeforeMethod(alwaysRun = true)
41 ColumnSelection sel = new ColumnSelection();
42 al.getHiddenColumns().revealAllHiddenColumns(sel);
43 al.getHiddenSequences().showAll(null);
44 smallAl.getHiddenColumns().revealAllHiddenColumns(sel);
45 smallAl.getHiddenSequences().showAll(null);
48 @Test(groups = { "Functional" })
49 public void testViewportRanges()
51 ViewportRanges vr = new ViewportRanges(al);
53 assertEquals(vr.getStartRes(),0);
54 assertEquals(vr.getEndRes(), al.getWidth()-1);
55 assertEquals(vr.getStartSeq(), 0);
56 assertEquals(vr.getEndSeq(), al.getHeight() - 1);
59 @Test(groups = { "Functional" })
60 public void testGetAbsoluteAlignmentHeight()
62 ViewportRanges vr = new ViewportRanges(al);
64 assertEquals(vr.getAbsoluteAlignmentHeight(), al.getHeight());
66 al.getHiddenSequences().hideSequence(al.getSequenceAt(3));
67 assertEquals(vr.getAbsoluteAlignmentHeight(), al.getHeight() + 1);
70 @Test(groups = { "Functional" })
71 public void testGetAbsoluteAlignmentWidth()
73 ViewportRanges vr = new ViewportRanges(al);
74 assertEquals(vr.getAbsoluteAlignmentWidth(), al.getWidth());
77 @Test(groups = { "Functional" })
78 public void testSetEndSeq()
80 ViewportRanges vr = new ViewportRanges(al);
82 assertEquals(vr.getEndSeq(), 0);
84 vr.setEndSeq(al.getHeight());
85 assertEquals(vr.getEndSeq(), al.getHeight() - 1);
87 // vr.setEndRes(al.getHeight() - 1);
88 vr.setEndSeq(al.getHeight() - 1);
89 assertEquals(vr.getEndSeq(), al.getHeight() - 1);
92 @Test(groups = { "Functional" })
93 public void testSetStartRes()
95 ViewportRanges vr = new ViewportRanges(al);
97 assertEquals(vr.getStartRes(), 0);
99 vr.setStartRes(al.getWidth());
100 assertEquals(vr.getStartRes(), al.getWidth() - 1);
102 vr.setStartRes(al.getWidth() - 1);
103 assertEquals(vr.getStartRes(), al.getWidth() - 1);
106 @Test(groups = { "Functional" })
107 public void testSetStartSeq()
109 ViewportRanges vr = new ViewportRanges(al);
111 assertEquals(vr.getStartSeq(), 0);
113 vr.setStartSeq(al.getHeight() - vr.getViewportHeight() + 1);
114 assertEquals(vr.getStartSeq(), al.getHeight() - vr.getViewportHeight());
116 vr.setStartSeq(al.getHeight() - vr.getViewportHeight());
117 assertEquals(vr.getStartSeq(), al.getHeight() - vr.getViewportHeight());
120 @Test(groups = { "Functional" })
121 public void testSetStartEndRes()
123 ViewportRanges vr = new ViewportRanges(al);
124 vr.setStartEndRes(-1, -1);
125 assertEquals(vr.getStartRes(), 0);
126 assertEquals(vr.getEndRes(), 0);
128 vr.setStartEndRes(5, 19);
129 assertEquals(vr.getStartRes(), 5);
130 assertEquals(vr.getEndRes(), 19);
132 vr.setStartEndRes(al.getWidth(), al.getWidth());
133 assertEquals(vr.getEndRes(), al.getWidth() - 1);
135 ViewportRanges vrsmall = new ViewportRanges(smallAl);
136 vrsmall.setStartEndRes(al.getWidth(), al.getWidth());
137 assertEquals(vrsmall.getEndRes(), 6);
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);
146 @Test(groups = { "Functional" })
147 public void testSetStartEndSeq()
149 ViewportRanges vr = new ViewportRanges(al);
150 vr.setStartEndSeq(-1, -1);
151 assertEquals(vr.getStartSeq(), 0);
152 assertEquals(vr.getEndSeq(), 0);
154 vr.setStartEndSeq(5, 19);
155 assertEquals(vr.getStartSeq(), 5);
156 assertEquals(vr.getEndSeq(), 19);
158 vr.setStartEndSeq(al.getHeight(), al.getHeight());
159 assertEquals(vr.getEndSeq(), al.getHeight() - 1);
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);
170 @Test(groups = { "Functional" })
171 public void testSetViewportHeight()
173 ViewportRanges vr = new ViewportRanges(al);
174 vr.setViewportHeight(13);
175 assertEquals(vr.getViewportHeight(), 13);
178 @Test(groups = { "Functional" })
179 public void testSetViewportWidth()
181 ViewportRanges vr = new ViewportRanges(al);
182 vr.setViewportWidth(13);
183 assertEquals(vr.getViewportWidth(), 13);
186 @Test(groups = { "Functional" })
187 public void testSetViewportStartAndHeight()
189 ViewportRanges vr = new ViewportRanges(al);
190 vr.setViewportStartAndHeight(2, 6);
191 assertEquals(vr.getViewportHeight(), 6);
192 assertEquals(vr.getStartSeq(), 2);
194 // reset -ve values of start to 0
195 vr.setViewportStartAndHeight(-1, 7);
196 assertEquals(vr.getViewportHeight(), 7);
197 assertEquals(vr.getStartSeq(), 0);
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);
205 @Test(groups = { "Functional" })
206 public void testSetViewportStartAndWidth()
208 ViewportRanges vr = new ViewportRanges(al);
209 vr.setViewportStartAndWidth(2, 6);
210 assertEquals(vr.getViewportWidth(), 6);
211 assertEquals(vr.getStartRes(), 2);
213 // reset -ve values of start to 0
214 vr.setViewportStartAndWidth(-1, 7);
215 assertEquals(vr.getViewportWidth(), 7);
216 assertEquals(vr.getStartRes(), 0);
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);
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);
230 @Test(groups = { "Functional" })
231 public void testPageUpDown()
233 ViewportRanges vr = new ViewportRanges(al);
234 vr.setViewportStartAndHeight(8, 6);
236 assertEquals(vr.getStartSeq(), 13);
239 assertEquals(vr.getStartSeq(), 8);
242 assertEquals(vr.getStartSeq(), 3);
245 // pageup does not go beyond 0, viewport height stays the same
246 assertEquals(vr.getStartSeq(), 0);
247 assertEquals(vr.getViewportHeight(), 6);
255 // pagedown to bottom does not go beyond end, and height stays same
256 assertEquals(vr.getStartSeq(), 24);
257 assertEquals(vr.getViewportHeight(), 6);
260 @Test(groups = { "Functional" })
261 public void testScrollUp()
263 ViewportRanges vr = new ViewportRanges(al);
264 vr.setViewportStartAndHeight(1, 5);
266 assertEquals(vr.getStartSeq(), 0);
267 // can't scroll above top
269 assertEquals(vr.getStartSeq(), 0);
271 vr.setViewportStartAndHeight(24, 5);
273 assertEquals(vr.getStartSeq(), 25);
274 // can't scroll beyond bottom
276 assertEquals(vr.getStartSeq(), 25);
279 @Test(groups = { "Functional" })
280 public void testScrollUpWithHidden()
282 ViewportRanges vr = new ViewportRanges(al);
284 // hide last sequence
285 HiddenSequences hidden = new HiddenSequences(al);
286 hidden.hideSequence(al.getSequenceAt(29));
288 vr.setViewportStartAndHeight(1, 5);
290 assertEquals(vr.getStartSeq(), 0);
291 // can't scroll above top
293 assertEquals(vr.getStartSeq(), 0);
295 vr.setViewportStartAndHeight(23, 5);
297 assertEquals(vr.getStartSeq(), 24);
298 // can't scroll beyond bottom
300 assertEquals(vr.getStartSeq(), 24);
303 @Test(groups = { "Functional" })
304 public void testScrollRight()
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);
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);
322 @Test(groups = { "Functional" })
323 public void testScrollRightWithHidden()
325 ViewportRanges vr = new ViewportRanges(al);
327 // hide last 2 columns
328 HiddenColumns cols = new HiddenColumns();
329 cols.hideColumns(19, 20);
330 al.setHiddenColumns(cols);
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);
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);
347 @Test(groups = { "Functional" })
348 public void testScrollToWrappedVisible()
350 AlignmentI al2 = gen.generate(60, 30, 1, 5, 5);
352 ViewportRanges vr = new ViewportRanges(al2);
354 // start with viewport on 5-14
355 vr.setViewportStartAndWidth(5, 10);
356 assertEquals(vr.getStartRes(), 5);
357 assertEquals(vr.getEndRes(), 14);
359 // scroll to 12 - no change
360 assertFalse(vr.scrollToWrappedVisible(12));
361 assertEquals(vr.getStartRes(), 5);
363 // scroll to 2 - back to 0-9
364 assertTrue(vr.scrollToWrappedVisible(2));
365 assertEquals(vr.getStartRes(), 0);
366 assertEquals(vr.getEndRes(), 9);
368 // scroll to 9 - no change
369 assertFalse(vr.scrollToWrappedVisible(9));
370 assertEquals(vr.getStartRes(), 0);
372 // scroll to 12 - moves to 10-19
373 assertTrue(vr.scrollToWrappedVisible(12));
374 assertEquals(vr.getStartRes(), 10);
375 assertEquals(vr.getEndRes(), 19);
378 assertEquals(vr.getStartRes(), 13);
379 assertEquals(vr.getEndRes(), 22);
381 // scroll to 45 - jumps to 43-52
382 assertTrue(vr.scrollToWrappedVisible(45));
383 assertEquals(vr.getStartRes(), 43);
384 assertEquals(vr.getEndRes(), 52);
387 // leave until JAL-2388 is merged and we can do without viewport
388 /*@Test(groups = { "Functional" })
389 public void testScrollToVisible()
391 ViewportRanges vr = new ViewportRanges(al);
392 vr.setViewportStartAndWidth(12,5);
393 vr.setViewportStartAndHeight(10,6);
394 vr.scrollToVisible(13,14)
397 assertEquals(vr.getStartRes(), 12);
398 assertEquals(vr.getStartSeq(), 10);
400 vr.scrollToVisible(5,6);
401 assertEquals(vr.getStartRes(), 5);
402 assertEquals(vr.getStartSeq(), 6);
404 // test for hidden columns too
407 @Test(groups = { "Functional" })
408 public void testEventFiring()
410 ViewportRanges vr = new ViewportRanges(al);
411 MockPropChangeListener l = new MockPropChangeListener(vr);
412 List<String> emptylist = new ArrayList<>();
414 vr.setViewportWidth(5);
415 vr.setViewportHeight(5);
418 // one event fired when startRes is called with new value
420 assertTrue(l.verify(1, Arrays.asList("startres")));
423 // no event fired for same value
425 assertTrue(l.verify(0, emptylist));
429 assertTrue(l.verify(1, Arrays.asList("startseq")));
433 assertTrue(l.verify(0, emptylist));
437 assertTrue(l.verify(1, Arrays.asList("startseq")));
441 assertTrue(l.verify(0, emptylist));
444 vr.setStartEndRes(2, 15);
445 assertTrue(l.verify(1, Arrays.asList("startres")));
448 vr.setStartEndRes(2, 15);
449 assertTrue(l.verify(0, emptylist));
452 // check new value fired by event is corrected startres
453 vr.setStartEndRes(-1, 5);
454 assertTrue(l.verify(1, Arrays.asList("startres"), Arrays.asList(0)));
457 // check new value fired by event is corrected endres
458 vr.setStartEndRes(0, -1);
459 assertTrue(l.verify(1, Arrays.asList("endres"), Arrays.asList(0)));
462 vr.setStartEndSeq(2, 15);
463 assertTrue(l.verify(1, Arrays.asList("startseq")));
466 vr.setStartEndSeq(2, 15);
467 assertTrue(l.verify(0, emptylist));
470 vr.setStartEndRes(2, 2); // so seq and res values should be different, in
471 // case of transposing in code
474 // check new value fired by event is corrected startseq
475 vr.setStartEndSeq(-1, 5);
476 assertTrue(l.verify(1, Arrays.asList("startseq"), Arrays.asList(0)));
479 // check new value fired by event is corrected endseq
480 vr.setStartEndSeq(0, -1);
481 assertTrue(l.verify(1, Arrays.asList("endseq"), Arrays.asList(0)));
484 // reset for later tests
485 vr.setStartEndSeq(2, 15);
488 // test viewport height and width setting triggers event
489 vr.setViewportHeight(10);
490 assertTrue(l.verify(1, Arrays.asList("endseq")));
493 vr.setViewportWidth(18);
494 assertTrue(l.verify(1, Arrays.asList("endres")));
497 // already has seq start set to 2, so triggers endseq
498 vr.setViewportStartAndHeight(2, 16);
499 assertTrue(l.verify(1, Arrays.asList("endseq")));
502 vr.setViewportStartAndWidth(1, 14);
503 assertTrue(l.verify(1, Arrays.asList("startres")));
506 // test page up/down triggers event
508 assertTrue(l.verify(1, Arrays.asList("startseq")));
512 assertTrue(l.verify(1, Arrays.asList("startseq")));
515 // test scrolling triggers event
517 assertTrue(l.verify(1, Arrays.asList("startseq")));
521 assertTrue(l.verify(1, Arrays.asList("startseq")));
524 vr.scrollRight(true);
525 assertTrue(l.verify(1, Arrays.asList("startres")));
528 vr.scrollRight(false);
529 assertTrue(l.verify(1, Arrays.asList("startres")));
532 vr.scrollToVisible(10, 10);
533 assertTrue(l.verify(4,
534 Arrays.asList("startseq", "startseq", "startseq", "startseq")));
537 vr.scrollToWrappedVisible(5);
538 assertTrue(l.verify(1, Arrays.asList("startres")));
542 @Test(groups = { "Functional" })
543 public void testGetWrappedScrollPosition()
545 AlignmentI al2 = gen.generate(157, 15, 1, 5, 5);
546 ViewportRanges vr = new ViewportRanges(al2);
547 vr.setStartEndRes(0, 39);
548 int width = vr.getViewportWidth(); // 40
551 * scroll is 0 at column 0 (only)
553 assertEquals(vr.getWrappedScrollPosition(0), 0);
556 * scroll is 1 at columns 1-40
562 assertEquals(1, vr.getWrappedScrollPosition(i));
566 * scroll is 2 at columns 41-80, etc
571 assertEquals(2, vr.getWrappedScrollPosition(i), "For " + i);
575 @Test(groups = { "Functional" })
576 public void testPageUpDownWrapped()
579 * 15 sequences, 110 residues wide (+gaps)
581 AlignmentI al2 = gen.generate(110, 15, 1, 5, 5);
583 ViewportRanges vr = new ViewportRanges(al2);
584 vr.setWrappedMode(true);
587 vr.setViewportStartAndWidth(0, 40);
588 int width = vr.getViewportWidth();
589 assertEquals(width, 40);
590 assertEquals(vr.getStartRes(), 0);
591 assertEquals(vr.getEndRes(), 39);
592 assertEquals(vr.getStartSeq(), 0);
593 assertEquals(vr.getEndSeq(), 14);
597 assertEquals(vr.getStartRes(), 40);
598 assertEquals(vr.getEndRes(), 79);
599 assertEquals(vr.getStartSeq(), 0);
600 assertEquals(vr.getEndSeq(), 14);
602 // third and last row
603 // note endRes is nominal (>width) to preserve viewport width
605 assertEquals(vr.getStartRes(), 80);
606 assertEquals(vr.getEndRes(), 119);
607 assertEquals(vr.getStartSeq(), 0);
608 assertEquals(vr.getEndSeq(), 14);
610 // another pageDown should do nothing
612 assertEquals(vr.getStartRes(), 80);
613 assertEquals(vr.getEndRes(), 119);
614 assertEquals(vr.getStartSeq(), 0);
615 assertEquals(vr.getEndSeq(), 14);
617 // back to second row
619 assertEquals(vr.getStartRes(), 40);
620 assertEquals(vr.getEndRes(), 79);
621 assertEquals(vr.getStartSeq(), 0);
622 assertEquals(vr.getEndSeq(), 14);
626 assertEquals(vr.getStartRes(), 0);
627 assertEquals(vr.getEndRes(), 39);
628 assertEquals(vr.getStartSeq(), 0);
629 assertEquals(vr.getEndSeq(), 14);
631 // another pageUp should do nothing
633 assertEquals(vr.getStartRes(), 0);
634 assertEquals(vr.getEndRes(), 39);
635 assertEquals(vr.getStartSeq(), 0);
636 assertEquals(vr.getEndSeq(), 14);
639 * simulate scroll right a few positions
642 assertEquals(vr.getStartRes(), 5);
643 assertEquals(vr.getEndRes(), 5 + width - 1); // 44
645 vr.pageDown(); // 5-44 shifts to 45-84
646 assertEquals(vr.getStartRes(), 45);
647 assertEquals(vr.getEndRes(), 84);
649 vr.pageDown(); // 45-84 shifts to 85-124
650 assertEquals(vr.getStartRes(), 85);
651 assertEquals(vr.getEndRes(), 124);
653 vr.pageDown(); // no change - at end already
654 assertEquals(vr.getStartRes(), 85);
655 assertEquals(vr.getEndRes(), 124);
657 vr.pageUp(); // back we go
658 assertEquals(vr.getStartRes(), 45);
659 assertEquals(vr.getEndRes(), 84);
662 assertEquals(vr.getStartRes(), 5);
663 assertEquals(vr.getEndRes(), 44);
665 vr.pageUp(); // back to the start
666 assertEquals(vr.getStartRes(), 0);
667 assertEquals(vr.getEndRes(), 39);
670 @Test(groups = { "Functional" })
671 public void testSetStartEndResWrapped()
673 ViewportRanges vr = new ViewportRanges(al);
674 vr.setWrappedMode(true);
675 vr.setStartEndRes(-1, -1);
676 assertEquals(vr.getStartRes(), 0);
677 assertEquals(vr.getEndRes(), 0);
679 vr.setStartEndRes(5, 19);
680 assertEquals(vr.getStartRes(), 5);
681 assertEquals(vr.getEndRes(), 19);
683 // bounds are not constrained to alignment width
684 // when in wrapped mode
685 vr.setStartEndRes(88, 888);
686 assertEquals(vr.getStartRes(), 88);
687 assertEquals(vr.getEndRes(), 888);
689 ViewportRanges vrsmall = new ViewportRanges(smallAl);
690 vrsmall.setWrappedMode(true);
691 vrsmall.setStartEndRes(88, 888);
692 assertEquals(vrsmall.getStartRes(), 88);
693 assertEquals(vrsmall.getEndRes(), 888);
695 // make visible alignment width = 0
696 smallAl.getHiddenColumns().hideColumns(0, 6);
697 vrsmall.setStartEndRes(0, 4);
698 assertEquals(vrsmall.getStartRes(), 0);
699 assertEquals(vrsmall.getEndRes(), 4);
702 @Test(groups = { "Functional" })
703 public void testSetViewportStartAndWidthWrapped()
705 ViewportRanges vr = new ViewportRanges(al);
706 vr.setWrappedMode(true);
707 vr.setViewportStartAndWidth(2, 6);
708 assertEquals(vr.getViewportWidth(), 6);
709 assertEquals(vr.getStartRes(), 2);
711 // reset -ve values of start to 0
712 vr.setViewportStartAndWidth(-1, 7);
713 assertEquals(vr.getViewportWidth(), 7);
714 assertEquals(vr.getStartRes(), 0);
716 // out of bounds values are not forced to within bounds
717 vr.setViewportStartAndWidth(35, 5);
718 assertEquals(vr.getViewportWidth(), 5);
719 assertEquals(vr.getStartRes(), 35);
721 // small alignment doesn't get bounds reset
722 ViewportRanges vrsmall = new ViewportRanges(smallAl);
723 vrsmall.setViewportStartAndWidth(0, 63);
724 assertEquals(vrsmall.getViewportWidth(), 7);
725 assertEquals(vrsmall.getStartRes(), 0);
728 @Test(groups = { "Functional" })
729 public void testGetWrappedMaxScroll()
731 // generate an ungapped alignment of width 140
732 int alignmentWidth = 140;
733 AlignmentI al2 = gen.generate(alignmentWidth, 15, 1, 0, 5);
734 ViewportRanges vr = new ViewportRanges(al2);
735 vr.setStartEndRes(0, 39);
736 int width = vr.getViewportWidth(); // 40
737 int partWidth = alignmentWidth % width; // 20
740 * there are 3 * 40 remainder 20 residues
741 * number of widths depends on offset (scroll right)
742 * 4 widths (maxScroll = 3) if offset by 0 or more than 19 columns
743 * 5 widths (maxScroll = 4) if 1 <= offset <= 19
745 for (int col = 0; col < alignmentWidth; col++)
747 int offset = col % width;
748 if (offset > 0 && offset < partWidth)
750 assertEquals(vr.getWrappedMaxScroll(col), 4, "col " + col);
754 assertEquals(vr.getWrappedMaxScroll(col), 3, "col " + col);
760 // mock listener for property change events
761 class MockPropChangeListener implements ViewportListenerI
763 private int firecount = 0;
765 private List<String> events = new ArrayList<>();
767 private List<Integer> newvalues = new ArrayList<>();
769 public MockPropChangeListener(ViewportRanges vr)
771 vr.addPropertyChangeListener(this);
775 public void propertyChange(PropertyChangeEvent evt)
778 events.add(evt.getPropertyName());
779 newvalues.add((Integer) evt.getNewValue());
782 public boolean verify(int count, List<String> eventslist,
783 List<Integer> valueslist)
785 return (count == firecount) && events.equals(eventslist)
786 && newvalues.equals(valueslist);
789 public boolean verify(int count, List<String> eventslist)
791 return (count == firecount) && events.equals(eventslist);