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