test/jalview/gui/AnnotationChooserTest.java

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