X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FSequenceTest.java;h=948a5fb5717d1fcbd04413484653a24b25402a00;hb=eb3e681d6e82ccdd5d312d1981dfb306e7f479f0;hp=79bb2bb066e26534b220dde57ea83f7b3cc403f5;hpb=6536eebed40b833ad60803e8f2a4b0a9bd395035;p=jalview.git diff --git a/test/jalview/datamodel/SequenceTest.java b/test/jalview/datamodel/SequenceTest.java index 79bb2bb..948a5fb 100644 --- a/test/jalview/datamodel/SequenceTest.java +++ b/test/jalview/datamodel/SequenceTest.java @@ -28,19 +28,13 @@ import static org.testng.AssertJUnit.assertNull; import static org.testng.AssertJUnit.assertSame; import static org.testng.AssertJUnit.assertTrue; -import jalview.analysis.AlignmentGenerator; -import jalview.commands.EditCommand; -import jalview.commands.EditCommand.Action; -import jalview.datamodel.PDBEntry.Type; -import jalview.gui.JvOptionPane; -import jalview.util.MapList; - import java.io.File; import java.util.ArrayList; import java.util.Arrays; import java.util.BitSet; import java.util.Iterator; import java.util.List; +import java.util.Locale; import java.util.Vector; import org.testng.Assert; @@ -48,11 +42,17 @@ import org.testng.annotations.BeforeClass; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; +import jalview.analysis.AlignmentGenerator; +import jalview.bin.Cache; +import jalview.commands.EditCommand; +import jalview.commands.EditCommand.Action; +import jalview.datamodel.PDBEntry.Type; +import jalview.gui.JvOptionPane; +import jalview.util.MapList; import junit.extensions.PA; public class SequenceTest { - @BeforeClass(alwaysRun = true) public void setUpJvOptionPane() { @@ -60,6 +60,12 @@ public class SequenceTest JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); } + @BeforeMethod(alwaysRun = true) + public void loadProperties() + { + Cache.loadProperties("test/jalview/util/comparisonTestProps.jvprops"); + } + Sequence seq; @BeforeMethod(alwaysRun = true) @@ -92,7 +98,8 @@ public class SequenceTest assertEquals("getInsertionsAsBits didn't mark expected number of gaps", 6, gapfield.cardinality()); - assertEquals("getInsertionsAsBits not correct.", expectedgaps, gapfield); + assertEquals("getInsertionsAsBits not correct.", expectedgaps, + gapfield); } @Test(groups = ("Functional")) @@ -110,6 +117,27 @@ public class SequenceTest assertTrue(sq.isProtein()); } + @Test(groups = ("Functional")) + public void testIsProteinWithXorNAmbiguityCodes() + { + // test Protein with N - poly asparagine + assertTrue(new Sequence("prot", "ASDFASDFASDFNNNNNNNNN").isProtein()); + assertTrue(new Sequence("prot", "NNNNNNNNNNNNNNNNNNNNN").isProtein()); + // test Protein with X + assertTrue(new Sequence("prot", "ASDFASDFASDFXXXXXXXXX").isProtein()); + // test DNA with X + assertFalse(new Sequence("prot", "ACGTACGTACGTXXXXXXXX").isProtein()); + // short sequence is nucleotide only if 50% is nucleotide and remaining N/X + // is either N or X only + assertTrue(new Sequence("prot", "ACGTACGTACGTXN").isProtein()); + // test DNA with N + assertFalse(new Sequence("prot", "ACGTACGTACGTNNNNNNNN").isProtein()); + // test RNA with X + assertFalse(new Sequence("prot", "ACGUACGUACGUACTGACAXX").isProtein()); + assertFalse(new Sequence("prot", "ACGUACGUACGUXXXXXXXXX").isProtein()); + assertFalse(new Sequence("prot", "ACGUACGUACGUNNNNNNNNN").isProtein()); + } + @Test(groups = { "Functional" }) public void testGetAnnotation() { @@ -175,6 +203,38 @@ public class SequenceTest assertTrue(seq.getAlignmentAnnotations(null, null).isEmpty()); } + @Test(groups = { "Functional" }) + public void testGetAlignmentAnnotations_forCalcIdLabelAndDescription() + { + addAnnotation("label1", "desc1", "calcId1", 1f); + AlignmentAnnotation ann2 = addAnnotation("label2", "desc2", "calcId2", + 1f); + addAnnotation("label2", "desc3", "calcId3", 1f); + AlignmentAnnotation ann4 = addAnnotation("label2", "desc3", "calcId2", + 1f); + addAnnotation("label5", "desc3", null, 1f); + addAnnotation(null, "desc3", "calcId3", 1f); + + List anns = seq.getAlignmentAnnotations("calcId2", + "label2", "desc3"); + assertEquals(1, anns.size()); + assertSame(ann4, anns.get(0)); + /** + * null matching should fail + */ + assertTrue(seq.getAlignmentAnnotations("calcId3", "label2", null) + .isEmpty()); + + assertTrue(seq.getAlignmentAnnotations("calcId2", "label3", null) + .isEmpty()); + assertTrue(seq.getAlignmentAnnotations("calcId3", "label5", null) + .isEmpty()); + assertTrue( + seq.getAlignmentAnnotations("calcId2", null, null).isEmpty()); + assertTrue(seq.getAlignmentAnnotations(null, "label3", null).isEmpty()); + assertTrue(seq.getAlignmentAnnotations(null, null, null).isEmpty()); + } + /** * Tests for addAlignmentAnnotation. Note this method has the side-effect of * setting the sequenceRef on the annotation. Adding the same annotation twice @@ -184,8 +244,8 @@ public class SequenceTest public void testAddAlignmentAnnotation() { assertNull(seq.getAnnotation()); - final AlignmentAnnotation annotation = new AlignmentAnnotation("a", - "b", 2d); + final AlignmentAnnotation annotation = new AlignmentAnnotation("a", "b", + 2d); assertNull(annotation.sequenceRef); seq.addAlignmentAnnotation(annotation); assertSame(seq, annotation.sequenceRef); @@ -290,6 +350,61 @@ public class SequenceTest assertEquals(0, sq.findIndex(2)); } + @Test(groups = { "Functional" }) + public void testFindPositions() + { + SequenceI sq = new Sequence("test/8-13", "-ABC---DE-F--"); + + /* + * invalid inputs + */ + assertNull(sq.findPositions(6, 5)); + assertNull(sq.findPositions(0, 5)); + assertNull(sq.findPositions(-1, 5)); + + /* + * all gapped ranges + */ + assertNull(sq.findPositions(1, 1)); // 1-based columns + assertNull(sq.findPositions(5, 5)); + assertNull(sq.findPositions(5, 6)); + assertNull(sq.findPositions(5, 7)); + + /* + * all ungapped ranges + */ + assertEquals(new Range(8, 8), sq.findPositions(2, 2)); // A + assertEquals(new Range(8, 9), sq.findPositions(2, 3)); // AB + assertEquals(new Range(8, 10), sq.findPositions(2, 4)); // ABC + assertEquals(new Range(9, 10), sq.findPositions(3, 4)); // BC + + /* + * gap to ungapped range + */ + assertEquals(new Range(8, 10), sq.findPositions(1, 4)); // ABC + assertEquals(new Range(11, 12), sq.findPositions(6, 9)); // DE + + /* + * ungapped to gapped range + */ + assertEquals(new Range(10, 10), sq.findPositions(4, 5)); // C + assertEquals(new Range(9, 13), sq.findPositions(3, 11)); // BCDEF + + /* + * ungapped to ungapped enclosing gaps + */ + assertEquals(new Range(10, 11), sq.findPositions(4, 8)); // CD + assertEquals(new Range(8, 13), sq.findPositions(2, 11)); // ABCDEF + + /* + * gapped to gapped enclosing ungapped + */ + assertEquals(new Range(8, 10), sq.findPositions(1, 5)); // ABC + assertEquals(new Range(11, 12), sq.findPositions(5, 10)); // DE + assertEquals(new Range(8, 13), sq.findPositions(1, 13)); // the lot + assertEquals(new Range(8, 13), sq.findPositions(1, 99)); + } + /** * Tests for the method that returns a dataset sequence position (start..) for * an aligned column position (base 0). @@ -304,7 +419,7 @@ public class SequenceTest SequenceI sq = new Sequence("test/8-13", "ABCDEF"); assertEquals(8, sq.findPosition(0)); // Sequence should now hold a cursor at [8, 0] - assertEquals("test:Pos8:Col1:startCol1:endCol0:tok0", + assertEquals("test:Pos8:Col1:startCol1:endCol0:tok1", PA.getValue(sq, "cursor").toString()); SequenceCursor cursor = (SequenceCursor) PA.getValue(sq, "cursor"); int token = (int) PA.getValue(sq, "changeCount"); @@ -320,24 +435,24 @@ public class SequenceTest cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(++token, (int) PA.getValue(sq, "changeCount")); assertEquals(new SequenceCursor(sq, 13, 6, token), cursor); - assertEquals("test:Pos13:Col6:startCol1:endCol6:tok1", + assertEquals("test:Pos13:Col6:startCol1:endCol6:tok2", PA.getValue(sq, "cursor").toString()); // assertEquals(-1, seq.findPosition(6)); // fails sq = new Sequence("test/8-11", "AB-C-D--"); - token = (int) PA.getValue(sq, "changeCount"); // 0 + token = (int) PA.getValue(sq, "changeCount"); // 1 for setStart assertEquals(8, sq.findPosition(0)); cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(new SequenceCursor(sq, 8, 1, token), cursor); - assertEquals("test:Pos8:Col1:startCol1:endCol0:tok0", + assertEquals("test:Pos8:Col1:startCol1:endCol0:tok1", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); assertEquals(9, sq.findPosition(1)); cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(new SequenceCursor(sq, 9, 2, ++token), cursor); - assertEquals("test:Pos9:Col2:startCol1:endCol0:tok1", + assertEquals("test:Pos9:Col2:startCol1:endCol0:tok2", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); @@ -346,14 +461,14 @@ public class SequenceTest assertEquals(10, sq.findPosition(2)); cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(new SequenceCursor(sq, 9, 2, ++token), cursor); - assertEquals("test:Pos9:Col2:startCol1:endCol0:tok2", + assertEquals("test:Pos9:Col2:startCol1:endCol0:tok3", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); assertEquals(10, sq.findPosition(3)); cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(new SequenceCursor(sq, 10, 4, ++token), cursor); - assertEquals("test:Pos10:Col4:startCol1:endCol0:tok3", + assertEquals("test:Pos10:Col4:startCol1:endCol0:tok4", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); @@ -362,7 +477,7 @@ public class SequenceTest assertEquals(11, sq.findPosition(4)); cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(new SequenceCursor(sq, 10, 4, ++token), cursor); - assertEquals("test:Pos10:Col4:startCol1:endCol0:tok4", + assertEquals("test:Pos10:Col4:startCol1:endCol0:tok5", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); @@ -370,7 +485,7 @@ public class SequenceTest cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(new SequenceCursor(sq, 11, 6, ++token), cursor); // lastCol has been found and saved in the cursor - assertEquals("test:Pos11:Col6:startCol1:endCol6:tok5", + assertEquals("test:Pos11:Col6:startCol1:endCol6:tok6", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); @@ -386,6 +501,7 @@ public class SequenceTest sq = new Sequence("test/8-13", "--AB-C-DEF--"); assertEquals(8, sq.findPosition(0)); assertNull(PA.getValue(sq, "cursor")); + assertEquals(1, PA.getValue(sq, "changeCount")); sq.sequenceChanged(); assertEquals(8, sq.findPosition(1)); @@ -393,41 +509,41 @@ public class SequenceTest sq.sequenceChanged(); assertEquals(8, sq.findPosition(2)); - assertEquals("test:Pos8:Col3:startCol3:endCol0:tok2", + assertEquals("test:Pos8:Col3:startCol3:endCol0:tok3", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); assertEquals(9, sq.findPosition(3)); - assertEquals("test:Pos9:Col4:startCol3:endCol0:tok3", + assertEquals("test:Pos9:Col4:startCol3:endCol0:tok4", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); // column[4] is a gap, returns next residue pos (C10) // cursor is set to last residue found [B] assertEquals(10, sq.findPosition(4)); - assertEquals("test:Pos9:Col4:startCol3:endCol0:tok4", + assertEquals("test:Pos9:Col4:startCol3:endCol0:tok5", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); assertEquals(10, sq.findPosition(5)); - assertEquals("test:Pos10:Col6:startCol3:endCol0:tok5", + assertEquals("test:Pos10:Col6:startCol3:endCol0:tok6", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); // column[6] is a gap, returns next residue pos (D11) // cursor is set to last residue found [C] assertEquals(11, sq.findPosition(6)); - assertEquals("test:Pos10:Col6:startCol3:endCol0:tok6", + assertEquals("test:Pos10:Col6:startCol3:endCol0:tok7", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); assertEquals(11, sq.findPosition(7)); - assertEquals("test:Pos11:Col8:startCol3:endCol0:tok7", + assertEquals("test:Pos11:Col8:startCol3:endCol0:tok8", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); assertEquals(12, sq.findPosition(8)); - assertEquals("test:Pos12:Col9:startCol3:endCol0:tok8", + assertEquals("test:Pos12:Col9:startCol3:endCol0:tok9", PA.getValue(sq, "cursor").toString()); /* @@ -435,12 +551,12 @@ public class SequenceTest */ sq.sequenceChanged(); assertEquals(13, sq.findPosition(9)); - assertEquals("test:Pos13:Col10:startCol3:endCol10:tok9", + assertEquals("test:Pos13:Col10:startCol3:endCol10:tok10", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); assertEquals(14, sq.findPosition(10)); - assertEquals("test:Pos13:Col10:startCol3:endCol10:tok10", + assertEquals("test:Pos13:Col10:startCol3:endCol10:tok11", PA.getValue(sq, "cursor").toString()); /* @@ -449,12 +565,12 @@ public class SequenceTest */ sq.sequenceChanged(); assertEquals(14, sq.findPosition(11)); - assertEquals("test:Pos13:Col10:startCol3:endCol10:tok11", + assertEquals("test:Pos13:Col10:startCol3:endCol10:tok12", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); assertEquals(14, sq.findPosition(99)); - assertEquals("test:Pos13:Col10:startCol3:endCol10:tok12", + assertEquals("test:Pos13:Col10:startCol3:endCol10:tok13", PA.getValue(sq, "cursor").toString()); /* @@ -462,20 +578,19 @@ public class SequenceTest */ sq = new Sequence("test/8-13", "--AB-C-DEF"); assertEquals(13, sq.findPosition(9)); - assertEquals("test:Pos13:Col10:startCol3:endCol10:tok0", + assertEquals("test:Pos13:Col10:startCol3:endCol10:tok1", PA.getValue(sq, "cursor").toString()); sq.sequenceChanged(); - assertEquals(12, sq.findPosition(8)); - cursor = (SequenceCursor) PA.getValue(sq, "cursor"); + assertEquals(12, sq.findPosition(8)); // E12 // sequenceChanged() invalidates cursor.lastResidueColumn cursor = (SequenceCursor) PA.getValue(sq, "cursor"); - assertEquals("test:Pos12:Col9:startCol3:endCol0:tok1", + assertEquals("test:Pos12:Col9:startCol3:endCol0:tok2", cursor.toString()); // findPosition with cursor accepts base 1 column values assertEquals(13, ((Sequence) sq).findPosition(10, cursor)); assertEquals(13, sq.findPosition(9)); // F13 // lastResidueColumn has now been found and saved in cursor - assertEquals("test:Pos13:Col10:startCol3:endCol10:tok1", + assertEquals("test:Pos13:Col10:startCol3:endCol10:tok2", PA.getValue(sq, "cursor").toString()); } @@ -505,6 +620,13 @@ public class SequenceTest assertEquals(6, sq.getEnd()); assertNull(PA.getValue(sq, "datasetSequence")); + sq = new Sequence("test", "ABCDE"); + sq.deleteChars(0, 3); + assertEquals("DE", sq.getSequenceAsString()); + assertEquals(4, sq.getStart()); + assertEquals(5, sq.getEnd()); + assertNull(PA.getValue(sq, "datasetSequence")); + /* * delete at end */ @@ -514,6 +636,21 @@ public class SequenceTest assertEquals(1, sq.getStart()); assertEquals(4, sq.getEnd()); assertNull(PA.getValue(sq, "datasetSequence")); + + /* + * delete more positions than there are + */ + sq = new Sequence("test/8-11", "ABCD"); + sq.deleteChars(0, 99); + assertEquals("", sq.getSequenceAsString()); + assertEquals(12, sq.getStart()); // = findPosition(99) ?!? + assertEquals(11, sq.getEnd()); + + sq = new Sequence("test/8-11", "----"); + sq.deleteChars(0, 99); // ArrayIndexOutOfBoundsException <= 2.10.2 + assertEquals("", sq.getSequenceAsString()); + assertEquals(8, sq.getStart()); + assertEquals(11, sq.getEnd()); } @Test(groups = { "Functional" }) @@ -539,9 +676,9 @@ public class SequenceTest assertNotNull(newDs); assertNotSame(ds, newDs); assertNotNull(sq.getDBRefs()); - assertEquals(1, sq.getDBRefs().length); - assertNotSame(dbr1, sq.getDBRefs()[0]); - assertEquals(dbr1, sq.getDBRefs()[0]); + assertEquals(1, sq.getDBRefs().size()); + assertNotSame(dbr1, sq.getDBRefs().get(0)); + assertEquals(dbr1, sq.getDBRefs().get(0)); /* * internal delete with sequence features @@ -602,8 +739,8 @@ public class SequenceTest assertEquals(4, sq.getEnd()); assertSame(ds, PA.getValue(sq, "datasetSequence")); assertNotNull(sq.getDBRefs()); - assertEquals(1, sq.getDBRefs().length); - assertSame(dbr1, sq.getDBRefs()[0]); + assertEquals(1, sq.getDBRefs().size()); + assertSame(dbr1, sq.getDBRefs().get(0)); } @Test(groups = { "Functional" }) @@ -646,7 +783,8 @@ public class SequenceTest /* * SequenceFeature on sequence */ - SequenceFeature sf = new SequenceFeature("Cath", "desc", 2, 4, 2f, null); + SequenceFeature sf = new SequenceFeature("Cath", "desc", 2, 4, 2f, + null); sq.addSequenceFeature(sf); List sfs = sq.getSequenceFeatures(); assertEquals(1, sfs.size()); @@ -685,11 +823,12 @@ public class SequenceTest try { sq.getDatasetSequence().setDatasetSequence(sq); // loop! - Assert.fail("Expected Error to be raised when calling setDatasetSequence with self reference"); + Assert.fail( + "Expected Error to be raised when calling setDatasetSequence with self reference"); } catch (IllegalArgumentException e) { // TODO Jalview error/exception class for raising implementation errors - assertTrue(e.getMessage().toLowerCase() + assertTrue(e.getMessage().toLowerCase(Locale.ROOT) .contains("implementation error")); } assertTrue(sq.getSequenceFeatures().isEmpty()); @@ -742,8 +881,8 @@ public class SequenceTest public void testCreateDatasetSequence() { SequenceI sq = new Sequence("my", "ASDASD"); - sq.addSequenceFeature(new SequenceFeature("type", "desc", 1, 10, 1f, - "group")); + 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")); @@ -792,15 +931,18 @@ public class SequenceTest DBRefEntry pdb1pdb = new DBRefEntry("PDB", "version1", "1PDB"); DBRefEntry pdb2pdb = new DBRefEntry("PDB", "version2", "2PDB"); - List primRefs = Arrays.asList(new DBRefEntry[] { pdb1pdb, - pdb2pdb }); + List primRefs = Arrays + .asList(new DBRefEntry[] + { pdb1pdb, pdb2pdb }); sq.getDatasetSequence().addDBRef(pdb1pdb); // should do nothing sq.getDatasetSequence().addDBRef(pdb2pdb); // should do nothing - sq.getDatasetSequence().addDBRef( - new DBRefEntry("PDB", "version3", "3PDB")); // should do nothing - sq.getDatasetSequence().addDBRef( - new DBRefEntry("PDB", "version4", "4PDB")); // should do nothing + sq.getDatasetSequence() + .addDBRef(new DBRefEntry("PDB", "version3", "3PDB")); // should do + // nothing + sq.getDatasetSequence() + .addDBRef(new DBRefEntry("PDB", "version4", "4PDB")); // should do + // nothing PDBEntry pdbe1a = new PDBEntry("1PDB", "A", Type.PDB, "filePath/test1"); PDBEntry pdbe1b = new PDBEntry("1PDB", "B", Type.PDB, "filePath/test1"); @@ -816,15 +958,15 @@ public class SequenceTest /* * test we added pdb entries to the dataset sequence */ - Assert.assertEquals(sq.getDatasetSequence().getAllPDBEntries(), Arrays - .asList(new PDBEntry[] { pdbe1a, pdbe1b, pdbe2a, pdbe2b }), + 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"), + 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()); @@ -833,16 +975,15 @@ public class SequenceTest 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)); + sq.getDatasetSequence().addAlignmentAnnotation(new AlignmentAnnotation( + "Test annot", "Test annot description", annots)); Assert.assertEquals(sq.getDescription(), "Test sequence description.."); - Assert.assertEquals(sq.getDBRefs().length, 5); // DBRefs are on dataset + Assert.assertEquals(sq.getDBRefs().size(), 5); // DBRefs are on dataset // sequence Assert.assertEquals(sq.getAllPDBEntries().size(), 4); Assert.assertNotNull(sq.getAnnotation()); Assert.assertEquals(sq.getAnnotation()[0].annotations.length, 2); - Assert.assertEquals(sq.getDatasetSequence().getDBRefs().length, 5); // same + Assert.assertEquals(sq.getDatasetSequence().getDBRefs().size(), 5); // same // as // sq.getDBRefs() Assert.assertEquals(sq.getDatasetSequence().getAllPDBEntries().size(), @@ -853,13 +994,13 @@ public class SequenceTest Assert.assertEquals(derived.getDescription(), "Test sequence description.."); - Assert.assertEquals(derived.getDBRefs().length, 5); // come from dataset + Assert.assertEquals(derived.getDBRefs().size(), 5); // 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, 5); - Assert.assertEquals(derived.getDatasetSequence().getAllPDBEntries() - .size(), 4); + Assert.assertEquals(derived.getDatasetSequence().getDBRefs().size(), 5); + Assert.assertEquals( + derived.getDatasetSequence().getAllPDBEntries().size(), 4); Assert.assertNotNull(derived.getDatasetSequence().getAnnotation()); assertEquals("CD", derived.getSequenceAsString()); @@ -892,8 +1033,8 @@ public class SequenceTest assertEquals(6, sq.getEnd()); SequenceI derived = sq.deriveSequence(); assertEquals("ABCDEF", derived.getSequenceAsString()); - assertEquals("ABCDEF", derived.getDatasetSequence() - .getSequenceAsString()); + assertEquals("ABCDEF", + derived.getDatasetSequence().getSequenceAsString()); } /** @@ -908,8 +1049,44 @@ public class SequenceTest assertNull(sq.getDatasetSequence()); SequenceI derived = sq.deriveSequence(); assertEquals("AB-C.D EF", derived.getSequenceAsString()); - assertEquals("ABCDEF", derived.getDatasetSequence() - .getSequenceAsString()); + assertEquals("ABCDEF", + derived.getDatasetSequence().getSequenceAsString()); + } + + /** + * test that creating a copy of an existing sequence with dataset sequence and + * associated contact matrix yields annotation associated with the same + * contact matrix in the copy + */ + @Test(groups = { "Functional" }) + public void testCopyPasteStyleDerivesequence_withcontactMatrixAnn() + { + SequenceI seq1 = new Sequence("seq1", "ACDACDACD"); + seq1.createDatasetSequence(); + ContactMatrixI cm = new SeqDistanceContactMatrix(seq1.getLength()); + // addContactList needs to return annotation addable to the sequence + // reference it was called from + AlignmentAnnotation aann = seq1.addContactList(cm); + assertTrue(aann.sequenceRef == seq1); + assertEquals(1, seq1.getAnnotation().length); + assertNotNull(seq1.getContactListFor(seq1.getAnnotation()[0], 1)); + + SequenceI seq_derived = seq1.deriveSequence(); + assertEquals(1, seq_derived.getAnnotation().length); + assertTrue(cm == seq_derived + .getContactMatrixFor(seq_derived.getAnnotation()[0])); + assertNotNull(seq_derived + .getContactListFor(seq_derived.getAnnotation()[0], 1)); + + // copy paste actually uses the copy constructor .. so + + SequenceI seq_copied = new Sequence((Sequence) seq_derived); + assertEquals(1, seq_copied.getAnnotation().length); + assertTrue(cm == seq_copied + .getContactMatrixFor(seq_copied.getAnnotation()[0])); + assertNotNull( + seq_copied.getContactListFor(seq_copied.getAnnotation()[0], 1)); + } @Test(groups = { "Functional" }) @@ -917,10 +1094,10 @@ public class SequenceTest { SequenceI seq1 = new Sequence("Seq1", "AB-C.D EF"); seq1.setDescription("description"); - seq1.addAlignmentAnnotation(new AlignmentAnnotation("label", "desc", - 1.3d)); - seq1.addSequenceFeature(new SequenceFeature("type", "desc", 22, 33, - 12.4f, "group")); + seq1.addAlignmentAnnotation( + new AlignmentAnnotation("label", "desc", 1.3d)); + seq1.addSequenceFeature( + new SequenceFeature("type", "desc", 22, 33, 12.4f, "group")); seq1.addPDBId(new PDBEntry("1A70", "B", Type.PDB, "File")); seq1.addDBRef(new DBRefEntry("EMBL", "1.2", "AZ12345")); @@ -936,10 +1113,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.getDBRefs(); - assertEquals(1, dbrefs.length); - assertFalse(dbrefs[0] == seq1.getDBRefs()[0]); - assertTrue(dbrefs[0].equals(seq1.getDBRefs()[0])); + List dbrefs = copy.getDBRefs(); + assertEquals(1, dbrefs.size()); + assertFalse(dbrefs.get(0) == seq1.getDBRefs().get(0)); + assertTrue(dbrefs.get(0).equals(seq1.getDBRefs().get(0))); } @Test(groups = { "Functional" }) @@ -948,16 +1125,16 @@ public class SequenceTest SequenceI seq1 = new Sequence("Seq1", "AB-C.D EF"); seq1.createDatasetSequence(); seq1.setDescription("description"); - seq1.addAlignmentAnnotation(new AlignmentAnnotation("label", "desc", - 1.3d)); + 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.addSequenceFeature( + new SequenceFeature("type", "desc", 22, 33, 12.4f, "group")); seq1.addPDBId(new PDBEntry("1A70", "B", Type.PDB, "File")); // here we add DBRef to the dataset sequence: - seq1.getDatasetSequence().addDBRef( - new DBRefEntry("EMBL", "1.2", "AZ12345")); + seq1.getDatasetSequence() + .addDBRef(new DBRefEntry("EMBL", "1.2", "AZ12345")); SequenceI copy = new Sequence(seq1); @@ -968,9 +1145,9 @@ public class SequenceTest // getDBRef looks inside dataset sequence and this is shared, // so holds the same dbref objects - DBRefEntry[] dbrefs = copy.getDBRefs(); - assertEquals(1, dbrefs.length); - assertSame(dbrefs[0], seq1.getDBRefs()[0]); + List dbrefs = copy.getDBRefs(); + assertEquals(1, dbrefs.size()); + assertSame(dbrefs.get(0), seq1.getDBRefs().get(0)); } /** @@ -1032,28 +1209,37 @@ public class SequenceTest { 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))); + 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))); + 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 + 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()); } @@ -1069,50 +1255,51 @@ public class SequenceTest assertNull(sq.getDBRefs()); DBRefEntry dbref = new DBRefEntry("Uniprot", "1", "P00340"); sq.addDBRef(dbref); - assertEquals(1, sq.getDBRefs().length); - assertSame(dbref, sq.getDBRefs()[0]); + assertEquals(1, sq.getDBRefs().size()); + assertSame(dbref, sq.getDBRefs().get(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]); + assertEquals(2, sq.getDBRefs().size()); + assertSame(dbref, sq.getDBRefs().get(0)); + assertSame(dbref2, sq.getDBRefs().get(1)); /* * matches existing entry - not added */ sq.addDBRef(new DBRefEntry("UNIPROT", "1", "p00340")); - assertEquals(2, sq.getDBRefs().length); + assertEquals(2, sq.getDBRefs().size()); /* * different source = new entry */ DBRefEntry dbref3 = new DBRefEntry("UniRef", "1", "p00340"); sq.addDBRef(dbref3); - assertEquals(3, sq.getDBRefs().length); - assertSame(dbref3, sq.getDBRefs()[2]); + assertEquals(3, sq.getDBRefs().size()); + assertSame(dbref3, sq.getDBRefs().get(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]); + assertEquals(4, sq.getDBRefs().size()); + assertSame(dbref4, sq.getDBRefs().get(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)); + 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]); + assertEquals(4, sq.getDBRefs().size()); + assertSame(dbref4, sq.getDBRefs().get(3)); assertSame(map, dbref4.getMap()); /* @@ -1122,8 +1309,8 @@ public class SequenceTest DBRefEntry dbref6 = new DBRefEntry(dbref2.getSource(), "3", dbref2.getAccessionId()); sq.addDBRef(dbref6); - assertEquals(4, sq.getDBRefs().length); - assertSame(dbref2, sq.getDBRefs()[1]); + assertEquals(4, sq.getDBRefs().size()); + assertSame(dbref2, sq.getDBRefs().get(1)); assertEquals("3", dbref2.getVersion()); /* @@ -1133,8 +1320,8 @@ public class SequenceTest DBRefEntry dbref7 = new DBRefEntry(dbref3.getSource(), "3", dbref3.getAccessionId()); sq.addDBRef(dbref7); - assertEquals(4, sq.getDBRefs().length); - assertSame(dbref3, sq.getDBRefs()[2]); + assertEquals(4, sq.getDBRefs().size()); + assertSame(dbref3, sq.getDBRefs().get(2)); assertEquals("3", dbref2.getVersion()); } @@ -1148,7 +1335,7 @@ public class SequenceTest assertTrue(primaryDBRefs.isEmpty()); // empty dbrefs - sq.setDBRefs(new DBRefEntry[] {}); + sq.setDBRefs(null); primaryDBRefs = sq.getPrimaryDBRefs(); assertTrue(primaryDBRefs.isEmpty()); @@ -1158,32 +1345,37 @@ public class SequenceTest // primary - uniprot with congruent map DBRefEntry upentry2 = new DBRefEntry("UNIPROT", "0", "Q04762"); - upentry2.setMap(new Mapping(null, new MapList(new int[] { 10, 22 }, - new int[] { 10, 22 }, 1, 1))); + upentry2.setMap( + new Mapping(null, new MapList(new int[] + { 10, 22 }, new int[] { 10, 22 }, 1, 1))); sq.addDBRef(upentry2); // primary - uniprot with map of enclosing sequence DBRefEntry upentry3 = new DBRefEntry("UNIPROT", "0", "Q04763"); - upentry3.setMap(new Mapping(null, new MapList(new int[] { 8, 24 }, - new int[] { 8, 24 }, 1, 1))); + upentry3.setMap( + new Mapping(null, new MapList(new int[] + { 8, 24 }, new int[] { 8, 24 }, 1, 1))); sq.addDBRef(upentry3); // not primary - uniprot with map of sub-sequence (5') DBRefEntry upentry4 = new DBRefEntry("UNIPROT", "0", "Q04764"); - upentry4.setMap(new Mapping(null, new MapList(new int[] { 10, 18 }, - new int[] { 10, 18 }, 1, 1))); + upentry4.setMap( + new Mapping(null, new MapList(new int[] + { 10, 18 }, new int[] { 10, 18 }, 1, 1))); sq.addDBRef(upentry4); // not primary - uniprot with map that overlaps 3' DBRefEntry upentry5 = new DBRefEntry("UNIPROT", "0", "Q04765"); - upentry5.setMap(new Mapping(null, new MapList(new int[] { 12, 22 }, - new int[] { 12, 22 }, 1, 1))); + upentry5.setMap( + new Mapping(null, new MapList(new int[] + { 12, 22 }, new int[] { 12, 22 }, 1, 1))); sq.addDBRef(upentry5); // not primary - uniprot with map to different coordinates frame DBRefEntry upentry6 = new DBRefEntry("UNIPROT", "0", "Q04766"); - upentry6.setMap(new Mapping(null, new MapList(new int[] { 12, 18 }, - new int[] { 112, 118 }, 1, 1))); + upentry6.setMap( + new Mapping(null, new MapList(new int[] + { 12, 18 }, new int[] { 112, 118 }, 1, 1))); sq.addDBRef(upentry6); // not primary - dbref to 'non-core' database @@ -1203,8 +1395,8 @@ public class SequenceTest // add corroborating PDB entry for primary DBref - // needs to have a file as well as matching ID // note PDB ID is not treated as case sensitive - sq.addPDBId(new PDBEntry("1QIP", null, Type.PDB, new File("/blah") - .toString())); + sq.addPDBId(new PDBEntry("1QIP", null, Type.PDB, + new File("/blah").toString())); // not valid DBRef - no file.. sq.addPDBId(new PDBEntry("1AAA", null, null, null)); @@ -1224,7 +1416,8 @@ public class SequenceTest @Test(groups = { "Functional" }) public void testGetPrimaryDBRefs_nucleotide() { - SequenceI sq = new Sequence("aseq", "TGATCACTCGACTAGCATCAGCATA", 10, 34); + SequenceI sq = new Sequence("aseq", "TGATCACTCGACTAGCATCAGCATA", 10, + 34); // primary - Ensembl DBRefEntry dbr1 = new DBRefEntry("ENSEMBL", "0", "ENSG1234"); @@ -1232,14 +1425,16 @@ public class SequenceTest // not primary - Ensembl 'transcript' mapping of sub-sequence DBRefEntry dbr2 = new DBRefEntry("ENSEMBL", "0", "ENST1234"); - dbr2.setMap(new Mapping(null, new MapList(new int[] { 15, 25 }, - new int[] { 1, 11 }, 1, 1))); + dbr2.setMap( + new Mapping(null, new MapList(new int[] + { 15, 25 }, new int[] { 1, 11 }, 1, 1))); sq.addDBRef(dbr2); // primary - EMBL with congruent map DBRefEntry dbr3 = new DBRefEntry("EMBL", "0", "J1234"); - dbr3.setMap(new Mapping(null, new MapList(new int[] { 10, 34 }, - new int[] { 10, 34 }, 1, 1))); + dbr3.setMap( + new Mapping(null, new MapList(new int[] + { 10, 34 }, new int[] { 10, 34 }, 1, 1))); sq.addDBRef(dbr3); // not primary - to non-core database @@ -1337,19 +1532,39 @@ public class SequenceTest seq.addPDBId(pdbe5); assertEquals(4, seq.getAllPDBEntries().size()); assertSame(pdbe5, seq.getAllPDBEntries().get(3)); + + // add with a fake pdbid + // (models don't have an embedded ID) + String realId = "RealIDQ"; + PDBEntry pdbe6 = new PDBEntry(realId, null, Type.PDB, "real/localpath"); + PDBEntry pdbe7 = new PDBEntry("RealID/real/localpath", "C", Type.MMCIF, + "real/localpath"); + pdbe7.setFakedPDBId(true); + seq.addPDBId(pdbe6); + assertEquals(5, seq.getAllPDBEntries().size()); + seq.addPDBId(pdbe7); + assertEquals(5, seq.getAllPDBEntries().size()); + assertFalse(pdbe6.fakedPDBId()); + assertSame(pdbe6, seq.getAllPDBEntries().get(4)); + assertEquals("C", pdbe6.getChainCode()); + assertEquals(realId, pdbe6.getId()); } @Test( - groups = { "Functional" }, - expectedExceptions = { IllegalArgumentException.class }) + groups = + { "Functional" }, + expectedExceptions = + { IllegalArgumentException.class }) public void testSetDatasetSequence_toSelf() { seq.setDatasetSequence(seq); } @Test( - groups = { "Functional" }, - expectedExceptions = { IllegalArgumentException.class }) + groups = + { "Functional" }, + expectedExceptions = + { IllegalArgumentException.class }) public void testSetDatasetSequence_cascading() { SequenceI seq2 = new Sequence("Seq2", "xyz"); @@ -1386,8 +1601,8 @@ public class SequenceTest "desc", 13, 14, 2f, null); sq.addSequenceFeature(sfContactFG); // add single position feature at [I] - SequenceFeature sfI = new SequenceFeature("Disulfide Bond", - "desc", 16, 16, null); + SequenceFeature sfI = new SequenceFeature("Disulfide Bond", "desc", 16, + 16, null); sq.addSequenceFeature(sfI); // no features in columns 1-2 (-A) @@ -1426,21 +1641,23 @@ public class SequenceTest public void testFindIndex_withCursor() { Sequence sq = new Sequence("test/8-13", "-A--BCD-EF--"); + final int tok = (int) PA.getValue(sq, "changeCount"); + assertEquals(1, tok); // find F given A, check cursor is now at the found position - assertEquals(10, sq.findIndex(13, new SequenceCursor(sq, 8, 2, 0))); + assertEquals(10, sq.findIndex(13, new SequenceCursor(sq, 8, 2, tok))); SequenceCursor cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(13, cursor.residuePosition); assertEquals(10, cursor.columnPosition); // find A given F - assertEquals(2, sq.findIndex(8, new SequenceCursor(sq, 13, 10, 0))); + assertEquals(2, sq.findIndex(8, new SequenceCursor(sq, 13, 10, tok))); cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(8, cursor.residuePosition); assertEquals(2, cursor.columnPosition); // find C given C (no cursor update is done for this case) - assertEquals(6, sq.findIndex(10, new SequenceCursor(sq, 10, 6, 0))); + assertEquals(6, sq.findIndex(10, new SequenceCursor(sq, 10, 6, tok))); SequenceCursor cursor2 = (SequenceCursor) PA.getValue(sq, "cursor"); assertSame(cursor2, cursor); @@ -1488,41 +1705,48 @@ public class SequenceTest public void testFindPosition_withCursor() { Sequence sq = new Sequence("test/8-13", "-A--BCD-EF--"); - + final int tok = (int) PA.getValue(sq, "changeCount"); + assertEquals(1, tok); + // find F pos given A - lastCol gets set in cursor - assertEquals(13, sq.findPosition(10, new SequenceCursor(sq, 8, 2, 0))); - assertEquals("test:Pos13:Col10:startCol0:endCol10:tok0", + assertEquals(13, + sq.findPosition(10, new SequenceCursor(sq, 8, 2, tok))); + assertEquals("test:Pos13:Col10:startCol0:endCol10:tok1", PA.getValue(sq, "cursor").toString()); // find A pos given F - first residue column is saved in cursor - assertEquals(8, sq.findPosition(2, new SequenceCursor(sq, 13, 10, 0))); - assertEquals("test:Pos8:Col2:startCol2:endCol10:tok0", + assertEquals(8, + sq.findPosition(2, new SequenceCursor(sq, 13, 10, tok))); + assertEquals("test:Pos8:Col2:startCol2:endCol10:tok1", PA.getValue(sq, "cursor").toString()); - + // find C pos given C (neither startCol nor endCol is set) - assertEquals(10, sq.findPosition(6, new SequenceCursor(sq, 10, 6, 0))); - assertEquals("test:Pos10:Col6:startCol0:endCol0:tok0", + assertEquals(10, + sq.findPosition(6, new SequenceCursor(sq, 10, 6, tok))); + assertEquals("test:Pos10:Col6:startCol0:endCol0:tok1", PA.getValue(sq, "cursor").toString()); // now the grey area - what residue position for a gapped column? JAL-2562 // find 'residue' for column 3 given cursor for D (so working left) // returns B9; cursor is updated to [B 5] - assertEquals(9, sq.findPosition(3, new SequenceCursor(sq, 11, 7, 0))); - assertEquals("test:Pos9:Col5:startCol0:endCol0:tok0", + assertEquals(9, sq.findPosition(3, new SequenceCursor(sq, 11, 7, tok))); + assertEquals("test:Pos9:Col5:startCol0:endCol0:tok1", PA.getValue(sq, "cursor").toString()); // find 'residue' for column 8 given cursor for D (so working right) // returns E12; cursor is updated to [D 7] - assertEquals(12, sq.findPosition(8, new SequenceCursor(sq, 11, 7, 0))); - assertEquals("test:Pos11:Col7:startCol0:endCol0:tok0", + assertEquals(12, + sq.findPosition(8, new SequenceCursor(sq, 11, 7, tok))); + assertEquals("test:Pos11:Col7:startCol0:endCol0:tok1", PA.getValue(sq, "cursor").toString()); // find 'residue' for column 12 given cursor for B // returns 1 more than last residue position; cursor is updated to [F 10] // lastCol position is saved in cursor - assertEquals(14, sq.findPosition(12, new SequenceCursor(sq, 9, 5, 0))); - assertEquals("test:Pos13:Col10:startCol0:endCol10:tok0", + assertEquals(14, + sq.findPosition(12, new SequenceCursor(sq, 9, 5, tok))); + assertEquals("test:Pos13:Col10:startCol0:endCol10:tok1", PA.getValue(sq, "cursor").toString()); /* @@ -1530,8 +1754,9 @@ public class SequenceTest * returns 1 more than the last residue position * cursor is set to last real residue position [F 10] */ - assertEquals(14, sq.findPosition(99, new SequenceCursor(sq, 8, 2, 0))); - assertEquals("test:Pos13:Col10:startCol0:endCol10:tok0", + assertEquals(14, + sq.findPosition(99, new SequenceCursor(sq, 8, 2, tok))); + assertEquals("test:Pos13:Col10:startCol0:endCol10:tok1", PA.getValue(sq, "cursor").toString()); /* @@ -1539,14 +1764,14 @@ public class SequenceTest */ sq = new Sequence("test/8-13", "-A--BCD-EF"); // first find C from A - assertEquals(10, sq.findPosition(6, new SequenceCursor(sq, 8, 2, 0))); + assertEquals(10, sq.findPosition(6, new SequenceCursor(sq, 8, 2, tok))); SequenceCursor cursor = (SequenceCursor) PA.getValue(sq, "cursor"); - assertEquals("test:Pos10:Col6:startCol0:endCol0:tok0", + assertEquals("test:Pos10:Col6:startCol0:endCol0:tok1", cursor.toString()); // now 'find' 99 from C // cursor is set to [F 10] and saved lastCol assertEquals(14, sq.findPosition(99, cursor)); - assertEquals("test:Pos13:Col10:startCol0:endCol10:tok0", + assertEquals("test:Pos13:Col10:startCol0:endCol10:tok1", PA.getValue(sq, "cursor").toString()); } @@ -1598,7 +1823,7 @@ public class SequenceTest public void testFindPosition_withCursorAndEdits() { Sequence sq = new Sequence("test/8-13", "-A--BCD-EF--"); - + // find F pos given A assertEquals(13, sq.findPosition(10, new SequenceCursor(sq, 8, 2, 0))); int token = (int) PA.getValue(sq, "changeCount"); // 0 @@ -1614,6 +1839,10 @@ public class SequenceTest // cursor should now be at [D 6] cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(new SequenceCursor(sq, 11, 6, ++token), cursor); + assertEquals(0, cursor.lastColumnPosition); // not yet found + assertEquals(13, sq.findPosition(8)); // E13 + cursor = (SequenceCursor) PA.getValue(sq, "cursor"); + assertEquals(9, cursor.lastColumnPosition); // found /* * deleteChars should invalidate the cached cursor @@ -1649,6 +1878,17 @@ public class SequenceTest // cursor should now be at [F 10] cursor = (SequenceCursor) PA.getValue(sq, "cursor"); assertEquals(new SequenceCursor(sq, 13, 10, ++token), cursor); + + /* + * changing sequence start should invalidate cursor + */ + sq = new Sequence("test/8-13", "-A--BCD-EF--"); + assertEquals(8, sq.getStart()); + assertEquals(9, sq.findPosition(4)); // B(9) + sq.setStart(7); + assertEquals(8, sq.findPosition(4)); // is now B(8) + sq.setStart(10); + assertEquals(11, sq.findPosition(4)); // is now B(11) } @Test(groups = { "Functional" }) @@ -1673,78 +1913,24 @@ public class SequenceTest { String seqstring = "-A--BCD-EF--"; SequenceI sq = new Sequence("test/8-13", seqstring); - assertEquals(0, PA.getValue(sq, "changeCount")); + // changeCount is incremented for setStart + assertEquals(1, PA.getValue(sq, "changeCount")); assertEquals(0, sq.replace('A', 'A')); // same char assertEquals(seqstring, sq.getSequenceAsString()); - assertEquals(0, PA.getValue(sq, "changeCount")); + assertEquals(1, PA.getValue(sq, "changeCount")); assertEquals(0, sq.replace('X', 'Y')); // not there assertEquals(seqstring, sq.getSequenceAsString()); - assertEquals(0, PA.getValue(sq, "changeCount")); + assertEquals(1, PA.getValue(sq, "changeCount")); assertEquals(1, sq.replace('A', 'K')); assertEquals("-K--BCD-EF--", sq.getSequenceAsString()); - assertEquals(1, PA.getValue(sq, "changeCount")); + assertEquals(2, PA.getValue(sq, "changeCount")); assertEquals(6, sq.replace('-', '.')); assertEquals(".K..BCD.EF..", sq.getSequenceAsString()); - assertEquals(2, PA.getValue(sq, "changeCount")); - } - - @Test(groups = { "Functional" }) - public void testFindPositions() - { - SequenceI sq = new Sequence("test/8-13", "-ABC---DE-F--"); - - /* - * invalid inputs - */ - assertNull(sq.findPositions(6, 5)); - assertNull(sq.findPositions(0, 5)); - assertNull(sq.findPositions(-1, 5)); - - /* - * all gapped ranges - */ - assertNull(sq.findPositions(1, 1)); // 1-based columns - assertNull(sq.findPositions(5, 5)); - assertNull(sq.findPositions(5, 6)); - assertNull(sq.findPositions(5, 7)); - - /* - * all ungapped ranges - */ - assertEquals(new Range(8, 8), sq.findPositions(2, 2)); // A - assertEquals(new Range(8, 9), sq.findPositions(2, 3)); // AB - assertEquals(new Range(8, 10), sq.findPositions(2, 4)); // ABC - assertEquals(new Range(9, 10), sq.findPositions(3, 4)); // BC - - /* - * gap to ungapped range - */ - assertEquals(new Range(8, 10), sq.findPositions(1, 4)); // ABC - assertEquals(new Range(11, 12), sq.findPositions(6, 9)); // DE - - /* - * ungapped to gapped range - */ - assertEquals(new Range(10, 10), sq.findPositions(4, 5)); // C - assertEquals(new Range(9, 13), sq.findPositions(3, 11)); // BCDEF - - /* - * ungapped to ungapped enclosing gaps - */ - assertEquals(new Range(10, 11), sq.findPositions(4, 8)); // CD - assertEquals(new Range(8, 13), sq.findPositions(2, 11)); // ABCDEF - - /* - * gapped to gapped enclosing ungapped - */ - assertEquals(new Range(8, 10), sq.findPositions(1, 5)); // ABC - assertEquals(new Range(11, 12), sq.findPositions(5, 10)); // DE - assertEquals(new Range(8, 13), sq.findPositions(1, 13)); // the lot - assertEquals(new Range(8, 13), sq.findPositions(1, 99)); + assertEquals(3, PA.getValue(sq, "changeCount")); } @Test(groups = { "Functional" }) @@ -1769,20 +1955,20 @@ public class SequenceTest */ SequenceI sq = new Sequence("test", "-ABC--DEF--", 1, 20); sq.createDatasetSequence(); - + assertTrue(sq.findFeatures(1, 9).isEmpty()); // should be no array bounds exception - JAL-2772 assertTrue(sq.findFeatures(1, 15).isEmpty()); - + // add feature on BCD SequenceFeature sfBCD = new SequenceFeature("Cath", "desc", 2, 4, 2f, null); sq.addSequenceFeature(sfBCD); - + // no features in columns 1-2 (-A) List found = sq.findFeatures(1, 2); assertTrue(found.isEmpty()); - + // columns 1-6 (-ABC--) includes BCD found = sq.findFeatures(1, 6); assertEquals(1, found.size()); @@ -2127,4 +2313,35 @@ public class SequenceTest assertEquals(0, seq.firstResidueOutsideIterator(cs.iterator())); } + + @Test(groups = { "Functional" }) + public void testTransferAnnotation() + { + Sequence origSeq = new Sequence("MYSEQ", "THISISASEQ"); + Sequence toSeq = new Sequence("MYSEQ", "THISISASEQ"); + origSeq.setDescription("DESCRIPTION"); + origSeq.addDBRef(new DBRefEntry("UNIPROT", "0", "Q12345", null, true)); + + toSeq.transferAnnotation(origSeq, null); + assertEquals("DESCRIPTION", toSeq.getDescription()); + toSeq = new Sequence("MYSEQ", "THISISASEQ"); + toSeq.setDescription("unchanged"); + toSeq.transferAnnotation(origSeq, null); + assertEquals("unchanged", toSeq.getDescription()); + + assertTrue(toSeq.getDBRefs().size() == 1); + + assertTrue(toSeq.getDBRefs().get(0).isCanonical()); + + // check for promotion of non-canonical + // to canonical (e.g. fetch-db-refs on a jalview project pre 2.11.2) + toSeq.setDBRefs(null); + toSeq.addDBRef(new DBRefEntry("UNIPROT", "0", "Q12345", null, false)); + toSeq.transferAnnotation(origSeq, null); + assertTrue(toSeq.getDBRefs().size() == 1); + + assertTrue("Promotion of non-canonical DBRefEntry failed", + toSeq.getDBRefs().get(0).isCanonical()); + + } }