return false;
}
}
- return verifyAlignmentDatasetRefs(alignment.getDataset(),
- raiseAssert, message);
+ return verifyAlignmentDatasetRefs(alignment.getDataset(), raiseAssert,
+ message);
}
else
{
{
if (raiseAssert)
{
- Assert.fail(message
- + " DBRefEntry " + dbr + " for sequence "
- + seqds
+ Assert.fail(message + " DBRefEntry " + dbr
+ + " for sequence " + seqds
+ " in alignment has map to sequence not in dataset");
}
return false;
ae.printStackTrace();
Assert.fail(
"Valid test alignment raised assertion errors when raiseAsserts enabled: "
- + msg, ae);
+ + msg,
+ ae);
}
// also check validation passes with asserts disabled
Assert.assertTrue(verifyAlignmentDatasetRefs(al, false, null),
}
if (!assertRaised)
{
- Assert.fail("Invalid test alignment passed when raiseAsserts enabled:"
- + msg);
+ Assert.fail(
+ "Invalid test alignment passed when raiseAsserts enabled:"
+ + msg);
}
// also check validation passes with asserts disabled
Assert.assertFalse(verifyAlignmentDatasetRefs(al, false, null),
@Test(groups = { "Functional" })
public void testVerifyAlignmentDatasetRefs()
{
- SequenceI sq1 = new Sequence("sq1", "ASFDD"), sq2 = new Sequence("sq2",
- "TTTTTT");
+ SequenceI sq1 = new Sequence("sq1", "ASFDD"),
+ sq2 = new Sequence("sq2", "TTTTTT");
// construct simple valid alignment dataset
Alignment al = new Alignment(new SequenceI[] { sq1, sq2 });
"didn't detect dataset sequence with a dataset sequence reference.");
sq1.setDatasetSequence(null);
- assertVerifyAlignment(
- al,
- true,
+ assertVerifyAlignment(al, true,
"didn't reinstate validity after nulling dataset sequence dataset reference");
// now create dataset and check again
// create a dbref on sq1 with a sequence ref to sq2
DBRefEntry dbrs1tos2 = new DBRefEntry("UNIPROT", "1", "Q111111");
- dbrs1tos2.setMap(new Mapping(sq2.getDatasetSequence(),
- new int[] { 1, 5 }, new int[] { 2, 6 }, 1, 1));
+ dbrs1tos2
+ .setMap(new Mapping(sq2.getDatasetSequence(), new int[]
+ { 1, 5 }, new int[] { 2, 6 }, 1, 1));
sq1.getDatasetSequence().addDBRef(dbrs1tos2);
assertVerifyAlignment(al, true,
"verify failed after addition of valid DBRefEntry/map");
// now create a dbref on a new sequence which maps to another sequence
// outside of the dataset
- SequenceI sqout = new Sequence("sqout", "ututututucagcagcag"), sqnew = new Sequence(
- "sqnew", "EEERRR");
+ SequenceI sqout = new Sequence("sqout", "ututututucagcagcag"),
+ sqnew = new Sequence("sqnew", "EEERRR");
DBRefEntry sqnewsqout = new DBRefEntry("ENAFOO", "1", "R000001");
- sqnewsqout.setMap(new Mapping(sqout, new int[] { 1, 6 }, new int[] { 1,
- 18 }, 1, 3));
+ sqnewsqout
+ .setMap(new Mapping(sqout, new int[]
+ { 1, 6 }, new int[] { 1, 18 }, 1, 3));
al.getDataset().addSequence(sqnew);
assertVerifyAlignment(al, true,
"verify failed after addition of new sequence to dataset");
// now start checking exception conditions
sqnew.addDBRef(sqnewsqout);
- assertVerifyAlignment(
- al,
- false,
+ assertVerifyAlignment(al, false,
"verify passed when a dbref with map to sequence outside of dataset was added");
// make the verify pass by adding the outsider back in
al.getDataset().addSequence(sqout);
"aggtutaggcagcagcag");
AlignedCodonFrame alc = new AlignedCodonFrame();
- alc.addMap(sqanotherout, sqnew, new MapList(new int[] { 1, 6 },
- new int[] { 1, 18 }, 3, 1));
+ alc.addMap(sqanotherout, sqnew,
+ new MapList(new int[]
+ { 1, 6 }, new int[] { 1, 18 }, 3, 1));
al.addCodonFrame(alc);
Assert.assertEquals(al.getDataset().getCodonFrames().size(), 1);
- assertVerifyAlignment(
- al,
- false,
+ assertVerifyAlignment(al, false,
"verify passed when alCodonFrame mapping to sequence outside of dataset was added");
// make the verify pass by adding the outsider back in
al.getDataset().addSequence(sqanotherout);
- assertVerifyAlignment(
- al,
- true,
+ assertVerifyAlignment(al, true,
"verify should have passed once all sequences involved in alCodonFrame were added to dataset");
al.getDataset().addSequence(sqanotherout);
assertVerifyAlignment(al, false,
* @param message
* - null or message prepended to exception message.
*/
- public static void assertDatasetIsNormalised(AlignmentI al, String message)
+ public static void assertDatasetIsNormalised(AlignmentI al,
+ String message)
{
if (al.getDataset() != null)
{
assertDatasetIsNormalised(al);
} catch (AssertionError ae)
{
- Assert.fail("Two different sequences should be valid normalised dataset.");
+ Assert.fail(
+ "Two different sequences should be valid normalised dataset.");
}
/*
* now change sq2's name in the alignment. should still be valid
assertDatasetIsNormalised(al);
} catch (AssertionError ae)
{
- Assert.fail("Two different sequences in dataset, but same name in alignment, should be valid normalised dataset.");
+ Assert.fail(
+ "Two different sequences in dataset, but same name in alignment, should be valid normalised dataset.");
}
al.addSequence(sq1seqd);
assertDatasetIsNormalised(al);
} catch (AssertionError ae)
{
- Assert.fail("sq1 and sq1 with different sequence should be distinct.");
+ Assert.fail(
+ "sq1 and sq1 with different sequence should be distinct.");
}
al.addSequence(sq1shift);
assertDatasetIsNormalised(al);
} catch (AssertionError ae)
{
- Assert.fail("sq1 and sq1 with different start/end should be distinct.");
+ Assert.fail(
+ "sq1 and sq1 with different start/end should be distinct.");
}
/*
* finally, the failure case
makeMappings(al1, al2);
((Alignment) al2).alignAs(al1, false, true);
- assertEquals("GC-TC--GUC-GTACT", al2.getSequenceAt(0)
- .getSequenceAsString());
- assertEquals("-GG-GTC--AGG--CAGT", al2.getSequenceAt(1)
- .getSequenceAsString());
+ assertEquals("GC-TC--GUC-GTACT",
+ al2.getSequenceAt(0).getSequenceAsString());
+ assertEquals("-GG-GTC--AGG--CAGT",
+ al2.getSequenceAt(1).getSequenceAsString());
}
/**
* Realign DNA; currently keeping existing gaps in introns only
*/
((Alignment) al1).alignAs(al2, false, true);
- assertEquals("ACG---GCUCCA------ACT---", al1.getSequenceAt(0)
- .getSequenceAsString());
- assertEquals("---CGT---TAACGA---AGT---", al1.getSequenceAt(1)
- .getSequenceAsString());
+ assertEquals("ACG---GCUCCA------ACT---",
+ al1.getSequenceAt(0).getSequenceAsString());
+ assertEquals("---CGT---TAACGA---AGT---",
+ al1.getSequenceAt(1).getSequenceAsString());
}
/**
{
SequenceI seqFrom = alFrom.getSequenceAt(i);
SequenceI seqTo = alTo.getSequenceAt(i);
- MapList ml = new MapList(new int[] { seqFrom.getStart(),
- seqFrom.getEnd() },
- new int[] { seqTo.getStart(), seqTo.getEnd() }, ratio, 1);
+ MapList ml = new MapList(
+ new int[]
+ { seqFrom.getStart(), seqFrom.getEnd() },
+ new int[]
+ { seqTo.getStart(), seqTo.getEnd() }, ratio, 1);
acf.addMap(seqFrom, seqTo, ml);
}
*/
String dna1 = "A-Aa-gG-GCC-cT-TT";
String dna2 = "c--CCGgg-TT--T-AA-A";
- AlignmentI al1 = loadAlignment(">Dna1/6-17\n" + dna1
- + "\n>Dna2/20-31\n" + dna2 + "\n", FileFormat.Fasta);
+ AlignmentI al1 = loadAlignment(
+ ">Dna1/6-17\n" + dna1 + "\n>Dna2/20-31\n" + dna2 + "\n",
+ FileFormat.Fasta);
AlignmentI al2 = loadAlignment(
">Pep1/7-9\n-P--YK\n>Pep2/11-13\nG-T--F\n", FileFormat.Fasta);
AlignedCodonFrame acf = new AlignedCodonFrame();
// Seq1 has intron at dna positions 3,4,9 so splice is AAG GCC TTT
// Seq2 has intron at dna positions 1,5,6 so splice is CCG TTT AAA
- MapList ml1 = new MapList(new int[] { 6, 7, 10, 13, 15, 17 }, new int[]
- { 7, 9 }, 3, 1);
+ MapList ml1 = new MapList(new int[] { 6, 7, 10, 13, 15, 17 },
+ new int[]
+ { 7, 9 }, 3, 1);
acf.addMap(al1.getSequenceAt(0), al2.getSequenceAt(0), ml1);
- MapList ml2 = new MapList(new int[] { 21, 23, 26, 31 }, new int[] { 11,
- 13 }, 3, 1);
+ MapList ml2 = new MapList(new int[] { 21, 23, 26, 31 },
+ new int[]
+ { 11, 13 }, 3, 1);
acf.addMap(al1.getSequenceAt(1), al2.getSequenceAt(1), ml2);
al2.addCodonFrame(acf);
* Align ignoring gaps in dna introns and exons
*/
((Alignment) al1).alignAs(al2, false, false);
- assertEquals("---AAagG------GCCcTTT", al1.getSequenceAt(0)
- .getSequenceAsString());
+ assertEquals("---AAagG------GCCcTTT",
+ al1.getSequenceAt(0).getSequenceAsString());
// note 1 gap in protein corresponds to 'gg-' in DNA (3 positions)
- assertEquals("cCCGgg-TTT------AAA", al1.getSequenceAt(1)
- .getSequenceAsString());
+ assertEquals("cCCGgg-TTT------AAA",
+ al1.getSequenceAt(1).getSequenceAsString());
/*
* Reset and realign, preserving gaps in dna introns and exons
// String dna1 = "A-Aa-gG-GCC-cT-TT";
// String dna2 = "c--CCGgg-TT--T-AA-A";
// assumption: we include 'the greater of' protein/dna gap lengths, not both
- assertEquals("---A-Aa-gG------GCC-cT-TT", al1.getSequenceAt(0)
- .getSequenceAsString());
- assertEquals("c--CCGgg-TT--T------AA-A", al1.getSequenceAt(1)
- .getSequenceAsString());
+ assertEquals("---A-Aa-gG------GCC-cT-TT",
+ al1.getSequenceAt(0).getSequenceAsString());
+ assertEquals("c--CCGgg-TT--T------AA-A",
+ al1.getSequenceAt(1).getSequenceAsString());
}
@Test(groups = "Functional")
// create sequence and alignment datasets
protein.setDataset(null);
AlignedCodonFrame acf = new AlignedCodonFrame();
- List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[]
- { acf });
+ List<AlignedCodonFrame> acfList = Arrays
+ .asList(new AlignedCodonFrame[]
+ { acf });
protein.getDataset().setCodonFrames(acfList);
AlignmentI copy = new Alignment(protein);
*/
assertFalse(copy.getSequenceAt(0) == protein.getSequenceAt(0));
assertFalse(copy.getSequenceAt(1) == protein.getSequenceAt(1));
- assertSame(copy.getSequenceAt(0).getDatasetSequence(), protein
- .getSequenceAt(0).getDatasetSequence());
- assertSame(copy.getSequenceAt(1).getDatasetSequence(), protein
- .getSequenceAt(1).getDatasetSequence());
+ assertSame(copy.getSequenceAt(0).getDatasetSequence(),
+ protein.getSequenceAt(0).getDatasetSequence());
+ assertSame(copy.getSequenceAt(1).getDatasetSequence(),
+ protein.getSequenceAt(1).getDatasetSequence());
// TODO should the copy constructor copy the dataset?
// or make a new one referring to the same dataset sequences??
// side-effect: dataset created on second sequence
assertNotNull(protein.getSequenceAt(1).getDatasetSequence());
// dataset alignment has references to dataset sequences
- assertEquals(ds.getSequenceAt(0), protein.getSequenceAt(0)
- .getDatasetSequence());
- assertEquals(ds.getSequenceAt(1), protein.getSequenceAt(1)
- .getDatasetSequence());
+ assertEquals(ds.getSequenceAt(0),
+ protein.getSequenceAt(0).getDatasetSequence());
+ assertEquals(ds.getSequenceAt(1),
+ protein.getSequenceAt(1).getDatasetSequence());
// codon frames should have been moved to the dataset
// getCodonFrames() should delegate to the dataset:
// cross-references to two more sequences.
DBRefEntry dbr = new DBRefEntry("SQ1", "", "sq3");
SequenceI sq3 = new Sequence("sq3", "VWANG");
- dbr.setMap(new Mapping(sq3, new MapList(new int[] { 1, 4 }, new int[] {
- 2, 5 }, 1, 1)));
+ dbr.setMap(
+ new Mapping(sq3, new MapList(new int[]
+ { 1, 4 }, new int[] { 2, 5 }, 1, 1)));
sq1.addDBRef(dbr);
SequenceI sq4 = new Sequence("sq4", "ERKWI");
DBRefEntry dbr2 = new DBRefEntry("SQ2", "", "sq4");
- dbr2.setMap(new Mapping(sq4, new MapList(new int[] { 1, 4 }, new int[] {
- 2, 5 }, 1, 1)));
+ dbr2.setMap(
+ new Mapping(sq4, new MapList(new int[]
+ { 1, 4 }, new int[] { 2, 5 }, 1, 1)));
sq2.addDBRef(dbr2);
// and a 1:1 codonframe mapping between them.
AlignedCodonFrame alc = new AlignedCodonFrame();
- alc.addMap(sq1, sq2, new MapList(new int[] { 1, 4 },
- new int[] { 1, 4 }, 1, 1));
+ alc.addMap(sq1, sq2,
+ new MapList(new int[]
+ { 1, 4 }, new int[] { 1, 4 }, 1, 1));
AlignmentI protein = new Alignment(new SequenceI[] { sq1, sq2 });
Assert.assertEquals(align.getDataset().getHeight(), 1,
"Dataset shouldn't have more than one sequence.");
- Sequence seq2 = new Sequence("newtestSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+ Sequence seq2 = new Sequence("newtestSeq",
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
align.addSequence(seq2);
Assert.assertEquals(align.getDataset().getHeight(), 2,
"Dataset should now have two sequences.");
// 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)));
+ 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)));
+ 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)));
+ 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)));
+ 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 });
/*
* 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);
+ List<DBRefEntry> dbRefs = pep.getDBRefs();
+ assertEquals(2, dbRefs.size());
+ assertSame(dna, dbRefs.get(0).map.to);
+ assertSame(cds, dbRefs.get(1).map.to);
+ assertEquals(1, dna.getDBRefs().size());
+ assertSame(pep.getDatasetSequence(), dna.getDBRefs().get(0).map.to);
+ assertEquals(1, cds.getDBRefs().size());
+ assertSame(pep.getDatasetSequence(), cds.getDBRefs().get(0).map.to);
}
@Test(groups = { "Functional" })
@Test(
groups = "Functional",
- expectedExceptions = { IllegalArgumentException.class })
+ expectedExceptions =
+ { IllegalArgumentException.class })
public void testSetDataset_selfReference()
{
SequenceI seq = new Sequence("a", "a");
assertEquals('-', alignment.getGapCharacter());
assertSame(seq, alignment.getSequenceAt(0));
- assertEquals("KP--L-FQII-", alignment.getSequenceAt(1)
- .getSequenceAsString());
+ assertEquals("KP--L-FQII-",
+ alignment.getSequenceAt(1).getSequenceAsString());
// todo test coverage for annotations, mappings, groups,
// hidden sequences, properties
assertEquals(".JKLMNO", seq2.getSequenceAsString());
assertEquals(".PQR...", seq3.getSequenceAsString());
}
+
+ /**
+ * Test for setHiddenColumns, to check it returns true if the hidden columns
+ * have changed, else false
+ */
+ @Test(groups = { "Functional" })
+ public void testSetHiddenColumns()
+ {
+ AlignmentI al = new Alignment(new SequenceI[] {});
+ assertFalse(al.getHiddenColumns().hasHiddenColumns());
+
+ HiddenColumns hc = new HiddenColumns();
+ assertFalse(al.setHiddenColumns(hc)); // no change
+ assertSame(hc, al.getHiddenColumns());
+
+ hc.hideColumns(2, 4);
+ assertTrue(al.getHiddenColumns().hasHiddenColumns());
+
+ /*
+ * set a different object but with the same columns hidden
+ */
+ HiddenColumns hc2 = new HiddenColumns();
+ hc2.hideColumns(2, 4);
+ assertFalse(al.setHiddenColumns(hc2)); // no change
+ assertSame(hc2, al.getHiddenColumns());
+
+ assertTrue(al.setHiddenColumns(null));
+ assertNull(al.getHiddenColumns());
+ assertTrue(al.setHiddenColumns(hc));
+ assertSame(hc, al.getHiddenColumns());
+
+ al.getHiddenColumns().hideColumns(10, 12);
+ hc2.hideColumns(10, 12);
+ assertFalse(al.setHiddenColumns(hc2)); // no change
+
+ /*
+ * hide columns 15-16 then 17-18 in hc
+ * hide columns 15-18 in hc2
+ * these are not now 'equal' objects even though they
+ * represent the same set of columns
+ */
+ assertSame(hc2, al.getHiddenColumns());
+ hc.hideColumns(15, 16);
+ hc.hideColumns(17, 18);
+ hc2.hideColumns(15, 18);
+ assertFalse(hc.equals(hc2));
+ assertTrue(al.setHiddenColumns(hc)); // 'changed'
+ }
+
+ @Test(groups = { "Functional" })
+ public void testGetWidth()
+ {
+ SequenceI seq1 = new Sequence("seq1", "ABCDEF--");
+ SequenceI seq2 = new Sequence("seq2", "-JKLMNO--");
+ SequenceI seq3 = new Sequence("seq2", "-PQR");
+ AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2, seq3 });
+
+ assertEquals(9, a.getWidth());
+
+ // width includes hidden columns
+ a.getHiddenColumns().hideColumns(2, 5);
+ assertEquals(9, a.getWidth());
+ }
+
+ @Test(groups = { "Functional" })
+ public void testGetVisibleWidth()
+ {
+ SequenceI seq1 = new Sequence("seq1", "ABCDEF--");
+ SequenceI seq2 = new Sequence("seq2", "-JKLMNO--");
+ SequenceI seq3 = new Sequence("seq2", "-PQR");
+ AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2, seq3 });
+
+ assertEquals(9, a.getVisibleWidth());
+
+ // width excludes hidden columns
+ a.getHiddenColumns().hideColumns(2, 5);
+ assertEquals(5, a.getVisibleWidth());
+ }
}