X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FSequenceTest.java;h=0a1ca67018915beea5df7b3657b18577e7350048;hb=bbcafe66766773929c15cbe80d7e7c731f743946;hp=851caf079376d8d1db61ff58567ff8e9b8d7c4d6;hpb=e256dd3bae79419ca293722a5c7e294fad8d78f5;p=jalview.git diff --git a/test/jalview/datamodel/SequenceTest.java b/test/jalview/datamodel/SequenceTest.java index 851caf0..0a1ca67 100644 --- a/test/jalview/datamodel/SequenceTest.java +++ b/test/jalview/datamodel/SequenceTest.java @@ -26,19 +26,24 @@ import static org.testng.AssertJUnit.assertNotNull; 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.util.MapList; +import java.io.File; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Vector; +import org.testng.Assert; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; public class SequenceTest { - SequenceI seq; + Sequence seq; @BeforeMethod(alwaysRun = true) public void setUp() @@ -61,6 +66,30 @@ public class SequenceTest assertEquals("Gap interval 2 end wrong", 8, gapInt.get(1)[1]); } + @Test(groups = ("Functional")) + public void testIsProtein() + { + // test Protein + assertTrue(new Sequence("prot","ASDFASDFASDF").isProtein()); + // test DNA + assertFalse(new Sequence("prot","ACGTACGTACGT").isProtein()); + // test RNA + SequenceI sq = new Sequence("prot","ACGUACGUACGU"); + assertFalse(sq.isProtein()); + // change sequence, should trigger an update of cached result + sq.setSequence("ASDFASDFADSF"); + assertTrue(sq.isProtein()); + /* + * in situ change of sequence doesn't change hashcode :-O + * (sequence should not expose internal implementation) + */ + for (int i = 0; i < sq.getSequence().length; i++) + { + sq.getSequence()[i] = "acgtu".charAt(i % 5); + } + assertTrue(sq.isProtein()); // but it isn't + } + @Test(groups = { "Functional" }) public void testGetAnnotation() { @@ -82,8 +111,7 @@ public class SequenceTest { AlignmentAnnotation ann1 = addAnnotation("label1", "desc1", "calcId1", 1f); - AlignmentAnnotation ann2 = addAnnotation("label2", "desc2", "calcId2", - 1f); + addAnnotation("label2", "desc2", "calcId2", 1f); AlignmentAnnotation ann3 = addAnnotation("label1", "desc3", "calcId3", 1f); AlignmentAnnotation[] anns = seq.getAnnotation("label1"); @@ -105,16 +133,15 @@ public class SequenceTest @Test(groups = { "Functional" }) public void testGetAlignmentAnnotations_forCalcIdAndLabel() { - AlignmentAnnotation ann1 = addAnnotation("label1", "desc1", "calcId1", - 1f); + addAnnotation("label1", "desc1", "calcId1", 1f); AlignmentAnnotation ann2 = addAnnotation("label2", "desc2", "calcId2", 1f); - AlignmentAnnotation ann3 = addAnnotation("label2", "desc3", "calcId3", - 1f); + addAnnotation("label2", "desc3", "calcId3", 1f); AlignmentAnnotation ann4 = addAnnotation("label2", "desc3", "calcId2", 1f); - AlignmentAnnotation ann5 = addAnnotation("label5", "desc3", null, 1f); - AlignmentAnnotation ann6 = addAnnotation(null, "desc3", "calcId3", 1f); + addAnnotation("label5", "desc3", null, 1f); + addAnnotation(null, "desc3", "calcId3", 1f); + List anns = seq.getAlignmentAnnotations("calcId2", "label2"); assertEquals(2, anns.size()); @@ -309,9 +336,13 @@ public class SequenceTest assertEquals(1, sfs.length); assertSame(sf, sfs[0]); + /* * SequenceFeature on sequence and dataset sequence; returns that on * sequence + * + * 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(); sq.getDatasetSequence().addSequenceFeature(sf2); @@ -321,17 +352,20 @@ public class SequenceTest /* * 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); - sfs = sq.getSequenceFeatures(); - assertEquals(1, sfs.length); - assertSame(sf2, sfs[0]); + assertNull(sq.getDatasetSequence().getSequenceFeatures()); /* * Corrupt case - no SequenceFeature, dataset's dataset is the original * sequence. Test shows no infinite loop results. */ sq.getDatasetSequence().setSequenceFeatures(null); + /** + * is there a usecase for this ? setDatasetSequence should throw an error if + * this actually occurs. + */ sq.getDatasetSequence().setDatasetSequence(sq); // loop! assertNull(sq.getSequenceFeatures()); } @@ -377,18 +411,137 @@ public class SequenceTest } /** + * test createDatasetSequence behaves to doc + */ + @Test(groups = { "Functional" }) + public void testCreateDatasetSequence() + { + SequenceI sq = new Sequence("my","ASDASD"); + assertNull(sq.getDatasetSequence()); + SequenceI rds = sq.createDatasetSequence(); + assertNotNull(rds); + assertNull(rds.getDatasetSequence()); + assertEquals(sq.getDatasetSequence(), rds); + } + + /** * Test for deriveSequence applied to a sequence with a dataset */ @Test(groups = { "Functional" }) public void testDeriveSequence_existingDataset() { - SequenceI sq = new Sequence("Seq1", "CD"); + Sequence sq = new Sequence("Seq1", "CD"); sq.setDatasetSequence(new Sequence("Seq1", "ABCDEF")); + sq.getDatasetSequence().addSequenceFeature( + new SequenceFeature("", "", 1, 2, 0f, null)); sq.setStart(3); sq.setEnd(4); - SequenceI derived = sq.deriveSequence(); + + sq.setDescription("Test sequence description.."); + sq.setVamsasId("TestVamsasId"); + sq.addDBRef(new DBRefEntry("PDB", "version0", "1TST")); + + sq.addDBRef(new DBRefEntry("PDB", "version1", "1PDB")); + sq.addDBRef(new DBRefEntry("PDB", "version2", "2PDB")); + sq.addDBRef(new DBRefEntry("PDB", "version3", "3PDB")); + sq.addDBRef(new DBRefEntry("PDB", "version4", "4PDB")); + + sq.addPDBId(new PDBEntry("1PDB", "A", Type.PDB, "filePath/test1")); + sq.addPDBId(new PDBEntry("1PDB", "B", Type.PDB, "filePath/test1")); + sq.addPDBId(new PDBEntry("2PDB", "A", Type.MMCIF, "filePath/test2")); + sq.addPDBId(new PDBEntry("2PDB", "B", Type.MMCIF, "filePath/test2")); + + DBRefEntry pdb1pdb = new DBRefEntry("PDB", "version1", "1PDB"); + DBRefEntry pdb2pdb = new DBRefEntry("PDB", "version1", "2PDB"); + + + List primRefs = Arrays.asList(new DBRefEntry[] { pdb1pdb, + pdb2pdb }); + + sq.getDatasetSequence().addDBRef(pdb1pdb); + sq.getDatasetSequence().addDBRef(pdb2pdb); + sq.getDatasetSequence().addDBRef( + new DBRefEntry("PDB", "version3", "3PDB")); + sq.getDatasetSequence().addDBRef( + new DBRefEntry("PDB", "version4", "4PDB")); + + PDBEntry pdbe1a=new PDBEntry("1PDB", "A", Type.PDB, "filePath/test1"); + PDBEntry pdbe1b = new PDBEntry("1PDB", "B", Type.PDB, "filePath/test1"); + PDBEntry pdbe2a=new PDBEntry("2PDB", "A", Type.MMCIF, "filePath/test2"); + PDBEntry pdbe2b = new PDBEntry("2PDB", "B", Type.MMCIF, "filePath/test2"); + sq.getDatasetSequence().addPDBId( + pdbe1a); + sq.getDatasetSequence().addPDBId( + pdbe1b); + sq.getDatasetSequence().addPDBId(pdbe2a); + sq.getDatasetSequence().addPDBId(pdbe2b); + + /* + * test we added pdb entries to the dataset sequence + */ + Assert.assertEquals(sq.getDatasetSequence().getAllPDBEntries(), Arrays + .asList(new PDBEntry[] { pdbe1a, pdbe1b, pdbe2a, pdbe2b }), + "PDB Entries were not found on dataset sequence."); + + /* + * we should recover a pdb entry that is on the dataset sequence via PDBEntry + */ + Assert.assertEquals(pdbe1a, + sq.getDatasetSequence().getPDBEntry("1PDB"), + "PDB Entry '1PDB' not found on dataset sequence via getPDBEntry."); + ArrayList annotsList = new ArrayList(); + System.out.println(">>>>>> " + sq.getSequenceAsString().length()); + annotsList.add(new Annotation("A", "A", 'X', 0.1f)); + annotsList.add(new Annotation("A", "A", 'X', 0.1f)); + Annotation[] annots = annotsList.toArray(new Annotation[0]); + sq.addAlignmentAnnotation(new AlignmentAnnotation("Test annot", + "Test annot description", annots)); + sq.getDatasetSequence().addAlignmentAnnotation( + new AlignmentAnnotation("Test annot", "Test annot description", + annots)); + Assert.assertEquals(sq.getDescription(), "Test sequence description.."); + Assert.assertEquals(sq.getDBRefs().length, 5); + Assert.assertEquals(sq.getAllPDBEntries().size(), 4); + Assert.assertNotNull(sq.getAnnotation()); + Assert.assertEquals(sq.getAnnotation()[0].annotations.length, 2); + Assert.assertEquals(sq.getDatasetSequence().getDBRefs().length, 4); + Assert.assertEquals(sq.getDatasetSequence().getAllPDBEntries().size(), + 4); + Assert.assertNotNull(sq.getDatasetSequence().getAnnotation()); + + Sequence derived = (Sequence) sq.deriveSequence(); + + Assert.assertEquals(derived.getDescription(), + "Test sequence description.."); + Assert.assertEquals(derived.getDBRefs().length, 4); // come from dataset + Assert.assertEquals(derived.getAllPDBEntries().size(), 4); + Assert.assertNotNull(derived.getAnnotation()); + Assert.assertEquals(derived.getAnnotation()[0].annotations.length, 2); + Assert.assertEquals(derived.getDatasetSequence().getDBRefs().length, 4); + Assert.assertEquals(derived.getDatasetSequence().getAllPDBEntries() + .size(), 4); + Assert.assertNotNull(derived.getDatasetSequence().getAnnotation()); + 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()); + + /* + * verify we have primary db refs *just* for PDB IDs with associated + * PDBEntry objects + */ + + assertEquals(primRefs, sq.getPrimaryDBRefs()); + assertEquals(primRefs, sq.getDatasetSequence().getPrimaryDBRefs()); + + assertEquals(sq.getPrimaryDBRefs(), derived.getPrimaryDBRefs()); + } /** @@ -446,10 +599,10 @@ public class SequenceTest // but that doesn't distinguish it from an aligned sequence // which has not yet generated a dataset sequence // NB getDBRef looks inside dataset sequence if not null - DBRefEntry[] dbrefs = copy.getDBRef(); + DBRefEntry[] dbrefs = copy.getDBRefs(); assertEquals(1, dbrefs.length); - assertFalse(dbrefs[0] == seq1.getDBRef()[0]); - assertTrue(dbrefs[0].equals(seq1.getDBRef()[0])); + assertFalse(dbrefs[0] == seq1.getDBRefs()[0]); + assertTrue(dbrefs[0].equals(seq1.getDBRefs()[0])); } @Test(groups = { "Functional" }) @@ -460,6 +613,8 @@ public class SequenceTest seq1.setDescription("description"); seq1.addAlignmentAnnotation(new AlignmentAnnotation("label", "desc", 1.3d)); + // JAL-2046 - what is the contract for using a derived sequence's + // addSequenceFeature ? seq1.addSequenceFeature(new SequenceFeature("type", "desc", 22, 33, 12.4f, "group")); seq1.addPDBId(new PDBEntry("1A70", "B", Type.PDB, "File")); @@ -476,9 +631,9 @@ public class SequenceTest // getDBRef looks inside dataset sequence and this is shared, // so holds the same dbref objects - DBRefEntry[] dbrefs = copy.getDBRef(); + DBRefEntry[] dbrefs = copy.getDBRefs(); assertEquals(1, dbrefs.length); - assertSame(dbrefs[0], seq1.getDBRef()[0]); + assertSame(dbrefs[0], seq1.getDBRefs()[0]); } /** @@ -507,7 +662,11 @@ public class SequenceTest // copy has a copy of the sequence feature: SequenceFeature[] sfs = copy.getSequenceFeatures(); assertEquals(1, sfs.length); - assertFalse(sfs[0] == seq1.getSequenceFeatures()[0]); + if (seq1.getDatasetSequence()!=null && copy.getDatasetSequence()==seq1.getDatasetSequence()) { + assertTrue(sfs[0] == seq1.getSequenceFeatures()[0]); + } else { + assertFalse(sfs[0] == seq1.getSequenceFeatures()[0]); + } assertTrue(sfs[0].equals(seq1.getSequenceFeatures()[0])); // copy has a copy of the PDB entry @@ -516,4 +675,125 @@ public class SequenceTest assertFalse(pdbs.get(0) == seq1.getAllPDBEntries().get(0)); assertTrue(pdbs.get(0).equals(seq1.getAllPDBEntries().get(0))); } + + @Test(groups = "Functional") + public void testGetCharAt() + { + SequenceI sq = new Sequence("", "abcde"); + assertEquals('a', sq.getCharAt(0)); + assertEquals('e', sq.getCharAt(4)); + assertEquals(' ', sq.getCharAt(5)); + assertEquals(' ', sq.getCharAt(-1)); + } + + /** + * Tests for adding (or updating) dbrefs + * + * @see DBRefEntry#updateFrom(DBRefEntry) + */ + @Test(groups = { "Functional" }) + public void testAddDBRef() + { + SequenceI sq = new Sequence("", "abcde"); + assertNull(sq.getDBRefs()); + DBRefEntry dbref = new DBRefEntry("Uniprot", "1", "P00340"); + sq.addDBRef(dbref); + assertEquals(1, sq.getDBRefs().length); + assertSame(dbref, sq.getDBRefs()[0]); + + /* + * change of version - new entry + */ + DBRefEntry dbref2 = new DBRefEntry("Uniprot", "2", "P00340"); + sq.addDBRef(dbref2); + assertEquals(2, sq.getDBRefs().length); + assertSame(dbref, sq.getDBRefs()[0]); + assertSame(dbref2, sq.getDBRefs()[1]); + + /* + * matches existing entry - not added + */ + sq.addDBRef(new DBRefEntry("UNIPROT", "1", "p00340")); + assertEquals(2, sq.getDBRefs().length); + + /* + * different source = new entry + */ + DBRefEntry dbref3 = new DBRefEntry("UniRef", "1", "p00340"); + sq.addDBRef(dbref3); + assertEquals(3, sq.getDBRefs().length); + assertSame(dbref3, sq.getDBRefs()[2]); + + /* + * different ref = new entry + */ + DBRefEntry dbref4 = new DBRefEntry("UniRef", "1", "p00341"); + sq.addDBRef(dbref4); + assertEquals(4, sq.getDBRefs().length); + assertSame(dbref4, sq.getDBRefs()[3]); + + /* + * matching ref with a mapping - map updated + */ + DBRefEntry dbref5 = new DBRefEntry("UniRef", "1", "p00341"); + Mapping map = new Mapping(new MapList(new int[] { 1, 3 }, new int[] { + 1, 1 }, 3, 1)); + dbref5.setMap(map); + sq.addDBRef(dbref5); + assertEquals(4, sq.getDBRefs().length); + assertSame(dbref4, sq.getDBRefs()[3]); + assertSame(map, dbref4.getMap()); + + /* + * 'real' version replaces "0" version + */ + dbref2.setVersion("0"); + DBRefEntry dbref6 = new DBRefEntry(dbref2.getSource(), "3", + dbref2.getAccessionId()); + sq.addDBRef(dbref6); + assertEquals(4, sq.getDBRefs().length); + assertSame(dbref2, sq.getDBRefs()[1]); + assertEquals("3", dbref2.getVersion()); + + /* + * 'real' version replaces "source:0" version + */ + dbref3.setVersion("Uniprot:0"); + DBRefEntry dbref7 = new DBRefEntry(dbref3.getSource(), "3", + dbref3.getAccessionId()); + sq.addDBRef(dbref7); + assertEquals(4, sq.getDBRefs().length); + assertSame(dbref3, sq.getDBRefs()[2]); + assertEquals("3", dbref2.getVersion()); + } + + @Test(groups = { "Functional" }) + public void testGetPrimaryDBRefs() + { + /* + * test PDB relationships for for getPrimaryDBRefs + */ + SequenceI seq = new Sequence("aseq", "ASDF"); + DBRefEntry upentry = new DBRefEntry("UNIPROT", "0", "1qip"); + // primary - uniprot + seq.addDBRef(upentry); + // primary - type is PDB + DBRefEntry pdbentry = new DBRefEntry("PDB", "0", "1qip"); + seq.addDBRef(pdbentry); + // not primary - PDBEntry has no file + seq.addDBRef(new DBRefEntry("PDB", "0", "1AAA")); + // not primary - no PDBEntry + seq.addDBRef(new DBRefEntry("PDB", "0", "1DDD")); + // add corroborating PDB entry for primary DBref - needs to have a file as + // well as matching ID + seq.addPDBId(new PDBEntry("1QIP", null, Type.PDB, new File("/blah") + .toString())); + // not valid DBRef - no file.. + seq.addPDBId(new PDBEntry("1AAA", null, null, null)); + assertTrue("Couldn't find simple primary reference (UNIPROT)", seq + .getPrimaryDBRefs().contains(upentry)); + assertTrue("Couldn't find expected PDB primary reference", seq + .getPrimaryDBRefs().contains(pdbentry)); + assertEquals(2, seq.getPrimaryDBRefs().size()); + } }