Merge branch 'develop' into bug/JAL-2255_seq-fetcher-broken-on-linux

[jalview.git] / test / jalview / datamodel / SequenceGroupTest.java

diff --git a/test/jalview/datamodel/SequenceGroupTest.java b/test/jalview/datamodel/SequenceGroupTest.java
new file mode 100644 (file)
index 0000000..6e1c2db
--- /dev/null
+++ b/test/jalview/datamodel/SequenceGroupTest.java
@@ -0,0 +1,203 @@
+package jalview.datamodel;
+
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertNull;
+import static org.testng.Assert.assertSame;
+import static org.testng.Assert.assertTrue;
+import static org.testng.Assert.fail;
+
+import jalview.schemes.NucleotideColourScheme;
+
+import junit.extensions.PA;
+
+import org.testng.annotations.Test;
+
+public class SequenceGroupTest
+{
+  @Test(groups={"Functional"})
+  public void testAddSequence()
+  {
+    SequenceGroup sg = new SequenceGroup();
+    assertTrue(sg.getSequences().isEmpty());
+
+    SequenceI seq1 = new Sequence("seq1", "abc");
+    SequenceI seq2 = new Sequence("seq2", "abc");
+    SequenceI seq3 = new Sequence(seq1);
+
+    sg.addSequence(null, false);
+    assertTrue(sg.getSequences().isEmpty());
+    sg.addSequence(seq1, false);
+    assertEquals(sg.getSequences().size(), 1);
+    assertTrue(sg.getSequences().contains(seq1));
+    // adding the same sequence again does nothing
+    sg.addSequence(seq1, false);
+    assertEquals(sg.getSequences().size(), 1);
+    assertTrue(sg.getSequences().contains(seq1));
+    sg.addSequence(seq2, false);
+    sg.addSequence(seq2, false);
+    sg.addSequence(seq3, false);
+    assertEquals(sg.getSequences().size(), 3);
+    assertTrue(sg.getSequences().contains(seq1));
+    assertTrue(sg.getSequences().contains(seq2));
+    assertTrue(sg.getSequences().contains(seq3));
+  }
+
+  @Test(groups={"Functional"})
+  public void testAddOrRemove()
+  {
+    SequenceGroup sg = new SequenceGroup();
+    assertTrue(sg.getSequences().isEmpty());
+  
+    SequenceI seq1 = new Sequence("seq1", "abc");
+    SequenceI seq2 = new Sequence("seq2", "abc");
+    SequenceI seq3 = new Sequence(seq1);
+  
+    sg.addOrRemove(seq1, false);
+    assertEquals(sg.getSequences().size(), 1);
+    sg.addOrRemove(seq2, false);
+    assertEquals(sg.getSequences().size(), 2);
+    sg.addOrRemove(seq3, false);
+    assertEquals(sg.getSequences().size(), 3);
+    assertTrue(sg.getSequences().contains(seq1));
+    assertTrue(sg.getSequences().contains(seq2));
+    assertTrue(sg.getSequences().contains(seq3));
+    sg.addOrRemove(seq1, false);
+    assertEquals(sg.getSequences().size(), 2);
+    assertFalse(sg.getSequences().contains(seq1));
+  }
+
+  @Test(groups={"Functional"})
+  public void testGetColourScheme()
+  {
+    SequenceGroup sg = new SequenceGroup();
+    assertNotNull(sg.getGroupColourScheme());
+    assertNull(sg.getColourScheme());
+
+    sg.setGroupColourScheme(null);
+    assertNull(sg.getColourScheme());
+
+    NucleotideColourScheme scheme = new NucleotideColourScheme();
+    sg.setColourScheme(scheme);
+    assertSame(scheme, sg.getColourScheme());
+  }
+
+  @Test(groups={"Functional"})
+  public void testSetContext()
+  {
+    SequenceGroup sg1 = new SequenceGroup();
+    SequenceGroup sg2 = new SequenceGroup();
+    SequenceGroup sg3 = new SequenceGroup();
+    assertNull(sg1.getContext());
+    sg1.setContext(null);
+    assertNull(sg1.getContext());
+    try
+    {
+      sg1.setContext(sg1); // self-reference :-O
+      fail("Expected exception");
+    } catch (IllegalArgumentException e)
+    {
+      // expected
+      assertNull(sg1.getContext());
+    }
+    sg1.setContext(sg2);
+    assertSame(sg2, sg1.getContext());
+    sg2.setContext(sg3);
+    try
+    {
+      sg3.setContext(sg1); // circular reference :-O
+      fail("Expected exception");
+    } catch (IllegalArgumentException e)
+    {
+      // expected
+      assertNull(sg3.getContext());
+    }
+
+    /*
+     * use PrivilegedAccessor to 'force' a SequenceGroup with
+     * a circular context reference
+     */
+    PA.setValue(sg2, "context", sg2);
+    try
+    {
+      sg3.setContext(sg2); // circular reference in sg2
+      fail("Expected exception");
+    } catch (IllegalArgumentException e)
+    {
+      // expected
+      assertNull(sg3.getContext());
+    }
+  }
+
+  @Test(groups = { "Functional" })
+  public void testContains()
+  {
+    /* 
+     * essentially the same tests as AlignmentI.findGroup 
+     * but from a particular group's perspective
+     */
+
+    SequenceI seq1 = new Sequence("seq1", "ABCDEF---GHI");
+    SequenceI seq2 = new Sequence("seq2", "---JKLMNO---");
+    AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2 });
+    /*
+     * add a group consisting of just "DEF"
+     */
+    SequenceGroup sg1 = new SequenceGroup();
+    sg1.addSequence(seq1, false);
+    sg1.setStartRes(3);
+    sg1.setEndRes(5);
+
+    /*
+     * test sequence membership
+     */
+    assertTrue(sg1.contains(seq1));
+    assertFalse(sg1.contains(seq2));
+
+    /*
+     * test sequence+position
+     */
+
+    assertFalse(sg1.contains(seq1, 2)); // position not in group
+    assertFalse(sg1.contains(seq1, 6)); // position not in group
+    assertFalse(sg1.contains(seq2, 5)); // sequence not in group
+    assertTrue(sg1.contains(seq1, 3)); // yes
+    assertTrue(sg1.contains(seq1, 4));
+    assertTrue(sg1.contains(seq1, 5));
+
+    /*
+     * add a group consisting of 
+     * EF--
+     * KLMN
+     */
+    SequenceGroup sg2 = new SequenceGroup();
+    sg2.addSequence(seq1, false);
+    sg2.addSequence(seq2, false);
+    sg2.setStartRes(4);
+    sg2.setEndRes(7);
+    a.addGroup(sg2);
+
+    /*
+     * if a residue is in more than one group, method returns
+     * the first found (in order groups were added)
+     */
+    assertTrue(sg2.contains(seq1, 4));
+    assertTrue(sg2.contains(seq1, 5));
+
+    /*
+     * seq2 only belongs to the second group
+     */
+    assertTrue(sg2.contains(seq2, 4));
+    assertTrue(sg2.contains(seq2, 5));
+    assertTrue(sg2.contains(seq2, 6));
+    assertTrue(sg2.contains(seq2, 7));
+    assertFalse(sg2.contains(seq2, 3));
+    assertFalse(sg2.contains(seq2, 8));
+    sg2.setEndRes(8);
+    assertTrue(sg2.contains(seq2, 8));
+    sg2.deleteSequence(seq2, false);
+    assertFalse(sg2.contains(seq2));
+
+  }
+}