2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
7 * Jalview is free software: you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation, either version 3
10 * of the License, or (at your option) any later version.
12 * Jalview is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty
14 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19 * The Jalview Authors are detailed in the 'AUTHORS' file.
23 import static org.testng.AssertJUnit.assertEquals;
24 import static org.testng.AssertJUnit.assertFalse;
25 import static org.testng.AssertJUnit.assertTrue;
27 import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
28 import jalview.bin.Cache;
29 import jalview.datamodel.AlignmentAnnotation;
30 import jalview.datamodel.AlignmentI;
31 import jalview.datamodel.Annotation;
32 import jalview.datamodel.SequenceGroup;
33 import jalview.datamodel.SequenceI;
34 import jalview.io.DataSourceType;
35 import jalview.io.FileFormat;
36 import jalview.io.FormatAdapter;
37 import jalview.util.MessageManager;
39 import java.awt.BorderLayout;
40 import java.awt.Checkbox;
41 import java.awt.Component;
42 import java.awt.Container;
43 import java.awt.FlowLayout;
44 import java.awt.event.ItemEvent;
45 import java.io.IOException;
46 import java.util.List;
48 import javax.swing.JButton;
49 import javax.swing.JPanel;
51 import org.testng.annotations.BeforeClass;
52 import org.testng.annotations.BeforeMethod;
53 import org.testng.annotations.Test;
56 * Unit tests for AnnotationChooser
61 public class AnnotationChooserTest
64 @BeforeClass(alwaysRun = true)
65 public void setUpJvOptionPane()
67 JvOptionPane.setInteractiveMode(false);
68 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
71 // 4 sequences x 13 positions
72 final static String TEST_DATA = ">FER_CAPAA Ferredoxin\n"
74 + ">FER_CAPAN Ferredoxin, chloroplast precursor\n"
76 + ">FER1_SOLLC Ferredoxin-1, chloroplast precursor\n"
77 + "TIETHKEEELTA-\n" + ">Q93XJ9_SOLTU Ferredoxin I precursor\n"
80 AnnotationChooser testee;
82 AlignmentPanel parentPanel;
86 @BeforeMethod(alwaysRun = true)
87 public void setUp() throws IOException
89 Cache.loadProperties("test/jalview/io/testProps.jvprops");
90 // pin down annotation sort order for test
91 Cache.applicationProperties.setProperty(Preferences.SORT_ANNOTATIONS,
92 SequenceAnnotationOrder.NONE.name());
93 final String TRUE = Boolean.TRUE.toString();
94 Cache.applicationProperties.setProperty(
95 Preferences.SHOW_AUTOCALC_ABOVE, TRUE);
96 Cache.applicationProperties.setProperty("SHOW_QUALITY", TRUE);
97 Cache.applicationProperties.setProperty("SHOW_CONSERVATION", TRUE);
98 Cache.applicationProperties.setProperty("SHOW_IDENTITY", TRUE);
100 AlignmentI al = new FormatAdapter().readFile(TEST_DATA,
101 DataSourceType.PASTE, FileFormat.Fasta);
102 af = new AlignFrame(al, 700, 500);
103 parentPanel = new AlignmentPanel(af, af.getViewport());
108 * Add 4 annotations, 3 of them sequence-specific.
111 * ann1 - for sequence 0 - label 'IUPRED'
112 * ann2 - not sequence related - label 'Beauty'
113 * ann3 - for sequence 3 - label 'JMol'
114 * ann4 - for sequence 2 - label 'IUPRED'
115 * ann5 - for sequence 1 - label 'JMol'
117 private void addAnnotations()
119 Annotation an = new Annotation(2f);
120 Annotation[] anns = new Annotation[] { an, an, an };
121 AlignmentAnnotation ann0 = new AlignmentAnnotation("IUPRED", "", anns);
122 AlignmentAnnotation ann1 = new AlignmentAnnotation("Beauty", "", anns);
123 AlignmentAnnotation ann2 = new AlignmentAnnotation("JMol", "", anns);
124 AlignmentAnnotation ann3 = new AlignmentAnnotation("IUPRED", "", anns);
125 AlignmentAnnotation ann4 = new AlignmentAnnotation("JMol", "", anns);
126 SequenceI[] seqs = parentPanel.getAlignment().getSequencesArray();
127 ann0.setSequenceRef(seqs[0]);
128 ann2.setSequenceRef(seqs[3]);
129 ann3.setSequenceRef(seqs[2]);
130 ann4.setSequenceRef(seqs[1]);
131 parentPanel.getAlignment().addAnnotation(ann0);
132 parentPanel.getAlignment().addAnnotation(ann1);
133 parentPanel.getAlignment().addAnnotation(ann2);
134 parentPanel.getAlignment().addAnnotation(ann3);
135 parentPanel.getAlignment().addAnnotation(ann4);
139 * Test creation of panel with OK and Cancel buttons
141 @Test(groups = { "Functional" })
142 public void testBuildActionButtonsPanel()
144 testee = new AnnotationChooser(parentPanel);
145 JPanel jp = testee.buildActionButtonsPanel();
146 assertTrue("Wrong layout", jp.getLayout() instanceof FlowLayout);
148 Component[] comps = jp.getComponents();
149 assertEquals("Not 2 action buttons", 2, comps.length);
151 final Component jb1 = comps[0];
152 final Component jb2 = comps[1];
154 assertEquals("Not 'OK' button", MessageManager.getString("action.ok"),
155 ((JButton) jb1).getText());
156 assertEquals("Wrong button font", JvSwingUtils.getLabelFont(),
159 assertEquals("Not 'Cancel' button",
160 MessageManager.getString("action.cancel"),
161 ((JButton) jb2).getText());
162 assertEquals("Wrong button font", JvSwingUtils.getLabelFont(),
167 * Test 'Apply to' has 3 radio buttons enabled, 'Selected Sequences' selected,
168 * when there is a current selection group.
170 @Test(groups = { "Functional" })
171 public void testBuildApplyToOptionsPanel_withSelectionGroup()
173 selectSequences(0, 2, 3);
174 testee = new AnnotationChooser(parentPanel);
176 JPanel jp = testee.buildApplyToOptionsPanel();
177 Component[] comps = jp.getComponents();
178 assertEquals("Not 3 radio buttons", 3, comps.length);
180 final Checkbox cb1 = (Checkbox) comps[0];
181 final Checkbox cb2 = (Checkbox) comps[1];
182 final Checkbox cb3 = (Checkbox) comps[2];
184 assertTrue("Not enabled", cb1.isEnabled());
185 assertTrue("Not enabled", cb2.isEnabled());
186 assertTrue("Not enabled", cb3.isEnabled());
187 assertEquals("Option not selected", cb2, cb2.getCheckboxGroup()
188 .getSelectedCheckbox());
190 // check state variables match checkbox selection
191 assertTrue(testee.isApplyToSelectedSequences());
192 assertFalse(testee.isApplyToUnselectedSequences());
196 * Add a sequence group to the alignment with the specified sequences (base 0)
202 private void selectSequences(int... selected)
204 SequenceI[] seqs = parentPanel.getAlignment().getSequencesArray();
205 SequenceGroup sg = new SequenceGroup();
206 for (int i : selected)
208 sg.addSequence(seqs[i], false);
210 parentPanel.av.setSelectionGroup(sg);
214 * Test 'Apply to' has 1 radio button enabled, 'All Sequences' selected, when
215 * there is no current selection group.
217 @Test(groups = { "Functional" })
218 public void testBuildApplyToOptionsPanel_noSelectionGroup()
220 testee = new AnnotationChooser(parentPanel);
221 JPanel jp = testee.buildApplyToOptionsPanel();
222 verifyApplyToOptionsPanel_noSelectionGroup(jp);
225 protected void verifyApplyToOptionsPanel_noSelectionGroup(JPanel jp)
227 assertTrue("Wrong layout", jp.getLayout() instanceof FlowLayout);
228 Component[] comps = jp.getComponents();
229 assertEquals("Not 3 radio buttons", 3, comps.length);
231 final Checkbox cb1 = (Checkbox) comps[0];
232 final Checkbox cb2 = (Checkbox) comps[1];
233 final Checkbox cb3 = (Checkbox) comps[2];
235 assertTrue("Not enabled", cb1.isEnabled());
236 assertFalse("Enabled", cb2.isEnabled());
237 assertFalse("Enabled", cb3.isEnabled());
238 assertEquals("Not selected", cb1, cb1.getCheckboxGroup()
239 .getSelectedCheckbox());
241 // check state variables match checkbox selection
242 assertTrue(testee.isApplyToSelectedSequences());
243 assertTrue(testee.isApplyToUnselectedSequences());
245 assertEquals("Wrong text",
246 MessageManager.getString("label.all_sequences"), cb1.getLabel());
247 assertEquals("Wrong text",
248 MessageManager.getString("label.selected_sequences"),
250 assertEquals("Wrong text",
251 MessageManager.getString("label.except_selected_sequences"),
256 * Test Show and Hide radio buttons created, with Hide initially selected.
258 @Test(groups = { "Functional" })
259 public void testBuildShowHidePanel()
261 testee = new AnnotationChooser(parentPanel);
262 JPanel jp = testee.buildShowHidePanel();
263 verifyShowHidePanel(jp);
267 protected void verifyShowHidePanel(JPanel jp)
269 assertTrue("Wrong layout", jp.getLayout() instanceof FlowLayout);
270 Component[] comps = jp.getComponents();
271 assertEquals("Not 2 radio buttons", 2, comps.length);
273 final Checkbox cb1 = (Checkbox) comps[0];
274 final Checkbox cb2 = (Checkbox) comps[1];
276 assertTrue("Show not enabled", cb1.isEnabled());
277 assertTrue("Hide not enabled", cb2.isEnabled());
279 // Hide (button 2) selected; note this may change to none (null)
280 assertEquals("Not selected", cb2, cb2.getCheckboxGroup()
281 .getSelectedCheckbox());
283 assertTrue("Show is flagged", !testee.isShowSelected());
285 assertEquals("Wrong text",
286 MessageManager.getString("label.show_selected_annotations"),
288 assertEquals("Wrong text",
289 MessageManager.getString("label.hide_selected_annotations"),
294 * Test construction of panel containing two sub-panels
296 @Test(groups = { "Functional" })
297 public void testBuildShowHideOptionsPanel()
299 testee = new AnnotationChooser(parentPanel);
300 JPanel jp = testee.buildShowHideOptionsPanel();
301 assertTrue("Wrong layout", jp.getLayout() instanceof BorderLayout);
302 Component[] comps = jp.getComponents();
303 assertEquals("Not 2 sub-panels", 2, comps.length);
305 verifyShowHidePanel((JPanel) comps[0]);
306 verifyApplyToOptionsPanel_noSelectionGroup((JPanel) comps[1]);
310 * Test that annotation types are (uniquely) identified.
313 @Test(groups = { "Functional" })
314 public void testGetAnnotationTypes()
317 testee = new AnnotationChooser(parentPanel);
318 // selection group should make no difference to the result
319 // as all annotation types for the alignment are considered
321 List<String> types = AnnotationChooser.getAnnotationTypes(
322 parentPanel.getAlignment(), true);
323 assertEquals("Not two annotation types", 2, types.size());
324 assertTrue("IUPRED missing", types.contains("IUPRED"));
325 assertTrue("JMol missing", types.contains("JMol"));
327 types = AnnotationChooser.getAnnotationTypes(
328 parentPanel.getAlignment(), false);
329 assertEquals("Not six annotation types", 6, types.size());
330 assertTrue("IUPRED missing", types.contains("IUPRED"));
331 assertTrue("JMol missing", types.contains("JMol"));
332 assertTrue("Beauty missing", types.contains("Beauty"));
333 // These are added by viewmodel.AlignViewport.initAutoAnnotation():
334 assertTrue("Consensus missing", types.contains("Consensus"));
335 assertTrue("Quality missing", types.contains("Quality"));
336 assertTrue("Conservation missing", types.contains("Conservation"));
340 * Test result of selecting an annotation type, with 'Hide for all sequences'.
342 * We expect all annotations of that type to be set hidden. Other annotations
343 * should be left visible.
345 @Test(groups = { "Functional" })
346 public void testSelectType_hideForAll()
348 selectSequences(1, 2);
349 testee = new AnnotationChooser(parentPanel);
350 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
351 setSelected(hideCheckbox, true);
353 final Checkbox allSequencesCheckbox = (Checkbox) getComponent(testee,
355 setSelected(allSequencesCheckbox, true);
357 AlignmentAnnotation[] anns = parentPanel.getAlignment()
358 .getAlignmentAnnotation();
360 assertTrue(anns[5].visible); // JMol for seq3
361 assertTrue(anns[7].visible); // JMol for seq1
363 setSelected(getTypeCheckbox("JMol"), true);
364 assertTrue(anns[0].visible); // Conservation
365 assertTrue(anns[1].visible); // Quality
366 assertTrue(anns[2].visible); // Consensus
367 assertTrue(anns[3].visible); // IUPred for seq0
368 assertTrue(anns[4].visible); // Beauty
369 assertFalse(anns[5].visible); // JMol for seq3 - not selected but hidden
370 assertTrue(anns[6].visible); // IUPRED for seq2
371 assertFalse(anns[7].visible); // JMol for seq1 - selected and hidden
375 * Test result of selecting an annotation type, with 'Hide for selected
378 * We expect the annotations of that type, linked to the sequence group, to be
379 * set hidden. Other annotations should be left visible.
381 @Test(groups = { "Functional" })
382 public void testSelectType_hideForSelected()
384 selectSequences(1, 2);
385 testee = new AnnotationChooser(parentPanel);
386 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
387 setSelected(hideCheckbox, true);
390 * Don't set the 'selected sequences' radio button since this would trigger
391 * an update, including unselected sequences / annotation types
393 // setSelected(getSelectedSequencesCheckbox());
395 AlignmentAnnotation[] anns = parentPanel.getAlignment()
396 .getAlignmentAnnotation();
398 assertTrue(anns[7].visible); // JMol for seq1
400 setSelected(getTypeCheckbox("JMol"), true);
401 assertTrue(anns[0].visible); // Conservation
402 assertTrue(anns[1].visible); // Quality
403 assertTrue(anns[2].visible); // Consensus
404 assertTrue(anns[3].visible); // IUPred for seq0
405 assertTrue(anns[4].visible); // Beauty
406 assertTrue(anns[5].visible); // JMol for seq3 not in selection group
407 assertTrue(anns[6].visible); // IUPRED for seq2
408 assertFalse(anns[7].visible); // JMol for seq1 in selection group
412 * Test result of deselecting an annotation type, with 'Hide for all
415 * We expect all annotations of that type to be set visible. Other annotations
416 * should be left unchanged.
418 @Test(groups = { "Functional" })
419 public void testDeselectType_hideForAll()
421 selectSequences(1, 2);
422 testee = new AnnotationChooser(parentPanel);
424 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
425 setSelected(hideCheckbox, true);
427 final Checkbox allSequencesCheckbox = (Checkbox) getComponent(testee,
429 setSelected(allSequencesCheckbox, true);
431 AlignmentAnnotation[] anns = parentPanel.getAlignment()
432 .getAlignmentAnnotation();
434 final Checkbox typeCheckbox = getTypeCheckbox("JMol");
436 // select JMol - all hidden
437 setSelected(typeCheckbox, true);
438 assertFalse(anns[5].visible); // JMol for seq3
439 assertFalse(anns[7].visible); // JMol for seq1
441 // deselect JMol - all unhidden
442 setSelected(typeCheckbox, false);
443 assertTrue(anns[0].visible); // Conservation
444 assertTrue(anns[1].visible); // Quality
445 assertTrue(anns[2].visible); // Consensus
446 assertTrue(anns[3].visible); // IUPred for seq0
447 assertTrue(anns[4].visible); // Beauty
448 assertTrue(anns[5].visible); // JMol for seq3
449 assertTrue(anns[6].visible); // IUPRED for seq2
450 assertTrue(anns[7].visible); // JMol for seq1
454 * Test result of deselecting an annotation type, with 'Hide for selected
457 * We expect the annotations of that type, linked to the sequence group, to be
458 * set visible. Other annotations should be left unchanged.
460 @Test(groups = { "Functional" })
461 public void testDeselectType_hideForSelected()
463 selectSequences(1, 2);
464 testee = new AnnotationChooser(parentPanel);
465 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
466 setSelected(hideCheckbox, true);
469 * Don't set the 'selected sequences' radio button since this would trigger
470 * an update, including unselected sequences / annotation types
472 // setSelected(getSelectedSequencesCheckbox());
474 setSelected(getTypeCheckbox("JMol"), true);
475 setSelected(getTypeCheckbox("JMol"), false);
477 AlignmentAnnotation[] anns = parentPanel.getAlignment()
478 .getAlignmentAnnotation();
479 assertTrue(anns[0].visible); // Conservation
480 assertTrue(anns[1].visible); // Quality
481 assertTrue(anns[2].visible); // Consensus
482 assertTrue(anns[3].visible); // IUPred for seq0
483 assertTrue(anns[4].visible); // Beauty
484 assertTrue(anns[5].visible); // JMol for seq3 not in selection group
485 assertTrue(anns[6].visible); // IUPRED for seq2
486 assertTrue(anns[7].visible); // JMol for seq1 in selection group
490 * Test result of selecting an annotation type, with 'Show for all sequences'.
492 * We expect all annotations of that type to be set visible. Other annotations
493 * should be left unchanged
495 @Test(groups = { "Functional" })
496 public void testSelectType_showForAll()
498 selectSequences(1, 2);
499 testee = new AnnotationChooser(parentPanel);
500 final Checkbox showCheckbox = (Checkbox) getComponent(testee, 1, 0, 0);
501 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
503 final Checkbox allSequencesCheckbox = (Checkbox) getComponent(testee,
506 AlignmentAnnotation[] anns = parentPanel.getAlignment()
507 .getAlignmentAnnotation();
509 // hide all JMol annotations
510 setSelected(allSequencesCheckbox, true);
511 setSelected(hideCheckbox, true);
512 setSelected(getTypeCheckbox("JMol"), true);
513 assertFalse(anns[5].visible); // JMol for seq3
514 assertFalse(anns[7].visible); // JMol for seq1
515 // ...now show them...
516 setSelected(showCheckbox, true);
517 assertTrue(anns[0].visible); // Conservation
518 assertTrue(anns[1].visible); // Quality
519 assertTrue(anns[2].visible); // Consensus
520 assertTrue(anns[3].visible); // IUPred for seq0
521 assertTrue(anns[4].visible); // Beauty
522 assertTrue(anns[5].visible); // JMol for seq3
523 assertTrue(anns[6].visible); // IUPRED for seq2
524 assertTrue(anns[7].visible); // JMol for seq1
528 * Test result of selecting an annotation type, with 'Show for selected
531 * We expect all annotations of that type, linked to the sequence group, to be
532 * set visible. Other annotations should be left unchanged
534 @Test(groups = { "Functional" })
535 public void testSelectType_showForSelected()
537 // sequences 1 and 2 have annotations IUPred and Jmol
538 selectSequences(1, 2);
539 testee = new AnnotationChooser(parentPanel);
540 final Checkbox showCheckbox = (Checkbox) getComponent(testee, 1, 0, 0);
541 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
543 final Checkbox selectedSequencesCheckbox = (Checkbox) getComponent(
546 AlignmentAnnotation[] anns = parentPanel.getAlignment()
547 .getAlignmentAnnotation();
549 // hide all JMol annotations in the selection region (== annotation 7)
550 setSelected(selectedSequencesCheckbox, true);
551 setSelected(hideCheckbox, true);
552 setSelected(getTypeCheckbox("JMol"), true);
554 assertTrue(anns[5].visible); // JMol for seq3
555 assertFalse(anns[7].visible); // JMol for seq1
556 // ...now show them...
557 setSelected(showCheckbox, true);
559 assertTrue(anns[0].visible); // Conservation
560 assertTrue(anns[1].visible); // Quality
561 assertTrue(anns[2].visible); // Consensus
562 assertTrue(anns[3].visible); // IUPred for seq0
563 assertTrue(anns[4].visible); // Beauty
564 assertTrue(anns[5].visible); // JMol for seq3
565 assertTrue(anns[6].visible); // IUPRED for seq2
566 assertTrue(anns[7].visible); // JMol for seq1
570 * Test result of deselecting an annotation type, with 'Show for all
573 * We expect all annotations of that type to be set hidden. Other annotations
574 * should be left unchanged.
576 @Test(groups = { "Functional" })
577 public void testDeselectType_showForAll()
579 selectSequences(1, 2);
580 testee = new AnnotationChooser(parentPanel);
582 final Checkbox showCheckbox = (Checkbox) getComponent(testee, 1, 0, 0);
583 setSelected(showCheckbox, true);
585 final Checkbox allSequencesCheckbox = (Checkbox) getComponent(testee,
587 setSelected(allSequencesCheckbox, true);
589 AlignmentAnnotation[] anns = parentPanel.getAlignment()
590 .getAlignmentAnnotation();
592 final Checkbox typeCheckbox = getTypeCheckbox("JMol");
593 // select JMol - all shown
594 setSelected(typeCheckbox, true);
595 assertTrue(anns[5].visible); // JMol for seq3
596 assertTrue(anns[7].visible); // JMol for seq1
598 // deselect JMol - all hidden
599 setSelected(typeCheckbox, false);
600 assertTrue(anns[0].visible); // Conservation
601 assertTrue(anns[1].visible); // Quality
602 assertTrue(anns[2].visible); // Consensus
603 assertTrue(anns[3].visible); // IUPred for seq0
604 assertTrue(anns[4].visible); // Beauty
605 assertFalse(anns[5].visible); // JMol for seq3
606 assertTrue(anns[6].visible); // IUPRED for seq2
607 assertFalse(anns[7].visible); // JMol for seq1
611 * Test result of deselecting an annotation type, with 'Show for selected
614 * We expect the annotations of that type, linked to the sequence group, to be
615 * set hidden. Other annotations should be left unchanged.
617 @Test(groups = { "Functional" })
618 public void testDeselectType_showForSelected()
620 selectSequences(1, 2);
621 testee = new AnnotationChooser(parentPanel);
622 final Checkbox showCheckbox = (Checkbox) getComponent(testee, 1, 0, 0);
623 setSelected(showCheckbox, true);
626 * Don't set the 'selected sequences' radio button since this would trigger
627 * an update, including unselected sequences / annotation types
629 // setSelected(getSelectedSequencesCheckbox());
631 AlignmentAnnotation[] anns = parentPanel.getAlignment()
632 .getAlignmentAnnotation();
634 // select JMol - should remain visible
635 setSelected(getTypeCheckbox("JMol"), true);
636 assertTrue(anns[5].visible); // JMol for seq3
637 assertTrue(anns[7].visible); // JMol for seq1
639 // deselect JMol - should be hidden for selected sequences only
640 setSelected(getTypeCheckbox("JMol"), false);
641 assertTrue(anns[0].visible); // Conservation
642 assertTrue(anns[1].visible); // Quality
643 assertTrue(anns[2].visible); // Consensus
644 assertTrue(anns[3].visible); // IUPred for seq0
645 assertTrue(anns[4].visible); // Beauty
646 assertTrue(anns[5].visible); // JMol for seq3 not in selection group
647 assertTrue(anns[6].visible); // IUPRED for seq2
648 assertFalse(anns[7].visible); // JMol for seq1 in selection group
652 * Helper method to drill down to a sub-component in a Container hierarchy.
660 public static Component getComponent(Container cont, int... positions)
662 Component comp = cont;
663 for (int i : positions)
665 comp = ((Container) comp).getComponent(i);
671 * Helper method to set or unset a checkbox and fire its action listener.
676 protected void setSelected(Checkbox cb, boolean select)
678 // TODO refactor to a test utility class
680 // have to manually fire the action listener
681 cb.getItemListeners()[0].itemStateChanged(new ItemEvent(cb,
682 ItemEvent.ITEM_STATE_CHANGED, cb, select ? ItemEvent.SELECTED
683 : ItemEvent.DESELECTED));
687 * Helper method to drill down to the 'Annotation type' checkbox with given
692 private Checkbox getTypeCheckbox(String forLabel)
694 Component[] cbs = ((JPanel) testee.getComponent(0)).getComponents();
695 for (Component comp : cbs)
697 final Checkbox cb = (Checkbox) comp;
698 if (cb.getLabel().equals(forLabel))
707 * Test isInActionScope for the case where the scope is selected sequences.
708 * Test cases include sequences in the selection group, and others not in the
711 @Test(groups = { "Functional" })
712 public void testIsInActionScope_selectedScope()
714 // sequences 1 and 2 have annotations 4 and 3 respectively
715 selectSequences(1, 2);
716 testee = new AnnotationChooser(parentPanel);
718 final Checkbox selectedSequencesCheckbox = (Checkbox) getComponent(
720 setSelected(selectedSequencesCheckbox, true);
722 AlignmentAnnotation[] anns = parentPanel.getAlignment()
723 .getAlignmentAnnotation();
724 // remember 3 annotations to skip (Conservation/Quality/Consensus)
725 assertFalse(testee.isInActionScope(anns[3]));
726 assertFalse(testee.isInActionScope(anns[4]));
727 assertFalse(testee.isInActionScope(anns[5]));
728 assertTrue(testee.isInActionScope(anns[6]));
729 assertTrue(testee.isInActionScope(anns[7]));
733 * Test isInActionScope for the case where the scope is unselected sequences.
734 * Test cases include sequences in the selection group, and others not in the
737 @Test(groups = { "Functional" })
738 public void testIsInActionScope_unselectedScope()
740 // sequences 1 and 2 have annotations 4 and 3 respectively
741 selectSequences(1, 2);
742 testee = new AnnotationChooser(parentPanel);
744 final Checkbox unselectedSequencesCheckbox = (Checkbox) getComponent(
746 setSelected(unselectedSequencesCheckbox, true);
748 AlignmentAnnotation[] anns = parentPanel.getAlignment()
749 .getAlignmentAnnotation();
750 // remember 3 annotations to skip (Conservation/Quality/Consensus)
751 assertTrue(testee.isInActionScope(anns[3]));
752 assertTrue(testee.isInActionScope(anns[4]));
753 assertTrue(testee.isInActionScope(anns[5]));
754 assertFalse(testee.isInActionScope(anns[6]));
755 assertFalse(testee.isInActionScope(anns[7]));
759 * Test that the reset method restores previous visibility flags.
761 @Test(groups = { "Functional" })
762 public void testResetOriginalState()
764 testee = new AnnotationChooser(parentPanel);
766 AlignmentAnnotation[] anns = parentPanel.getAlignment()
767 .getAlignmentAnnotation();
769 for (int i = 0; i < anns.length; i++)
771 assertTrue(i + "'th sequence not visible", anns[i].visible);
775 * check options to hide JMol and IUPRED annotations for all sequences
777 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
778 setSelected(hideCheckbox, true);
780 final Checkbox allSequencesCheckbox = (Checkbox) getComponent(testee,
782 setSelected(allSequencesCheckbox, true);
784 setSelected(getTypeCheckbox("JMol"), true);
785 setSelected(getTypeCheckbox("IUPRED"), true);
787 assertTrue(anns[0].visible); // Conservation
788 assertTrue(anns[1].visible); // Quality
789 assertTrue(anns[2].visible); // Consensus
790 assertFalse(anns[3].visible); // IUPRED
791 assertTrue(anns[4].visible); // Beauty (not seq-related)
792 assertFalse(anns[5].visible); // JMol
793 assertFalse(anns[6].visible); // IUPRED
794 assertFalse(anns[7].visible); // JMol
796 // reset - should all be visible
797 testee.resetOriginalState();
798 for (int i = 0; i < anns.length; i++)
800 assertTrue(i + "'th sequence not visible", anns[i].visible);