X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FSequenceTest.java;h=4da11eb578912e4165112b016eedd9dab04c613f;hb=480d7b96f089281a3caf77d2a4e5adec09dc5bfa;hp=065bed7b37e211c1bcdfc840b2bb7dd5f666d94b;hpb=528c0f1815bc67b54618ad5b16c2162946974caf;p=jalview.git diff --git a/test/jalview/datamodel/SequenceTest.java b/test/jalview/datamodel/SequenceTest.java index 065bed7..4da11eb 100644 --- a/test/jalview/datamodel/SequenceTest.java +++ b/test/jalview/datamodel/SequenceTest.java @@ -23,12 +23,13 @@ package jalview.datamodel; import static org.testng.AssertJUnit.assertEquals; import static org.testng.AssertJUnit.assertFalse; import static org.testng.AssertJUnit.assertNotNull; +import static org.testng.AssertJUnit.assertNotSame; import static org.testng.AssertJUnit.assertNull; import static org.testng.AssertJUnit.assertSame; import static org.testng.AssertJUnit.assertTrue; -import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals; import jalview.datamodel.PDBEntry.Type; +import jalview.gui.JvOptionPane; import jalview.util.MapList; import java.io.File; @@ -37,12 +38,23 @@ import java.util.Arrays; import java.util.List; import java.util.Vector; +import junit.extensions.PA; + import org.testng.Assert; +import org.testng.annotations.BeforeClass; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; public class SequenceTest { + + @BeforeClass(alwaysRun = true) + public void setUpJvOptionPane() + { + JvOptionPane.setInteractiveMode(false); + JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); + } + Sequence seq; @BeforeMethod(alwaysRun = true) @@ -219,10 +231,10 @@ public class SequenceTest assertEquals(6, sq.findIndex(6)); assertEquals(6, sq.findIndex(9)); - sq = new Sequence("test", "-A--B-C-D-E-F--"); - assertEquals(2, sq.findIndex(1)); - assertEquals(5, sq.findIndex(2)); - assertEquals(7, sq.findIndex(3)); + sq = new Sequence("test/8-13", "-A--B-C-D-E-F--"); + assertEquals(2, sq.findIndex(8)); + assertEquals(5, sq.findIndex(9)); + assertEquals(7, sq.findIndex(10)); // before start returns 0 assertEquals(0, sq.findIndex(0)); @@ -275,19 +287,128 @@ public class SequenceTest @Test(groups = { "Functional" }) public void testDeleteChars() { + /* + * internal delete + */ SequenceI sq = new Sequence("test", "ABCDEF"); + assertNull(PA.getValue(sq, "datasetSequence")); assertEquals(1, sq.getStart()); assertEquals(6, sq.getEnd()); sq.deleteChars(2, 3); assertEquals("ABDEF", sq.getSequenceAsString()); assertEquals(1, sq.getStart()); assertEquals(5, sq.getEnd()); + assertNull(PA.getValue(sq, "datasetSequence")); + /* + * delete at start + */ sq = new Sequence("test", "ABCDEF"); sq.deleteChars(0, 2); assertEquals("CDEF", sq.getSequenceAsString()); assertEquals(3, sq.getStart()); assertEquals(6, sq.getEnd()); + assertNull(PA.getValue(sq, "datasetSequence")); + + /* + * delete at end + */ + sq = new Sequence("test", "ABCDEF"); + sq.deleteChars(4, 6); + assertEquals("ABCD", sq.getSequenceAsString()); + assertEquals(1, sq.getStart()); + assertEquals(4, sq.getEnd()); + assertNull(PA.getValue(sq, "datasetSequence")); + } + + @Test(groups = { "Functional" }) + public void testDeleteChars_withDbRefsAndFeatures() + { + /* + * internal delete - new dataset sequence created + * gets a copy of any dbrefs + */ + SequenceI sq = new Sequence("test", "ABCDEF"); + sq.createDatasetSequence(); + DBRefEntry dbr1 = new DBRefEntry("Uniprot", "0", "a123"); + sq.addDBRef(dbr1); + Object ds = PA.getValue(sq, "datasetSequence"); + assertNotNull(ds); + assertEquals(1, sq.getStart()); + assertEquals(6, sq.getEnd()); + sq.deleteChars(2, 3); + assertEquals("ABDEF", sq.getSequenceAsString()); + assertEquals(1, sq.getStart()); + assertEquals(5, sq.getEnd()); + Object newDs = PA.getValue(sq, "datasetSequence"); + assertNotNull(newDs); + assertNotSame(ds, newDs); + assertNotNull(sq.getDBRefs()); + assertEquals(1, sq.getDBRefs().length); + assertNotSame(dbr1, sq.getDBRefs()[0]); + assertEquals(dbr1, sq.getDBRefs()[0]); + + /* + * internal delete with sequence features + * (failure case for JAL-2541) + */ + sq = new Sequence("test", "ABCDEF"); + sq.createDatasetSequence(); + SequenceFeature sf1 = new SequenceFeature("Cath", "desc", 2, 4, 2f, + "CathGroup"); + sq.addSequenceFeature(sf1); + ds = PA.getValue(sq, "datasetSequence"); + assertNotNull(ds); + assertEquals(1, sq.getStart()); + assertEquals(6, sq.getEnd()); + sq.deleteChars(2, 4); + assertEquals("ABEF", sq.getSequenceAsString()); + assertEquals(1, sq.getStart()); + assertEquals(4, sq.getEnd()); + newDs = PA.getValue(sq, "datasetSequence"); + assertNotNull(newDs); + assertNotSame(ds, newDs); + List sfs = sq.getSequenceFeatures(); + assertEquals(1, sfs.size()); + assertNotSame(sf1, sfs.get(0)); + assertEquals(sf1, sfs.get(0)); + + /* + * delete at start - no new dataset sequence created + * any sequence features remain as before + */ + sq = new Sequence("test", "ABCDEF"); + sq.createDatasetSequence(); + ds = PA.getValue(sq, "datasetSequence"); + sf1 = new SequenceFeature("Cath", "desc", 2, 4, 2f, "CathGroup"); + sq.addSequenceFeature(sf1); + sq.deleteChars(0, 2); + assertEquals("CDEF", sq.getSequenceAsString()); + assertEquals(3, sq.getStart()); + assertEquals(6, sq.getEnd()); + assertSame(ds, PA.getValue(sq, "datasetSequence")); + sfs = sq.getSequenceFeatures(); + assertNotNull(sfs); + assertEquals(1, sfs.size()); + assertSame(sf1, sfs.get(0)); + + /* + * delete at end - no new dataset sequence created + * any dbrefs remain as before + */ + sq = new Sequence("test", "ABCDEF"); + sq.createDatasetSequence(); + ds = PA.getValue(sq, "datasetSequence"); + dbr1 = new DBRefEntry("Uniprot", "0", "a123"); + sq.addDBRef(dbr1); + sq.deleteChars(4, 6); + assertEquals("ABCD", sq.getSequenceAsString()); + assertEquals(1, sq.getStart()); + assertEquals(4, sq.getEnd()); + assertSame(ds, PA.getValue(sq, "datasetSequence")); + assertNotNull(sq.getDBRefs()); + assertEquals(1, sq.getDBRefs().length); + assertSame(dbr1, sq.getDBRefs()[0]); } @Test(groups = { "Functional" }) @@ -325,16 +446,16 @@ public class SequenceTest SequenceI sq = new Sequence("test", "GATCAT"); sq.createDatasetSequence(); - assertNull(sq.getSequenceFeatures()); + assertTrue(sq.getSequenceFeatures().isEmpty()); /* * SequenceFeature on sequence */ - SequenceFeature sf = new SequenceFeature(); + SequenceFeature sf = new SequenceFeature("Cath", "desc", 2, 4, 2f, null); sq.addSequenceFeature(sf); - SequenceFeature[] sfs = sq.getSequenceFeatures(); - assertEquals(1, sfs.length); - assertSame(sf, sfs[0]); + List sfs = sq.getSequenceFeatures(); + assertEquals(1, sfs.size()); + assertSame(sf, sfs.get(0)); /* * SequenceFeature on sequence and dataset sequence; returns that on @@ -343,18 +464,19 @@ public class SequenceTest * Note JAL-2046: spurious: we have no use case for this at the moment. * This test also buggy - as sf2.equals(sf), no new feature is added */ - SequenceFeature sf2 = new SequenceFeature(); + SequenceFeature sf2 = new SequenceFeature("Cath", "desc", 2, 4, 2f, + null); sq.getDatasetSequence().addSequenceFeature(sf2); sfs = sq.getSequenceFeatures(); - assertEquals(1, sfs.length); - assertSame(sf, sfs[0]); + assertEquals(1, sfs.size()); + assertSame(sf, sfs.get(0)); /* * SequenceFeature on dataset sequence only * Note JAL-2046: spurious: we have no use case for setting a non-dataset sequence's feature array to null at the moment. */ sq.setSequenceFeatures(null); - assertNull(sq.getDatasetSequence().getSequenceFeatures()); + assertTrue(sq.getDatasetSequence().getSequenceFeatures().isEmpty()); /* * Corrupt case - no SequenceFeature, dataset's dataset is the original @@ -375,7 +497,7 @@ public class SequenceTest assertTrue(e.getMessage().toLowerCase() .contains("implementation error")); } - assertNull(sq.getSequenceFeatures()); + assertTrue(sq.getSequenceFeatures().isEmpty()); } /** @@ -425,11 +547,23 @@ public class SequenceTest public void testCreateDatasetSequence() { SequenceI sq = new Sequence("my", "ASDASD"); + sq.addSequenceFeature(new SequenceFeature("type", "desc", 1, 10, 1f, + "group")); + sq.addDBRef(new DBRefEntry("source", "version", "accession")); assertNull(sq.getDatasetSequence()); + assertNotNull(PA.getValue(sq, "sequenceFeatureStore")); + assertNotNull(PA.getValue(sq, "dbrefs")); + SequenceI rds = sq.createDatasetSequence(); assertNotNull(rds); assertNull(rds.getDatasetSequence()); - assertEquals(sq.getDatasetSequence(), rds); + assertSame(sq.getDatasetSequence(), rds); + + // sequence features and dbrefs transferred to dataset sequence + assertNull(PA.getValue(sq, "sequenceFeatureStore")); + assertNull(PA.getValue(sq, "dbrefs")); + assertNotNull(PA.getValue(rds, "sequenceFeatureStore")); + assertNotNull(PA.getValue(rds, "dbrefs")); } /** @@ -536,12 +670,9 @@ public class SequenceTest assertEquals("CD", derived.getSequenceAsString()); assertSame(sq.getDatasetSequence(), derived.getDatasetSequence()); - assertNull(sq.sequenceFeatures); - assertNull(derived.sequenceFeatures); // derived sequence should access dataset sequence features assertNotNull(sq.getSequenceFeatures()); - assertArrayEquals(sq.getSequenceFeatures(), - derived.getSequenceFeatures()); + assertEquals(sq.getSequenceFeatures(), derived.getSequenceFeatures()); /* * verify we have primary db refs *just* for PDB IDs with associated @@ -671,18 +802,18 @@ public class SequenceTest assertEquals(anns[0].score, seq1.getAnnotation()[0].score); // copy has a copy of the sequence feature: - SequenceFeature[] sfs = copy.getSequenceFeatures(); - assertEquals(1, sfs.length); + List sfs = copy.getSequenceFeatures(); + assertEquals(1, sfs.size()); if (seq1.getDatasetSequence() != null && copy.getDatasetSequence() == seq1.getDatasetSequence()) { - assertTrue(sfs[0] == seq1.getSequenceFeatures()[0]); + assertSame(sfs.get(0), seq1.getSequenceFeatures().get(0)); } else { - assertFalse(sfs[0] == seq1.getSequenceFeatures()[0]); + assertNotSame(sfs.get(0), seq1.getSequenceFeatures().get(0)); } - assertTrue(sfs[0].equals(seq1.getSequenceFeatures()[0])); + assertEquals(sfs.get(0), seq1.getSequenceFeatures().get(0)); // copy has a copy of the PDB entry Vector pdbs = copy.getAllPDBEntries(); @@ -701,6 +832,36 @@ public class SequenceTest assertEquals(' ', sq.getCharAt(-1)); } + @Test(groups = { "Functional" }) + public void testAddSequenceFeatures() + { + SequenceI sq = new Sequence("", "abcde"); + // type may not be null + assertFalse(sq.addSequenceFeature(new SequenceFeature(null, "desc", 4, + 8, 0f, null))); + assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 4, + 8, 0f, null))); + // can't add a duplicate feature + assertFalse(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", + 4, 8, 0f, null))); + // can add a different feature + assertTrue(sq.addSequenceFeature(new SequenceFeature("Scop", "desc", 4, + 8, 0f, null))); // different type + assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", + "description", 4, 8, 0f, null)));// different description + assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 3, + 8, 0f, null))); // different start position + assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 4, + 9, 0f, null))); // different end position + assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 4, + 8, 1f, null))); // different score + assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 4, + 8, Float.NaN, null))); // score NaN + assertTrue(sq.addSequenceFeature(new SequenceFeature("Cath", "desc", 4, + 8, 0f, "Metal"))); // different group + assertEquals(8, sq.getFeatures().getAllFeatures().size()); + } + /** * Tests for adding (or updating) dbrefs * @@ -1000,4 +1161,24 @@ public class SequenceTest seq2.createDatasetSequence(); seq.setDatasetSequence(seq2); } + + @Test + public void testFindPositions() + { + SequenceI sq = new Sequence("Seq", "ABC--DE-F", 8, 13); + + Range range = sq.findPositions(1, 4); // BC + assertEquals(new Range(9, 10), range); + + range = sq.findPositions(2, 4); // C + assertEquals(new Range(10, 10), range); + + assertNull(sq.findPositions(3, 4)); // all gaps + + range = sq.findPositions(2, 6); // CDE + assertEquals(new Range(10, 12), range); + + range = sq.findPositions(3, 7); // DE + assertEquals(new Range(11, 12), range); + } }