Clover icon

Coverage Report

  1. Project Clover database Fri Dec 6 2024 13:47:14 GMT
  2. Package jalview.gui

File AnnotationChooserTest.java

 

Code metrics

10
313
27
1
822
520
32
0.1
11.59
27
1.19

Classes

Class Line # Actions
AnnotationChooserTest 61 313 32
0.9971428599.7%
 

Contributing tests

This file is covered by 17 tests. .

Source view

1    /*
2    * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3    * Copyright (C) $$Year-Rel$$ The Jalview Authors
4    *
5    * This file is part of Jalview.
6    *
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.
11    *
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.
16    *
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.
20    */
21    package jalview.gui;
22   
23    import static org.testng.AssertJUnit.assertEquals;
24    import static org.testng.AssertJUnit.assertFalse;
25    import static org.testng.AssertJUnit.assertTrue;
26   
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;
38   
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;
47   
48    import javax.swing.JButton;
49    import javax.swing.JPanel;
50   
51    import org.testng.annotations.BeforeClass;
52    import org.testng.annotations.BeforeMethod;
53    import org.testng.annotations.Test;
54   
55    /**
56    * Unit tests for AnnotationChooser
57    *
58    * @author gmcarstairs
59    *
60    */
 
61    public class AnnotationChooserTest
62    {
63   
 
64  1 toggle @BeforeClass(alwaysRun = true)
65    public void setUpJvOptionPane()
66    {
67  1 JvOptionPane.setInteractiveMode(false);
68  1 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
69    }
70   
71    // 4 sequences x 13 positions
72    final static String TEST_DATA = ">FER_CAPAA Ferredoxin\n"
73    + "TIETHKEAELVG-\n"
74    + ">FER_CAPAN Ferredoxin, chloroplast precursor\n"
75    + "TIETHKEAELVG-\n"
76    + ">FER1_SOLLC Ferredoxin-1, chloroplast precursor\n"
77    + "TIETHKEEELTA-\n" + ">Q93XJ9_SOLTU Ferredoxin I precursor\n"
78    + "TIETHKEEELTA-\n";
79   
80    AnnotationChooser testee;
81   
82    AlignmentPanel parentPanel;
83   
84    AlignFrame af;
85   
 
86  17 toggle @BeforeMethod(alwaysRun = true)
87    public void setUp() throws IOException
88    {
89  17 Cache.loadProperties("test/jalview/io/testProps.jvprops");
90    // pin down annotation sort order for test
91  17 Cache.applicationProperties.setProperty(Preferences.SORT_ANNOTATIONS,
92    SequenceAnnotationOrder.NONE.name());
93  17 final String TRUE = Boolean.TRUE.toString();
94  17 Cache.applicationProperties.setProperty(Preferences.SHOW_AUTOCALC_ABOVE,
95    TRUE);
96  17 Cache.applicationProperties.setProperty("SHOW_QUALITY", TRUE);
97  17 Cache.applicationProperties.setProperty("SHOW_CONSERVATION", TRUE);
98  17 Cache.applicationProperties.setProperty("SHOW_IDENTITY", TRUE);
99   
100  17 AlignmentI al = new FormatAdapter().readFile(TEST_DATA,
101    DataSourceType.PASTE, FileFormat.Fasta);
102  17 af = new AlignFrame(al, 700, 500);
103  17 parentPanel = new AlignmentPanel(af, af.getViewport());
104  17 addAnnotations();
105    }
106   
107    /**
108    * Add 4 annotations, 3 of them sequence-specific.
109    *
110    * <PRE>
111    * ann1 - for sequence 0 - label 'IUPRED' ann2 - not sequence related - label
112    * 'Beauty' ann3 - for sequence 3 - label 'JMol' ann4 - for sequence 2 - label
113    * 'IUPRED' ann5 - for sequence 1 - label 'JMol'
114    */
 
115  17 toggle private void addAnnotations()
116    {
117  17 Annotation an = new Annotation(2f);
118  17 Annotation[] anns = new Annotation[] { an, an, an };
119  17 AlignmentAnnotation ann0 = new AlignmentAnnotation("IUPRED", "", anns);
120  17 AlignmentAnnotation ann1 = new AlignmentAnnotation("Beauty", "", anns);
121  17 AlignmentAnnotation ann2 = new AlignmentAnnotation("JMol", "", anns);
122  17 AlignmentAnnotation ann3 = new AlignmentAnnotation("IUPRED", "", anns);
123  17 AlignmentAnnotation ann4 = new AlignmentAnnotation("JMol", "", anns);
124  17 SequenceI[] seqs = parentPanel.getAlignment().getSequencesArray();
125  17 ann0.setSequenceRef(seqs[0]);
126  17 ann2.setSequenceRef(seqs[3]);
127  17 ann3.setSequenceRef(seqs[2]);
128  17 ann4.setSequenceRef(seqs[1]);
129  17 parentPanel.getAlignment().addAnnotation(ann0);
130  17 parentPanel.getAlignment().addAnnotation(ann1);
131  17 parentPanel.getAlignment().addAnnotation(ann2);
132  17 parentPanel.getAlignment().addAnnotation(ann3);
133  17 parentPanel.getAlignment().addAnnotation(ann4);
134    }
135   
136    /**
137    * Test creation of panel with OK and Cancel buttons
138    */
 
139  1 toggle @Test(groups = { "Functional" })
140    public void testBuildActionButtonsPanel()
141    {
142  1 testee = new AnnotationChooser(parentPanel);
143  1 JPanel jp = testee.buildActionButtonsPanel();
144  1 assertTrue("Wrong layout", jp.getLayout() instanceof FlowLayout);
145   
146  1 Component[] comps = jp.getComponents();
147  1 assertEquals("Not 2 action buttons", 2, comps.length);
148   
149  1 final Component jb1 = comps[0];
150  1 final Component jb2 = comps[1];
151   
152  1 assertEquals("Not 'OK' button", MessageManager.getString("action.ok"),
153    ((JButton) jb1).getText());
154  1 assertEquals("Wrong button font", JvSwingUtils.getLabelFont(),
155    jb1.getFont());
156   
157  1 assertEquals("Not 'Cancel' button",
158    MessageManager.getString("action.cancel"),
159    ((JButton) jb2).getText());
160  1 assertEquals("Wrong button font", JvSwingUtils.getLabelFont(),
161    jb2.getFont());
162    }
163   
164    /**
165    * Test 'Apply to' has 3 radio buttons enabled, 'Selected Sequences' selected,
166    * when there is a current selection group.
167    */
 
168  1 toggle @Test(groups = { "Functional" })
169    public void testBuildApplyToOptionsPanel_withSelectionGroup()
170    {
171  1 selectSequences(0, 2, 3);
172  1 testee = new AnnotationChooser(parentPanel);
173   
174  1 JPanel jp = testee.buildApplyToOptionsPanel();
175  1 Component[] comps = jp.getComponents();
176  1 assertEquals("Not 3 radio buttons", 3, comps.length);
177   
178  1 final Checkbox cb1 = (Checkbox) comps[0];
179  1 final Checkbox cb2 = (Checkbox) comps[1];
180  1 final Checkbox cb3 = (Checkbox) comps[2];
181   
182  1 assertTrue("Not enabled", cb1.isEnabled());
183  1 assertTrue("Not enabled", cb2.isEnabled());
184  1 assertTrue("Not enabled", cb3.isEnabled());
185  1 assertEquals("Option not selected", cb2,
186    cb2.getCheckboxGroup().getSelectedCheckbox());
187   
188    // check state variables match checkbox selection
189  1 assertTrue(testee.isApplyToSelectedSequences());
190  1 assertFalse(testee.isApplyToUnselectedSequences());
191    }
192   
193    /**
194    * Add a sequence group to the alignment with the specified sequences (base 0)
195    * in it
196    *
197    * @param i
198    * @param more
199    */
 
200  12 toggle private void selectSequences(int... selected)
201    {
202  12 SequenceI[] seqs = parentPanel.getAlignment().getSequencesArray();
203  12 SequenceGroup sg = new SequenceGroup();
204  12 for (int i : selected)
205    {
206  24 sg.addSequence(seqs[i], false);
207    }
208  12 parentPanel.av.setSelectionGroup(sg);
209    }
210   
211    /**
212    * Test 'Apply to' has 1 radio button enabled, 'All Sequences' selected, when
213    * there is no current selection group.
214    */
 
215  1 toggle @Test(groups = { "Functional" })
216    public void testBuildApplyToOptionsPanel_noSelectionGroup()
217    {
218  1 testee = new AnnotationChooser(parentPanel);
219  1 JPanel jp = testee.buildApplyToOptionsPanel();
220  1 verifyApplyToOptionsPanel_noSelectionGroup(jp);
221    }
222   
 
223  2 toggle protected void verifyApplyToOptionsPanel_noSelectionGroup(JPanel jp)
224    {
225  2 assertTrue("Wrong layout", jp.getLayout() instanceof FlowLayout);
226  2 Component[] comps = jp.getComponents();
227  2 assertEquals("Not 3 radio buttons", 3, comps.length);
228   
229  2 final Checkbox cb1 = (Checkbox) comps[0];
230  2 final Checkbox cb2 = (Checkbox) comps[1];
231  2 final Checkbox cb3 = (Checkbox) comps[2];
232   
233  2 assertTrue("Not enabled", cb1.isEnabled());
234  2 assertFalse("Enabled", cb2.isEnabled());
235  2 assertFalse("Enabled", cb3.isEnabled());
236  2 assertEquals("Not selected", cb1,
237    cb1.getCheckboxGroup().getSelectedCheckbox());
238   
239    // check state variables match checkbox selection
240  2 assertTrue(testee.isApplyToSelectedSequences());
241  2 assertTrue(testee.isApplyToUnselectedSequences());
242   
243  2 assertEquals("Wrong text",
244    MessageManager.getString("label.all_sequences"),
245    cb1.getLabel());
246  2 assertEquals("Wrong text",
247    MessageManager.getString("label.selected_sequences"),
248    cb2.getLabel());
249  2 assertEquals("Wrong text",
250    MessageManager.getString("label.except_selected_sequences"),
251    cb3.getLabel());
252    }
253   
254    /**
255    * Test Show and Hide radio buttons created, with Hide initially selected.
256    */
 
257  1 toggle @Test(groups = { "Functional" })
258    public void testBuildShowHidePanel()
259    {
260  1 testee = new AnnotationChooser(parentPanel);
261  1 JPanel jp = testee.buildShowHidePanel();
262  1 verifyShowHidePanel(jp);
263   
264    }
265   
 
266  2 toggle protected void verifyShowHidePanel(JPanel jp)
267    {
268  2 assertTrue("Wrong layout", jp.getLayout() instanceof FlowLayout);
269  2 Component[] comps = jp.getComponents();
270  2 assertEquals("Not 2 radio buttons", 2, comps.length);
271   
272  2 final Checkbox cb1 = (Checkbox) comps[0];
273  2 final Checkbox cb2 = (Checkbox) comps[1];
274   
275  2 assertTrue("Show not enabled", cb1.isEnabled());
276  2 assertTrue("Hide not enabled", cb2.isEnabled());
277   
278    // Hide (button 2) selected; note this may change to none (null)
279  2 assertEquals("Not selected", cb2,
280    cb2.getCheckboxGroup().getSelectedCheckbox());
281   
282  2 assertTrue("Show is flagged", !testee.isShowSelected());
283   
284  2 assertEquals("Wrong text",
285    MessageManager.getString("label.show_selected_annotations"),
286    cb1.getLabel());
287  2 assertEquals("Wrong text",
288    MessageManager.getString("label.hide_selected_annotations"),
289    cb2.getLabel());
290    }
291   
292    /**
293    * Test construction of panel containing two sub-panels
294    */
 
295  1 toggle @Test(groups = { "Functional" })
296    public void testBuildShowHideOptionsPanel()
297    {
298  1 testee = new AnnotationChooser(parentPanel);
299  1 JPanel jp = testee.buildShowHideOptionsPanel();
300  1 assertTrue("Wrong layout", jp.getLayout() instanceof BorderLayout);
301  1 Component[] comps = jp.getComponents();
302  1 assertEquals("Not 2 sub-panels", 2, comps.length);
303   
304  1 verifyShowHidePanel((JPanel) comps[0]);
305  1 verifyApplyToOptionsPanel_noSelectionGroup((JPanel) comps[1]);
306    }
307   
308    /**
309    * Test that annotation types are (uniquely) identified.
310    *
311    */
 
312  1 toggle @Test(groups = { "Functional" })
313    public void testGetAnnotationTypes()
314    {
315  1 selectSequences(1);
316  1 testee = new AnnotationChooser(parentPanel);
317    // selection group should make no difference to the result
318    // as all annotation types for the alignment are considered
319   
320  1 List<String> types = AnnotationChooser
321    .getAnnotationTypes(parentPanel.getAlignment(), true);
322  1 assertEquals("Not two annotation types", 2, types.size());
323  1 assertTrue("IUPRED missing", types.contains("IUPRED"));
324  1 assertTrue("JMol missing", types.contains("JMol"));
325   
326  1 types = AnnotationChooser.getAnnotationTypes(parentPanel.getAlignment(),
327    false);
328  1 assertEquals("Not six annotation types", 7, types.size());
329  1 assertTrue("IUPRED missing", types.contains("IUPRED"));
330  1 assertTrue("JMol missing", types.contains("JMol"));
331  1 assertTrue("Beauty missing", types.contains("Beauty"));
332    // These are added by viewmodel.AlignViewport.initAutoAnnotation():
333  1 assertTrue("Consensus missing", types.contains("Consensus"));
334  1 assertTrue("Quality missing", types.contains("Quality"));
335  1 assertTrue("Conservation missing", types.contains("Conservation"));
336  1 assertTrue("Occupancy missing", types.contains("Occupancy"));
337    }
338   
339    /**
340    * Test result of selecting an annotation type, with 'Hide for all sequences'.
341    *
342    * We expect all annotations of that type to be set hidden. Other annotations
343    * should be left visible.
344    */
 
345  1 toggle @Test(groups = { "Functional" })
346    public void testSelectType_hideForAll()
347    {
348  1 selectSequences(1, 2);
349  1 testee = new AnnotationChooser(parentPanel);
350  1 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
351  1 setSelected(hideCheckbox, true);
352   
353  1 final Checkbox allSequencesCheckbox = (Checkbox) getComponent(testee, 1,
354    1, 0);
355  1 setSelected(allSequencesCheckbox, true);
356   
357  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
358    .getAlignmentAnnotation();
359   
360  1 int autocalc = countAutocalc(anns);
361  1 assertTrue(anns[autocalc + 2].visible); // JMol for seq3
362  1 assertTrue(anns[autocalc + 4].visible); // JMol for seq1
363   
364  1 setSelected(getTypeCheckbox("JMol"), true);
365  1 assertTrue(anns[0].visible); // Conservation
366  1 assertTrue(anns[1].visible); // Quality
367  1 assertTrue(anns[2].visible); // Consensus
368  1 assertTrue(anns[3].visible); // Occupancy
369  1 assertTrue(anns[4].visible); // IUPred for seq0
370  1 assertTrue(anns[5].visible); // Beauty
371  1 assertFalse(anns[6].visible); // JMol for seq3 - not selected but hidden
372  1 assertTrue(anns[7].visible); // IUPRED for seq2
373  1 assertFalse(anns[8].visible); // JMol for seq1 - selected and hidden
374    }
375   
376    /**
377    * Test result of selecting an annotation type, with 'Hide for selected
378    * sequences'.
379    *
380    * We expect the annotations of that type, linked to the sequence group, to be
381    * set hidden. Other annotations should be left visible.
382    */
 
383  1 toggle @Test(groups = { "Functional" })
384    public void testSelectType_hideForSelected()
385    {
386  1 selectSequences(1, 2);
387  1 testee = new AnnotationChooser(parentPanel);
388  1 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
389  1 setSelected(hideCheckbox, true);
390   
391    /*
392    * Don't set the 'selected sequences' radio button since this would trigger
393    * an update, including unselected sequences / annotation types
394    */
395    // setSelected(getSelectedSequencesCheckbox());
396   
397  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
398    .getAlignmentAnnotation();
399   
400  1 int autocalc = countAutocalc(anns);
401  1 assertTrue(anns[autocalc + 4].visible); // JMol for seq1
402   
403  1 setSelected(getTypeCheckbox("JMol"), true);
404  1 assertTrue(anns[0].visible); // Conservation
405  1 assertTrue(anns[1].visible); // Quality
406  1 assertTrue(anns[2].visible); // Consensus
407  1 assertTrue(anns[3].visible); // Occupancy
408  1 assertTrue(anns[4].visible); // IUPred for seq0
409  1 assertTrue(anns[5].visible); // Beauty
410  1 assertTrue(anns[6].visible); // JMol for seq3 not in selection group
411  1 assertTrue(anns[7].visible); // IUPRED for seq2
412  1 assertFalse(anns[8].visible); // JMol for seq1 in selection group
413    }
414   
415    /**
416    * Test result of deselecting an annotation type, with 'Hide for all
417    * sequences'.
418    *
419    * We expect all annotations of that type to be set visible. Other annotations
420    * should be left unchanged.
421    */
 
422  1 toggle @Test(groups = { "Functional" })
423    public void testDeselectType_hideForAll()
424    {
425  1 selectSequences(1, 2);
426  1 testee = new AnnotationChooser(parentPanel);
427   
428  1 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
429  1 setSelected(hideCheckbox, true);
430   
431  1 final Checkbox allSequencesCheckbox = (Checkbox) getComponent(testee, 1,
432    1, 0);
433  1 setSelected(allSequencesCheckbox, true);
434   
435  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
436    .getAlignmentAnnotation();
437   
438  1 final Checkbox typeCheckbox = getTypeCheckbox("JMol");
439   
440    // select JMol - all hidden
441  1 setSelected(typeCheckbox, true);
442  1 int autocalc = countAutocalc(anns);
443  1 assertFalse(anns[autocalc + 2].visible); // JMol for seq3
444  1 assertFalse(anns[autocalc + 4].visible); // JMol for seq1
445   
446    // deselect JMol - all unhidden
447  1 setSelected(typeCheckbox, false);
448  1 for (AlignmentAnnotation ann : anns)
449    {
450  9 assertTrue(ann.visible);
451    }
452    }
453   
454    /**
455    * Returns a count of autocalculated annotations in the set provided
456    *
457    * @param anns
458    * @return
459    */
 
460  9 toggle private int countAutocalc(AlignmentAnnotation[] anns)
461    {
462  9 int count = 0;
463  9 for (AlignmentAnnotation ann : anns)
464    {
465  81 if (ann.autoCalculated)
466    {
467  36 count++;
468    }
469    }
470  9 return count;
471    }
472   
473    /**
474    * Test result of deselecting an annotation type, with 'Hide for selected
475    * sequences'.
476    *
477    * We expect the annotations of that type, linked to the sequence group, to be
478    * set visible. Other annotations should be left unchanged.
479    */
 
480  1 toggle @Test(groups = { "Functional" })
481    public void testDeselectType_hideForSelected()
482    {
483  1 selectSequences(1, 2);
484  1 testee = new AnnotationChooser(parentPanel);
485  1 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
486  1 setSelected(hideCheckbox, true);
487   
488    /*
489    * Don't set the 'selected sequences' radio button since this would trigger
490    * an update, including unselected sequences / annotation types
491    */
492    // setSelected(getSelectedSequencesCheckbox());
493   
494  1 setSelected(getTypeCheckbox("JMol"), true);
495  1 setSelected(getTypeCheckbox("JMol"), false);
496   
497  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
498    .getAlignmentAnnotation();
499  1 assertTrue(anns[0].visible); // Conservation
500  1 assertTrue(anns[1].visible); // Quality
501  1 assertTrue(anns[2].visible); // Consensus
502  1 assertTrue(anns[3].visible); // IUPred for seq0
503  1 assertTrue(anns[4].visible); // Beauty
504  1 assertTrue(anns[5].visible); // JMol for seq3 not in selection group
505  1 assertTrue(anns[6].visible); // IUPRED for seq2
506  1 assertTrue(anns[7].visible); // JMol for seq1 in selection group
507    }
508   
509    /**
510    * Test result of selecting an annotation type, with 'Show for all sequences'.
511    *
512    * We expect all annotations of that type to be set visible. Other annotations
513    * should be left unchanged
514    */
 
515  1 toggle @Test(groups = { "Functional" })
516    public void testSelectType_showForAll()
517    {
518  1 selectSequences(1, 2);
519  1 testee = new AnnotationChooser(parentPanel);
520  1 final Checkbox showCheckbox = (Checkbox) getComponent(testee, 1, 0, 0);
521  1 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
522   
523  1 final Checkbox allSequencesCheckbox = (Checkbox) getComponent(testee, 1,
524    1, 0);
525   
526  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
527    .getAlignmentAnnotation();
528   
529    // hide all JMol annotations
530  1 setSelected(allSequencesCheckbox, true);
531  1 setSelected(hideCheckbox, true);
532  1 setSelected(getTypeCheckbox("JMol"), true);
533  1 int autocalc = countAutocalc(anns);
534  1 assertFalse(anns[autocalc + 2].visible); // JMol for seq3
535  1 assertFalse(anns[autocalc + 4].visible); // JMol for seq1
536    // ...now show them...
537  1 setSelected(showCheckbox, true);
538  1 for (AlignmentAnnotation ann : anns)
539    {
540  9 assertTrue(ann.visible);
541    }
542    }
543   
544    /**
545    * Test result of selecting an annotation type, with 'Show for selected
546    * sequences'.
547    *
548    * We expect all annotations of that type, linked to the sequence group, to be
549    * set visible. Other annotations should be left unchanged
550    */
 
551  1 toggle @Test(groups = { "Functional" })
552    public void testSelectType_showForSelected()
553    {
554    // sequences 1 and 2 have annotations IUPred and Jmol
555  1 selectSequences(1, 2);
556  1 testee = new AnnotationChooser(parentPanel);
557  1 final Checkbox showCheckbox = (Checkbox) getComponent(testee, 1, 0, 0);
558  1 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
559   
560  1 final Checkbox selectedSequencesCheckbox = (Checkbox) getComponent(
561    testee, 1, 1, 1);
562   
563  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
564    .getAlignmentAnnotation();
565   
566    // hide all JMol annotations in the selection region (== annotation 7)
567  1 setSelected(selectedSequencesCheckbox, true);
568  1 setSelected(hideCheckbox, true);
569  1 setSelected(getTypeCheckbox("JMol"), true);
570   
571  1 int autocalc = countAutocalc(anns);
572  1 assertTrue(anns[autocalc + 2].visible); // JMol for seq3
573  1 assertFalse(anns[autocalc + 4].visible); // JMol for seq1
574    // ...now show them...
575  1 setSelected(showCheckbox, true);
576   
577  1 for (AlignmentAnnotation ann : anns)
578    {
579  9 assertTrue(ann.visible);
580    }
581    }
582   
583    /**
584    * Test result of deselecting an annotation type, with 'Show for all
585    * sequences'.
586    *
587    * We expect all annotations of that type to be set hidden. Other annotations
588    * should be left unchanged.
589    */
 
590  1 toggle @Test(groups = { "Functional" })
591    public void testDeselectType_showForAll()
592    {
593  1 selectSequences(1, 2);
594  1 testee = new AnnotationChooser(parentPanel);
595   
596  1 final Checkbox showCheckbox = (Checkbox) getComponent(testee, 1, 0, 0);
597  1 setSelected(showCheckbox, true);
598   
599  1 final Checkbox allSequencesCheckbox = (Checkbox) getComponent(testee, 1,
600    1, 0);
601  1 setSelected(allSequencesCheckbox, true);
602   
603  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
604    .getAlignmentAnnotation();
605   
606  1 final Checkbox typeCheckbox = getTypeCheckbox("JMol");
607    // select JMol - all shown
608  1 setSelected(typeCheckbox, true);
609  1 int autocalc = countAutocalc(anns);
610  1 assertTrue(anns[autocalc + 2].visible); // JMol for seq3
611  1 assertTrue(anns[autocalc + 4].visible); // JMol for seq1
612   
613    // deselect JMol - all hidden
614  1 setSelected(typeCheckbox, false);
615  1 assertTrue(anns[0].visible); // Conservation
616  1 assertTrue(anns[1].visible); // Quality
617  1 assertTrue(anns[2].visible); // Consensus
618  1 assertTrue(anns[3].visible); // Occupancy
619  1 assertTrue(anns[4].visible); // IUPred for seq0
620  1 assertTrue(anns[5].visible); // Beauty
621  1 assertFalse(anns[6].visible); // JMol for seq3
622  1 assertTrue(anns[7].visible); // IUPRED for seq2
623  1 assertFalse(anns[8].visible); // JMol for seq1
624    }
625   
626    /**
627    * Test result of deselecting an annotation type, with 'Show for selected
628    * sequences'.
629    *
630    * We expect the annotations of that type, linked to the sequence group, to be
631    * set hidden. Other annotations should be left unchanged.
632    */
 
633  1 toggle @Test(groups = { "Functional" })
634    public void testDeselectType_showForSelected()
635    {
636  1 selectSequences(1, 2);
637  1 testee = new AnnotationChooser(parentPanel);
638  1 final Checkbox showCheckbox = (Checkbox) getComponent(testee, 1, 0, 0);
639  1 setSelected(showCheckbox, true);
640   
641    /*
642    * Don't set the 'selected sequences' radio button since this would trigger
643    * an update, including unselected sequences / annotation types
644    */
645    // setSelected(getSelectedSequencesCheckbox());
646   
647  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
648    .getAlignmentAnnotation();
649   
650    // select JMol - should remain visible
651  1 setSelected(getTypeCheckbox("JMol"), true);
652  1 int autocalc = countAutocalc(anns);
653  1 assertTrue(anns[autocalc + 2].visible); // JMol for seq3
654  1 assertTrue(anns[autocalc + 4].visible); // JMol for seq1
655   
656    // deselect JMol - should be hidden for selected sequences only
657  1 setSelected(getTypeCheckbox("JMol"), false);
658  1 assertTrue(anns[0].visible); // Conservation
659  1 assertTrue(anns[1].visible); // Quality
660  1 assertTrue(anns[2].visible); // Consensus
661  1 assertTrue(anns[3].visible); // Occupancy
662  1 assertTrue(anns[4].visible); // IUPred for seq0
663  1 assertTrue(anns[5].visible); // Beauty
664  1 assertTrue(anns[6].visible); // JMol for seq3 not in selection group
665  1 assertTrue(anns[7].visible); // IUPRED for seq2
666  1 assertFalse(anns[8].visible); // JMol for seq1 in selection group
667    }
668   
669    /**
670    * Helper method to drill down to a sub-component in a Container hierarchy.
671    *
672    * @param cont
673    * @param i
674    * @param j
675    * @param k
676    * @return
677    */
 
678  19 toggle public static Component getComponent(Container cont, int... positions)
679    {
680  19 Component comp = cont;
681  19 for (int i : positions)
682    {
683  57 comp = ((Container) comp).getComponent(i);
684    }
685  19 return comp;
686    }
687   
688    /**
689    * Helper method to set or unset a checkbox and fire its action listener.
690    *
691    * @param cb
692    * @param select
693    */
 
694  33 toggle protected void setSelected(Checkbox cb, boolean select)
695    {
696    // TODO refactor to a test utility class
697  33 cb.setState(select);
698    // have to manually fire the action listener
699  33 cb.getItemListeners()[0].itemStateChanged(
700    new ItemEvent(cb, ItemEvent.ITEM_STATE_CHANGED, cb,
701  33 select ? ItemEvent.SELECTED : ItemEvent.DESELECTED));
702    }
703   
704    /**
705    * Helper method to drill down to the 'Annotation type' checkbox with given
706    * label.
707    *
708    * @return
709    */
 
710  12 toggle private Checkbox getTypeCheckbox(String forLabel)
711    {
712  12 Component[] cbs = ((JPanel) testee.getComponent(0)).getComponents();
713  12 for (Component comp : cbs)
714    {
715  23 final Checkbox cb = (Checkbox) comp;
716  23 if (cb.getLabel().equals(forLabel))
717    {
718  12 return cb;
719    }
720    }
721  0 return null;
722    }
723   
724    /**
725    * Test isInActionScope for the case where the scope is selected sequences.
726    * Test cases include sequences in the selection group, and others not in the
727    * group.
728    */
 
729  1 toggle @Test(groups = { "Functional" })
730    public void testIsInActionScope_selectedScope()
731    {
732    // sequences 1 and 2 have annotations 4 and 3 respectively
733  1 selectSequences(1, 2);
734  1 testee = new AnnotationChooser(parentPanel);
735   
736  1 final Checkbox selectedSequencesCheckbox = (Checkbox) getComponent(
737    testee, 1, 1, 1);
738  1 setSelected(selectedSequencesCheckbox, true);
739   
740  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
741    .getAlignmentAnnotation();
742  1 int autocalc = countAutocalc(anns);
743  1 assertFalse(testee.isInActionScope(anns[autocalc]));
744  1 assertFalse(testee.isInActionScope(anns[autocalc + 1]));
745  1 assertFalse(testee.isInActionScope(anns[autocalc + 2]));
746  1 assertTrue(testee.isInActionScope(anns[autocalc + 3]));
747  1 assertTrue(testee.isInActionScope(anns[autocalc + 4]));
748    }
749   
750    /**
751    * Test isInActionScope for the case where the scope is unselected sequences.
752    * Test cases include sequences in the selection group, and others not in the
753    * group.
754    */
 
755  1 toggle @Test(groups = { "Functional" })
756    public void testIsInActionScope_unselectedScope()
757    {
758    // sequences 1 and 2 have annotations 4 and 3 respectively
759  1 selectSequences(1, 2);
760  1 testee = new AnnotationChooser(parentPanel);
761   
762  1 final Checkbox unselectedSequencesCheckbox = (Checkbox) getComponent(
763    testee, 1, 1, 2);
764  1 setSelected(unselectedSequencesCheckbox, true);
765   
766  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
767    .getAlignmentAnnotation();
768  1 int autocalc = countAutocalc(anns);
769  1 assertTrue(testee.isInActionScope(anns[autocalc]));
770  1 assertTrue(testee.isInActionScope(anns[autocalc + 1]));
771  1 assertTrue(testee.isInActionScope(anns[autocalc + 2]));
772  1 assertFalse(testee.isInActionScope(anns[autocalc + 3]));
773  1 assertFalse(testee.isInActionScope(anns[autocalc + 4]));
774    }
775   
776    /**
777    * Test that the reset method restores previous visibility flags.
778    */
 
779  1 toggle @Test(groups = { "Functional" })
780    public void testResetOriginalState()
781    {
782  1 testee = new AnnotationChooser(parentPanel);
783   
784  1 AlignmentAnnotation[] anns = parentPanel.getAlignment()
785    .getAlignmentAnnotation();
786    // all start visible
787  10 for (int i = 0; i < anns.length; i++)
788    {
789  9 assertTrue(i + "'th sequence not visible", anns[i].visible);
790    }
791   
792    /*
793    * check options to hide JMol and IUPRED annotations for all sequences
794    */
795  1 final Checkbox hideCheckbox = (Checkbox) getComponent(testee, 1, 0, 1);
796  1 setSelected(hideCheckbox, true);
797   
798  1 final Checkbox allSequencesCheckbox = (Checkbox) getComponent(testee, 1,
799    1, 0);
800  1 setSelected(allSequencesCheckbox, true);
801   
802  1 setSelected(getTypeCheckbox("JMol"), true);
803  1 setSelected(getTypeCheckbox("IUPRED"), true);
804   
805  1 assertTrue(anns[0].visible); // Conservation
806  1 assertTrue(anns[1].visible); // Quality
807  1 assertTrue(anns[2].visible); // Consensus
808  1 assertTrue(anns[3].visible); // Occupancy
809  1 assertFalse(anns[4].visible); // IUPRED
810  1 assertTrue(anns[5].visible); // Beauty (not seq-related)
811  1 assertFalse(anns[6].visible); // JMol
812  1 assertFalse(anns[7].visible); // IUPRED
813  1 assertFalse(anns[8].visible); // JMol
814   
815    // reset - should all be visible
816  1 testee.resetOriginalState();
817  10 for (int i = 0; i < anns.length; i++)
818    {
819  9 assertTrue(i + "'th sequence not visible", anns[i].visible);
820    }
821    }
822    }
  • Report generated by OpenClover v 4.4.1 on Fri Dec 6 2024 13:54:25 GMT using coverage data from Fri Dec 6 2024 13:54:13 GMT.
  • OpenClover is free and open-source software.