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.assertNull;
   7 import static org.testng.Assert.assertSame;
   8 import static org.testng.Assert.assertTrue;
   9 import static org.testng.Assert.fail;
  10
  11 import jalview.schemes.NucleotideColourScheme;
  12
  13 import org.testng.annotations.Test;
  14
  15 import junit.extensions.PA;
  16
  17 public class SequenceGroupTest
  18 {
  19   @Test(groups={"Functional"})
  20   public void testAddSequence()
  21   {
  22     SequenceGroup sg = new SequenceGroup();
  23     assertTrue(sg.getSequences().isEmpty());
  24
  25     SequenceI seq1 = new Sequence("seq1", "abc");
  26     SequenceI seq2 = new Sequence("seq2", "abc");
  27     SequenceI seq3 = new Sequence(seq1);
  28
  29     sg.addSequence(null, false);
  30     assertTrue(sg.getSequences().isEmpty());
  31     sg.addSequence(seq1, false);
  32     assertEquals(sg.getSequences().size(), 1);
  33     assertTrue(sg.getSequences().contains(seq1));
  34     // adding the same sequence again does nothing
  35     sg.addSequence(seq1, false);
  36     assertEquals(sg.getSequences().size(), 1);
  37     assertTrue(sg.getSequences().contains(seq1));
  38     sg.addSequence(seq2, false);
  39     sg.addSequence(seq2, false);
  40     sg.addSequence(seq3, false);
  41     assertEquals(sg.getSequences().size(), 3);
  42     assertTrue(sg.getSequences().contains(seq1));
  43     assertTrue(sg.getSequences().contains(seq2));
  44     assertTrue(sg.getSequences().contains(seq3));
  45   }
  46
  47   @Test(groups={"Functional"})
  48   public void testAddOrRemove()
  49   {
  50     SequenceGroup sg = new SequenceGroup();
  51     assertTrue(sg.getSequences().isEmpty());
  52
  53     SequenceI seq1 = new Sequence("seq1", "abc");
  54     SequenceI seq2 = new Sequence("seq2", "abc");
  55     SequenceI seq3 = new Sequence(seq1);
  56
  57     sg.addOrRemove(seq1, false);
  58     assertEquals(sg.getSequences().size(), 1);
  59     sg.addOrRemove(seq2, false);
  60     assertEquals(sg.getSequences().size(), 2);
  61     sg.addOrRemove(seq3, false);
  62     assertEquals(sg.getSequences().size(), 3);
  63     assertTrue(sg.getSequences().contains(seq1));
  64     assertTrue(sg.getSequences().contains(seq2));
  65     assertTrue(sg.getSequences().contains(seq3));
  66     sg.addOrRemove(seq1, false);
  67     assertEquals(sg.getSequences().size(), 2);
  68     assertFalse(sg.getSequences().contains(seq1));
  69   }
  70
  71   @Test(groups={"Functional"})
  72   public void testGetColourScheme()
  73   {
  74     SequenceGroup sg = new SequenceGroup();
  75     assertNotNull(sg.getGroupColourScheme());
  76     assertNull(sg.getColourScheme());
  77
  78     sg.setGroupColourScheme(null);
  79     assertNull(sg.getColourScheme());
  80
  81     NucleotideColourScheme scheme = new NucleotideColourScheme();
  82     sg.setColourScheme(scheme);
  83     assertSame(scheme, sg.getColourScheme());
  84   }
  85
  86   @Test(groups={"Functional"})
  87   public void testSetContext()
  88   {
  89     SequenceGroup sg1 = new SequenceGroup();
  90     SequenceGroup sg2 = new SequenceGroup();
  91     SequenceGroup sg3 = new SequenceGroup();
  92     assertNull(sg1.getContext());
  93     sg1.setContext(null);
  94     assertNull(sg1.getContext());
  95     try
  96     {
  97       sg1.setContext(sg1); // self-reference :-O
  98       fail("Expected exception");
  99     } catch (IllegalArgumentException e)
 100     {
 101       // expected
 102       assertNull(sg1.getContext());
 103     }
 104     sg1.setContext(sg2);
 105     assertSame(sg2, sg1.getContext());
 106     sg2.setContext(sg3);
 107     try
 108     {
 109       sg3.setContext(sg1); // circular reference :-O
 110       fail("Expected exception");
 111     } catch (IllegalArgumentException e)
 112     {
 113       // expected
 114       assertNull(sg3.getContext());
 115     }
 116
 117     /*
 118      * use PrivilegedAccessor to 'force' a SequenceGroup with
 119      * a circular context reference
 120      */
 121     PA.setValue(sg2, "context", sg2);
 122     try
 123     {
 124       sg3.setContext(sg2, false); // circular reference in sg2
 125       fail("Expected exception");
 126     } catch (IllegalArgumentException e)
 127     {
 128       // expected
 129       assertNull(sg3.getContext());
 130     }
 131
 132     // test isDefined setting behaviour
 133     sg2 = new SequenceGroup();
 134     sg1.setContext(null, false);
 135     assertFalse(sg1.isDefined());
 136
 137     sg1.setContext(sg2, false);
 138     assertFalse(sg1.isDefined());
 139
 140     sg1.setContext(sg2, true);
 141     assertTrue(sg1.isDefined());
 142
 143     // setContext without defined parameter does not change isDefined
 144     sg1.setContext(null);
 145     assertTrue(sg1.isDefined());
 146
 147     sg1.setContext(null, false);
 148     sg1.setContext(sg2);
 149     assertFalse(sg1.isDefined());
 150   }
 151
 152   @Test(groups = { "Functional" })
 153   public void testContains()
 154   {
 155     /*
 156      * essentially the same tests as AlignmentI.findGroup
 157      * but from a particular group's perspective
 158      */
 159
 160     SequenceI seq1 = new Sequence("seq1", "ABCDEF---GHI");
 161     SequenceI seq2 = new Sequence("seq2", "---JKLMNO---");
 162     AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2 });
 163     /*
 164      * add a group consisting of just "DEF"
 165      */
 166     SequenceGroup sg1 = new SequenceGroup();
 167     sg1.addSequence(seq1, false);
 168     sg1.setStartRes(3);
 169     sg1.setEndRes(5);
 170
 171     /*
 172      * test sequence membership
 173      */
 174     assertTrue(sg1.contains(seq1));
 175     assertFalse(sg1.contains(seq2));
 176
 177     /*
 178      * test sequence+position
 179      */
 180
 181     assertFalse(sg1.contains(seq1, 2)); // position not in group
 182     assertFalse(sg1.contains(seq1, 6)); // position not in group
 183     assertFalse(sg1.contains(seq2, 5)); // sequence not in group
 184     assertTrue(sg1.contains(seq1, 3)); // yes
 185     assertTrue(sg1.contains(seq1, 4));
 186     assertTrue(sg1.contains(seq1, 5));
 187
 188     /*
 189      * add a group consisting of
 190      * EF--
 191      * KLMN
 192      */
 193     SequenceGroup sg2 = new SequenceGroup();
 194     sg2.addSequence(seq1, false);
 195     sg2.addSequence(seq2, false);
 196     sg2.setStartRes(4);
 197     sg2.setEndRes(7);
 198     a.addGroup(sg2);
 199
 200     /*
 201      * if a residue is in more than one group, method returns
 202      * the first found (in order groups were added)
 203      */
 204     assertTrue(sg2.contains(seq1, 4));
 205     assertTrue(sg2.contains(seq1, 5));
 206
 207     /*
 208      * seq2 only belongs to the second group
 209      */
 210     assertTrue(sg2.contains(seq2, 4));
 211     assertTrue(sg2.contains(seq2, 5));
 212     assertTrue(sg2.contains(seq2, 6));
 213     assertTrue(sg2.contains(seq2, 7));
 214     assertFalse(sg2.contains(seq2, 3));
 215     assertFalse(sg2.contains(seq2, 8));
 216     sg2.setEndRes(8);
 217     assertTrue(sg2.contains(seq2, 8));
 218     sg2.deleteSequence(seq2, false);
 219     assertFalse(sg2.contains(seq2));
 220
 221   }
 222 }