* - the alignmentI object to verify (either alignment or dataset)
* @param raiseAssert
* - when set, testng assertions are raised.
- * @param message
- * - null or a string message to prepend to the assert failed messages.
+ * @param message
+ * - null or a string message to prepend to the assert failed
+ * messages.
* @return true if alignment references were in order, otherwise false.
*/
public static boolean verifyAlignmentDatasetRefs(AlignmentI alignment,
boolean raiseAssert, String message)
{
- if (message==null) { message = ""; }
+ if (message == null)
+ {
+ message = "";
+ }
if (alignment == null)
{
if (raiseAssert)
{
- Assert.fail(message+"Alignment for verification was null.");
+ Assert.fail(message + "Alignment for verification was null.");
}
return false;
}
{
if (raiseAssert)
{
- Assert.fail(message+" Alignment contained a sequence who's dataset sequence has a second dataset reference.");
+ Assert.fail(message
+ + " Alignment contained a sequence who's dataset sequence has a second dataset reference.");
}
return false;
}
{
if (raiseAssert)
{
- Assert.fail(message+" Alignment contained a sequence who's dataset sequence was not in the dataset.");
+ Assert.fail(message
+ + " Alignment contained a sequence who's dataset sequence was not in the dataset.");
}
return false;
}
}
- return verifyAlignmentDatasetRefs(alignment.getDataset(), raiseAssert, message);
+ return verifyAlignmentDatasetRefs(alignment.getDataset(),
+ raiseAssert, message);
}
else
{
{
if (raiseAssert)
{
- Assert.fail(message+" Dataset contained a sequence with non-null dataset reference (ie not a dataset sequence!)");
+ Assert.fail(message
+ + " Dataset contained a sequence with non-null dataset reference (ie not a dataset sequence!)");
}
return false;
}
{
if (raiseAssert)
{
- Assert.fail(message+" DBRefEntry for sequence in alignment had map to sequence which was not a dataset sequence");
+ Assert.fail(message
+ + " DBRefEntry for sequence in alignment had map to sequence which was not a dataset sequence");
}
return false;
{
if (raiseAssert)
{
- Assert.fail(message+" DBRefEntry for sequence in alignment had map to sequence not in dataset");
+ Assert.fail(message
+ + " DBRefEntry for sequence in alignment had map to sequence not in dataset");
}
return false;
}
{
if (raiseAssert)
{
- Assert.fail(message+" CodonFrame-SSM-FromSeq is not a dataset sequence");
+ Assert.fail(message
+ + " CodonFrame-SSM-FromSeq is not a dataset sequence");
}
return false;
}
if (raiseAssert)
{
- Assert.fail(message+" CodonFrame-SSM-FromSeq is not contained in dataset");
+ Assert.fail(message
+ + " CodonFrame-SSM-FromSeq is not contained in dataset");
}
return false;
}
{
if (raiseAssert)
{
- Assert.fail(message+" CodonFrame-SSM-Mapping-ToSeq is not a dataset sequence");
+ Assert.fail(message
+ + " CodonFrame-SSM-Mapping-ToSeq is not a dataset sequence");
}
return false;
}
if (raiseAssert)
{
- Assert.fail(message+" CodonFrame-SSM-Mapping-ToSeq is not contained in dataset");
+ Assert.fail(message
+ + " CodonFrame-SSM-Mapping-ToSeq is not contained in dataset");
}
return false;
}
+ msg);
}
}
+
@Test(groups = { "Functional" })
public void testVerifyAlignmentDatasetRefs()
{
"TTTTTT");
// construct simple valid alignment dataset
- Alignment al = new Alignment(new SequenceI[] {
- sq1, sq2 });
+ Alignment al = new Alignment(new SequenceI[] { sq1, sq2 });
// expect this to pass
assertVerifyAlignment(al, true, "Simple valid alignment didn't verify");
// check test for sequence->datasetSequence validity
sq1.setDatasetSequence(sq2);
- assertVerifyAlignment(
- al,
- false,
+ assertVerifyAlignment(al, false,
"didn't detect dataset sequence with a dataset sequence reference.");
sq1.setDatasetSequence(null);
al.getDataset().deleteSequence(sqanotherout);
assertVerifyAlignment(al, true,
"verify should have passed after duplicate entry for sequence was removed");
+ }
+
+ /**
+ * checks that the sequence data for an alignment's dataset is non-redundant.
+ * Fails if there are sequences with same id, sequence, start, and.
+ */
+
+ public static void assertDatasetIsNormalised(AlignmentI al)
+ {
+ assertDatasetIsNormalised(al, null);
+ }
+
+ /**
+ * checks that the sequence data for an alignment's dataset is non-redundant.
+ * Fails if there are sequences with same id, sequence, start, and.
+ *
+ * @param al
+ * - alignment to verify
+ * @param message
+ * - null or message prepended to exception message.
+ */
+ public static void assertDatasetIsNormalised(AlignmentI al, String message)
+ {
+ if (al.getDataset() != null)
+ {
+ assertDatasetIsNormalised(al.getDataset(), message);
+ return;
+ }
+ /*
+ * look for pairs of sequences with same ID, start, end, and sequence
+ */
+ List<SequenceI> seqSet = al.getSequences();
+ for (int p = 0; p < seqSet.size(); p++)
+ {
+ SequenceI pSeq = seqSet.get(p);
+ for (int q = p + 1; q < seqSet.size(); q++)
+ {
+ SequenceI qSeq = seqSet.get(q);
+ if (pSeq.getStart() != qSeq.getStart())
+ {
+ continue;
+ }
+ if (pSeq.getEnd() != qSeq.getEnd())
+ {
+ continue;
+ }
+ if (!pSeq.getName().equals(qSeq.getName()))
+ {
+ continue;
+ }
+ if (!Arrays.equals(pSeq.getSequence(), qSeq.getSequence()))
+ {
+ continue;
+ }
+ Assert.fail((message == null ? "" : message + " :")
+ + "Found similar sequences at position " + p + " and " + q
+ + "\n" + pSeq.toString());
+ }
+ }
+ }
+
+ @Test(groups = { "Functional", "Asserts" })
+ public void testAssertDatasetIsNormalised()
+ {
+ Sequence sq1 = new Sequence("s1/1-4", "asdf");
+ Sequence sq1shift = new Sequence("s1/2-5", "asdf");
+ Sequence sq1seqd = new Sequence("s1/1-4", "asdt");
+ Sequence sq2 = new Sequence("s2/1-4", "asdf");
+ Sequence sq1dup = new Sequence("s1/1-4", "asdf");
+
+ Alignment al = new Alignment(new SequenceI[] { sq1 });
+ al.setDataset(null);
+
+ try
+ {
+ assertDatasetIsNormalised(al);
+ } catch (AssertionError ae)
+ {
+ Assert.fail("Single sequence should be valid normalised dataset.");
+ }
+ al.addSequence(sq2);
+ try
+ {
+ assertDatasetIsNormalised(al);
+ } catch (AssertionError ae)
+ {
+ Assert.fail("Two different sequences should be valid normalised dataset.");
+ }
+ /*
+ * now change sq2's name in the alignment. should still be valid
+ */
+ al.findName(sq2.getName()).setName("sq1");
+ try
+ {
+ assertDatasetIsNormalised(al);
+ } catch (AssertionError ae)
+ {
+ Assert.fail("Two different sequences in dataset, but same name in alignment, should be valid normalised dataset.");
+ }
+ al.addSequence(sq1seqd);
+ try
+ {
+ assertDatasetIsNormalised(al);
+ } catch (AssertionError ae)
+ {
+ Assert.fail("sq1 and sq1 with different sequence should be distinct.");
+ }
+
+ al.addSequence(sq1shift);
+ try
+ {
+ assertDatasetIsNormalised(al);
+ } catch (AssertionError ae)
+ {
+ Assert.fail("sq1 and sq1 with different start/end should be distinct.");
+ }
+ /*
+ * finally, the failure case
+ */
+ al.addSequence(sq1dup);
+ boolean ssertRaised = false;
+ try
+ {
+ assertDatasetIsNormalised(al);
+
+ } catch (AssertionError ae)
+ {
+ ssertRaised = true;
+ }
+ if (!ssertRaised)
+ {
+ Assert.fail("Expected identical sequence to raise exception.");
+ }
}
+
/*
* Read in Stockholm format test data including secondary structure
* annotations.
assertAlignmentDatasetRefs(align,
"addSequence broke dataset reference integrity");
}
+
@Test(groups = "Functional")
public void getVisibleStartAndEndIndexTest()
{
assertEquals(1, startEnd[0]);
assertEquals(23, startEnd[1]);
}
+
+ /**
+ * Tests that dbrefs with mappings to sequence get updated if the sequence
+ * acquires a dataset sequence
+ */
+ @Test(groups = "Functional")
+ public void testCreateDataset_updateDbrefMappings()
+ {
+ SequenceI pep = new Sequence("pep", "ASD");
+ SequenceI dna = new Sequence("dna", "aaaGCCTCGGATggg");
+ SequenceI cds = new Sequence("cds", "GCCTCGGAT");
+
+ // add dbref from dna to peptide
+ DBRefEntry dbr = new DBRefEntry("UNIPROT", "", "pep");
+ dbr.setMap(new Mapping(pep, new MapList(new int[] { 4, 15 }, new int[] {
+ 1, 4 }, 3, 1)));
+ dna.addDBRef(dbr);
+
+ // add dbref from dna to peptide
+ DBRefEntry dbr2 = new DBRefEntry("UNIPROT", "", "pep");
+ dbr2.setMap(new Mapping(pep, new MapList(new int[] { 1, 12 }, new int[]
+ { 1, 4 }, 3, 1)));
+ cds.addDBRef(dbr2);
+
+ // add dbref from peptide to dna
+ DBRefEntry dbr3 = new DBRefEntry("EMBL", "", "dna");
+ dbr3.setMap(new Mapping(dna, new MapList(new int[] { 1, 4 }, new int[] {
+ 4, 15 }, 1, 3)));
+ pep.addDBRef(dbr3);
+
+ // add dbref from peptide to cds
+ DBRefEntry dbr4 = new DBRefEntry("EMBLCDS", "", "cds");
+ dbr4.setMap(new Mapping(cds, new MapList(new int[] { 1, 4 }, new int[] {
+ 1, 12 }, 1, 3)));
+ pep.addDBRef(dbr4);
+
+ AlignmentI protein = new Alignment(new SequenceI[] { pep });
+
+ /*
+ * create the alignment dataset
+ */
+ ((Alignment) protein).createDatasetAlignment();
+
+ AlignmentI ds = protein.getDataset();
+
+ // should be 3 sequences in dataset
+ assertEquals(3, ds.getHeight());
+ assertTrue(ds.getSequences().contains(pep.getDatasetSequence()));
+ assertTrue(ds.getSequences().contains(dna));
+ assertTrue(ds.getSequences().contains(cds));
+
+ /*
+ * verify peptide.cdsdbref.peptidedbref is now mapped to peptide dataset
+ */
+ DBRefEntry[] dbRefs = pep.getDBRefs();
+ assertEquals(2, dbRefs.length);
+ assertSame(dna, dbRefs[0].map.to);
+ assertSame(cds, dbRefs[1].map.to);
+ assertEquals(1, dna.getDBRefs().length);
+ assertSame(pep.getDatasetSequence(), dna.getDBRefs()[0].map.to);
+ assertEquals(1, cds.getDBRefs().length);
+ assertSame(pep.getDatasetSequence(), cds.getDBRefs()[0].map.to);
+ }
+
}