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