test/jalview/datamodel/SequenceGroupTest.java

   1 package jalview.datamodel;
   2
   3 import static org.testng.Assert.assertEquals;
   4 import static org.testng.Assert.assertFalse;
   5 import static org.testng.Assert.assertNotNull;
   6 import static org.testng.Assert.assertNotSame;
   7 import static org.testng.Assert.assertNull;
   8 import static org.testng.Assert.assertSame;
   9 import static org.testng.Assert.assertTrue;
  10 import static org.testng.Assert.fail;
  11
  12 import jalview.schemes.NucleotideColourScheme;
  13 import jalview.schemes.PIDColourScheme;
  14
  15 import java.awt.Color;
  16
  17 import junit.extensions.PA;
  18
  19 import org.testng.annotations.Test;
  20
  21 public class SequenceGroupTest
  22 {
  23   @Test(groups={"Functional"})
  24   public void testAddSequence()
  25   {
  26     SequenceGroup sg = new SequenceGroup();
  27     assertTrue(sg.getSequences().isEmpty());
  28
  29     SequenceI seq1 = new Sequence("seq1", "abc");
  30     SequenceI seq2 = new Sequence("seq2", "abc");
  31     SequenceI seq3 = new Sequence(seq1);
  32
  33     sg.addSequence(null, false);
  34     assertTrue(sg.getSequences().isEmpty());
  35     sg.addSequence(seq1, false);
  36     assertEquals(sg.getSequences().size(), 1);
  37     assertTrue(sg.getSequences().contains(seq1));
  38     // adding the same sequence again does nothing
  39     sg.addSequence(seq1, false);
  40     assertEquals(sg.getSequences().size(), 1);
  41     assertTrue(sg.getSequences().contains(seq1));
  42     sg.addSequence(seq2, false);
  43     sg.addSequence(seq2, false);
  44     sg.addSequence(seq3, false);
  45     assertEquals(sg.getSequences().size(), 3);
  46     assertTrue(sg.getSequences().contains(seq1));
  47     assertTrue(sg.getSequences().contains(seq2));
  48     assertTrue(sg.getSequences().contains(seq3));
  49   }
  50
  51   @Test(groups={"Functional"})
  52   public void testAddOrRemove()
  53   {
  54     SequenceGroup sg = new SequenceGroup();
  55     assertTrue(sg.getSequences().isEmpty());
  56
  57     SequenceI seq1 = new Sequence("seq1", "abc");
  58     SequenceI seq2 = new Sequence("seq2", "abc");
  59     SequenceI seq3 = new Sequence(seq1);
  60
  61     sg.addOrRemove(seq1, false);
  62     assertEquals(sg.getSequences().size(), 1);
  63     sg.addOrRemove(seq2, false);
  64     assertEquals(sg.getSequences().size(), 2);
  65     sg.addOrRemove(seq3, false);
  66     assertEquals(sg.getSequences().size(), 3);
  67     assertTrue(sg.getSequences().contains(seq1));
  68     assertTrue(sg.getSequences().contains(seq2));
  69     assertTrue(sg.getSequences().contains(seq3));
  70     sg.addOrRemove(seq1, false);
  71     assertEquals(sg.getSequences().size(), 2);
  72     assertFalse(sg.getSequences().contains(seq1));
  73   }
  74
  75   @Test(groups={"Functional"})
  76   public void testGetColourScheme()
  77   {
  78     SequenceGroup sg = new SequenceGroup();
  79     assertNotNull(sg.getGroupColourScheme());
  80     assertNull(sg.getColourScheme());
  81
  82     sg.setGroupColourScheme(null);
  83     assertNull(sg.getColourScheme());
  84
  85     NucleotideColourScheme scheme = new NucleotideColourScheme();
  86     sg.setColourScheme(scheme);
  87     assertSame(scheme, sg.getColourScheme());
  88   }
  89
  90   @Test(groups={"Functional"})
  91   public void testSetContext()
  92   {
  93     SequenceGroup sg1 = new SequenceGroup();
  94     SequenceGroup sg2 = new SequenceGroup();
  95     SequenceGroup sg3 = new SequenceGroup();
  96     assertNull(sg1.getContext());
  97     sg1.setContext(null);
  98     assertNull(sg1.getContext());
  99     try
 100     {
 101       sg1.setContext(sg1); // self-reference :-O
 102       fail("Expected exception");
 103     } catch (IllegalArgumentException e)
 104     {
 105       // expected
 106       assertNull(sg1.getContext());
 107     }
 108     sg1.setContext(sg2);
 109     assertSame(sg2, sg1.getContext());
 110     sg2.setContext(sg3);
 111     try
 112     {
 113       sg3.setContext(sg1); // circular reference :-O
 114       fail("Expected exception");
 115     } catch (IllegalArgumentException e)
 116     {
 117       // expected
 118       assertNull(sg3.getContext());
 119     }
 120
 121     /*
 122      * use PrivilegedAccessor to 'force' a SequenceGroup with
 123      * a circular context reference
 124      */
 125     PA.setValue(sg2, "context", sg2);
 126     try
 127     {
 128       sg3.setContext(sg2, false); // circular reference in sg2
 129       fail("Expected exception");
 130     } catch (IllegalArgumentException e)
 131     {
 132       // expected
 133       assertNull(sg3.getContext());
 134     }
 135
 136     // test isDefined setting behaviour
 137     sg2 = new SequenceGroup();
 138     sg1.setContext(null, false);
 139     assertFalse(sg1.isDefined());
 140
 141     sg1.setContext(sg2, false);
 142     assertFalse(sg1.isDefined());
 143
 144     sg1.setContext(sg2, true);
 145     assertTrue(sg1.isDefined());
 146
 147     // setContext without defined parameter does not change isDefined
 148     sg1.setContext(null);
 149     assertTrue(sg1.isDefined());
 150
 151     sg1.setContext(null, false);
 152     sg1.setContext(sg2);
 153     assertFalse(sg1.isDefined());
 154   }
 155
 156   @Test(groups = { "Functional" })
 157   public void testContains()
 158   {
 159     /*
 160      * essentially the same tests as AlignmentI.findGroup
 161      * but from a particular group's perspective
 162      */
 163
 164     SequenceI seq1 = new Sequence("seq1", "ABCDEF---GHI");
 165     SequenceI seq2 = new Sequence("seq2", "---JKLMNO---");
 166     AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2 });
 167     /*
 168      * add a group consisting of just "DEF"
 169      */
 170     SequenceGroup sg1 = new SequenceGroup();
 171     sg1.addSequence(seq1, false);
 172     sg1.setStartRes(3);
 173     sg1.setEndRes(5);
 174
 175     /*
 176      * test sequence membership
 177      */
 178     assertTrue(sg1.contains(seq1));
 179     assertFalse(sg1.contains(seq2));
 180
 181     /*
 182      * test sequence+position
 183      */
 184
 185     assertFalse(sg1.contains(seq1, 2)); // position not in group
 186     assertFalse(sg1.contains(seq1, 6)); // position not in group
 187     assertFalse(sg1.contains(seq2, 5)); // sequence not in group
 188     assertTrue(sg1.contains(seq1, 3)); // yes
 189     assertTrue(sg1.contains(seq1, 4));
 190     assertTrue(sg1.contains(seq1, 5));
 191
 192     /*
 193      * add a group consisting of
 194      * EF--
 195      * KLMN
 196      */
 197     SequenceGroup sg2 = new SequenceGroup();
 198     sg2.addSequence(seq1, false);
 199     sg2.addSequence(seq2, false);
 200     sg2.setStartRes(4);
 201     sg2.setEndRes(7);
 202     a.addGroup(sg2);
 203
 204     /*
 205      * if a residue is in more than one group, method returns
 206      * the first found (in order groups were added)
 207      */
 208     assertTrue(sg2.contains(seq1, 4));
 209     assertTrue(sg2.contains(seq1, 5));
 210
 211     /*
 212      * seq2 only belongs to the second group
 213      */
 214     assertTrue(sg2.contains(seq2, 4));
 215     assertTrue(sg2.contains(seq2, 5));
 216     assertTrue(sg2.contains(seq2, 6));
 217     assertTrue(sg2.contains(seq2, 7));
 218     assertFalse(sg2.contains(seq2, 3));
 219     assertFalse(sg2.contains(seq2, 8));
 220     sg2.setEndRes(8);
 221     assertTrue(sg2.contains(seq2, 8));
 222     sg2.deleteSequence(seq2, false);
 223     assertFalse(sg2.contains(seq2));
 224   }
 225
 226   @Test(groups = { "Functional" })
 227   public void testCopyConstructor()
 228   {
 229     SequenceI seq = new Sequence("seq", "ABC");
 230     SequenceGroup sg = new SequenceGroup();
 231     sg.addSequence(seq, false);
 232     sg.setName("g1");
 233     sg.setDescription("desc");
 234     sg.setColourScheme(new PIDColourScheme());
 235     sg.setDisplayBoxes(false);
 236     sg.setDisplayText(false);
 237     sg.setColourText(true);
 238     sg.isDefined = true;
 239     sg.setShowNonconserved(true);
 240     sg.setOutlineColour(Color.red);
 241     sg.setIdColour(Color.blue);
 242     sg.thresholdTextColour = 1;
 243     sg.textColour = Color.orange;
 244     sg.textColour2 = Color.yellow;
 245     sg.setIgnoreGapsConsensus(false);
 246     sg.setshowSequenceLogo(true);
 247     sg.setNormaliseSequenceLogo(true);
 248     sg.setHidereps(true);
 249     sg.setHideCols(true);
 250     sg.setShowConsensusHistogram(true);
 251     sg.setContext(new SequenceGroup());
 252
 253     SequenceGroup sg2 = new SequenceGroup(sg);
 254     assertEquals(sg2.getName(), sg.getName());
 255     assertEquals(sg2.getDescription(), sg.getDescription());
 256     assertNotSame(sg2.getGroupColourScheme(), sg.getGroupColourScheme());
 257     assertSame(sg2.getColourScheme(), sg.getColourScheme());
 258     assertEquals(sg2.getDisplayBoxes(), sg.getDisplayBoxes());
 259     assertEquals(sg2.getDisplayText(), sg.getDisplayText());
 260     assertEquals(sg2.getColourText(), sg.getColourText());
 261     assertEquals(sg2.getShowNonconserved(), sg.getShowNonconserved());
 262     assertEquals(sg2.getOutlineColour(), sg.getOutlineColour());
 263     assertEquals(sg2.getIdColour(), sg.getIdColour());
 264     assertEquals(sg2.thresholdTextColour, sg.thresholdTextColour);
 265     assertEquals(sg2.textColour, sg.textColour);
 266     assertEquals(sg2.textColour2, sg.textColour2);
 267     assertEquals(sg2.getIgnoreGapsConsensus(), sg.getIgnoreGapsConsensus());
 268     assertEquals(sg2.isShowSequenceLogo(), sg.isShowSequenceLogo());
 269     assertEquals(sg2.isNormaliseSequenceLogo(),
 270             sg.isNormaliseSequenceLogo());
 271     assertEquals(sg2.isHidereps(), sg.isHidereps());
 272     assertEquals(sg2.isHideCols(), sg.isHideCols());
 273     assertEquals(sg2.isShowConsensusHistogram(),
 274             sg.isShowConsensusHistogram());
 275
 276     /*
 277      * copy of sequences
 278      */
 279     assertNotSame(sg2.getSequences(), sg.getSequences());
 280     assertEquals(sg2.getSequences(), sg.getSequences());
 281
 282     /*
 283      * isDefined should only be set true when a new group is added to
 284      * an alignment, not in the copy constructor
 285      */
 286     assertFalse(sg2.isDefined());
 287
 288     /*
 289      * context should be set explicitly, not by copy
 290      */
 291     assertNull(sg2.getContext());
 292   }
 293 }