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.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()
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);
/*
* 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());
}
@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.setSourceDBRef(new DBRefEntry("PDB", "version0", "1TST"));
+
+ sq.addDBRef(new DBRefEntry("PDB", "version1", "1Tst"));
+ sq.addDBRef(new DBRefEntry("PDB", "version2", "2Tst"));
+ sq.addDBRef(new DBRefEntry("PDB", "version3", "3Tst"));
+ sq.addDBRef(new DBRefEntry("PDB", "version4", "4Tst"));
+
+ 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"));
+
+ sq.getDatasetSequence().addDBRef(
+ new DBRefEntry("PDB", "version1", "1Tst"));
+ sq.getDatasetSequence().addDBRef(
+ new DBRefEntry("PDB", "version2", "2Tst"));
+ sq.getDatasetSequence().addDBRef(
+ new DBRefEntry("PDB", "version3", "3Tst"));
+ sq.getDatasetSequence().addDBRef(
+ new DBRefEntry("PDB", "version4", "4Tst"));
+
+ sq.getDatasetSequence().addPDBId(
+ new PDBEntry("1PDB", "A", Type.PDB, "filePath/test1"));
+ sq.getDatasetSequence().addPDBId(
+ new PDBEntry("1PDB", "B", Type.PDB, "filePath/test1"));
+ sq.getDatasetSequence().addPDBId(
+ new PDBEntry("2PDB", "A", Type.MMCIF, "filePath/test2"));
+ sq.getDatasetSequence().addPDBId(
+ new PDBEntry("2PDB", "B", Type.MMCIF, "filePath/test2"));
+
+ ArrayList<Annotation> annotsList = new ArrayList<Annotation>();
+ 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, 4);
+ 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);
+ 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());
}
/**
// 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" })
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"));
// 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]);
}
/**
// 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
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());
+ }
}